@causa/workspace-google 1.4.0-beta.2 → 1.4.0-beta.3

package/README.md

@@ -60,7 +60,7 @@ Backfilling is supported when `google.pubSub` is set as the `events.broker`. Tem
 - As a raw URI, using the format `[[projects/<projectId>/]locations/<location>/]services/<name>/path-to-trigger`.
 - As a project-scoped trigger, using the format `<projectPath>#<triggerName>[?<options>]`. The referenced project must be of type `serviceContainer` with `google.cloudRun` as `serviceContainer.platform`. The HTTP path is read from `serviceContainer.triggers[<triggerName>].endpoint` (whose `type` must be `http`), and the `options` query string is forwarded as URL query parameters. The target Cloud Run service name defaults to `project.name`, and can be overridden by setting `google.cloudRun.eventBackfillServiceName`.
 
-When no source is specified, the default is to fetch events to backfill from the BigQuery dataset configured in `google.pubSub.bigQueryStorage`. A custom BigQuery table can also be set as source using the `bq://<projectId>.<datasetId>.<tableId>` format. It should have the `data` and `attributes` columns.
+When no source is specified, the default is to fetch events to backfill from the BigQuery dataset configured in `google.pubSub.bigQueryStorage`, once per Pub/Sub message ID. A custom BigQuery table can also be set as source using the `bq://<projectId>.<datasetId>.<tableId>` format. It should have the `data` and `attributes` columns.
 
 The Pub/Sub publish options used when backfilling can be tuned through `google.pubSub.backfillPublishOptions`, which exposes the `maxOutstandingBytes`, `maxOutstandingMessages`, `maxBytes`, `maxMessages`, and `maxMilliseconds` fields.
 
@@ -68,11 +68,13 @@ By default, project-scoped triggers send backfill events to the live Cloud Run s
 
 ### Querying
 
-This module implements the `DatabaseQueryRecords`, `ServiceContainerQueryLogs`, and `EventTopicQueryEvents` workspace functions, which expose read-only access to data stored in or emitted by deployed services:
+This module implements the `DatabaseQueryRecords`, `DatabaseCountRecords`, `ServiceContainerQueryLogs`, `EventTopicQueryEvents`, and `EventTopicCountEvents` workspace functions, which expose read-only access to data stored in or emitted by deployed services:
 
 - `DatabaseQueryRecords` is supported for the `google.spanner` and `google.firestore` engines. For Spanner, the function takes a database name and a SQL query, runs it on the configured Spanner instance, and returns the matching rows (capped to 100000). For Firestore, the query is the path to a single document, fetched from the default database (or the specified one). The document data is returned as a single-element array. An empty array is returned when the document does not exist.
+- `DatabaseCountRecords` is supported for the `google.spanner` engine. It counts the rows of the table in the schema's `googleSpannerTable` binding, in the database whose DDL creates it, or the one in the domain of the schema when several databases create a table with that name. Properties are read from the column named by their `googleSpannerColumn` extension, or from the column with the same name, and nested properties are read from JSON columns, where a value only equals a constant of the same JSON type.
 - `ServiceContainerQueryLogs` is supported when `serviceContainer.platform` is `google.cloudRun`. It queries Cloud Logging for log entries emitted by the service's Cloud Run revisions. By default, only the last hour of logs and up to 1 000 entries are returned.
-- `EventTopicQueryEvents` is supported when `events.broker` is `google.pubSub`, `events.format` is `json`, and `google.pubSub.bigQueryStorage.rawEventsDatasetId` is set. It reads events from the topic's BigQuery raw events table. Same defaults as for log queries: last hour and up to 1 000 events.
+- `EventTopicQueryEvents` is supported when `events.broker` is `google.pubSub`, `events.format` is `json`, and `google.pubSub.bigQueryStorage.rawEventsDatasetId` is set. It reads events from the topic's BigQuery raw events table, once per Pub/Sub message ID, as the BigQuery subscription may write a message several times. Same defaults as for log queries: last hour and up to 1 000 events.
+- `EventTopicCountEvents` is supported in the same cases as `EventTopicQueryEvents`. It counts the events published within the time range in the topic's BigQuery raw events table, whose `data` column should be of the `JSON` type, once per Pub/Sub message ID. A value only equals a constant of the same JSON type.
 
 ### Architecture graph
 

package/dist/functions/event-topic/count-events-bigquery.call.d.ts

@@ -0,0 +1,3 @@
+import type { RecordCounts } from '@causa/workspace-core';
+import type { EventTopicCountEventsForBigQuery } from './count-events-bigquery.js';
+export default function call(this: EventTopicCountEventsForBigQuery): Promise<RecordCounts>;

package/dist/functions/event-topic/count-events-bigquery.call.js

@@ -0,0 +1,75 @@
+import { BigQueryService } from '../../services/index.js';
+import { rawEventsTableName } from '../google-pubsub/index.js';
+/**
+ * Returns the function converting a JSON value to the type of the given value, without failing for other types.
+ *
+ * @param value The value to which the JSON value is compared.
+ * @returns The name of the BigQuery conversion function.
+ */
+function laxConversion(value) {
+    switch (typeof value) {
+        case 'string':
+            return 'LAX_STRING';
+        case 'number':
+            return 'LAX_FLOAT64';
+        case 'boolean':
+            return 'LAX_BOOL';
+    }
+}
+/**
+ * Builds the condition on the event payload, stored in the `data` JSON column, for a {@link RecordCondition}.
+ *
+ * @param condition The condition.
+ * @param addParam A function adding a parameter to the query, and returning its name.
+ * @returns The SQL condition.
+ */
+function sqlCondition(condition, addParam) {
+    const value = `data${condition.path.map((key) => `[${JSON.stringify(key)}]`).join('')}`;
+    switch (condition.operator) {
+        case 'isNull':
+            return `(${value} IS NULL OR JSON_TYPE(${value}) = 'null')`;
+        case 'isNotNull':
+            return `JSON_TYPE(${value}) != 'null'`;
+        case 'equals':
+            // The type is checked as lax conversions also convert values of other types, e.g. the string `"false"` to `FALSE`.
+            return `JSON_TYPE(${value}) = '${typeof condition.value}' AND ${laxConversion(condition.value)}(${value}) = @${addParam(condition.value)}`;
+    }
+}
+export default async function call() {
+    const googleConf = this._context.asConfiguration();
+    const projectId = googleConf.getOrThrow('google.project');
+    const rawEventsDatasetId = googleConf.getOrThrow('google.pubSub.bigQueryStorage.rawEventsDatasetId');
+    const tableId = `${projectId}.${rawEventsDatasetId}.${rawEventsTableName(this.topic)}`;
+    const names = Object.keys(this.filters);
+    const params = {
+        from: this.from.toISOString(),
+        to: this.to.toISOString(),
+    };
+    let paramCount = 0;
+    const addParam = (value) => {
+        const param = `p${paramCount++}`;
+        params[param] = value;
+        return param;
+    };
+    const counts = names.map((name, index) => {
+        const conditions = this.filters[name].map((c) => sqlCondition(c, addParam));
+        return `COUNTIF(${conditions.join(' AND ') || 'TRUE'}) AS f${index}`;
+    });
+    // Events written several times to the table by the BigQuery subscription are only counted once.
+    const query = `
+    WITH events AS (
+      SELECT data
+      FROM \`${tableId}\`
+      WHERE publish_time >= @from AND publish_time < @to
+      QUALIFY ROW_NUMBER() OVER (PARTITION BY message_id ORDER BY publish_time) = 1
+    )
+    SELECT ${['COUNT(*) AS total', ...counts].join(', ')}
+    FROM events`;
+    this._context.logger.debug(`Counting events in BigQuery:\n${query}`);
+    const bigQuery = this._context.service(BigQueryService).bigQuery;
+    const [[row]] = await bigQuery.query({ query, params });
+    return {
+        total: Number(row.total),
+        counts: Object.fromEntries(names.map((name, index) => [name, Number(row[`f${index}`])])),
+    };
+}

