@causa/workspace-google 1.3.1 → 1.4.0-beta.1

package/dist/graph/rules/configuration/firestore.js

@@ -0,0 +1,93 @@
+import { GraphOriginKind, } from '@causa/workspace-core';
+import { tableId, tableLocator, databaseId, ModelFact, graphTemplate, } from '@causa/workspace-core/graph';
+import { FIRESTORE_ENGINE, firestoreCollectionPath, firestoreDatabaseLocator, } from '../../ids.js';
+/**
+ * The Firestore database of the workspace, `google.firestore.database`, and the collections schemas bind to:
+ *
+ * - A `database` node for the database.
+ * - A `table` node per Firestore collection a schema binds to (`causa.googleFirestoreCollection`). The locator is the
+ *   collection path, with `{}` in place of document IDs (e.g. `users/{}/bookmarks`), under the single Firestore database
+ *   of the workspace. A binding that does not name its root collection is reported.
+ * - A `realizes` edge from each collection to the entity whose binding declares it.
+ */
+export const firestoreFromConfiguration = {
+    name: 'firestoreFromConfiguration',
+    kind: GraphOriginKind.Declared,
+    description: 'One `database` node from `google.firestore.database`, located by the database name. One `table` node per schema with a Firestore binding, located by its collection path under that database, and one `realizes` edge from the table to the entity.',
+    async run(graph) {
+        const { locator, context } = graph;
+        const model = await graph.get(ModelFact);
+        const nodes = [];
+        const edges = [];
+        const warnings = [];
+        const database = context
+            .asConfiguration()
+            .get('google.firestore.database');
+        if (typeof database === 'string') {
+            const data = {
+                engine: FIRESTORE_ENGINE,
+                resource: {
+                    type: 'firestore.googleapis.com/Database',
+                    id: graphTemplate('projects/', { configuration: 'google.project' }, '/databases/', { configuration: 'google.firestore.database' }),
+                },
+            };
+            nodes.push({
+                layer: 'infrastructure',
+                type: 'database',
+                locator: firestoreDatabaseLocator(database),
+                name: database,
+                sources: [
+                    await locator.configurationSource(context, [
+                        'google',
+                        'firestore',
+                        'database',
+                    ]),
+                ],
+                data,
+            });
+        }
+        for (const entity of model.entities.values()) {
+            const { schema } = entity;
+            const table = schema.definition.databases.find((d) => d.engine === FIRESTORE_ENGINE)?.table;
+            if (!table) {
+                continue;
+            }
+            const source = await locator.source(schema.file, [
+                ...schema.segments,
+                'causa',
+                'googleFirestoreCollection',
+            ]);
+            if (typeof database !== 'string') {
+                warnings.push({
+                    message: `Schema '${schema.definition.name}' binds to Firestore but 'google.firestore.database' is not set.`,
+                    sources: [source],
+                });
+                continue;
+            }
+            const collection = firestoreCollectionPath(table);
+            if (!collection) {
+                warnings.push({
+                    message: `Schema '${schema.definition.name}' binds to Firestore documents '${table}', whose root collection is not named.`,
+                    sources: [source],
+                });
+                continue;
+            }
+            const databaseLocator = firestoreDatabaseLocator(database);
+            nodes.push({
+                layer: 'infrastructure',
+                type: 'table',
+                locator: tableLocator(databaseLocator, collection),
+                parent: databaseId(databaseLocator),
+                name: collection,
+                sources: [source],
+            });
+            edges.push({
+                type: 'realizes',
+                from: tableId(databaseLocator, collection),
+                to: entity.id,
+                sources: [source],
+            });
+        }
+        return { nodes, edges, warnings };
+    },
+};

package/dist/graph/rules/configuration/index.d.ts

@@ -0,0 +1,5 @@
+import type { GraphRule } from '@causa/workspace-core';
+/**
+ * The Google rules reading the workspace configuration and model, independently of the infrastructure code.
+ */
+export declare const GOOGLE_GRAPH_RULES: readonly GraphRule[];

