Preaggregation "${preAggregation.preAggregationName}" refere

Error message

Preaggregation "${preAggregation.preAggregationName}" referenced property "${member}" not found in cube "${preAggregation.cube}"

What it means

While building the SQL render for a pre-aggregation's references, Cube looks up each referenced member's refKey in the cube's compiled references. If a member path has no entry — meaning the member doesn't exist in the pre-aggregation's cube — this Error is thrown. Unlike UserErrors, this is a plain Error and usually indicates a deeper schema mismatch or bug.

Source

Thrown at packages/cubejs-schema-compiler/src/adapter/PreAggregations.ts:1541

    const targetMeasuresReferences = this.measureAliasesRenderedReference(preAggregationForQuery);

    const columnsFor = (targetReferences, references, preAggregation) => Object.keys(targetReferences).map(
      member => {
        const [, memberProp] = member.split('.');

        let refKey = references[member];

        if (refKey) {
          return `${refKey} ${targetReferences[member]}`;
        }

        refKey = references[this.query.cubeEvaluator.pathFromArray([preAggregation.cube, memberProp])];

        if (refKey) {
          return `${refKey} ${targetReferences[member]}`;
        }

        throw new Error(`Preaggregation "${preAggregation.preAggregationName}" referenced property "${member}" not found in cube "${preAggregation.cube}"`);
      }
    );

    const tables = preAggregationForQuery.referencedPreAggregations.map(preAggregation => {
      const dimensionsReferences = this.dimensionsRenderedReference(preAggregation);
      const timeDimensionsReferences = this.timeDimensionsRenderedReference(rollupGranularity, preAggregation);
      const measuresReferences = this.measureAliasesRenderedReference(preAggregation);

      return {
        tableName: this.preAggregationTableName(
          preAggregation.cube,
          preAggregation.preAggregationName,
          preAggregation.preAggregation
        ),
        columns: columnsFor(targetDimensionsReferences, dimensionsReferences, preAggregation)
          .concat(columnsFor(targetTimeDimensionsReferences, timeDimensionsReferences, preAggregation))
          .concat(columnsFor(targetMeasuresReferences, measuresReferences, preAggregation))
      };

View on GitHub (pinned to 7d981676b3)

Solutions

Fix the pre-aggregation definition so all members exist in the cube (use ${CUBE}.xxx or the correct cube prefix).
Remove or update members that were renamed or deleted from the cube schema.
Recompile/restart after schema changes so the references map and the pre-aggregation definition are in sync.
If definitions are generated dynamically, validate emitted member paths against the cube before compiling.

Example fix

// before
// Cube B, copied from Cube A
preAggregations: { main: { measures: [CUBE.totalAmount] } } // totalAmount only exists in A
// after
preAggregations: { main: { measures: [CUBE.amount] } } // member that exists in B

Defensive patterns

Strategy: validation

Validate before calling

// Verify every member referenced by a pre-aggregation exists in its cube before compiling
function validatePreAggMembers(cube, def, cubeSchema) {
  const members = [...(def.measures || []), ...(def.dimensions || []), ...(def.timeDimensions || [])];
  for (const m of members) {
    const name = typeof m === 'string' ? m : m.dimension;
    if (!cubeSchema.memberExists(cube, name)) throw new Error(`Member ${name} not found in cube ${cube}`);
  }
}

Type guard

function memberExists(cubeSchema, cube, member) { try { return cubeSchema.resolveMember(member.startsWith('CUBE') ? `${cube}.${member.split('.')[1]}` : member) !== undefined; } catch { return false; } }

Try / catch

try { await cube.query(query); } catch (e) { if (/referenced property .* not found in cube/.test(e.message)) { console.error('Fix or remove the stale member in the pre-aggregation definition:', e.message); } else throw e; }

Prevention

Rewrite ${CUBE}.xxx paths when copying pre-aggregations between cubes
Grep pre-aggregation definitions after renaming/deleting members
Restart/compile after schema edits so references are in sync
Add a schema-lint step that resolves every pre-aggregation member

When it happens

Trigger: A pre-aggregation's references (measures/dimensions/timeDimensions from its definition) include a member path that resolves to nothing in cubeEvaluator for preAggregation.cube — e.g. the pre-aggregation definition was copied from another cube keeping the other cube's member names, or cubeEvaluator.pathFromArray produces a path missing from the references map during reference building (PreAggregations.ts:1541).

Common situations: Copy-pasting a pre-aggregation between cubes without rewriting '${CUBE}.member' paths; renamed/deleted members still listed in a pre-aggregation; dynamic schema generation emitting members that don't exist; version upgrades where member names changed.

Related errors

AI-assisted analysis of cube-js/cube@7d981676b3 (2026-09-02). Data as JSON: /api/errors/74fc1724eab43d8d. Report an issue: GitHub.