package/dist/functions/event-topic/count-events-bigquery.d.ts

@@ -0,0 +1,11 @@
+import { EventTopicCountEvents, type RecordCounts } from '@causa/workspace-core';
+/**
+ * Implements {@link EventTopicCountEvents} for Pub/Sub topics whose events are stored in BigQuery via a BigQuery
+ * subscription. The events are read from the dataset configured at `google.pubSub.bigQueryStorage.rawEventsDatasetId`,
+ * whose `data` column is expected to be of the `JSON` type.
+ * Events are counted once per Pub/Sub message ID, and the time range applies to their publish time.
+ */
+export declare class EventTopicCountEventsForBigQuery extends EventTopicCountEvents {
+    _call(): Promise<RecordCounts>;
+    _supports(): boolean;
+}

package/dist/functions/event-topic/count-events-bigquery.js

@@ -0,0 +1,19 @@
+import { callDeferred } from '@causa/workspace';
+import { EventTopicCountEvents, } from '@causa/workspace-core';
+/**
+ * Implements {@link EventTopicCountEvents} for Pub/Sub topics whose events are stored in BigQuery via a BigQuery
+ * subscription. The events are read from the dataset configured at `google.pubSub.bigQueryStorage.rawEventsDatasetId`,
+ * whose `data` column is expected to be of the `JSON` type.
+ * Events are counted once per Pub/Sub message ID, and the time range applies to their publish time.
+ */
+export class EventTopicCountEventsForBigQuery extends EventTopicCountEvents {
+    async _call() {
+        return await callDeferred(this, import.meta.url);
+    }
+    _supports() {
+        const conf = this._context.asConfiguration();
+        return (conf.get('events.broker') === 'google.pubSub' &&
+            conf.get('events.format') === 'json' &&
+            !!conf.get('google.pubSub.bigQueryStorage.rawEventsDatasetId'));
+    }
+}

package/dist/functions/event-topic/create-backfill-source-bigquery.call.js