package/dist/graph/rules/configuration/index.js

@@ -0,0 +1,11 @@
+import { enqueuesAssumedFromGoogleTaskTrigger } from './enqueues-assumed-from-google-task-trigger.js';
+import { firestoreFromConfiguration } from './firestore.js';
+import { googleServiceContainerFromConfiguration } from './service-container.js';
+/**
+ * The Google rules reading the workspace configuration and model, independently of the infrastructure code.
+ */
+export const GOOGLE_GRAPH_RULES = [
+    firestoreFromConfiguration,
+    googleServiceContainerFromConfiguration,
+    enqueuesAssumedFromGoogleTaskTrigger,
+];

package/dist/graph/rules/configuration/service-container.d.ts

@@ -0,0 +1,13 @@
+import { type GraphRule } from '@causa/workspace-core';
+/**
+ * The elements declared by the Google-specific parts of the `serviceContainer` configuration of every service container
+ * project.
+ *
+ * - A `delivers` edge from a topic to each `google.pubSub` trigger consuming it. A trigger on a topic that no event
+ *   schema defines has no topic node to come from: its edge only exists in the infrastructure layer.
+ * - An `accesses` edge from a project to each entity whose table lives in a datastore the project owns.
+ *   `outputs['google.spanner']` lists databases (`<instance>.<database>`), and `outputs['google.firestore']` lists root
+ *   collections. A Spanner entity belongs to the database whose DDL creates its table. A Firestore entity belongs to
+ *   the root collection of its path.
+ */
+export declare const googleServiceContainerFromConfiguration: GraphRule;

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

@@ -0,0 +1,123 @@
+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';
+/**
+ * The elements declared by the Google-specific parts of the `serviceContainer` configuration of every service container
+ * project.
+ *
+ * - A `delivers` edge from a topic to each `google.pubSub` trigger consuming it. A trigger on a topic that no event
+ *   schema defines has no topic node to come from: its edge only exists in the infrastructure layer.
+ * - An `accesses` edge from a project to each entity whose table lives in a datastore the project owns.
+ *   `outputs['google.spanner']` lists databases (`<instance>.<database>`), and `outputs['google.firestore']` lists root
+ *   collections. A Spanner entity belongs to the database whose DDL creates its table. A Firestore entity belongs to
+ *   the root collection of its path.
+ */
+export const googleServiceContainerFromConfiguration = {
+    name: '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 [domains, projects, model, spanner] = await Promise.all([
+            graph.get(DomainsFact),
+            graph.get(ProjectsFact),
+            graph.get(ModelFact),
+            graph.get(SpannerFact),
+        ]);
+        const edges = [];
+        const warnings = [];
+        const entities = [...model.entities.values()];
+        const spannerEntities = entities.flatMap((entity) => {
+            const resolution = resolveSpannerTable(spanner, entity, domains);
+            return resolution?.kind === 'resolved' ? [{ entity, resolution }] : [];
+        });
+        for (const project of projects.filter((p) => p.type === 'serviceContainer')) {
+            const configuration = project.context.asConfiguration();
+            const triggers = configuration.get('serviceContainer.triggers', { unsafe: true }) ?? {};
+            for (const [name, trigger] of Object.entries(triggers)) {
+                if (trigger.type !== 'google.pubSub' ||
+                    typeof trigger.topic !== 'string' ||
+                    !model.topics.has(trigger.topic)) {
+                    continue;
+                }
+                edges.push({
+                    type: 'delivers',
+                    from: topicId(trigger.topic),
+                    to: triggerId(project.directory, name),
+                    sources: [
+                        await locator.configurationSource(project.context, [
+                            'serviceContainer',
+                            'triggers',
+                            name,
+                            'topic',
+                        ]),
+                    ],
+                });
+            }
+            const outputs = configuration.get('serviceContainer.outputs', {
+                unsafe: true,
+            });
+            const databases = (outputs?.[SPANNER_ENGINE] ?? []);
+            for (const [index, database] of databases.entries()) {
+                const source = await locator.configurationSource(project.context, [
+                    'serviceContainer',
+                    'outputs',
+                    SPANNER_ENGINE,
+                    index,
+                ]);
+                const owned = spannerEntities.filter(({ resolution }) => resolution.database.name === database);
+                if (owned.length === 0) {
+                    warnings.push({
+                        message: `Project '${project.name}' owns Spanner database '${database}' but no entity resolves to it.`,
+                        sources: [source],
+                    });
+                }
+                for (const { entity, resolution } of owned) {
+                    edges.push({
+                        type: 'accesses',
+                        from: projectId(project.directory),
+                        to: entity.id,
+                        sources: [source, ddlSource(resolution.table)],
+                    });
+                }
+            }
+            const collections = (outputs?.[FIRESTORE_ENGINE] ?? []);
+            for (const [index, collection] of collections.entries()) {
+                const source = await locator.configurationSource(project.context, [
+                    'serviceContainer',
+                    'outputs',
+                    FIRESTORE_ENGINE,
+                    index,
+                ]);
+                const owned = entities.filter((entity) => {
+                    const table = entity.schema.definition.databases.find((d) => d.engine === FIRESTORE_ENGINE)?.table;
+                    return (!!table &&
+                        firestoreCollectionPath(table)?.split('/')[0] === collection);
+                });
+                if (owned.length === 0) {
+                    warnings.push({
+                        message: `Project '${project.name}' owns Firestore collection '${collection}' but no schema binds to it.`,
+                        sources: [source],
+                    });
+                }
+                for (const entity of owned) {
+                    edges.push({
+                        type: 'accesses',
+                        from: projectId(project.directory),
+                        to: entity.id,
+                        sources: [
+                            source,
+                            await locator.source(entity.schema.file, [
+                                ...entity.schema.segments,
+                                'causa',
+                                'googleFirestoreCollection',
+                            ]),
+                        ],
+                    });
+                }
+            }
+        }
+        return { edges, warnings };
+    },
+};

