@finos/legend-cube-builder 0.0.4 → 0.0.5

package/src/stores/CubeLambdaSources.ts

@@ -0,0 +1,390 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  CubeLambdaReadError,
+  DATA_PRODUCT_ACCESS_POINT_SOURCE_DEFINITION,
+  DataProductAccessPointSource,
+  INGEST_DATASET_SOURCE_DEFINITION,
+  IngestDatasetSource,
+  RELATIONAL_TABLE_SOURCE_DEFINITION,
+  RelationalTableSource,
+  Schema,
+  type CubeContext,
+  type CubeSourceStep,
+  type IR,
+} from '@finos/legend-cube';
+import {
+  createCubeDataProductModel,
+  CUBE_DATA_PRODUCT_RUNTIME_PATH,
+  CUBE_DEFAULT_CONSUMER_WAREHOUSE,
+  getCubeDataProductProject,
+  type CubeDataProductEnvironmentType,
+} from '../graph-manager/CubeDataProduct.js';
+import type { CubeDataProductCandidate } from '../graph-manager/CubeDataProductCatalog.js';
+import {
+  createCubeIngestModel,
+  CUBE_INGEST_RUNTIME_PATH,
+  getCubeIngestSettings,
+} from '../graph-manager/CubeIngest.js';
+import type { CubeIngestDataSet } from '../graph-manager/CubeIngestCatalog.js';
+import type { CubeEditorState } from './CubeEditorState.js';
+
+// Import Pure's sources (PLAN §11.18): each accessor of a lambda bound to the
+// source step the source dialog would add for it, typed as the dialog types
+// one, before the steps are read. A host with a project (Studio) binds within
+// it; another binds within the cube's own model or source, and asks for a
+// source first when the lambda alone doesn't say where its sources are.
+
+export const CUBE_LAMBDA_SOURCES_MESSAGE = {
+  NONE: 'The query reads no source Cube knows: #>{…}#, #P{…}# or #I{…}#.',
+  MIXED:
+    'A cube reads one kind of source, and this query reads several: tables, data products or ingest data sets.',
+  NOT_YET: 'Cube reads tables, data products and ingest data sets so far.',
+  NO_INGEST: 'This page has no ingest data sets to read.',
+  NO_DATA_PRODUCTS: 'This page has no data products to read.',
+  INGEST_SETTINGS:
+    'Add an ingest data set first, so Cube knows which deployment the query reads, then import it.',
+  NO_DEFINITION: (definition: string): string =>
+    `Cube finds no ingest definition ${definition}.`,
+  NO_DATA_SET: (dataSet: string, definition: string): string =>
+    `Ingest definition ${definition} has no data set "${dataSet}".`,
+  DATA_SET_UNREADABLE: (
+    dataSet: string,
+    definition: string,
+    reason: string,
+  ): string => `Cube can't read ${definition}.${dataSet}: ${reason}`,
+  NO_DATA_PRODUCT: (dataProduct: string): string =>
+    `Cube finds no data product ${dataProduct}.`,
+  DATA_PRODUCTS: (dataProduct: string): string =>
+    `Several data products are ${dataProduct}: add an access point of the one the query reads first, then import it.`,
+  NO_ACCESS_POINT: (accessPoint: string, dataProduct: string): string =>
+    `Data product ${dataProduct} has no access point "${accessPoint}".`,
+  ACCESS_POINT_UNREADABLE: (
+    accessPoint: string,
+    dataProduct: string,
+    reason: string,
+  ): string => `Cube can't read ${dataProduct}.${accessPoint}: ${reason}`,
+  TABLE_MODEL:
+    'Add a table first, so Cube knows the model the query reads, then import it.',
+};
+
+/** What the lambda's sources bind to: the cube's model and runtime, and the step of each */
+export interface CubeLambdaBinding {
+  readonly context: CubeContext;
+  readonly bindSource: (source: IR) => CubeSourceStep;
+}
+
+const keyOf = (source: IR): string =>
+  source.k === 'ingestAccessor' ||
+  source.k === 'dataProductAccessor' ||
+  source.k === 'storeAccessor'
+    ? `${source.k}:${source.path.join('\u0000')}`
+    : `${source.k}`;
+
+const bindingOf = (
+  context: CubeContext,
+  steps: ReadonlyMap<string, CubeSourceStep>,
+): CubeLambdaBinding => ({
+  context,
+  bindSource: (source) => {
+    const step = steps.get(keyOf(source));
+    if (!step) {
+      throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.NOT_YET);
+    }
+    return step;
+  },
+});
+
+/** The warehouse a new cube runs on: the project runtime's, the viewer's last, the default */
+const newCubeWarehouse = async (
+  editorState: CubeEditorState,
+  ownWarehouse: string | undefined,
+): Promise<string> => {
+  if (ownWarehouse !== undefined) {
+    return ownWarehouse;
+  }
+  const runtime = editorState.host.project
+    ? await editorState.host.project.resolveRuntime()
+    : undefined;
+  return (
+    runtime?.warehouse ??
+    editorState.dataProductRuntime.rememberedWarehouse ??
+    CUBE_DEFAULT_CONSUMER_WAREHOUSE
+  );
+};
+
+const bindIngestDataSets = async (
+  editorState: CubeEditorState,
+  sources: readonly Extract<IR, { readonly k: 'ingestAccessor' }>[],
+): Promise<CubeLambdaBinding> => {
+  const catalog = editorState.host.ingestCatalog;
+  if (!catalog) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.NO_INGEST);
+  }
+  const { context } = editorState.document;
+  const current = context ? getCubeIngestSettings(context.model) : undefined;
+  const environmentType =
+    current?.environmentType ??
+    (catalog.environmentTypes.length === 1
+      ? catalog.environmentTypes[0]
+      : undefined);
+  if (environmentType === undefined) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.INGEST_SETTINGS);
+  }
+  let producerDeploymentId = current?.producerDeploymentId;
+  if (producerDeploymentId === undefined) {
+    const producers = await catalog.listProducers(environmentType);
+    producerDeploymentId =
+      producers.length === 1 ? producers[0]?.deploymentId : undefined;
+  }
+  if (producerDeploymentId === undefined) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.INGEST_SETTINGS);
+  }
+  const { candidates } = await catalog.listDefinitions(
+    environmentType,
+    producerDeploymentId,
+  );
+  const steps = new Map<string, CubeSourceStep>();
+  const described = new Map<string, readonly CubeIngestDataSet[]>();
+  for (const source of sources) {
+    const [definition, dataSetName] = source.path;
+    const candidate = candidates.find((each) => each.definition === definition);
+    if (!candidate) {
+      throw new CubeLambdaReadError(
+        CUBE_LAMBDA_SOURCES_MESSAGE.NO_DEFINITION(definition),
+      );
+    }
+    const dataSets =
+      described.get(candidate.urn) ??
+      (await catalog.describe(candidate.urn, environmentType));
+    described.set(candidate.urn, dataSets);
+    const dataSet = dataSets.find((each) => each.name === dataSetName);
+    if (!dataSet) {
+      throw new CubeLambdaReadError(
+        CUBE_LAMBDA_SOURCES_MESSAGE.NO_DATA_SET(dataSetName, definition),
+      );
+    }
+    const { schema } = dataSet;
+    if (!dataSet.isPickable || !schema) {
+      throw new CubeLambdaReadError(
+        CUBE_LAMBDA_SOURCES_MESSAGE.DATA_SET_UNREADABLE(
+          dataSetName,
+          definition,
+          dataSet.disabledReason ?? '',
+        ),
+      );
+    }
+    steps.set(keyOf(source), {
+      type: IngestDatasetSource.TYPE,
+      create: (id) =>
+        INGEST_DATASET_SOURCE_DEFINITION.resolve(
+          INGEST_DATASET_SOURCE_DEFINITION.fromCoordinates(id, {
+            ingestDefinitionUrn: candidate.urn,
+            ingestDefinition: definition,
+            dataSet: dataSetName,
+          }),
+          { kind: 'resolved', schema },
+        ),
+    });
+  }
+  const warehouse =
+    current?.warehouse ??
+    (await catalog.resolveEnvironment(environmentType)).warehouse;
+  return bindingOf(
+    {
+      model: createCubeIngestModel({
+        environmentType,
+        producerDeploymentId,
+        warehouse: await newCubeWarehouse(editorState, warehouse),
+      }),
+      runtime: CUBE_INGEST_RUNTIME_PATH,
+    },
+    steps,
+  );
+};
+
+const bindDataProducts = async (
+  editorState: CubeEditorState,
+  sources: readonly Extract<IR, { readonly k: 'dataProductAccessor' }>[],
+): Promise<CubeLambdaBinding> => {
+  const catalog = editorState.host.dataProductCatalog;
+  if (!catalog) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.NO_DATA_PRODUCTS);
+  }
+  const { context } = editorState.document;
+  const current = context
+    ? getCubeDataProductProject(context.model)
+    : undefined;
+  const environmentType = (current?.environmentType ??
+    catalog.environmentTypes[0]) as CubeDataProductEnvironmentType;
+  const products = new Map<string, CubeDataProductCandidate>();
+  const steps = new Map<string, CubeSourceStep>();
+  for (const source of sources) {
+    const [dataProduct, accessPointId] = source.path;
+    let candidate = products.get(dataProduct);
+    if (!candidate) {
+      // a catalog searches titles and ids, not paths: by the product's name,
+      // then the whole list, each matched on its path
+      let found: CubeDataProductCandidate[] = [];
+      for (const text of [dataProduct.split('::').at(-1) ?? dataProduct, '']) {
+        found = (await catalog.search({ text, environmentType })).filter(
+          (each) =>
+            each.dataProductPath === dataProduct &&
+            (!current ||
+              (each.groupId === current.groupId &&
+                each.artifactId === current.artifactId &&
+                each.versionId === current.versionId)),
+        );
+        if (found.length) {
+          break;
+        }
+      }
+      if (found.length > 1) {
+        throw new CubeLambdaReadError(
+          CUBE_LAMBDA_SOURCES_MESSAGE.DATA_PRODUCTS(dataProduct),
+        );
+      }
+      candidate = found[0];
+      if (!candidate) {
+        throw new CubeLambdaReadError(
+          CUBE_LAMBDA_SOURCES_MESSAGE.NO_DATA_PRODUCT(dataProduct),
+        );
+      }
+      products.set(dataProduct, candidate);
+    }
+    const product = candidate;
+    const { groups } = await catalog.describe(product);
+    const group = groups.find((each) =>
+      each.accessPoints.some((point) => point.id === accessPointId),
+    );
+    const accessPoint = group?.accessPoints.find(
+      (point) => point.id === accessPointId,
+    );
+    if (!group || !accessPoint) {
+      throw new CubeLambdaReadError(
+        CUBE_LAMBDA_SOURCES_MESSAGE.NO_ACCESS_POINT(accessPointId, dataProduct),
+      );
+    }
+    const { schema } = accessPoint;
+    if (accessPoint.disabledReason !== undefined || !schema) {
+      throw new CubeLambdaReadError(
+        CUBE_LAMBDA_SOURCES_MESSAGE.ACCESS_POINT_UNREADABLE(
+          accessPointId,
+          dataProduct,
+          accessPoint.disabledReason ?? '',
+        ),
+      );
+    }
+    steps.set(keyOf(source), {
+      type: DataProductAccessPointSource.TYPE,
+      create: (id) =>
+        DATA_PRODUCT_ACCESS_POINT_SOURCE_DEFINITION.resolve(
+          DATA_PRODUCT_ACCESS_POINT_SOURCE_DEFINITION.fromCoordinates(id, {
+            dataProduct,
+            accessPointGroup: group.id,
+            accessPoint: accessPointId,
+            dataProductId: product.id,
+            deploymentId: product.deploymentId,
+          }),
+          { kind: 'resolved', schema },
+        ),
+    });
+  }
+  const [first] = [...products.values()];
+  if (!first) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.NONE);
+  }
+  return bindingOf(
+    {
+      model: createCubeDataProductModel({
+        groupId: first.groupId,
+        artifactId: first.artifactId,
+        versionId: first.versionId,
+        environmentType: first.environmentType,
+        warehouse: await newCubeWarehouse(editorState, current?.warehouse),
+      }),
+      runtime: CUBE_DATA_PRODUCT_RUNTIME_PATH,
+    },
+    steps,
+  );
+};
+
+/** Tables of the cube's own model, typed by the engine in one call */
+const bindTables = async (
+  editorState: CubeEditorState,
+  sources: readonly Extract<IR, { readonly k: 'storeAccessor' }>[],
+): Promise<CubeLambdaBinding> => {
+  const { context } = editorState.document;
+  if (!context) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.TABLE_MODEL);
+  }
+  const typed = await editorState.host.engine.resolveSchemas(
+    context.model,
+    new Map(sources.map((source) => [keyOf(source), source.path])),
+  );
+  const steps = new Map<string, CubeSourceStep>();
+  sources.forEach((source) => {
+    const [database, schema, table] = source.path;
+    const columns = typed.get(keyOf(source));
+    steps.set(keyOf(source), {
+      type: RelationalTableSource.TYPE,
+      create: (id) => {
+        const node = RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(id, {
+          database,
+          schema,
+          table,
+        });
+        // a table the engine can't type is read anyway, and shows its error
+        return columns instanceof Schema
+          ? RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(node, {
+              kind: 'resolved',
+              schema: columns,
+            })
+          : node;
+      },
+    });
+  });
+  return bindingOf(context, steps);
+};
+
+/**
+ * The cube's model and runtime and the step of each source, for a lambda's
+ * sources, all of one kind (PLAN §11.18). Throws a `CubeLambdaReadError` that
+ * names a source Cube can't bind, or what to add first.
+ */
+export const bindCubeLambdaSources = async (
+  editorState: CubeEditorState,
+  sources: readonly IR[],
+): Promise<CubeLambdaBinding> => {
+  const kinds = new Set(sources.map((source) => source.k));
+  if (!kinds.size) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.NONE);
+  }
+  if (kinds.size > 1) {
+    throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.MIXED);
+  }
+  if (sources.every((source) => source.k === 'ingestAccessor')) {
+    return bindIngestDataSets(editorState, sources);
+  }
+  if (sources.every((source) => source.k === 'dataProductAccessor')) {
+    return bindDataProducts(editorState, sources);
+  }
+  if (sources.every((source) => source.k === 'storeAccessor')) {
+    return bindTables(editorState, sources);
+  }
+  throw new CubeLambdaReadError(CUBE_LAMBDA_SOURCES_MESSAGE.NOT_YET);
+};