@@ -34,6 +34,12 @@ export default async function call() {
     WHERE
       (${this.filter})`;
     }
+    if (!this.source) {
+        // Events written several times to the default storage by the BigQuery subscription are only backfilled once.
+        query += `
+    QUALIFY
+      ROW_NUMBER() OVER (PARTITION BY message_id ORDER BY publish_time) = 1`;
+    }
     this._context.logger.debug(`Creating BigQuery job from query '${query}'.`);
     const bigQuery = this._context.service(BigQueryService).bigQuery;
     const [job] = await bigQuery.createQueryJob(query);

package/dist/functions/event-topic/create-backfill-source-bigquery.d.ts

@@ -9,7 +9,7 @@ export declare const BIGQUERY_SOURCE_REGEX: RegExp;
  * Two cases are supported:
  * - The `source` is a `bq://<projectId>.<datasetId>.<tableId>` URI.
  * - The `source` is omitted and the broker is `google.pubSub` with `google.pubSub.bigQueryStorage.rawEventsDatasetId`
- *   configured: events are read from the default BigQuery storage for the topic.
+ *   configured: events are read from the default BigQuery storage for the topic, once per Pub/Sub message ID.
  *
  * The returned async iterable pages through the query results and yields each row as a {@link BackfillEvent}.
  */

package/dist/functions/event-topic/create-backfill-source-bigquery.js

@@ -10,7 +10,7 @@ export const BIGQUERY_SOURCE_REGEX = /^bq:\/\/(?<tableId>.+)$/;
  * Two cases are supported:
  * - The `source` is a `bq://<projectId>.<datasetId>.<tableId>` URI.
  * - The `source` is omitted and the broker is `google.pubSub` with `google.pubSub.bigQueryStorage.rawEventsDatasetId`
- *   configured: events are read from the default BigQuery storage for the topic.
+ *   configured: events are read from the default BigQuery storage for the topic, once per Pub/Sub message ID.
  *
  * The returned async iterable pages through the query results and yields each row as a {@link BackfillEvent}.
  */

package/dist/functions/event-topic/index.d.ts

@@ -8,5 +8,6 @@ export { EventTopicBrokerDeleteTriggerResourceForServiceAccount } from './broker
 export { EventTopicBrokerGetTopicIdForPubSub } from './broker-get-topic-id-pubsub.js';
 export { EventTopicBrokerPublishEventsForGoogle } from './broker-publish-events-google.js';
 export { EventTopicBrokerWaitForProcessingForPubSub } from './broker-wait-for-processing-pubsub.js';
+export { EventTopicCountEventsForBigQuery } from './count-events-bigquery.js';
 export { EventTopicCreateBackfillSourceForBigQuery } from './create-backfill-source-bigquery.js';
 export { EventTopicQueryEventsForBigQuery } from './query-events-bigquery.js';

package/dist/functions/event-topic/index.js

@@ -8,5 +8,6 @@ export { EventTopicBrokerDeleteTriggerResourceForServiceAccount } from './broker
 export { EventTopicBrokerGetTopicIdForPubSub } from './broker-get-topic-id-pubsub.js';
 export { EventTopicBrokerPublishEventsForGoogle } from './broker-publish-events-google.js';
 export { EventTopicBrokerWaitForProcessingForPubSub } from './broker-wait-for-processing-pubsub.js';
+export { EventTopicCountEventsForBigQuery } from './count-events-bigquery.js';
 export { EventTopicCreateBackfillSourceForBigQuery } from './create-backfill-source-bigquery.js';
 export { EventTopicQueryEventsForBigQuery } from './query-events-bigquery.js';

package/dist/functions/event-topic/query-events-bigquery.call.js

@@ -24,10 +24,12 @@ export default async function call() {
     if (this.filter) {
         conditions.push(`(${this.filter})`);
     }
+    // Events written several times to the table by the BigQuery subscription are only returned once.
     const query = `
     SELECT message_id, publish_time, data, attributes
     FROM \`${tableId}\`
     WHERE ${conditions.join(' AND ')}
+    QUALIFY ROW_NUMBER() OVER (PARTITION BY message_id ORDER BY publish_time) = 1
     ORDER BY publish_time ASC
     LIMIT ${limit}`;
     this._context.logger.debug(`Querying BigQuery for events:\n${query}`);

package/dist/functions/event-topic/query-events-bigquery.d.ts

@@ -2,6 +2,7 @@ import { EventTopicQueryEvents, type QueriedEvent } from '@causa/workspace-core'
 /**
  * Implements {@link EventTopicQueryEvents} for Pub/Sub topics whose events are stored in BigQuery via a BigQuery
  * subscription. The events are read from the dataset configured at `google.pubSub.bigQueryStorage.rawEventsDatasetId`.
+ * Events are returned once per Pub/Sub message ID.
  */
 export declare class EventTopicQueryEventsForBigQuery extends EventTopicQueryEvents {
     _call(): Promise<QueriedEvent[]>;

package/dist/functions/event-topic/query-events-bigquery.js

@@ -3,6 +3,7 @@ import { EventTopicQueryEvents, } from '@causa/workspace-core';
 /**
  * Implements {@link EventTopicQueryEvents} for Pub/Sub topics whose events are stored in BigQuery via a BigQuery
  * subscription. The events are read from the dataset configured at `google.pubSub.bigQueryStorage.rawEventsDatasetId`.
+ * Events are returned once per Pub/Sub message ID.
  */
 export class EventTopicQueryEventsForBigQuery extends EventTopicQueryEvents {
     async _call() {

package/dist/functions/google-spanner/count-records.call.d.ts

@@ -0,0 +1,16 @@
+import type { ObjectSchema, RecordCondition, RecordCounts } from '@causa/workspace-core';
+import type { DatabaseCountRecordsForSpanner } from './count-records.js';
+/**
+ * Builds the SQL query counting the rows of a table, and those matching each filter.
+ *
+ * @param table The name of the table.
+ * @param schema The schema persisted in the table.
+ * @param filters The conditions of each filter, in order.
+ * @returns The SQL query and its parameters. The counts are returned in the `total` column, and the `f<index>` column
+ *   for each filter.
+ */
+export declare function buildCountQuery(table: string, schema: ObjectSchema, filters: RecordCondition[][]): {
+    sql: string;
+    params: Record<string, string | number | boolean>;
+};
+export default function call(this: DatabaseCountRecordsForSpanner): Promise<RecordCounts>;

package/dist/functions/google-spanner/count-records.call.js

@@ -0,0 +1,120 @@
+import { splitSchemaPath } from '@causa/workspace-core/jsonschema';
+import { Spanner } from '@google-cloud/spanner';
+import { GoogleSpannerListDatabases } from './list-databases.js';
+import { SPANNER_ENGINE } from './query-records.js';
+import { resolveSpannerTable } from './resolve-table.js';
+/**
+ * Finds the database whose DDL creates a table, using {@link resolveSpannerTable}.
+ *
+ * @param context The {@link WorkspaceContext}.
+ * @param table The name of the table.
+ * @param schema The schema persisted in the table.
+ * @returns The ID of the database.
+ */
+async function findDatabase(context, table, schema) {
+    const [databases, domainPaths] = await Promise.all([
+        context.call(GoogleSpannerListDatabases, {}),
+        context.listDomainPaths(),
+    ]);
+    const { file } = splitSchemaPath(schema.path);
+    const resolution = resolveSpannerTable(databases, table, file, domainPaths);
+    switch (resolution.kind) {
+        case 'resolved':
+            return resolution.database.id;
+        case 'missing':
+            throw new Error(`No Spanner DDL creates the table '${table}'.`);
+        case 'ambiguous':
+            throw new Error(`The table '${table}' is created in several Spanner databases: ${resolution.candidates
+                .map(({ id }) => `'${id}'`)
+                .join(', ')}.`);
+    }
+}
+/**
+ * Returns the SQL expression reading the value at a path in the records of a schema.
+ *
+ * @param schema The schema persisted in the table.
+ * @param path The names of the properties leading to the value.
+ * @returns The SQL expression, and the JSON value when it reads a nested value from a JSON column.
+ */
+function valueExpression(schema, path) {
+    const [name, ...nested] = path;
+    const property = schema.properties.find((p) => p.name === name);
+    if (!property) {
+        throw new Error(`'${name}' is not a property of '${schema.name}'.`);
+    }
+    const columnExtension = property.extensions.googleSpannerColumn;
+    const column = typeof columnExtension?.name === 'string' ? columnExtension.name : name;
+    const expression = `\`${column}\``;
+    if (nested.length === 0) {
+        return { expression };
+    }
+    const json = `${expression}${nested.map((key) => `[${JSON.stringify(key)}]`).join('')}`;
+    return { expression: `JSON_VALUE(${json})`, json };
+}
+/**
+ * Builds the SQL query counting the rows of a table, and those matching each filter.
+ *
+ * @param table The name of the table.
+ * @param schema The schema persisted in the table.
+ * @param filters The conditions of each filter, in order.
+ * @returns The SQL query and its parameters. The counts are returned in the `total` column, and the `f<index>` column
+ *   for each filter.
+ */
+export function buildCountQuery(table, schema, filters) {
+    const params = {};
+    const condition = (c) => {
+        const { expression, json } = valueExpression(schema, c.path);
+        if (c.operator !== 'equals') {
+            return `${expression} ${c.operator === 'isNull' ? 'IS NULL' : 'IS NOT NULL'}`;
+        }
+        const param = `p${Object.keys(params).length}`;
+        if (!json) {
+            params[param] = c.value;
+            return `${expression} = @${param}`;
+        }
+        // Nested values are read as strings from JSON columns, and only match values of the same JSON type.
+        const type = `JSON_TYPE(${json}) = '${typeof c.value}'`;
+        if (typeof c.value === 'number') {
+            params[param] = c.value;
+            return `${type} AND SAFE_CAST(${expression} AS FLOAT64) = @${param}`;
+        }
+        params[param] = String(c.value);
+        return `${type} AND ${expression} = @${param}`;
+    };
+    const counts = filters.map((conditions, index) => `COUNTIF(${conditions.map(condition).join(' AND ') || 'TRUE'}) AS f${index}`);
+    const sql = `SELECT ${['COUNT(*) AS total', ...counts].join(', ')} FROM \`${table}\``;
+    return { sql, params };
+}
+export default async function call() {
+    const table = this.schema.databases.find((d) => d.engine === SPANNER_ENGINE)?.table;
+    if (!table) {
+        throw new Error(`The schema '${this.schema.name}' is not persisted in a Spanner table.`);
+    }
+    const names = Object.keys(this.filters);
+    const { sql, params } = buildCountQuery(table, this.schema, names.map((n) => this.filters[n]));
+    const databaseId = await findDatabase(this._context, table, this.schema);
+    const googleConf = this._context.asConfiguration();
+    const projectId = googleConf.getOrThrow('google.project');
+    const instanceName = googleConf.getOrThrow('google.spanner.instance.name');
+    this._context.logger.debug(`🗃️ Counting rows in Spanner database '${databaseId}' in instance '${instanceName}' (project '${projectId}'):\n${sql}`);
+    const spanner = new Spanner({ projectId });
+    let database;
+    try {
+        database = spanner.instance(instanceName).database(databaseId);
+        const [rows] = await database.run({
+            sql,
+            params,
+            json: true,
+            jsonOptions: { wrapNumbers: false },
+        });
+        const row = rows[0];
+        return {
+            total: Number(row.total),
+            counts: Object.fromEntries(names.map((name, index) => [name, Number(row[`f${index}`])])),
+        };
+    }
+    finally {
+        await database?.close();
+        spanner.close();
+    }
+}

package/dist/functions/google-spanner/count-records.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseCountRecords, type RecordCounts } from '@causa/workspace-core';
+/**
+ * Implements {@link DatabaseCountRecords} for Spanner databases.
+ *
+ * The table is the one in the schema's `google.spanner` binding, in the database whose DDL creates it. When several
+ * databases create a table with that name, the one in the domain of the schema is chosen. The Spanner instance and GCP
+ * project are read from the workspace configuration.
+ *
+ * Properties are read from the column named by their `googleSpannerColumn` extension, or from the column with the same
+ * name. Nested properties are read from JSON columns.
+ */
+export declare class DatabaseCountRecordsForSpanner extends DatabaseCountRecords {
+    _call(): Promise<RecordCounts>;
+    _supports(): boolean;
+}

package/dist/functions/google-spanner/count-records.js

@@ -0,0 +1,21 @@
+import { callDeferred } from '@causa/workspace';
+import { DatabaseCountRecords } from '@causa/workspace-core';
+import { SPANNER_ENGINE } from './query-records.js';
+/**
+ * Implements {@link DatabaseCountRecords} for Spanner databases.
+ *
+ * The table is the one in the schema's `google.spanner` binding, in the database whose DDL creates it. When several
+ * databases create a table with that name, the one in the domain of the schema is chosen. The Spanner instance and GCP
+ * project are read from the workspace configuration.
+ *
+ * Properties are read from the column named by their `googleSpannerColumn` extension, or from the column with the same
+ * name. Nested properties are read from JSON columns.
+ */
+export class DatabaseCountRecordsForSpanner extends DatabaseCountRecords {
+    async _call() {
+        return await callDeferred(this, import.meta.url);
+    }
+    _supports() {
+        return this.engine === SPANNER_ENGINE;
+    }
+}

package/dist/functions/google-spanner/index.d.ts

@@ -1,5 +1,7 @@
+export { DatabaseCountRecordsForSpanner } from './count-records.js';
 export { ModelSchemaExtractDatabaseForGoogleSpanner } from './extract-database.js';
 export { ModelGenerateTypeScriptDecoratorsForGoogleSpanner } from './generate-typescript-decorators.js';
-export { GoogleSpannerListDatabases } from './list-databases.js';
+export { GoogleSpannerListDatabases, type SpannerDatabase, type SpannerTable, } from './list-databases.js';
 export { DatabaseQueryRecordsForSpanner } from './query-records.js';
+export { resolveSpannerTable, type SpannerTableResolution, } from './resolve-table.js';
 export { GoogleSpannerWriteDatabases } from './write-databases.js';

package/dist/functions/google-spanner/index.js

@@ -1,5 +1,7 @@
+export { DatabaseCountRecordsForSpanner } from './count-records.js';
 export { ModelSchemaExtractDatabaseForGoogleSpanner } from './extract-database.js';
 export { ModelGenerateTypeScriptDecoratorsForGoogleSpanner } from './generate-typescript-decorators.js';
-export { GoogleSpannerListDatabases } from './list-databases.js';
+export { GoogleSpannerListDatabases, } from './list-databases.js';
 export { DatabaseQueryRecordsForSpanner } from './query-records.js';
+export { resolveSpannerTable, } from './resolve-table.js';
 export { GoogleSpannerWriteDatabases } from './write-databases.js';

package/dist/functions/google-spanner/list-databases.d.ts

@@ -1,4 +1,21 @@
 import { WorkspaceFunction } from '@causa/workspace';
+/**
+ * A table created by a `CREATE TABLE` statement in a Spanner DDL file.
+ */
+export type SpannerTable = {
+    /**
+     * The name of the table.
+     */
+    readonly name: string;
+    /**
+     * The absolute path of the DDL file creating the table.
+     */
+    readonly file: string;
+    /**
+     * The line of the statement in the file.
+     */
+    readonly line: number;
+};
 /**
  * The definition of a Spanner database with its DDL statements.
  */
@@ -15,6 +32,10 @@ export type SpannerDatabase = {
      * The DDL statements for the database.
      */
     ddls: string[];
+    /**
+     * The tables created by the `CREATE TABLE` statements of the DDL files.
+     */
+    tables: SpannerTable[];
 };
 /**
  * A function that lists Spanner databases defined in the workspace, and returns their corresponding DDLs.
@@ -26,7 +47,7 @@ export declare class GoogleSpannerListDatabases extends WorkspaceFunction<Promis
      * End-of-the-line comments are removed, and statements are split using semicolons.
      *
      * @param path The path to the SQL file containing DDL statements.
-     * @returns The list of DDL statements.
+     * @returns The list of DDL statements, along with the file and the line at which each statement starts.
      */
     private parseDdlFile;
     _supports(): boolean;

package/dist/functions/google-spanner/list-databases.js

@@ -1,5 +1,9 @@
 import { WorkspaceFunction, listFilesAndFormat } from '@causa/workspace';
 import { readFile } from 'fs/promises';
+/**
+ * Matches a `CREATE TABLE` DDL statement, capturing the name of the table.
+ */
+const CREATE_TABLE_REGEX = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"']?([A-Za-z_]\w*)/i;
 /**
  * The default format used to infer the ID / name of the database from the format parts.
  */
@@ -33,10 +37,14 @@ export class GoogleSpannerListDatabases extends WorkspaceFunction {
         }, {});
         return await Promise.all(Object.entries(databaseDdlFiles).map(async ([id, ddlFiles]) => {
             ddlFiles.sort();
-            const ddlsInFiles = await Promise.all(ddlFiles.map((ddlFile) => this.parseDdlFile(ddlFile)));
-            const ddls = ddlsInFiles.flatMap((ddls) => ddls);
+            const statements = (await Promise.all(ddlFiles.map((ddlFile) => this.parseDdlFile(ddlFile)))).flat();
+            const ddls = statements.map(({ statement }) => statement);
+            const tables = statements.flatMap(({ statement, file, line }) => {
+                const name = statement.match(CREATE_TABLE_REGEX)?.[1];
+                return name ? [{ name, file, line }] : [];
+            });
             this._context.logger.debug(`🗃️ Found Spanner database '${id}' with ${ddlFiles.length} DDL file(s) and ${ddls.length} statement(s).`);
-            return { id, ddlFiles, ddls };
+            return { id, ddlFiles, ddls, tables };
         }));
     }
     /**
@@ -44,21 +52,25 @@ export class GoogleSpannerListDatabases extends WorkspaceFunction {
      * End-of-the-line comments are removed, and statements are split using semicolons.
      *
      * @param path The path to the SQL file containing DDL statements.
-     * @returns The list of DDL statements.
+     * @returns The list of DDL statements, along with the file and the line at which each statement starts.
      */
     async parseDdlFile(path) {
         const rawFile = (await readFile(path)).toString();
-        return (rawFile
-            // Removing comments using the `-- My comment until the end of the line` syntax.
-            .replace(/--.*$/gm, '')
-            // Trimming lines for readability in logs, and joining them to easily split into statements.
-            .split('\n')
-            .map((statement) => statement.trim())
-            .join(' ')
-            // Splitting the SQL statements.
-            .split(';')
-            // Trimming for readability in logs.
-            .map((statement) => statement.trim()));
+        // Removing comments using the `-- My comment until the end of the line` syntax, which preserves line numbers.
+        const withoutComments = rawFile.replace(/--.*$/gm, '');
+        let line = 1;
+        return withoutComments.split(';').map((rawStatement) => {
+            const leadingWhitespace = rawStatement.match(/^\s*/)[0];
+            const startLine = line + leadingWhitespace.split('\n').length - 1;
+            line += rawStatement.split('\n').length - 1;
+            const statement = rawStatement
+                // Trimming lines for readability in logs, and joining them into a single line.
+                .split('\n')
+                .map((statementLine) => statementLine.trim())
+                .join(' ')
+                .trim();
+            return { statement, file: path, line: startLine };
+        });
     }
     _supports() {
         return true;

package/dist/functions/google-spanner/resolve-table.d.ts

@@ -0,0 +1,25 @@
+import type { SpannerDatabase, SpannerTable } from './list-databases.js';
+/**
+ * The resolution of a table name to the database whose DDL creates it.
+ */
+export type SpannerTableResolution<D extends SpannerDatabase = SpannerDatabase> = {
+    readonly kind: 'resolved';
+    readonly database: D;
+    readonly table: SpannerTable;
+} | {
+    readonly kind: 'ambiguous';
+    readonly candidates: D[];
+} | {
+    readonly kind: 'missing';
+};
+/**
+ * Resolves a table name to the database whose DDL creates it. When several databases create a table with that name, the
+ * one with DDL files in the domain of the schema is chosen.
+ *
+ * @param databases The Spanner databases, as listed by `GoogleSpannerListDatabases`.
+ * @param table The name of the table.
+ * @param schemaFile The absolute path of the file declaring the schema persisted in the table.
+ * @param domainPaths The absolute paths of the domains of the workspace.
+ * @returns The resolution.
+ */
+export declare function resolveSpannerTable<D extends SpannerDatabase>(databases: readonly D[], table: string, schemaFile: string, domainPaths: readonly string[]): SpannerTableResolution<D>;

package/dist/functions/google-spanner/resolve-table.js

@@ -0,0 +1,44 @@
+import { sep } from 'path';
+/**
+ * Returns the deepest domain containing a path.
+ *
+ * @param domainPaths The absolute paths of the domains.
+ * @param path The absolute path.
+ * @returns The absolute path of the domain, or `undefined` if the path is not part of a domain.
+ */
+function domainOf(domainPaths, path) {
+    return domainPaths
+        .filter((domain) => path.startsWith(`${domain}${sep}`))
+        .sort((a, b) => b.length - a.length)[0];
+}
+/**
+ * Resolves a table name to the database whose DDL creates it. When several databases create a table with that name, the
+ * one with DDL files in the domain of the schema is chosen.
+ *
+ * @param databases The Spanner databases, as listed by `GoogleSpannerListDatabases`.
+ * @param table The name of the table.
+ * @param schemaFile The absolute path of the file declaring the schema persisted in the table.
+ * @param domainPaths The absolute paths of the domains of the workspace.
+ * @returns The resolution.
+ */
+export function resolveSpannerTable(databases, table, schemaFile, domainPaths) {
+    const candidates = databases.filter((d) => d.tables.some((t) => t.name === table));
+    const pick = (database) => ({
+        kind: 'resolved',
+        database,
+        table: database.tables.find((t) => t.name === table),
+    });
+    if (candidates.length === 1) {
+        return pick(candidates[0]);
+    }
+    if (candidates.length === 0) {
+        return { kind: 'missing' };
+    }
+    const domain = domainOf(domainPaths, schemaFile);
+    const inDomain = domain
+        ? candidates.filter(({ ddlFiles }) => ddlFiles.some((f) => domainOf(domainPaths, f) === domain))
+        : [];
+    return inDomain.length === 1
+        ? pick(inDomain[0])
+        : { kind: 'ambiguous', candidates };
+}

package/dist/functions/index.js

@@ -1,18 +1,18 @@
 import { CausaListConfigurationSchemasForGoogle } from './causa/index.js';
 import { EmulatorStartForFirebaseStorage, EmulatorStartForFirestore, EmulatorStartForIdentityPlatform, EmulatorStartForPubSub, EmulatorStartForSpanner, EmulatorStopForFirebaseStorage, EmulatorStopForFirestore, EmulatorStopForIdentityPlatform, EmulatorStopForPubSub, EmulatorStopForSpanner, } from './emulator/index.js';
-import { EventTopicBrokerCreateTopicForPubSub, EventTopicBrokerCreateTriggerForCloudRun, EventTopicBrokerDeleteTopicForPubSub, EventTopicBrokerDeleteTriggerResourceForCloudRunInvokerRole, EventTopicBrokerDeleteTriggerResourceForCloudRunService, EventTopicBrokerDeleteTriggerResourceForPubSubSubscription, EventTopicBrokerDeleteTriggerResourceForServiceAccount, EventTopicBrokerGetTopicIdForPubSub, EventTopicBrokerPublishEventsForGoogle, EventTopicBrokerWaitForProcessingForPubSub, EventTopicCreateBackfillSourceForBigQuery, EventTopicQueryEventsForBigQuery, } from './event-topic/index.js';
+import { EventTopicBrokerCreateTopicForPubSub, EventTopicBrokerCreateTriggerForCloudRun, EventTopicBrokerDeleteTopicForPubSub, EventTopicBrokerDeleteTriggerResourceForCloudRunInvokerRole, EventTopicBrokerDeleteTriggerResourceForCloudRunService, EventTopicBrokerDeleteTriggerResourceForPubSubSubscription, EventTopicBrokerDeleteTriggerResourceForServiceAccount, EventTopicBrokerGetTopicIdForPubSub, EventTopicBrokerPublishEventsForGoogle, EventTopicBrokerWaitForProcessingForPubSub, EventTopicCountEventsForBigQuery, EventTopicCreateBackfillSourceForBigQuery, EventTopicQueryEventsForBigQuery, } from './event-topic/index.js';
 import { GoogleAppCheckGenerateToken } from './google-app-check/index.js';
 import { GoogleFirebaseStorageMergeRules } from './google-firebase-storage/index.js';
 import { DatabaseQueryRecordsForFirestore, GoogleFirestoreMergeRules, ModelGenerateTypeScriptDecoratorsForGoogleFirestore, ModelSchemaExtractDatabaseForGoogleFirestore, } from './google-firestore/index.js';
 import { GoogleIdentityPlatformGenerateCustomToken, GoogleIdentityPlatformGenerateToken, } from './google-identity-platform/index.js';
 import { GooglePubSubWriteTopics } from './google-pubsub/index.js';
 import { GoogleServicesEnable } from './google-services/index.js';
-import { DatabaseQueryRecordsForSpanner, GoogleSpannerListDatabases, GoogleSpannerWriteDatabases, ModelGenerateTypeScriptDecoratorsForGoogleSpanner, ModelSchemaExtractDatabaseForGoogleSpanner, } from './google-spanner/index.js';
+import { DatabaseCountRecordsForSpanner, DatabaseQueryRecordsForSpanner, GoogleSpannerListDatabases, GoogleSpannerWriteDatabases, ModelGenerateTypeScriptDecoratorsForGoogleSpanner, ModelSchemaExtractDatabaseForGoogleSpanner, } from './google-spanner/index.js';
 import { GraphFetchEnvironmentMetricSeriesForGoogle, GraphGetEnvironmentProviderForGoogle, GraphListRulesForGoogle, } from './graph/index.js';
 import { ProjectGetArtefactDestinationForCloudFunctions, ProjectGetArtefactDestinationForCloudRun, ProjectPushArtefactForCloudFunctions, } from './project/index.js';
 import { SecretFetchForGoogleAccessToken, SecretFetchForGoogleSecretManager, } from './secret/index.js';
 import { ServiceContainerQueryLogsForCloudRun } from './service-container/index.js';
 import { ModelGenerateTypeScriptTriggerDecoratorsForGoogle } from './typescript/index.js';
 export function registerFunctions(context) {
-    context.registerFunctionImplementations(CausaListConfigurationSchemasForGoogle, DatabaseQueryRecordsForFirestore, DatabaseQueryRecordsForSpanner, EmulatorStartForFirebaseStorage, EmulatorStartForFirestore, EmulatorStartForIdentityPlatform, EmulatorStartForPubSub, EmulatorStartForSpanner, EmulatorStopForFirebaseStorage, EmulatorStopForFirestore, EmulatorStopForIdentityPlatform, EmulatorStopForPubSub, EmulatorStopForSpanner, EventTopicBrokerCreateTopicForPubSub, EventTopicBrokerCreateTriggerForCloudRun, EventTopicBrokerDeleteTopicForPubSub, EventTopicBrokerDeleteTriggerResourceForCloudRunInvokerRole, EventTopicBrokerDeleteTriggerResourceForCloudRunService, EventTopicBrokerDeleteTriggerResourceForPubSubSubscription, EventTopicBrokerDeleteTriggerResourceForServiceAccount, EventTopicBrokerGetTopicIdForPubSub, EventTopicBrokerPublishEventsForGoogle, EventTopicBrokerWaitForProcessingForPubSub, EventTopicCreateBackfillSourceForBigQuery, EventTopicQueryEventsForBigQuery, GoogleAppCheckGenerateToken, GoogleFirebaseStorageMergeRules, GoogleFirestoreMergeRules, GoogleIdentityPlatformGenerateCustomToken, GoogleIdentityPlatformGenerateToken, GooglePubSubWriteTopics, GoogleServicesEnable, GoogleSpannerListDatabases, GoogleSpannerWriteDatabases, GraphFetchEnvironmentMetricSeriesForGoogle, GraphGetEnvironmentProviderForGoogle, GraphListRulesForGoogle, ModelGenerateTypeScriptDecoratorsForGoogleFirestore, ModelGenerateTypeScriptDecoratorsForGoogleSpanner, ModelGenerateTypeScriptTriggerDecoratorsForGoogle, ModelSchemaExtractDatabaseForGoogleFirestore, ModelSchemaExtractDatabaseForGoogleSpanner, ProjectGetArtefactDestinationForCloudFunctions, ProjectGetArtefactDestinationForCloudRun, ProjectPushArtefactForCloudFunctions, SecretFetchForGoogleAccessToken, SecretFetchForGoogleSecretManager, ServiceContainerQueryLogsForCloudRun);
+    context.registerFunctionImplementations(CausaListConfigurationSchemasForGoogle, DatabaseCountRecordsForSpanner, DatabaseQueryRecordsForFirestore, DatabaseQueryRecordsForSpanner, EmulatorStartForFirebaseStorage, EmulatorStartForFirestore, EmulatorStartForIdentityPlatform, EmulatorStartForPubSub, EmulatorStartForSpanner, EmulatorStopForFirebaseStorage, EmulatorStopForFirestore, EmulatorStopForIdentityPlatform, EmulatorStopForPubSub, EmulatorStopForSpanner, EventTopicBrokerCreateTopicForPubSub, EventTopicBrokerCreateTriggerForCloudRun, EventTopicBrokerDeleteTopicForPubSub, EventTopicBrokerDeleteTriggerResourceForCloudRunInvokerRole, EventTopicBrokerDeleteTriggerResourceForCloudRunService, EventTopicBrokerDeleteTriggerResourceForPubSubSubscription, EventTopicBrokerDeleteTriggerResourceForServiceAccount, EventTopicBrokerGetTopicIdForPubSub, EventTopicBrokerPublishEventsForGoogle, EventTopicBrokerWaitForProcessingForPubSub, EventTopicCountEventsForBigQuery, EventTopicCreateBackfillSourceForBigQuery, EventTopicQueryEventsForBigQuery, GoogleAppCheckGenerateToken, GoogleFirebaseStorageMergeRules, GoogleFirestoreMergeRules, GoogleIdentityPlatformGenerateCustomToken, GoogleIdentityPlatformGenerateToken, GooglePubSubWriteTopics, GoogleServicesEnable, GoogleSpannerListDatabases, GoogleSpannerWriteDatabases, GraphFetchEnvironmentMetricSeriesForGoogle, GraphGetEnvironmentProviderForGoogle, GraphListRulesForGoogle, ModelGenerateTypeScriptDecoratorsForGoogleFirestore, ModelGenerateTypeScriptDecoratorsForGoogleSpanner, ModelGenerateTypeScriptTriggerDecoratorsForGoogle, ModelSchemaExtractDatabaseForGoogleFirestore, ModelSchemaExtractDatabaseForGoogleSpanner, ProjectGetArtefactDestinationForCloudFunctions, ProjectGetArtefactDestinationForCloudRun, ProjectPushArtefactForCloudFunctions, SecretFetchForGoogleAccessToken, SecretFetchForGoogleSecretManager, ServiceContainerQueryLogsForCloudRun);
 }

package/dist/graph/rules/configuration/service-container.js

@@ -1,7 +1,7 @@
 import { GraphOriginKind, } from '@causa/workspace-core';
 import { DomainsFact, ModelFact, projectId, ProjectsFact, topicId, triggerId, } from '@causa/workspace-core/graph';
 import { FIRESTORE_ENGINE, firestoreCollectionPath, SPANNER_ENGINE, } from '../../ids.js';
-import { ddlSource, resolveSpannerTable, SpannerFact } from '../../spanner.js';
+import { ddlSource, resolveEntitySpannerTable, SpannerFact, } from '../../spanner.js';
 /**
  * The elements declared by the Google-specific parts of the `serviceContainer` configuration of every service container
  * project.
@@ -18,7 +18,7 @@ export const googleServiceContainerFromConfiguration = {
     kind: GraphOriginKind.Declared,
     description: 'One `delivers` edge from a topic to each trigger of type `google.pubSub` naming it, when an event schema defines the topic. One `accesses` edge from a project to each entity persisted in a Spanner database or a Firestore collection listed in its `serviceContainer.outputs`.',
     async run(graph) {
-        const { locator } = graph;
+        const { locator, context } = graph;
         const [domains, projects, model, spanner] = await Promise.all([
             graph.get(DomainsFact),
             graph.get(ProjectsFact),
@@ -29,7 +29,7 @@ export const googleServiceContainerFromConfiguration = {
         const warnings = [];
         const entities = [...model.entities.values()];
         const spannerEntities = entities.flatMap((entity) => {
-            const resolution = resolveSpannerTable(spanner, entity, domains);
+            const resolution = resolveEntitySpannerTable(spanner, entity, domains);
             return resolution?.kind === 'resolved' ? [{ entity, resolution }] : [];
         });
         for (const project of projects.filter((p) => p.type === 'serviceContainer')) {
@@ -78,7 +78,7 @@ export const googleServiceContainerFromConfiguration = {
                         type: 'accesses',
                         from: projectId(project.directory),
                         to: entity.id,
-                        sources: [source, ddlSource(resolution.table)],
+                        sources: [source, ddlSource(context.rootPath, resolution.table)],
                     });
                 }
             }

package/dist/graph/rules/terraform/spanner-databases.js

@@ -2,7 +2,7 @@ import { GraphOriginKind, } from '@causa/workspace-core';
 import { databaseId, tableId, tableLocator, DomainsFact, ModelFact, nodeId, } from '@causa/workspace-core/graph';
 import { terraformDeploys } from '@causa/workspace-terraform';
 import { SPANNER_ENGINE, spannerInstanceId } from '../../ids.js';
-import { ddlSource, resolveSpannerTable, SpannerFact } from '../../spanner.js';
+import { ddlSource, resolveEntitySpannerTable, SpannerFact, } from '../../spanner.js';
 import { blockResource, infrastructureModules, argumentOrConfiguration, } from '../../terraform-modules.js';
 /**
  * The source of the Causa Terraform module creating the Spanner instance and databases.
@@ -135,13 +135,13 @@ export const spannerDatabasesModule = {
                     locator: nodeLocator,
                     parent: databaseId(database.locator),
                     name: table.name,
-                    sources: [ddlSource(table), ...blocks],
+                    sources: [ddlSource(context.rootPath, table), ...blocks],
                 });
                 edges.push(...spannerDatabases.flatMap((module) => terraformDeploys(module.block, nodeId('table', nodeLocator))));
             }
         }
         for (const entity of model.entities.values()) {
-            const resolution = resolveSpannerTable(spanner, entity, domains);
+            const resolution = resolveEntitySpannerTable(spanner, entity, domains);
             if (!resolution) {
                 continue;
             }
@@ -172,7 +172,7 @@ export const spannerDatabasesModule = {
                 type: 'realizes',
                 from: tableId(resolution.database.locator, resolution.table.name),
                 to: entity.id,
-                sources: [binding, ddlSource(resolution.table)],
+                sources: [binding, ddlSource(context.rootPath, resolution.table)],
             });
         }
         return { nodes, edges, warnings };

package/dist/graph/spanner.d.ts

@@ -1,30 +1,10 @@
 import type { GraphOriginSource } from '@causa/workspace-core';
 import { GraphExtractionFact, type EntityFacts, type GraphContext, type GraphFactOutput, type WorkspaceDomain } from '@causa/workspace-core/graph';
+import { type SpannerDatabase, type SpannerTable, type SpannerTableResolution } from '../functions/google-spanner/index.js';
 /**
- * A table created by a `CREATE TABLE` statement in a Spanner DDL file.
+ * A Spanner database of the workspace, as `GoogleSpannerListDatabases` lists it, and its graph identifiers.
  */
-export type SpannerTable = {
-    /**
-     * The name of the table.
-     */
-    readonly name: string;
-    /**
-     * The DDL file declaring the table, relative to the workspace root.
-     */
-    readonly file: string;
-    /**
-     * The line of the statement in the file.
-     */
-    readonly line: number;
-};
-/**
- * A Spanner database of the workspace, and the tables its DDL files create.
- */
-export type SpannerDatabaseFacts = {
-    /**
-     * The ID of the database, as `GoogleSpannerListDatabases` returns it.
-     */
-    readonly id: string;
+export type SpannerDatabaseFacts = SpannerDatabase & {
     /**
      * The name of the database within its engine, `<instance>.<database>`, as `outputs['google.spanner']` lists it.
      */
@@ -37,14 +17,6 @@ export type SpannerDatabaseFacts = {
      * The directory holding the DDL files, relative to the workspace root.
      */
     readonly directory: string;
-    /**
-     * The domain the DDL files belong to.
-     */
-    readonly domain: WorkspaceDomain | undefined;
-    /**
-     * The tables created by the DDL files.
-     */
-    readonly tables: SpannerTable[];
 };
 /**
  * The Spanner databases of the workspace.
@@ -60,47 +32,26 @@ export type SpannerFacts = {
     readonly databases: SpannerDatabaseFacts[];
 };
 /**
- * The Spanner databases of the workspace, as `GoogleSpannerListDatabases` lists them, and the tables their DDL files
- * create.
+ * The Spanner databases of the workspace, as `GoogleSpannerListDatabases` lists them.
  */
 export declare class SpannerFact extends GraphExtractionFact<SpannerFacts> {
     compute(graph: GraphContext): Promise<GraphFactOutput<SpannerFacts>>;
-    /**
-     * Parses the tables created by the `CREATE TABLE` statements of DDL files.
-     *
-     * @param context The workspace context.
-     * @param files The DDL files, relative to the workspace root.
-     * @returns The tables, in the order of the files and statements.
-     */
-    private parseTables;
 }
 /**
- * The resolution of an entity's Spanner binding to a table.
- */
-export type SpannerTableResolution = {
-    readonly kind: 'resolved';
-    readonly database: SpannerDatabaseFacts;
-    readonly table: SpannerTable;
-} | {
-    readonly kind: 'ambiguous';
-    readonly candidates: SpannerDatabaseFacts[];
-} | {
-    readonly kind: 'missing';
-};
-/**
- * Resolves the Spanner binding of an entity to the database whose DDL creates a table of that name. When several
- * databases declare the name, the one in the entity's domain is chosen.
+ * Resolves the Spanner binding of an entity to the database whose DDL creates a table of that name, using
+ * {@link resolveSpannerTable}.
  *
  * @param spanner The Spanner databases.
  * @param entity The entity.
  * @param domains The domains of the workspace, in which the domain of the entity is looked up.
  * @returns The resolution, or `undefined` if the entity is not persisted in Spanner.
  */
-export declare function resolveSpannerTable(spanner: SpannerFacts, entity: EntityFacts, domains: readonly WorkspaceDomain[]): SpannerTableResolution | undefined;
+export declare function resolveEntitySpannerTable(spanner: SpannerFacts, entity: EntityFacts, domains: readonly WorkspaceDomain[]): SpannerTableResolution<SpannerDatabaseFacts> | undefined;
 /**
  * Returns the origin source of a `CREATE TABLE` statement.
  *
+ * @param rootPath The absolute path of the workspace root.
  * @param table The table.
  * @returns The origin source.
  */
-export declare function ddlSource(table: SpannerTable): GraphOriginSource;
+export declare function ddlSource(rootPath: string, table: SpannerTable): GraphOriginSource;

package/dist/graph/spanner.js

@@ -1,11 +1,10 @@
-import { domainAt, domainOfFile, DomainsFact, GraphExtractionFact, } from '@causa/workspace-core/graph';
-import { readFile } from 'fs/promises';
-import { dirname, join, relative } from 'path';
-import { GoogleSpannerListDatabases } from '../functions/google-spanner/index.js';
+import { GraphExtractionFact, } from '@causa/workspace-core/graph';
+import { splitSchemaPath } from '@causa/workspace-core/jsonschema';
+import { dirname, relative } from 'path';
+import { GoogleSpannerListDatabases, resolveSpannerTable, } from '../functions/google-spanner/index.js';
 import { SPANNER_ENGINE, spannerDatabaseLocator, spannerDatabaseName, } from './ids.js';
 /**
- * The Spanner databases of the workspace, as `GoogleSpannerListDatabases` lists them, and the tables their DDL files
- * create.
+ * The Spanner databases of the workspace, as `GoogleSpannerListDatabases` lists them.
  */
 export class SpannerFact extends GraphExtractionFact {
     async compute(graph) {
@@ -13,23 +12,16 @@ export class SpannerFact extends GraphExtractionFact {
         const instance = context
             .asConfiguration()
             .get('google.spanner.instance.name');
-        const [listed, domains] = await Promise.all([
-            context.call(GoogleSpannerListDatabases, {}),
-            graph.get(DomainsFact),
-        ]);
-        const databases = await Promise.all(listed.map(async ({ id, ddlFiles }) => {
-            const files = ddlFiles.map((f) => relative(context.rootPath, f)).sort();
-            const tables = await this.parseTables(context, files);
-            const directory = files[0] ? dirname(files[0]) : '';
+        const listed = await context.call(GoogleSpannerListDatabases, {});
+        const databases = listed.map((database) => {
+            const [file] = database.ddlFiles;
             return {
-                id,
-                name: spannerDatabaseName(instance ?? '', id),
-                locator: spannerDatabaseLocator(instance ?? '', id),
-                directory,
-                domain: directory ? domainAt(domains, directory) : undefined,
-                tables,
+                ...database,
+                name: spannerDatabaseName(instance ?? '', database.id),
+                locator: spannerDatabaseLocator(instance ?? '', database.id),
+                directory: file ? dirname(relative(context.rootPath, file)) : '',
             };
-        }));
+        });
         databases.sort((a, b) => a.id.localeCompare(b.id));
         const warnings = [];
         for (const database of databases) {
@@ -38,7 +30,7 @@ export class SpannerFact extends GraphExtractionFact {
                 if (names.has(table.name)) {
                     warnings.push({
                         message: `Table '${table.name}' is created twice in database '${database.id}'.`,
-                        sources: [ddlSource(table)],
+                        sources: [ddlSource(context.rootPath, table)],
                     });
                 }
                 names.add(table.name);
@@ -46,72 +38,36 @@ export class SpannerFact extends GraphExtractionFact {
         }
         return { value: { instance, databases }, warnings };
     }
-    /**
-     * Parses the tables created by the `CREATE TABLE` statements of DDL files.
-     *
-     * @param context The workspace context.
-     * @param files The DDL files, relative to the workspace root.
-     * @returns The tables, in the order of the files and statements.
-     */
-    async parseTables(context, files) {
-        const tables = [];
-        for (const file of files) {
-            const content = await readFile(join(context.rootPath, file), 'utf-8');
-            const withoutComments = content.replace(/--.*$/gm, (m) => ' '.repeat(m.length));
-            const statements = withoutComments.matchAll(/\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"']?([A-Za-z_]\w*)[`"']?/gi);
-            for (const match of statements) {
-                tables.push({
-                    name: match[1],
-                    file,
-                    line: withoutComments.slice(0, match.index).split('\n').length,
-                });
-            }
-        }
-        return tables;
-    }
 }
 /**
- * Resolves the Spanner binding of an entity to the database whose DDL creates a table of that name. When several
- * databases declare the name, the one in the entity's domain is chosen.
+ * Resolves the Spanner binding of an entity to the database whose DDL creates a table of that name, using
+ * {@link resolveSpannerTable}.
  *
  * @param spanner The Spanner databases.
  * @param entity The entity.
  * @param domains The domains of the workspace, in which the domain of the entity is looked up.
  * @returns The resolution, or `undefined` if the entity is not persisted in Spanner.
  */
-export function resolveSpannerTable(spanner, entity, domains) {
-    const { definition, file } = entity.schema;
+export function resolveEntitySpannerTable(spanner, entity, domains) {
+    const { definition, path } = entity.schema;
     const table = definition.databases.find((d) => d.engine === SPANNER_ENGINE)?.table;
     if (!table) {
         return undefined;
     }
-    const candidates = spanner.databases.filter((d) => d.tables.some((t) => t.name === table));
-    const pick = (database) => ({
-        kind: 'resolved',
-        database,
-        table: database.tables.find((t) => t.name === table),
-    });
-    if (candidates.length === 1) {
-        return pick(candidates[0]);
-    }
-    if (candidates.length === 0) {
-        return { kind: 'missing' };
-    }
-    const domain = domainOfFile(domains, file);
-    const sameDomain = candidates.filter((d) => domain && d.domain?.directory === domain.directory);
-    return sameDomain.length === 1
-        ? pick(sameDomain[0])
-        : { kind: 'ambiguous', candidates };
+    return resolveSpannerTable(spanner.databases, table, splitSchemaPath(path).file, 
+    // The working directory of a domain's context is the absolute path of the domain.
+    domains.map((d) => d.context.workingDirectory));
 }
 /**
  * Returns the origin source of a `CREATE TABLE` statement.
  *
+ * @param rootPath The absolute path of the workspace root.
  * @param table The table.
  * @returns The origin source.
  */
-export function ddlSource(table) {
+export function ddlSource(rootPath, table) {
     return {
-        path: table.file,
+        path: relative(rootPath, table.file),
         pointer: `CREATE TABLE ${table.name}`,
         location: { start: { line: table.line } },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@causa/workspace-google",
-  "version": "1.4.0-beta.2",
+  "version": "1.4.0-beta.3",
   "description": "The Causa workspace module providing many functionalities related to GCP and its services.",
   "repository": {
     "type": "git",
@@ -37,28 +37,28 @@
   "dependencies": {
     "@causa/cli": "^1.0.1-beta.1",
     "@causa/workspace": "^1.3.0-beta.1",
-    "@causa/workspace-core": "^1.5.0-beta.2",
+    "@causa/workspace-core": "^1.5.0-beta.3",
     "@causa/workspace-terraform": "^1.1.0-beta.2",
     "@causa/workspace-typescript": "^1.4.0-beta.1",
     "@google-cloud/apikeys": "^3.1.1",
-    "@google-cloud/bigquery": "^9.1.0",
+    "@google-cloud/bigquery": "^9.2.0",
     "@google-cloud/iam-credentials": "^5.0.1",
-    "@google-cloud/logging": "^12.1.0",
+    "@google-cloud/logging": "^12.2.0",
     "@google-cloud/monitoring": "^6.1.1",
-    "@google-cloud/pubsub": "^6.1.0",
+    "@google-cloud/pubsub": "^6.2.0",
     "@google-cloud/resource-manager": "^7.1.1",
     "@google-cloud/run": "^4.1.1",
     "@google-cloud/secret-manager": "^7.1.1",
     "@google-cloud/service-usage": "^5.1.1",
     "@google-cloud/spanner": "^9.0.0",
-    "@google-cloud/storage": "^8.2.0",
+    "@google-cloud/storage": "^8.4.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.15.1",
-    "firebase": "^12.19.0",
+    "firebase": "^13.0.0",
     "firebase-admin": "^14.5.0",
     "globby": "^16.2.4",
     "google-gax": "5.0.6",
-    "googleapis": "^183.0.0",
+    "googleapis": "^185.0.0",
     "micromatch": "^4.0.8",
     "pino": "^10.4.0"
   },