package/dist/graph/rules/terraform/api-router.d.ts

@@ -0,0 +1,15 @@
+import { type GraphRule } from '@causa/workspace-core';
+/**
+ * The source of the Causa Terraform module creating the load balancer routing requests to services.
+ */
+export declare const API_ROUTER_MODULE_SOURCE = "causa-io/api-router/google";
+/**
+ * The resources created by the blocks of the API router module:
+ *
+ * - An `apiRouter` node per block, located by its `name` argument (default `api`). The module does not read the
+ *   workspace configuration: the GCP project of its URL map is assumed to be `google.project` when the
+ *   `gcp_project_id` argument cannot be evaluated.
+ * - A `routes` edge from the router to each service whose Cloud Run module block sets `enable_public_http_endpoints`,
+ *   with the project's `serviceContainer.endpoints.http` as paths.
+ */
+export declare const apiRouterModule: GraphRule;

package/dist/graph/rules/terraform/api-router.js

@@ -0,0 +1,117 @@
+import { GraphOriginKind, } from '@causa/workspace-core';
+import { apiRouterId, nodeId } from '@causa/workspace-core/graph';
+import { modulesWithSource, terraformDeploys, TerraformProjectsFact, terraformValue, } from '@causa/workspace-terraform';
+import { CloudRunFact } from '../../cloud-run.js';
+import { blockResource, argumentOrConfiguration, } from '../../terraform-modules.js';
+/**
+ * The source of the Causa Terraform module creating the load balancer routing requests to services.
+ */
+export const API_ROUTER_MODULE_SOURCE = 'causa-io/api-router/google';
+/**
+ * The default name of the API router.
+ */
+const DEFAULT_API_ROUTER_NAME = 'api';
+/**
+ * Returns the name of an API router, from its `name` argument or the module's default.
+ */
+function routerName(block) {
+    const argument = block.arguments['name'];
+    if (argument === undefined) {
+        return DEFAULT_API_ROUTER_NAME;
+    }
+    const value = terraformValue(argument);
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * The resources created by the blocks of the API router module:
+ *
+ * - An `apiRouter` node per block, located by its `name` argument (default `api`). The module does not read the
+ *   workspace configuration: the GCP project of its URL map is assumed to be `google.project` when the
+ *   `gcp_project_id` argument cannot be evaluated.
+ * - A `routes` edge from the router to each service whose Cloud Run module block sets `enable_public_http_endpoints`,
+ *   with the project's `serviceContainer.endpoints.http` as paths.
+ */
+export const apiRouterModule = {
+    name: 'apiRouterModule',
+    kind: GraphOriginKind.Declared,
+    description: 'One `apiRouter` node per API router module block, located by its `name` argument or the module default `api`, and linked by a `deploys` edge from the projects applying the block. One `routes` edge from the router to each service whose Cloud Run module block enables public HTTP endpoints, with the project’s `endpoints.http` as paths, assuming the single router is wired to them.',
+    async run(graph) {
+        const { locator } = graph;
+        const [terraformProjects, cloudRun] = await Promise.all([
+            graph.get(TerraformProjectsFact),
+            graph.get(CloudRunFact),
+        ]);
+        const apiRouters = modulesWithSource(terraformProjects, API_ROUTER_MODULE_SOURCE);
+        const nodes = [];
+        const edges = [];
+        const warnings = [];
+        for (const block of apiRouters) {
+            const source = block.declaration;
+            const name = routerName(block) ?? DEFAULT_API_ROUTER_NAME;
+            if (!routerName(block)) {
+                warnings.push({
+                    message: `The router name is computed. Assuming '${DEFAULT_API_ROUTER_NAME}'.`,
+                    sources: [source],
+                });
+            }
+            const part = argumentOrConfiguration(block, 'gcp_project_id', 'google.project', warnings);
+            nodes.push({
+                layer: 'infrastructure',
+                type: 'apiRouter',
+                locator: name,
+                name,
+                sources: [source],
+                data: {
+                    resource: await blockResource(graph, block, {
+                        type: 'compute.googleapis.com/UrlMap',
+                        id: ['projects/', part, `/global/urlMaps/${name}`],
+                    }, warnings),
+                },
+            });
+            edges.push(...terraformDeploys(block, nodeId('apiRouter', name)));
+        }
+        const exposed = cloudRun.filter((s) => s.enablePublicHttpEndpoints);
+        if (exposed.length === 0) {
+            return { nodes, edges, warnings };
+        }
+        if (apiRouters.length !== 1) {
+            warnings.push({
+                message: `There are ${apiRouters.length} API router module blocks. Cannot tell which one routes to ${exposed
+                    .map((s) => `'${s.name}'`)
+                    .join(', ')}.`,
+                sources: apiRouters.map((b) => b.declaration),
+            });
+            return { nodes, edges, warnings };
+        }
+        const [router] = apiRouters;
+        const name = routerName(router) ?? DEFAULT_API_ROUTER_NAME;
+        for (const service of exposed) {
+            const paths = service.project.context
+                .asConfiguration()
+                .get('serviceContainer.endpoints.http') ?? [];
+            if (paths.length === 0) {
+                warnings.push({
+                    message: `Service '${service.name}' enables public HTTP endpoints but its project declares no 'endpoints.http'.`,
+                    sources: [service.block.declaration],
+                });
+            }
+            const data = { paths };
+            edges.push({
+                type: 'routes',
+                from: apiRouterId(name),
+                to: service.id,
+                sources: [
+                    service.block.declaration,
+                    await locator.configurationSource(service.project.context, [
+                        'serviceContainer',
+                        'endpoints',
+                        'http',
+                    ]),
+                    router.declaration,
+                ],
+                data,
+            });
+        }
+        return { nodes, edges, warnings };
+    },
+};

package/dist/graph/rules/terraform/cloud-run-cron-triggers.d.ts

@@ -0,0 +1,11 @@
+import { type GraphRuleOutput } from '@causa/workspace-core';
+import { type GraphContext } from '@causa/workspace-core/graph';
+/**
+ * A `scheduledJob` node per cron trigger of a project, for each Cloud Run module block deploying it with cron triggers
+ * enabled. The module names the job `run-<service>-<trigger>`. The locator is the trigger's. The job `realizes` its
+ * trigger, and `targets` the service the block deploys.
+ *
+ * @param graph The context of the extraction.
+ * @returns The scheduled jobs, and their edges.
+ */
+export declare function cloudRunCronTriggers(graph: GraphContext): Promise<GraphRuleOutput>;

package/dist/graph/rules/terraform/cloud-run-cron-triggers.js

@@ -0,0 +1,67 @@
+import {} from '@causa/workspace-core';
+import { nodeId, scheduledJobId, triggerId, triggerLocator, } from '@causa/workspace-core/graph';
+import { terraformDeploys } from '@causa/workspace-terraform';
+import { CloudRunFact } from '../../cloud-run.js';
+import { blockResource } from '../../terraform-modules.js';
+/**
+ * A `scheduledJob` node per cron trigger of a project, for each Cloud Run module block deploying it with cron triggers
+ * enabled. The module names the job `run-<service>-<trigger>`. The locator is the trigger's. The job `realizes` its
+ * trigger, and `targets` the service the block deploys.
+ *
+ * @param graph The context of the extraction.
+ * @returns The scheduled jobs, and their edges.
+ */
+export async function cloudRunCronTriggers(graph) {
+    const { locator } = graph;
+    const cloudRun = await graph.get(CloudRunFact);
+    const nodes = [];
+    const edges = [];
+    const warnings = [];
+    for (const service of cloudRun) {
+        const source = service.block.declaration;
+        for (const [name, trigger] of service.cronTriggers) {
+            const jobLocator = triggerLocator(service.project.directory, name);
+            const job = `run-${service.name}-${name}`;
+            nodes.push({
+                layer: 'infrastructure',
+                type: 'scheduledJob',
+                locator: jobLocator,
+                name: job,
+                sources: [
+                    source,
+                    await locator.configurationSource(service.project.context, [
+                        'serviceContainer',
+                        'triggers',
+                        name,
+                    ]),
+                ],
+                data: {
+                    resource: await blockResource(graph, service.block, {
+                        type: 'cloudscheduler.googleapis.com/Job',
+                        scope: service.project,
+                        id: [
+                            'projects/',
+                            service.projectPart,
+                            '/locations/',
+                            service.locationPart,
+                            `/jobs/${job}`,
+                        ],
+                    }, warnings),
+                },
+            });
+            edges.push(...terraformDeploys(service.block, nodeId('scheduledJob', jobLocator)), {
+                type: 'realizes',
+                from: scheduledJobId(jobLocator),
+                to: triggerId(service.project.directory, name),
+                sources: [source],
+            }, {
+                type: 'targets',
+                from: scheduledJobId(jobLocator),
+                to: service.id,
+                label: trigger.endpoint?.path,
+                sources: [source],
+            });
+        }
+    }
+    return { nodes, edges, warnings };
+}

package/dist/graph/rules/terraform/cloud-run-grants.d.ts

@@ -0,0 +1,16 @@
+import { type GraphRuleOutput } from '@causa/workspace-core';
+import { type GraphContext } from '@causa/workspace-core/graph';
+/**
+ * The edges granted by the IAM bindings of the Cloud Run module blocks deploying a project.
+ *
+ * - A `publishes` edge from every service of the project to each broker topic of its `outputs.eventTopics`, when any
+ *   block grants the publisher role.
+ * - An `accesses` edge from every service of the project to each datastore of its outputs, when any block grants
+ *   access. Spanner access is granted on each database. Firestore access is granted on
+ *   the whole database, but is declared for the collections listed in the outputs: edges target the collections under
+ *   each listed root.
+ *
+ * @param graph The context of the extraction.
+ * @returns The edges granted by the blocks.
+ */
+export declare function cloudRunGrants(graph: GraphContext): Promise<GraphRuleOutput>;

package/dist/graph/rules/terraform/cloud-run-grants.js

@@ -0,0 +1,118 @@
+import {} from '@causa/workspace-core';
+import { brokerTopicId, databaseId, databaseLocator, ModelFact, tableId, } from '@causa/workspace-core/graph';
+import { CloudRunFact } from '../../cloud-run.js';
+import { FIRESTORE_ENGINE, firestoreCollectionPath, firestoreDatabaseLocator, SPANNER_ENGINE, } from '../../ids.js';
+/**
+ * The edges granted by the IAM bindings of the Cloud Run module blocks deploying a project.
+ *
+ * - A `publishes` edge from every service of the project to each broker topic of its `outputs.eventTopics`, when any
+ *   block grants the publisher role.
+ * - An `accesses` edge from every service of the project to each datastore of its outputs, when any block grants
+ *   access. Spanner access is granted on each database. Firestore access is granted on
+ *   the whole database, but is declared for the collections listed in the outputs: edges target the collections under
+ *   each listed root.
+ *
+ * @param graph The context of the extraction.
+ * @returns The edges granted by the blocks.
+ */
+export async function cloudRunGrants(graph) {
+    const { locator, context } = graph;
+    const [cloudRun, model] = await Promise.all([
+        graph.get(CloudRunFact),
+        graph.get(ModelFact),
+    ]);
+    const edges = [];
+    const warnings = [];
+    const firestoreDatabase = context
+        .asConfiguration()
+        .get('google.firestore.database');
+    const firestorePaths = [...model.entities.values()].flatMap((e) => {
+        const table = e.schema.definition.databases.find((d) => d.engine === FIRESTORE_ENGINE)?.table;
+        const path = table ? firestoreCollectionPath(table) : undefined;
+        return path ? [path] : [];
+    });
+    // What the project declares is granted to all its services as soon as one of its blocks grants it.
+    for (const [project, services] of Map.groupBy(cloudRun, (s) => s.project)) {
+        const configuration = project.context.asConfiguration();
+        const publisherBlocks = services
+            .filter((s) => s.setPubsubPermissions)
+            .map((s) => s.block.declaration);
+        if (publisherBlocks.length > 0) {
+            const topics = configuration.get('serviceContainer.outputs.eventTopics') ?? [];
+            for (const [index, topic] of topics.entries()) {
+                const source = await locator.configurationSource(project.context, [
+                    'serviceContainer',
+                    'outputs',
+                    'eventTopics',
+                    index,
+                ]);
+                for (const service of services) {
+                    edges.push({
+                        type: 'publishes',
+                        from: service.id,
+                        to: brokerTopicId(topic),
+                        sources: [...publisherBlocks, source],
+                    });
+                }
+            }
+        }
+        const outputs = configuration.get('serviceContainer.outputs', {
+            unsafe: true,
+        });
+        const spannerBlocks = services
+            .filter((s) => s.setSpannerPermissions)
+            .map((s) => s.block.declaration);
+        if (spannerBlocks.length > 0) {
+            const databases = (outputs?.[SPANNER_ENGINE] ?? []);
+            for (const [index, database] of databases.entries()) {
+                const source = await locator.configurationSource(project.context, [
+                    'serviceContainer',
+                    'outputs',
+                    SPANNER_ENGINE,
+                    index,
+                ]);
+                for (const service of services) {
+                    edges.push({
+                        type: 'accesses',
+                        from: service.id,
+                        to: databaseId(databaseLocator(SPANNER_ENGINE, database)),
+                        sources: [...spannerBlocks, source],
+                    });
+                }
+            }
+        }
+        const firestoreBlocks = services
+            .filter((s) => s.setFirestorePermissions)
+            .map((s) => s.block.declaration);
+        if (firestoreBlocks.length === 0 || !firestoreDatabase) {
+            continue;
+        }
+        const collections = (outputs?.[FIRESTORE_ENGINE] ?? []);
+        for (const [index, collection] of collections.entries()) {
+            const source = await locator.configurationSource(project.context, [
+                'serviceContainer',
+                'outputs',
+                FIRESTORE_ENGINE,
+                index,
+            ]);
+            const paths = new Set(firestorePaths.filter((p) => p.split('/')[0] === collection));
+            if (paths.size === 0) {
+                warnings.push({
+                    message: `Project '${project.name}' is granted Firestore access for '${collection}' but no schema binds to that collection.`,
+                    sources: [source],
+                });
+            }
+            for (const path of paths) {
+                for (const service of services) {
+                    edges.push({
+                        type: 'accesses',
+                        from: service.id,
+                        to: tableId(firestoreDatabaseLocator(firestoreDatabase), path),
+                        sources: [...firestoreBlocks, source],
+                    });
+                }
+            }
+        }
+    }
+    return { edges, warnings };
+}

package/dist/graph/rules/terraform/cloud-run-module.d.ts

@@ -0,0 +1,6 @@
+import { type GraphRule } from '@causa/workspace-core';
+/**
+ * The resources created by the blocks of the Cloud Run module, each part following a file of the module: the service,
+ * the Pub/Sub, tasks, and cron triggers, and the IAM grants.
+ */
+export declare const cloudRunModule: GraphRule;

package/dist/graph/rules/terraform/cloud-run-module.js

@@ -0,0 +1,29 @@
+import { GraphOriginKind, } from '@causa/workspace-core';
+import { cloudRunCronTriggers } from './cloud-run-cron-triggers.js';
+import { cloudRunGrants } from './cloud-run-grants.js';
+import { cloudRunPubSubTriggers } from './cloud-run-pubsub-triggers.js';
+import { cloudRunServices } from './cloud-run-services.js';
+import { cloudRunTasksTriggers } from './cloud-run-tasks-triggers.js';
+/**
+ * The resources created by the blocks of the Cloud Run module, each part following a file of the module: the service,
+ * the Pub/Sub, tasks, and cron triggers, and the IAM grants.
+ */
+export const cloudRunModule = {
+    name: 'cloudRunModule',
+    kind: GraphOriginKind.Declared,
+    description: 'The resources each Cloud Run module block creates: the `service` realizing the project read back from `configuration_file`, a push `brokerSubscription` per Pub/Sub trigger, a `queue` per task trigger, and a `scheduledJob` per cron trigger, with the edges between them, and the `publishes`, `accesses`, and `enqueues` edges its IAM bindings grant. Each resource is linked by a `deploys` edge from the projects applying the block.',
+    async run(graph) {
+        const outputs = await Promise.all([
+            cloudRunServices(graph),
+            cloudRunPubSubTriggers(graph),
+            cloudRunTasksTriggers(graph),
+            cloudRunCronTriggers(graph),
+            cloudRunGrants(graph),
+        ]);
+        return {
+            nodes: outputs.flatMap((o) => o.nodes ?? []),
+            edges: outputs.flatMap((o) => o.edges ?? []),
+            warnings: outputs.flatMap((o) => o.warnings ?? []),
+        };
+    },
+};

package/dist/graph/rules/terraform/cloud-run-pubsub-triggers.d.ts

@@ -0,0 +1,14 @@
+import { type GraphRuleOutput } from '@causa/workspace-core';
+import { type GraphContext } from '@causa/workspace-core/graph';
+/**
+ * A push `brokerSubscription` per Pub/Sub trigger of a project, for each Cloud Run module block deploying it with
+ * Pub/Sub triggers enabled. The locator is the trigger's. The module names the subscription `run-<service>-<trigger>`.
+ *
+ * Each subscription `realizes` its trigger, `targets` the service its module block deploys, and is delivered to by the
+ * broker topic of its trigger. A topic that no event schema of the workspace defines is created outside of it, and
+ * gets its own `brokerTopic` node.
+ *
+ * @param graph The context of the extraction.
+ * @returns The subscriptions, the external broker topics, and their edges.
+ */
+export declare function cloudRunPubSubTriggers(graph: GraphContext): Promise<GraphRuleOutput>;