package/src/stores/CubeQueryRun.ts

@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type IR,
+  type ModelContext,
+  needsDatabaseType,
+  type Query,
+  QueryEmitter,
+  type Schema,
+} from '@finos/legend-cube';
+import { flowResult } from 'mobx';
+import {
+  CubeEngineError,
+  CubeEngineErrorKind,
+  type CubeResultValue,
+} from '../graph-manager/CubeEngine.js';
+import type { CubeEditorState } from './CubeEditorState.js';
+
+/** A query to run up to its selected node, with what it runs in */
+export interface CubeQueryRunRequest {
+  /** The query, its selected node the one to run */
+  readonly query: Query;
+  readonly model: ModelContext;
+  readonly runtime: string;
+  /** The schema Cube infers for the node: the engine's columns must be these */
+  readonly schema: Schema;
+  /** The most rows to keep: one more is fetched to tell whether there are more */
+  readonly rowLimit: number;
+  readonly abortController: AbortController;
+  /** What the Runs panel calls the run, e.g. `Execute` (PLAN §11.16) */
+  readonly label: string;
+}
+
+export interface CubeQueryRunResult {
+  /** At most `rowLimit` rows, by the schema's column positions */
+  readonly rows: readonly (readonly CubeResultValue[])[];
+  /** The engine returned more than `rowLimit` rows */
+  readonly limited: boolean;
+  readonly sql: readonly string[];
+  readonly durationMs: number;
+  /** The execution lambda that ran, its row limit included */
+  readonly lambda: IR;
+}
+
+/** Thrown when a run is aborted while it waits for the model's outline */
+export class CubeQueryRunAborted extends Error {
+  constructor() {
+    super('The run was stopped');
+    this.name = 'CubeQueryRunAborted';
+  }
+}
+
+/** Runs the query and checks the engine's columns, keeping the lambda once it is written */
+const runAndCheck = async (
+  editorState: CubeEditorState,
+  request: CubeQueryRunRequest,
+  sent: { lambda?: IR },
+): Promise<CubeQueryRunResult> => {
+  const { query, model, runtime, schema, rowLimit, abortController } = request;
+  const nodeId = query.selected;
+  if (nodeId === undefined) {
+    throw new Error('A query to run has a selected node');
+  }
+  let databaseType: string | undefined;
+  if (needsDatabaseType(query, nodeId)) {
+    await flowResult(editorState.loadModelOutline(model));
+    if (abortController.signal.aborted) {
+      throw new CubeQueryRunAborted();
+    }
+    databaseType = editorState.getRunDatabaseType(
+      query,
+      nodeId,
+      model,
+      runtime,
+    );
+  }
+  const lambda = new QueryEmitter(
+    query,
+    editorState.registry,
+  ).emitExecutionLambda({ rowLimit, runtime, databaseType });
+  sent.lambda = lambda;
+  const response = await editorState.host.engine.execute(model, lambda, {
+    abortController,
+  });
+  // rows are read by position, so the engine's columns must be the query's
+  if (response.columns.length !== schema.columns.length) {
+    throw new CubeEngineError(
+      CubeEngineErrorKind.EXECUTION,
+      `The engine returned ${response.columns.length} columns, but the query has ${schema.columns.length}`,
+      nodeId,
+    );
+  }
+  const misplaced = schema.columns.findIndex(
+    (column, position) => response.columns[position] !== column.name,
+  );
+  if (misplaced !== -1) {
+    throw new CubeEngineError(
+      CubeEngineErrorKind.EXECUTION,
+      `The engine returned the column "${response.columns[misplaced]}" at position ${misplaced + 1}, but the query has "${schema.columns[misplaced]?.name}" there`,
+      nodeId,
+    );
+  }
+  const limited = response.rows.length > rowLimit;
+  return {
+    rows: limited ? response.rows.slice(0, rowLimit) : response.rows,
+    limited,
+    sql: response.sql,
+    durationMs: response.durationMs,
+    lambda,
+  };
+};
+
+/**
+ * Runs a query up to its selected node (PLAN §8.2, §9), as Execute and the
+ * grid's fetches do (PLAN §11.10): a Drop, Slice, Limit or Distinct is written
+ * for the database it runs on (PLAN §11.4), which the model's outline gives,
+ * loaded once and waited for only then; the row limit is the emitter's
+ * `limit(rowLimit + 1)`. The engine's columns are checked against the schema,
+ * since rows are read by position. Rejects with a `CubeEngineError`, or a
+ * `CubeQueryRunAborted` when aborted before the engine is called. Each run
+ * is recorded in the Runs panel under its label with the lambda it sent,
+ * one that failed too; a stopped one isn't (PLAN §11.16).
+ */
+export const runCubeQuery = async (
+  editorState: CubeEditorState,
+  request: CubeQueryRunRequest,
+): Promise<CubeQueryRunResult> => {
+  const startedAt = Date.now();
+  const sent: { lambda?: IR } = {};
+  try {
+    const result = await runAndCheck(editorState, request, sent);
+    // a run stopped while it ran is let go of, even when it answers
+    if (!request.abortController.signal.aborted) {
+      editorState.runStats.record(request.label, result);
+    }
+    return result;
+  } catch (error) {
+    if (
+      !request.abortController.signal.aborted &&
+      !(error instanceof CubeQueryRunAborted)
+    ) {
+      editorState.runStats.record(request.label, {
+        durationMs: Date.now() - startedAt,
+        lambda: sent.lambda,
+        error:
+          error instanceof CubeEngineError
+            ? error.firstLine
+            : error instanceof Error
+              ? error.message
+              : String(error),
+      });
+    }
+    throw error;
+  }
+};

package/src/stores/CubeRunStatsState.ts

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { IR } from '@finos/legend-cube';
+import { action, makeObservable, observable } from 'mobx';
+
+/** How many of the latest runs are kept (spec §12.6) */
+export const MAX_CUBE_RUN_STATS = 15;
+
+/**
+ * One run on the engine: an Execute, a fetch of the grid's rows, an export,
+ * the Pivot editor's value load; one that failed too (PLAN §11.16)
+ */
+export interface CubeRunStat {
+  readonly id: number;
+  /** What ran, e.g. `Execute` or `Rows of SHIP_COUNTRY "France"` */
+  readonly label: string;
+  /** When it finished, in milliseconds since the epoch */
+  readonly finishedAt: number;
+  readonly durationMs: number;
+  /** The SQL statements the engine ran */
+  readonly sql: readonly string[];
+  /**
+   * The execution lambda sent, as it ran (its row limit included), for its
+   * Pure and JSON (PLAN §11.16); `undefined` when the run failed before one
+   * was written
+   */
+  readonly lambda: IR | undefined;
+  /** Why the run failed, the engine's first line; `undefined` for one that ran */
+  readonly error: string | undefined;
+}
+
+/** What a run gives to be recorded */
+export interface CubeRunRecord {
+  readonly durationMs: number;
+  readonly sql?: readonly string[] | undefined;
+  readonly lambda: IR | undefined;
+  readonly error?: string | undefined;
+}
+
+/**
+ * The latest runs of the page, newest first, at most `MAX_CUBE_RUN_STATS`
+ * (spec §12.6, PLAN §11.10): each Execute, fetch, export and Pivot value
+ * load records one, failed or not; a stopped one records nothing (PLAN
+ * §11.16). They are the page's, not the cube's, and aren't saved.
+ */
+export class CubeRunStatsState {
+  entries: readonly CubeRunStat[] = [];
+  private count = 0;
+
+  constructor() {
+    makeObservable<CubeRunStatsState, 'count'>(this, {
+      entries: observable.ref,
+      count: false,
+      record: action,
+      clear: action,
+    });
+  }
+
+  record(label: string, run: CubeRunRecord): void {
+    this.entries = [
+      {
+        id: ++this.count,
+        label,
+        finishedAt: Date.now(),
+        durationMs: run.durationMs,
+        sql: run.sql ?? [],
+        lambda: run.lambda,
+        error: run.error,
+      },
+      ...this.entries,
+    ].slice(0, MAX_CUBE_RUN_STATS);
+  }
+
+  clear(): void {
+    this.entries = [];
+  }
+}