@pattern-stack/codegen 0.15.1 → 0.15.3

package/dist/chunk-HNWZFNKP.js

@@ -0,0 +1,168 @@
+// runtime/subsystems/integration/integration-audit.schema.ts
+import {
+  pgEnum,
+  pgTable,
+  uuid,
+  text,
+  jsonb,
+  integer,
+  boolean,
+  timestamp,
+  index,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
+  "inbound",
+  "outbound"
+]);
+var integrationRunActionEnum = pgEnum("integration_run_action", [
+  "poll",
+  "cdc",
+  "webhook",
+  "manual",
+  "writeback"
+]);
+var integrationRunStatusEnum = pgEnum("integration_run_status", [
+  "running",
+  "success",
+  "no_changes",
+  "failed"
+]);
+var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
+  "created",
+  "updated",
+  "deleted",
+  "noop"
+]);
+var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
+  "success",
+  "failed",
+  "skipped"
+]);
+var integrationSubscriptions = pgTable(
+  "integration_subscriptions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    connectionId: text("connection_id").notNull(),
+    adapter: text("adapter").notNull(),
+    domain: text("domain").notNull(),
+    externalRef: text("external_ref"),
+    enabled: boolean("enabled").notNull().default(true),
+    /**
+     * Per-subscription configuration bag. Strategies type it internally;
+     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.
+     */
+    config: jsonb("config").notNull().default({}).$type(),
+    /**
+     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
+     * successful run advances it.
+     */
+    cursor: jsonb("cursor").$type(),
+    lastIntegrationAt: timestamp("last_integration_at", { withTimezone: true }),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text("tenant_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (t) => ({
+    /**
+     * Composite uniqueness per the epic shape. `external_ref` is nullable;
+     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
+     * two rows with the same `(connection_id, adapter, domain)` and NULL
+     * external_ref are allowed. That's intentional — a subscription with
+     * NULL external_ref covers the full domain, and duplicates there would
+     * be a consumer-layer modeling issue, not a schema concern.
+     */
+    uqIntegrationSubscriptionTuple: uniqueIndex("uq_integration_subscriptions_tuple").on(
+      t.connectionId,
+      t.adapter,
+      t.domain,
+      t.externalRef
+    ),
+    /** Scheduling query: list enabled subscriptions ordered by staleness. */
+    idxIntegrationSubscriptionsEnabledLastIntegration: index(
+      "idx_integration_subscriptions_enabled_last_integration"
+    ).on(t.enabled, t.lastIntegrationAt)
+  })
+);
+var integrationRuns = pgTable(
+  "integration_runs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    subscriptionId: uuid("subscription_id").notNull().references(() => integrationSubscriptions.id, { onDelete: "cascade" }),
+    direction: integrationRunDirectionEnum("direction").notNull(),
+    action: integrationRunActionEnum("action").notNull(),
+    status: integrationRunStatusEnum("status").notNull().default("running"),
+    recordsFound: integer("records_found").notNull().default(0),
+    recordsProcessed: integer("records_processed").notNull().default(0),
+    cursorBefore: jsonb("cursor_before").$type(),
+    cursorAfter: jsonb("cursor_after").$type(),
+    durationMs: integer("duration_ms"),
+    error: text("error"),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text("tenant_id")
+  },
+  (t) => ({
+    /** Timeline read: "most recent runs for this subscription". */
+    idxIntegrationRunsSubscriptionStartedAt: index(
+      "idx_integration_runs_subscription_started_at"
+    ).on(t.subscriptionId, t.startedAt),
+    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
+    idxIntegrationRunsStatusStartedAt: index("idx_integration_runs_status_started_at").on(
+      t.status,
+      t.startedAt
+    )
+  })
+);
+var integrationRunItems = pgTable(
+  "integration_run_items",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    integrationRunId: uuid("integration_run_id").notNull().references(() => integrationRuns.id, { onDelete: "cascade" }),
+    entityType: text("entity_type").notNull(),
+    externalId: text("external_id").notNull(),
+    localId: text("local_id"),
+    operation: integrationRunItemOperationEnum("operation").notNull(),
+    status: integrationRunItemStatusEnum("status").notNull(),
+    /**
+     * Structured per-field diff — ADR-0003 shape enforced by
+     * `FieldDiffSchema.parse` at the recorder service layer.
+     *
+     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.
+     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`
+     * for created items; `{ [field]: { from: <value>, to: null } }` for
+     * deleted items.
+     */
+    changedFields: jsonb("changed_fields").notNull().default({}).$type(),
+    title: text("title"),
+    error: text("error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text("tenant_id")
+  },
+  (t) => ({
+    /** Ordered timeline within a run. */
+    idxIntegrationRunItemsRunCreatedAt: index("idx_integration_run_items_run_created_at").on(
+      t.integrationRunId,
+      t.createdAt
+    ),
+    /** Per-record history: "every integration that touched opportunity/$extId". */
+    idxIntegrationRunItemsEntityExternal: index(
+      "idx_integration_run_items_entity_external"
+    ).on(t.entityType, t.externalId)
+  })
+);
+
+export {
+  integrationRunDirectionEnum,
+  integrationRunActionEnum,
+  integrationRunStatusEnum,
+  integrationRunItemOperationEnum,
+  integrationRunItemStatusEnum,
+  integrationSubscriptions,
+  integrationRuns,
+  integrationRunItems
+};
+//# sourceMappingURL=chunk-HNWZFNKP.js.map

package/dist/chunk-HNWZFNKP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/integration-audit.schema.ts"],"sourcesContent":["/**\n * Drizzle schema for the integration subsystem audit/observability tables (SYNC-1).\n *\n * Three tables model end-to-end integration observability, keyed by the single port\n * every integration adapter implements (`IChangeSource<T>` from SYNC-2):\n *\n *   - `integration_subscriptions` — owns the cursor per\n *       `(connection_id, adapter, domain, external_ref)` tuple. Addressed\n *       by id by `ICursorStore` (SYNC-3/SYNC-4).\n *   - `integration_runs`          — per-run audit log: start/complete, status,\n *       cursor before/after, counts, direction (inbound|outbound),\n *       action (poll|cdc|webhook|manual|writeback).\n *   - `integration_run_items`     — per-record change log with structured\n *       `changed_fields` jsonb enforced by the Zod `FieldDiffSchema`\n *       contract (ADR-0003; protocol lives in SYNC-2's\n *       integration-field-diff.protocol.ts).\n *\n * Design calls (vs. issue #126 open questions):\n *\n *   - `integration_subscriptions` ships in the subsystem (not consumer-owned).\n *     Rationale: SYNC-4's `PostgresCursorStore` needs to read/write this\n *     table directly; making it consumer-owned would require consumers to\n *     hand-wire a shape the backend already knows. The row is addressable\n *     by id and scoped by the uniqueness tuple; consumers can still\n *     query/list it freely. Same stance as `job_run` being subsystem-\n *     owned while remaining consumer-queryable.\n *\n *   - `tenant_id` is always emitted on the three tables as nullable text.\n *     The `INTEGRATION_MULTI_TENANT` DI flag (SYNC-6) is what enforces the\n *     non-null + cross-tenant-isolation contract at the service/orchestrator\n *     boundary. This mirrors JOB-1/JOB-8's final shape — runtime guard, not\n *     a scaffold-time conditional column. Keeps the schema file uniform\n *     across single-tenant and multi-tenant deployments.\n *\n *   - `changed_fields` on `integration_run_items` is typed via the Zod-inferred\n *     `FieldDiff` shape from SYNC-2 (`{ [fieldName]: { from, to } }`). The\n *     recorder service (SYNC-5) validates every write against\n *     `FieldDiffSchema.parse` so consumers can rely on the shape.\n */\nimport {\n  pgEnum,\n  pgTable,\n  uuid,\n  text,\n  jsonb,\n  integer,\n  boolean,\n  timestamp,\n  index,\n  uniqueIndex,\n} from 'drizzle-orm/pg-core';\nimport type { InferSelectModel } from 'drizzle-orm';\n\nimport type { FieldDiff } from './integration-field-diff.protocol';\n\n// ─── Enums ──────────────────────────────────────────────────────────────────\n\n/**\n * Direction of a integration run relative to local state.\n *\n *   - `inbound`  — external → local (the common case: SFDC poll → local DB).\n *   - `outbound` — local → external (writeback; deferred per epic but the\n *     column shape is reserved so future writeback runs share the audit log).\n */\nexport const integrationRunDirectionEnum = pgEnum('integration_run_direction', [\n  'inbound',\n  'outbound',\n]);\n\n/**\n * How the run detected upstream changes. Maps 1:1 to the `Change.source`\n * provenance on inbound runs; `manual` captures operator-triggered re-integrations\n * and `writeback` captures outbound runs.\n */\nexport const integrationRunActionEnum = pgEnum('integration_run_action', [\n  'poll',\n  'cdc',\n  'webhook',\n  'manual',\n  'writeback',\n]);\n\n/**\n * Lifecycle status of a integration run.\n *\n *   - `running`     — in-flight; recorder has started but not completed.\n *   - `success`     — completed with at least one change processed.\n *   - `no_changes`  — completed cleanly, no upstream changes found.\n *   - `failed`      — errored before completion; `error` column carries the\n *     message. `records_processed` may be non-zero (partial progress).\n */\nexport const integrationRunStatusEnum = pgEnum('integration_run_status', [\n  'running',\n  'success',\n  'no_changes',\n  'failed',\n]);\n\n/**\n * Operation applied per record. Mirrors `Change<T>.operation` from SYNC-2,\n * plus the recorder's own `'noop'` for changes that matched existing state.\n */\nexport const integrationRunItemOperationEnum = pgEnum('integration_run_item_operation', [\n  'created',\n  'updated',\n  'deleted',\n  'noop',\n]);\n\n/**\n * Per-record status within a run. `skipped` captures loopback-detected echoes\n * of the local system's own writes (see `ILoopbackFingerprintStore` in the\n * epic), which record the external_id but intentionally do not touch local\n * state.\n */\nexport const integrationRunItemStatusEnum = pgEnum('integration_run_item_status', [\n  'success',\n  'failed',\n  'skipped',\n]);\n\n// ─── integration_subscriptions ─────────────────────────────────────────────────────\n\n/**\n * One cursor owner per (integration, adapter, domain, external_ref).\n *\n *   - `connection_id` — opaque id of the connected account/instance. E.g.\n *     the SFDC org id for polling strategies, the GitHub installation id\n *     for webhook strategies.\n *   - `adapter`        — short adapter label, e.g. `'salesforce'`, `'hubspot'`.\n *   - `domain`         — canonical entity domain this subscription tracks,\n *     e.g. `'opportunity'`, `'contact'`.\n *   - `external_ref`   — optional upstream scope (e.g. a filter id, a\n *     webhook subscription id). NULL when the subscription covers the\n *     entire domain.\n *\n * The cursor shape is opaque jsonb — strategies type it internally (poll:\n * `{ systemModstamp }`, cdc: `{ replayId }`, webhook: `{ ts }`). Overwritten\n * by `ICursorStore.put(id, cursor)`.\n */\nexport const integrationSubscriptions = pgTable(\n  'integration_subscriptions',\n  {\n    id: uuid('id').primaryKey().defaultRandom(),\n    connectionId: text('connection_id').notNull(),\n    adapter: text('adapter').notNull(),\n    domain: text('domain').notNull(),\n    externalRef: text('external_ref'),\n    enabled: boolean('enabled').notNull().default(true),\n    /**\n     * Per-subscription configuration bag. Strategies type it internally;\n     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.\n     */\n    config: jsonb('config').notNull().default({}).$type<Record<string, unknown>>(),\n    /**\n     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first\n     * successful run advances it.\n     */\n    cursor: jsonb('cursor').$type<unknown>(),\n    lastIntegrationAt: timestamp('last_integration_at', { withTimezone: true }),\n    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */\n    tenantId: text('tenant_id'),\n    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),\n  },\n  (t) => ({\n    /**\n     * Composite uniqueness per the epic shape. `external_ref` is nullable;\n     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means\n     * two rows with the same `(connection_id, adapter, domain)` and NULL\n     * external_ref are allowed. That's intentional — a subscription with\n     * NULL external_ref covers the full domain, and duplicates there would\n     * be a consumer-layer modeling issue, not a schema concern.\n     */\n    uqIntegrationSubscriptionTuple: uniqueIndex('uq_integration_subscriptions_tuple').on(\n      t.connectionId,\n      t.adapter,\n      t.domain,\n      t.externalRef,\n    ),\n    /** Scheduling query: list enabled subscriptions ordered by staleness. */\n    idxIntegrationSubscriptionsEnabledLastIntegration: index(\n      'idx_integration_subscriptions_enabled_last_integration',\n    ).on(t.enabled, t.lastIntegrationAt),\n  }),\n);\n\nexport type IntegrationSubscriptionRow = InferSelectModel<typeof integrationSubscriptions>;\n\n// ─── integration_runs ──────────────────────────────────────────────────────────────\n\n/**\n * One row per invocation of `ExecuteIntegrationUseCase`. `started_at` is set when\n * the recorder opens the run; `completed_at`, `status`, `records_*`,\n * `cursor_after`, and `duration_ms` are filled on completion.\n *\n * `cursor_before` / `cursor_after` carry the opaque cursor snapshots so the\n * run log is fully self-describing — given a run id, an operator can reason\n * about exactly what window was scanned without cross-referencing another\n * table.\n */\nexport const integrationRuns = pgTable(\n  'integration_runs',\n  {\n    id: uuid('id').primaryKey().defaultRandom(),\n    subscriptionId: uuid('subscription_id')\n      .notNull()\n      .references(() => integrationSubscriptions.id, { onDelete: 'cascade' }),\n    direction: integrationRunDirectionEnum('direction').notNull(),\n    action: integrationRunActionEnum('action').notNull(),\n    status: integrationRunStatusEnum('status').notNull().default('running'),\n    recordsFound: integer('records_found').notNull().default(0),\n    recordsProcessed: integer('records_processed').notNull().default(0),\n    cursorBefore: jsonb('cursor_before').$type<unknown>(),\n    cursorAfter: jsonb('cursor_after').$type<unknown>(),\n    durationMs: integer('duration_ms'),\n    error: text('error'),\n    startedAt: timestamp('started_at', { withTimezone: true })\n      .notNull()\n      .defaultNow(),\n    completedAt: timestamp('completed_at', { withTimezone: true }),\n    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */\n    tenantId: text('tenant_id'),\n  },\n  (t) => ({\n    /** Timeline read: \"most recent runs for this subscription\". */\n    idxIntegrationRunsSubscriptionStartedAt: index(\n      'idx_integration_runs_subscription_started_at',\n    ).on(t.subscriptionId, t.startedAt),\n    /** Stale-run sweeper: \"runs that started > N minutes ago and are still running\". */\n    idxIntegrationRunsStatusStartedAt: index('idx_integration_runs_status_started_at').on(\n      t.status,\n      t.startedAt,\n    ),\n  }),\n);\n\nexport type IntegrationRunRow = InferSelectModel<typeof integrationRuns>;\n\n// ─── integration_run_items ─────────────────────────────────────────────────────────\n\n/**\n * One row per upstream change processed within a run. Captures the canonical\n * decision the orchestrator made (`operation` + `status`), the structured\n * per-field diff (`changed_fields`, ADR-0003), and the local row id\n * (`local_id`) for drill-down joins.\n *\n * `changed_fields` is validated at the recorder layer via `FieldDiffSchema`\n * (SYNC-2) — the $type<FieldDiff> annotation here only documents the shape\n * for Drizzle consumers. The runtime enforcement is non-negotiable: downstream\n * drift-detection queries rely on the `{from, to}` shape per field.\n *\n * `title` is an optional human-readable label captured at write time (e.g.\n * `\"Pinnacle opportunity\"`) so run-log UIs don't need to re-hydrate the\n * canonical record.\n */\nexport const integrationRunItems = pgTable(\n  'integration_run_items',\n  {\n    id: uuid('id').primaryKey().defaultRandom(),\n    integrationRunId: uuid('integration_run_id')\n      .notNull()\n      .references(() => integrationRuns.id, { onDelete: 'cascade' }),\n    entityType: text('entity_type').notNull(),\n    externalId: text('external_id').notNull(),\n    localId: text('local_id'),\n    operation: integrationRunItemOperationEnum('operation').notNull(),\n    status: integrationRunItemStatusEnum('status').notNull(),\n    /**\n     * Structured per-field diff — ADR-0003 shape enforced by\n     * `FieldDiffSchema.parse` at the recorder service layer.\n     *\n     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.\n     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`\n     * for created items; `{ [field]: { from: <value>, to: null } }` for\n     * deleted items.\n     */\n    changedFields: jsonb('changed_fields').notNull().default({}).$type<FieldDiff>(),\n    title: text('title'),\n    error: text('error'),\n    createdAt: timestamp('created_at', { withTimezone: true })\n      .notNull()\n      .defaultNow(),\n    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */\n    tenantId: text('tenant_id'),\n  },\n  (t) => ({\n    /** Ordered timeline within a run. */\n    idxIntegrationRunItemsRunCreatedAt: index('idx_integration_run_items_run_created_at').on(\n      t.integrationRunId,\n      t.createdAt,\n    ),\n    /** Per-record history: \"every integration that touched opportunity/$extId\". */\n    idxIntegrationRunItemsEntityExternal: index(\n      'idx_integration_run_items_entity_external',\n    ).on(t.entityType, t.externalId),\n  }),\n);\n\nexport type IntegrationRunItemRow = InferSelectModel<typeof integrationRunItems>;\n"],"mappings":";AAuCA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAcA,IAAM,8BAA8B,OAAO,6BAA6B;AAAA,EAC7E;AAAA,EACA;AACF,CAAC;AAOM,IAAM,2BAA2B,OAAO,0BAA0B;AAAA,EACvE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAWM,IAAM,2BAA2B,OAAO,0BAA0B;AAAA,EACvE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAMM,IAAM,kCAAkC,OAAO,kCAAkC;AAAA,EACtF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAQM,IAAM,+BAA+B,OAAO,+BAA+B;AAAA,EAChF;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAqBM,IAAM,2BAA2B;AAAA,EACtC;AAAA,EACA;AAAA,IACE,IAAI,KAAK,IAAI,EAAE,WAAW,EAAE,cAAc;AAAA,IAC1C,cAAc,KAAK,eAAe,EAAE,QAAQ;AAAA,IAC5C,SAAS,KAAK,SAAS,EAAE,QAAQ;AAAA,IACjC,QAAQ,KAAK,QAAQ,EAAE,QAAQ;AAAA,IAC/B,aAAa,KAAK,cAAc;AAAA,IAChC,SAAS,QAAQ,SAAS,EAAE,QAAQ,EAAE,QAAQ,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA,IAKlD,QAAQ,MAAM,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,MAA+B;AAAA;AAAA;AAAA;AAAA;AAAA,IAK7E,QAAQ,MAAM,QAAQ,EAAE,MAAe;AAAA,IACvC,mBAAmB,UAAU,uBAAuB,EAAE,cAAc,KAAK,CAAC;AAAA;AAAA,IAE1E,UAAU,KAAK,WAAW;AAAA,IAC1B,WAAW,UAAU,cAAc,EAAE,cAAc,KAAK,CAAC,EAAE,QAAQ,EAAE,WAAW;AAAA,IAChF,WAAW,UAAU,cAAc,EAAE,cAAc,KAAK,CAAC,EAAE,QAAQ,EAAE,WAAW;AAAA,EAClF;AAAA,EACA,CAAC,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASN,gCAAgC,YAAY,oCAAoC,EAAE;AAAA,MAChF,EAAE;AAAA,MACF,EAAE;AAAA,MACF,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,mDAAmD;AAAA,MACjD;AAAA,IACF,EAAE,GAAG,EAAE,SAAS,EAAE,iBAAiB;AAAA,EACrC;AACF;AAgBO,IAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AAAA,IACE,IAAI,KAAK,IAAI,EAAE,WAAW,EAAE,cAAc;AAAA,IAC1C,gBAAgB,KAAK,iBAAiB,EACnC,QAAQ,EACR,WAAW,MAAM,yBAAyB,IAAI,EAAE,UAAU,UAAU,CAAC;AAAA,IACxE,WAAW,4BAA4B,WAAW,EAAE,QAAQ;AAAA,IAC5D,QAAQ,yBAAyB,QAAQ,EAAE,QAAQ;AAAA,IACnD,QAAQ,yBAAyB,QAAQ,EAAE,QAAQ,EAAE,QAAQ,SAAS;AAAA,IACtE,cAAc,QAAQ,eAAe,EAAE,QAAQ,EAAE,QAAQ,CAAC;AAAA,IAC1D,kBAAkB,QAAQ,mBAAmB,EAAE,QAAQ,EAAE,QAAQ,CAAC;AAAA,IAClE,cAAc,MAAM,eAAe,EAAE,MAAe;AAAA,IACpD,aAAa,MAAM,cAAc,EAAE,MAAe;AAAA,IAClD,YAAY,QAAQ,aAAa;AAAA,IACjC,OAAO,KAAK,OAAO;AAAA,IACnB,WAAW,UAAU,cAAc,EAAE,cAAc,KAAK,CAAC,EACtD,QAAQ,EACR,WAAW;AAAA,IACd,aAAa,UAAU,gBAAgB,EAAE,cAAc,KAAK,CAAC;AAAA;AAAA,IAE7D,UAAU,KAAK,WAAW;AAAA,EAC5B;AAAA,EACA,CAAC,OAAO;AAAA;AAAA,IAEN,yCAAyC;AAAA,MACvC;AAAA,IACF,EAAE,GAAG,EAAE,gBAAgB,EAAE,SAAS;AAAA;AAAA,IAElC,mCAAmC,MAAM,wCAAwC,EAAE;AAAA,MACjF,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA,EACF;AACF;AAqBO,IAAM,sBAAsB;AAAA,EACjC;AAAA,EACA;AAAA,IACE,IAAI,KAAK,IAAI,EAAE,WAAW,EAAE,cAAc;AAAA,IAC1C,kBAAkB,KAAK,oBAAoB,EACxC,QAAQ,EACR,WAAW,MAAM,gBAAgB,IAAI,EAAE,UAAU,UAAU,CAAC;AAAA,IAC/D,YAAY,KAAK,aAAa,EAAE,QAAQ;AAAA,IACxC,YAAY,KAAK,aAAa,EAAE,QAAQ;AAAA,IACxC,SAAS,KAAK,UAAU;AAAA,IACxB,WAAW,gCAAgC,WAAW,EAAE,QAAQ;AAAA,IAChE,QAAQ,6BAA6B,QAAQ,EAAE,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUvD,eAAe,MAAM,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,MAAiB;AAAA,IAC9E,OAAO,KAAK,OAAO;AAAA,IACnB,OAAO,KAAK,OAAO;AAAA,IACnB,WAAW,UAAU,cAAc,EAAE,cAAc,KAAK,CAAC,EACtD,QAAQ,EACR,WAAW;AAAA;AAAA,IAEd,UAAU,KAAK,WAAW;AAAA,EAC5B;AAAA,EACA,CAAC,OAAO;AAAA;AAAA,IAEN,oCAAoC,MAAM,0CAA0C,EAAE;AAAA,MACpF,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,sCAAsC;AAAA,MACpC;AAAA,IACF,EAAE,GAAG,EAAE,YAAY,EAAE,UAAU;AAAA,EACjC;AACF;","names":[]}

package/dist/chunk-HUH73XGI.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-HUH73XGI.js.map

package/dist/chunk-HUH73XGI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-I6MVCB5A.js

@@ -0,0 +1,39 @@
+import {
+  loadPoolConfig
+} from "./chunk-RHVN6NA7.js";
+import {
+  tokenKey
+} from "./chunk-GYGNEQSC.js";
+
+// runtime/subsystems/jobs/bullmq.config.ts
+var BULLMQ_CONNECTION = Symbol.for(tokenKey("jobs", "bullmq-connection"));
+var BULLMQ_RESOLVED_CONFIG = Symbol.for(tokenKey("jobs", "bullmq-resolved-config"));
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var DEFAULT_BULL_BOARD_MOUNT = "/admin/queues";
+function resolveBullMqConfig(ext) {
+  const url = ext?.redis_url ?? process.env.REDIS_URL ?? DEFAULT_REDIS_URL;
+  const resolved = {
+    connection: { url },
+    queuePrefix: ext?.queue_prefix
+  };
+  if (ext?.bull_board?.enabled) {
+    resolved.bullBoard = {
+      enabled: true,
+      mountPath: ext.bull_board.mount_path ?? DEFAULT_BULL_BOARD_MOUNT
+    };
+  }
+  return resolved;
+}
+function resolvePoolQueueName(pool, config, poolConfig = loadPoolConfig()) {
+  const alias = poolConfig.get(pool)?.queue ?? pool;
+  const prefix = config?.queuePrefix;
+  return prefix ? `${prefix}:${alias}` : alias;
+}
+
+export {
+  BULLMQ_CONNECTION,
+  BULLMQ_RESOLVED_CONFIG,
+  resolveBullMqConfig,
+  resolvePoolQueueName
+};
+//# sourceMappingURL=chunk-I6MVCB5A.js.map

package/dist/chunk-I6MVCB5A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/bullmq.config.ts"],"sourcesContent":["/**\n * BullMQ backend configuration surface (BULLMQ-1, ADR-022 extension slot).\n *\n * The core `IJobOrchestrator` contract is backend-agnostic; everything in\n * this file is BullMQ-specific and lives behind the\n * `jobs.extensions.bullmq.*` config namespace (CLAUDE.md core/extension\n * protocol). The Drizzle backend never reads any of it.\n */\nimport { tokenKey } from '../token-key';\nimport { loadPoolConfig, type PoolConfig } from './pool-config.loader';\n\n/**\n * #6 — Structural mirror of BullMQ's `ConnectionOptions`. Declared locally\n * so this config file (which ships into EVERY jobs install, drizzle or\n * bullmq) does NOT need the `bullmq` peer dep resolved by the consumer's\n * tsc. The bullmq backend internally casts to the real `ConnectionOptions`\n * — that file is only vendored when `--backend bullmq` is selected\n * (see `backendFileFilter`).\n *\n * Accepts the `{ url }` shape this resolver emits, plus the host/port/\n * password/db form BullMQ also accepts, with an open index for any extra\n * ioredis options consumers may flow through.\n */\nexport type BullMqConnectionOptions = {\n  url?: string;\n  host?: string;\n  port?: number;\n  password?: string;\n  db?: number;\n  [key: string]: unknown;\n};\n\n/**\n * Typed shape of `codegen.config.yaml: jobs.extensions.bullmq`. Snake_case\n * because it mirrors the YAML the consumer authors.\n *\n * ```yaml\n * jobs:\n *   backend: bullmq\n *   extensions:\n *     bullmq:\n *       redis_url: redis://localhost:6379   # or env REDIS_URL\n *       queue_prefix: myapp                  # optional namespace (ADR-022 OQ)\n *       bull_board:\n *         enabled: true\n *         mount_path: /api/admin/queues\n * ```\n */\nexport interface BullMqExtensionsConfig {\n  /**\n   * Redis/Valkey connection URL. When omitted, the runtime resolves\n   * `process.env.REDIS_URL`, then falls back to `redis://localhost:6379`.\n   */\n  redis_url?: string;\n  /**\n   * Optional queue-name prefix to avoid collisions when several codegen apps\n   * share one Redis (ADR-022 §\"BullMQ queue naming collisions\"). Applied to\n   * every pool queue alias.\n   */\n  queue_prefix?: string;\n  /**\n   * Bull Board dashboard — opt-in extension (not core). Mounting is the\n   * consumer's responsibility (it needs the consumer's Express/Nest adapter +\n   * admin auth); we only carry the config. See README + spec §Extensions.\n   */\n  bull_board?: {\n    enabled: boolean;\n    mount_path?: string;\n  };\n}\n\n/**\n * The runtime form after `redis_url`/env resolution. This is what the\n * orchestrator + worker actually consume.\n */\nexport interface BullMqResolvedConfig {\n  connection: BullMqConnectionOptions;\n  queuePrefix?: string;\n  bullBoard?: { enabled: boolean; mountPath: string };\n}\n\n// ADR-037: namespaced `Symbol.for(...)` (via `tokenKey()`) — matches by value\n// across runtime copies.\n/** DI token for the resolved BullMQ `ConnectionOptions` (ioredis-compatible). */\nexport const BULLMQ_CONNECTION = Symbol.for(tokenKey('jobs', 'bullmq-connection'));\n\n/** DI token for the full resolved BullMQ config (prefix + bull board). */\nexport const BULLMQ_RESOLVED_CONFIG = Symbol.for(tokenKey('jobs', 'bullmq-resolved-config'));\n\nconst DEFAULT_REDIS_URL = 'redis://localhost:6379';\nconst DEFAULT_BULL_BOARD_MOUNT = '/admin/queues';\n\n/**\n * Resolve the BullMQ runtime config from the extension block.\n *\n * Precedence for the connection URL:\n *   1. explicit `extensions.bullmq.redis_url`\n *   2. `process.env.REDIS_URL`\n *   3. `redis://localhost:6379`\n *\n * Returns a `{ url }` connection shape — BullMQ/ioredis accept a URL string\n * via the `{ url }` ConnectionOptions form.\n */\nexport function resolveBullMqConfig(\n  ext: BullMqExtensionsConfig | undefined,\n): BullMqResolvedConfig {\n  const url =\n    ext?.redis_url ?? process.env.REDIS_URL ?? DEFAULT_REDIS_URL;\n\n  const resolved: BullMqResolvedConfig = {\n    connection: { url },\n    queuePrefix: ext?.queue_prefix,\n  };\n  if (ext?.bull_board?.enabled) {\n    resolved.bullBoard = {\n      enabled: true,\n      mountPath: ext.bull_board.mount_path ?? DEFAULT_BULL_BOARD_MOUNT,\n    };\n  }\n  return resolved;\n}\n\n/**\n * Resolve the BullMQ queue name for a *logical pool name*. The orchestrator\n * and worker MUST agree on this mapping or jobs are enqueued onto a queue\n * nobody consumes. Both derive it identically:\n *\n *   1. Look up the pool's `queue` alias (e.g. `jobs-batch`) in the resolved\n *      pool config — the same alias `JobWorkerModule.onModuleInit` logs and\n *      that the BullMQ `Worker` binds to.\n *   2. Fall back to the logical pool name when the pool is unknown (defensive;\n *      still a stable, colon-free identifier).\n *   3. Apply the optional `queue_prefix` namespace for multi-app Redis\n *      sharing — `:` is fine in the *queue name* (it is only forbidden in the\n *      `jobId`, hence the sha1 there).\n *\n * `poolConfig` defaults to the cached `loadPoolConfig()` so callers that only\n * hold the logical pool name (the orchestrator) don't need to thread the map.\n */\nexport function resolvePoolQueueName(\n  pool: string,\n  config: BullMqResolvedConfig | null | undefined,\n  poolConfig: PoolConfig = loadPoolConfig(),\n): string {\n  const alias = poolConfig.get(pool)?.queue ?? pool;\n  const prefix = config?.queuePrefix;\n  return prefix ? `${prefix}:${alias}` : alias;\n}\n"],"mappings":";;;;;;;;AAoFO,IAAM,oBAAoB,OAAO,IAAI,SAAS,QAAQ,mBAAmB,CAAC;AAG1E,IAAM,yBAAyB,OAAO,IAAI,SAAS,QAAQ,wBAAwB,CAAC;AAE3F,IAAM,oBAAoB;AAC1B,IAAM,2BAA2B;AAa1B,SAAS,oBACd,KACsB;AACtB,QAAM,MACJ,KAAK,aAAa,QAAQ,IAAI,aAAa;AAE7C,QAAM,WAAiC;AAAA,IACrC,YAAY,EAAE,IAAI;AAAA,IAClB,aAAa,KAAK;AAAA,EACpB;AACA,MAAI,KAAK,YAAY,SAAS;AAC5B,aAAS,YAAY;AAAA,MACnB,SAAS;AAAA,MACT,WAAW,IAAI,WAAW,cAAc;AAAA,IAC1C;AAAA,EACF;AACA,SAAO;AACT;AAmBO,SAAS,qBACd,MACA,QACA,aAAyB,eAAe,GAChC;AACR,QAAM,QAAQ,WAAW,IAAI,IAAI,GAAG,SAAS;AAC7C,QAAM,SAAS,QAAQ;AACvB,SAAO,SAAS,GAAG,MAAM,IAAI,KAAK,KAAK;AACzC;","names":[]}

package/dist/chunk-IBGER4YK.js

@@ -0,0 +1,12 @@
+// runtime/base-classes/with-analytics.ts
+function WithAnalytics(Base) {
+  class WithAnalyticsMixin extends Base {
+    analytics;
+  }
+  return WithAnalyticsMixin;
+}
+
+export {
+  WithAnalytics
+};
+//# sourceMappingURL=chunk-IBGER4YK.js.map

package/dist/chunk-IBGER4YK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/with-analytics.ts"],"sourcesContent":["/**\n * WithAnalytics mixin\n *\n * Adds an optional `.analytics` property to the service class.\n * The analytics provider is a per-entity @Injectable (e.g., AccountAnalytics)\n * injected via @Optional() in the generated service constructor.\n *\n * Usage: class MyService extends WithAnalytics(BaseService<...>) { ... }\n *\n * The generated service adds:\n *   @Optional() @Inject(AccountAnalytics) override analytics?: AccountAnalytics\n */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Constructor<T = {}> = abstract new (...args: any[]) => T;\n\nexport function WithAnalytics<TBase extends Constructor>(Base: TBase) {\n  abstract class WithAnalyticsMixin extends Base {\n    analytics?: any;\n  }\n  return WithAnalyticsMixin as TBase & typeof WithAnalyticsMixin;\n}\n"],"mappings":";AAgBO,SAAS,cAAyC,MAAa;AAAA,EACpE,MAAe,2BAA2B,KAAK;AAAA,IAC7C;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-IF5I3DAA.js

@@ -0,0 +1,92 @@
+import {
+  CACHE_DEFAULT_TTL
+} from "./chunk-L6FTY45T.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/cache/cache.memory-backend.ts
+import { Injectable, Inject, Optional } from "@nestjs/common";
+var MemoryCacheService = class {
+  constructor(defaultTtl = null) {
+    this.defaultTtl = defaultTtl;
+  }
+  defaultTtl;
+  store = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  /** In-flight getOrSet promises — keyed by cache key to deduplicate stampedes. */
+  inflight = /* @__PURE__ */ new Map();
+  async get(key) {
+    const record = this.store.get(key);
+    if (!record) return null;
+    if (record.expiresAt !== null && record.expiresAt <= Date.now()) {
+      this.evict(key);
+      return null;
+    }
+    return record.value;
+  }
+  async set(key, value, ttlSeconds) {
+    const effectiveTtl = ttlSeconds ?? this.defaultTtl ?? null;
+    this.clearTimer(key);
+    const expiresAt = effectiveTtl !== null ? Date.now() + effectiveTtl * 1e3 : null;
+    this.store.set(key, { value, expiresAt });
+    if (effectiveTtl !== null) {
+      const timer = setTimeout(() => this.evict(key), effectiveTtl * 1e3);
+      this.timers.set(key, timer);
+    }
+  }
+  async delete(key) {
+    this.evict(key);
+  }
+  async invalidateByPrefix(prefix) {
+    let count = 0;
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        this.evict(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  async getOrSet(key, factory, ttlSeconds) {
+    const cached = await this.get(key);
+    if (cached !== null) return cached;
+    const existing = this.inflight.get(key);
+    if (existing !== void 0) return existing;
+    const promise = factory().then(async (value) => {
+      await this.set(key, value, ttlSeconds);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /** Remove a key from store and cancel its expiry timer. */
+  evict(key) {
+    this.store.delete(key);
+    this.clearTimer(key);
+  }
+  clearTimer(key) {
+    const timer = this.timers.get(key);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+  }
+};
+MemoryCacheService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Optional()),
+  __decorateParam(0, Inject(CACHE_DEFAULT_TTL))
+], MemoryCacheService);
+
+export {
+  MemoryCacheService
+};
+//# sourceMappingURL=chunk-IF5I3DAA.js.map

package/dist/chunk-IF5I3DAA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.memory-backend.ts"],"sourcesContent":["/**\n * MemoryCacheService — Map-backed ICacheService for tests and development.\n *\n * TTL is enforced via setTimeout — expired entries are deleted from the Map\n * when the timer fires. get() / has() also check the expiry time defensively\n * in case the timer fires late.\n *\n * No lifecycle hooks required — all state is in-process.\n *\n * Error behavior:\n * - get() / has() never throw; they return null/false.\n * - set() / delete() / invalidateByPrefix() throw on failure (consistent with protocol).\n */\nimport { Injectable, Inject, Optional } from '@nestjs/common';\nimport type { ICacheService } from './cache.protocol';\nimport { CACHE_DEFAULT_TTL } from './cache.tokens';\n\ninterface CacheRecord {\n  value: unknown;\n  expiresAt: number | null; // epoch ms, or null for no expiry\n}\n\n@Injectable()\nexport class MemoryCacheService implements ICacheService {\n  private readonly store = new Map<string, CacheRecord>();\n  private readonly timers = new Map<string, ReturnType<typeof setTimeout>>();\n  /** In-flight getOrSet promises — keyed by cache key to deduplicate stampedes. */\n  private readonly inflight = new Map<string, Promise<unknown>>();\n\n  constructor(\n    @Optional() @Inject(CACHE_DEFAULT_TTL) private readonly defaultTtl: number | null = null,\n  ) {}\n\n  async get<T = unknown>(key: string): Promise<T | null> {\n    const record = this.store.get(key);\n    if (!record) return null;\n    if (record.expiresAt !== null && record.expiresAt <= Date.now()) {\n      this.evict(key);\n      return null;\n    }\n    return record.value as T;\n  }\n\n  async set<T = unknown>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const effectiveTtl = ttlSeconds ?? this.defaultTtl ?? null;\n\n    // Clear any existing timer for this key\n    this.clearTimer(key);\n\n    const expiresAt = effectiveTtl !== null ? Date.now() + effectiveTtl * 1000 : null;\n    this.store.set(key, { value, expiresAt });\n\n    if (effectiveTtl !== null) {\n      const timer = setTimeout(() => this.evict(key), effectiveTtl * 1000);\n      this.timers.set(key, timer);\n    }\n  }\n\n  async delete(key: string): Promise<void> {\n    this.evict(key);\n  }\n\n  async invalidateByPrefix(prefix: string): Promise<number> {\n    let count = 0;\n    for (const key of this.store.keys()) {\n      if (key.startsWith(prefix)) {\n        this.evict(key);\n        count++;\n      }\n    }\n    return count;\n  }\n\n  async has(key: string): Promise<boolean> {\n    const value = await this.get(key);\n    return value !== null;\n  }\n\n  async getOrSet<T = unknown>(\n    key: string,\n    factory: () => Promise<T>,\n    ttlSeconds?: number,\n  ): Promise<T> {\n    // Fast path: cache hit\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    // Stampede protection: if another call is already computing this key, reuse its promise\n    const existing = this.inflight.get(key) as Promise<T> | undefined;\n    if (existing !== undefined) return existing;\n\n    const promise = factory().then(async (value) => {\n      await this.set(key, value, ttlSeconds);\n      return value;\n    }).finally(() => {\n      this.inflight.delete(key);\n    });\n\n    this.inflight.set(key, promise as Promise<unknown>);\n    return promise;\n  }\n\n  /** Remove a key from store and cancel its expiry timer. */\n  private evict(key: string): void {\n    this.store.delete(key);\n    this.clearTimer(key);\n  }\n\n  private clearTimer(key: string): void {\n    const timer = this.timers.get(key);\n    if (timer !== undefined) {\n      clearTimeout(timer);\n      this.timers.delete(key);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AAaA,SAAS,YAAY,QAAQ,gBAAgB;AAUtC,IAAM,qBAAN,MAAkD;AAAA,EAMvD,YAC0D,aAA4B,MACpF;AADwD;AAAA,EACvD;AAAA,EADuD;AAAA,EANzC,QAAQ,oBAAI,IAAyB;AAAA,EACrC,SAAS,oBAAI,IAA2C;AAAA;AAAA,EAExD,WAAW,oBAAI,IAA8B;AAAA,EAM9D,MAAM,IAAiB,KAAgC;AACrD,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,CAAC,OAAQ,QAAO;AACpB,QAAI,OAAO,cAAc,QAAQ,OAAO,aAAa,KAAK,IAAI,GAAG;AAC/D,WAAK,MAAM,GAAG;AACd,aAAO;AAAA,IACT;AACA,WAAO,OAAO;AAAA,EAChB;AAAA,EAEA,MAAM,IAAiB,KAAa,OAAU,YAAoC;AAChF,UAAM,eAAe,cAAc,KAAK,cAAc;AAGtD,SAAK,WAAW,GAAG;AAEnB,UAAM,YAAY,iBAAiB,OAAO,KAAK,IAAI,IAAI,eAAe,MAAO;AAC7E,SAAK,MAAM,IAAI,KAAK,EAAE,OAAO,UAAU,CAAC;AAExC,QAAI,iBAAiB,MAAM;AACzB,YAAM,QAAQ,WAAW,MAAM,KAAK,MAAM,GAAG,GAAG,eAAe,GAAI;AACnE,WAAK,OAAO,IAAI,KAAK,KAAK;AAAA,IAC5B;AAAA,EACF;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,SAAK,MAAM,GAAG;AAAA,EAChB;AAAA,EAEA,MAAM,mBAAmB,QAAiC;AACxD,QAAI,QAAQ;AACZ,eAAW,OAAO,KAAK,MAAM,KAAK,GAAG;AACnC,UAAI,IAAI,WAAW,MAAM,GAAG;AAC1B,aAAK,MAAM,GAAG;AACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAI,KAA+B;AACvC,UAAM,QAAQ,MAAM,KAAK,IAAI,GAAG;AAChC,WAAO,UAAU;AAAA,EACnB;AAAA,EAEA,MAAM,SACJ,KACA,SACA,YACY;AAEZ,UAAM,SAAS,MAAM,KAAK,IAAO,GAAG;AACpC,QAAI,WAAW,KAAM,QAAO;AAG5B,UAAM,WAAW,KAAK,SAAS,IAAI,GAAG;AACtC,QAAI,aAAa,OAAW,QAAO;AAEnC,UAAM,UAAU,QAAQ,EAAE,KAAK,OAAO,UAAU;AAC9C,YAAM,KAAK,IAAI,KAAK,OAAO,UAAU;AACrC,aAAO;AAAA,IACT,CAAC,EAAE,QAAQ,MAAM;AACf,WAAK,SAAS,OAAO,GAAG;AAAA,IAC1B,CAAC;AAED,SAAK,SAAS,IAAI,KAAK,OAA2B;AAClD,WAAO;AAAA,EACT;AAAA;AAAA,EAGQ,MAAM,KAAmB;AAC/B,SAAK,MAAM,OAAO,GAAG;AACrB,SAAK,WAAW,GAAG;AAAA,EACrB;AAAA,EAEQ,WAAW,KAAmB;AACpC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,QAAI,UAAU,QAAW;AACvB,mBAAa,KAAK;AAClB,WAAK,OAAO,OAAO,GAAG;AAAA,IACxB;AAAA,EACF;AACF;AA5Fa,qBAAN;AAAA,EADN,WAAW;AAAA,EAQP,4BAAS;AAAA,EAAG,0BAAO,iBAAiB;AAAA,GAP5B;","names":[]}

package/dist/chunk-IP4OO26U.js

@@ -0,0 +1,54 @@
+// runtime/subsystems/auth/backends/encryption-key/env.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+var ALGO = "aes-256-gcm";
+var NONCE_BYTES = 12;
+var TAG_BYTES = 16;
+var KEY_BYTES = 32;
+var EnvEncryptionKey = class {
+  key;
+  constructor(opts = {}) {
+    const env = opts.env ?? process.env;
+    const envVar = opts.envVar ?? "INTEGRATION_TOKEN_ENCRYPTION_KEY";
+    const raw = env[envVar];
+    if (!raw) {
+      throw new Error(
+        `EnvEncryptionKey: ${envVar} is not set. Generate with: openssl rand -base64 32`
+      );
+    }
+    const decoded = Buffer.from(raw, "base64");
+    if (decoded.length !== KEY_BYTES) {
+      throw new Error(
+        `EnvEncryptionKey: ${envVar} must decode to ${KEY_BYTES} bytes (got ${decoded.length}). Use: openssl rand -base64 32`
+      );
+    }
+    this.key = decoded;
+  }
+  async encrypt(plaintext) {
+    const nonce = randomBytes(NONCE_BYTES);
+    const cipher = createCipheriv(ALGO, this.key, nonce);
+    const ciphertext = Buffer.concat([
+      cipher.update(plaintext, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([nonce, ciphertext, authTag]).toString("base64");
+  }
+  async decrypt(ciphertext) {
+    const buf = Buffer.from(ciphertext, "base64");
+    if (buf.length < NONCE_BYTES + TAG_BYTES) {
+      throw new Error("EnvEncryptionKey: ciphertext too short");
+    }
+    const nonce = buf.subarray(0, NONCE_BYTES);
+    const authTag = buf.subarray(buf.length - TAG_BYTES);
+    const body = buf.subarray(NONCE_BYTES, buf.length - TAG_BYTES);
+    const decipher = createDecipheriv(ALGO, this.key, nonce);
+    decipher.setAuthTag(authTag);
+    const plain = Buffer.concat([decipher.update(body), decipher.final()]);
+    return plain.toString("utf8");
+  }
+};
+
+export {
+  EnvEncryptionKey
+};
+//# sourceMappingURL=chunk-IP4OO26U.js.map

package/dist/chunk-IP4OO26U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/backends/encryption-key/env.ts"],"sourcesContent":["/**\n * Env-backed AES-256-GCM encryption.\n *\n * Framing: `base64( nonce(12B) || ciphertext || authTag(16B) )`. Random nonce\n * per call means two encryptions of the same plaintext produce different\n * ciphertexts — prevents replay-style inference. Auth tag enforces integrity;\n * any tampering throws on decrypt.\n *\n * Key source: `INTEGRATION_TOKEN_ENCRYPTION_KEY` env var, 32 bytes base64-encoded.\n * Generate via `openssl rand -base64 32`.\n *\n * Future backend: `kms.ts` (AWS/GCP KMS) for production deployments that\n * need key rotation + audit trails.\n */\nimport { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';\nimport type { IEncryptionKey } from '../../protocols/encryption-key';\n\nexport interface EnvEncryptionKeyOptions {\n  /** Defaults to `process.env`. Tests inject a fixture. */\n  env?: NodeJS.ProcessEnv;\n  /** Defaults to `'INTEGRATION_TOKEN_ENCRYPTION_KEY'`. */\n  envVar?: string;\n}\n\nconst ALGO = 'aes-256-gcm';\nconst NONCE_BYTES = 12;\nconst TAG_BYTES = 16;\nconst KEY_BYTES = 32;\n\nexport class EnvEncryptionKey implements IEncryptionKey {\n  private readonly key: Buffer;\n\n  constructor(opts: EnvEncryptionKeyOptions = {}) {\n    const env = opts.env ?? process.env;\n    const envVar = opts.envVar ?? 'INTEGRATION_TOKEN_ENCRYPTION_KEY';\n    const raw = env[envVar];\n    if (!raw) {\n      throw new Error(\n        `EnvEncryptionKey: ${envVar} is not set. Generate with: openssl rand -base64 32`,\n      );\n    }\n    const decoded = Buffer.from(raw, 'base64');\n    if (decoded.length !== KEY_BYTES) {\n      throw new Error(\n        `EnvEncryptionKey: ${envVar} must decode to ${KEY_BYTES} bytes (got ${decoded.length}). Use: openssl rand -base64 32`,\n      );\n    }\n    this.key = decoded;\n  }\n\n  async encrypt(plaintext: string): Promise<string> {\n    const nonce = randomBytes(NONCE_BYTES);\n    const cipher = createCipheriv(ALGO, this.key, nonce);\n    const ciphertext = Buffer.concat([\n      cipher.update(plaintext, 'utf8'),\n      cipher.final(),\n    ]);\n    const authTag = cipher.getAuthTag();\n    return Buffer.concat([nonce, ciphertext, authTag]).toString('base64');\n  }\n\n  async decrypt(ciphertext: string): Promise<string> {\n    const buf = Buffer.from(ciphertext, 'base64');\n    if (buf.length < NONCE_BYTES + TAG_BYTES) {\n      throw new Error('EnvEncryptionKey: ciphertext too short');\n    }\n    const nonce = buf.subarray(0, NONCE_BYTES);\n    const authTag = buf.subarray(buf.length - TAG_BYTES);\n    const body = buf.subarray(NONCE_BYTES, buf.length - TAG_BYTES);\n\n    const decipher = createDecipheriv(ALGO, this.key, nonce);\n    decipher.setAuthTag(authTag);\n    const plain = Buffer.concat([decipher.update(body), decipher.final()]);\n    return plain.toString('utf8');\n  }\n}\n"],"mappings":";AAcA,SAAS,gBAAgB,kBAAkB,mBAAmB;AAU9D,IAAM,OAAO;AACb,IAAM,cAAc;AACpB,IAAM,YAAY;AAClB,IAAM,YAAY;AAEX,IAAM,mBAAN,MAAiD;AAAA,EACrC;AAAA,EAEjB,YAAY,OAAgC,CAAC,GAAG;AAC9C,UAAM,MAAM,KAAK,OAAO,QAAQ;AAChC,UAAM,SAAS,KAAK,UAAU;AAC9B,UAAM,MAAM,IAAI,MAAM;AACtB,QAAI,CAAC,KAAK;AACR,YAAM,IAAI;AAAA,QACR,qBAAqB,MAAM;AAAA,MAC7B;AAAA,IACF;AACA,UAAM,UAAU,OAAO,KAAK,KAAK,QAAQ;AACzC,QAAI,QAAQ,WAAW,WAAW;AAChC,YAAM,IAAI;AAAA,QACR,qBAAqB,MAAM,mBAAmB,SAAS,eAAe,QAAQ,MAAM;AAAA,MACtF;AAAA,IACF;AACA,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,MAAM,QAAQ,WAAoC;AAChD,UAAM,QAAQ,YAAY,WAAW;AACrC,UAAM,SAAS,eAAe,MAAM,KAAK,KAAK,KAAK;AACnD,UAAM,aAAa,OAAO,OAAO;AAAA,MAC/B,OAAO,OAAO,WAAW,MAAM;AAAA,MAC/B,OAAO,MAAM;AAAA,IACf,CAAC;AACD,UAAM,UAAU,OAAO,WAAW;AAClC,WAAO,OAAO,OAAO,CAAC,OAAO,YAAY,OAAO,CAAC,EAAE,SAAS,QAAQ;AAAA,EACtE;AAAA,EAEA,MAAM,QAAQ,YAAqC;AACjD,UAAM,MAAM,OAAO,KAAK,YAAY,QAAQ;AAC5C,QAAI,IAAI,SAAS,cAAc,WAAW;AACxC,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC1D;AACA,UAAM,QAAQ,IAAI,SAAS,GAAG,WAAW;AACzC,UAAM,UAAU,IAAI,SAAS,IAAI,SAAS,SAAS;AACnD,UAAM,OAAO,IAAI,SAAS,aAAa,IAAI,SAAS,SAAS;AAE7D,UAAM,WAAW,iBAAiB,MAAM,KAAK,KAAK,KAAK;AACvD,aAAS,WAAW,OAAO;AAC3B,UAAM,QAAQ,OAAO,OAAO,CAAC,SAAS,OAAO,IAAI,GAAG,SAAS,MAAM,CAAC,CAAC;AACrE,WAAO,MAAM,SAAS,MAAM;AAAA,EAC9B;AACF;","names":[]}

package/dist/chunk-IWAOY6KC.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-IWAOY6KC.js.map

package/dist/chunk-IWAOY6KC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-IYNSRIGR.js

@@ -0,0 +1,122 @@
+import {
+  bridgeRegistry
+} from "./chunk-5A432NZJ.js";
+import {
+  EventFlowService
+} from "./chunk-32BMMV4H.js";
+import {
+  BRIDGE_RESERVED_POOLS
+} from "./chunk-EDKJU5BO.js";
+import {
+  DrizzleBridgeDeliveryRepo
+} from "./chunk-K2I6XIK5.js";
+import {
+  MemoryBridgeDeliveryRepo
+} from "./chunk-4DOJBQTP.js";
+import {
+  BridgeOutboxDrainHook
+} from "./chunk-L7BNNRGI.js";
+import {
+  BridgeDeliveryHandler
+} from "./chunk-YTN6BKWA.js";
+import {
+  BridgeReservedPoolsNotPolledError
+} from "./chunk-NXXDZ6ZF.js";
+import {
+  JOB_WORKER_MODULE_OPTIONS
+} from "./chunk-4H3PETLM.js";
+import {
+  BRIDGE_DELIVERY_REPO,
+  BRIDGE_MODULE_OPTIONS,
+  BRIDGE_MULTI_TENANT,
+  BRIDGE_OUTBOX_DRAIN_HOOK,
+  BRIDGE_REGISTRY,
+  EVENT_FLOW
+} from "./chunk-4LH67P4U.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/bridge/bridge.module.ts
+import {
+  Inject,
+  Module,
+  Optional
+} from "@nestjs/common";
+var BridgeModule = class {
+  /**
+   * `JOB_WORKER_MODULE_OPTIONS` is declared `@Optional()` so unit tests
+   * that mount `BridgeModule` alone (no `JobWorkerModule`) boot
+   * cleanly — the boot-time check skips when the token is undefined.
+   */
+  constructor(workerOpts) {
+    this.workerOpts = workerOpts;
+  }
+  workerOpts;
+  static forRoot(opts) {
+    const repoProvider = opts.backend === "memory" ? { provide: BRIDGE_DELIVERY_REPO, useClass: MemoryBridgeDeliveryRepo } : { provide: BRIDGE_DELIVERY_REPO, useClass: DrizzleBridgeDeliveryRepo };
+    return {
+      module: BridgeModule,
+      global: true,
+      // BridgeModule consumes EVENT_BUS / JOB_ORCHESTRATOR / DRIZZLE
+      // from sibling subsystems via DI; no `imports` needed here. The
+      // consumer is responsible for wiring EventsModule + JobsDomainModule
+      // (or JobWorkerModule, which transitively imports the latter)
+      // BEFORE BridgeModule.
+      providers: [
+        { provide: BRIDGE_MODULE_OPTIONS, useValue: opts },
+        { provide: BRIDGE_MULTI_TENANT, useValue: opts.multiTenant ?? false },
+        // Package mode threads the consumer's generated registry through
+        // `opts.registry`; vendored mode omits it and we fall back to the
+        // bundled `./generated/registry` (which IS the consumer's generated
+        // file in a vendored tree). See `BridgeModuleOptions.registry`.
+        { provide: BRIDGE_REGISTRY, useValue: opts.registry ?? bridgeRegistry },
+        repoProvider,
+        // Drain hook — always wired; `DrizzleEventBus` consumes it via
+        // `@Optional()`, so non-bridge mounts simply see `undefined`.
+        { provide: BRIDGE_OUTBOX_DRAIN_HOOK, useClass: BridgeOutboxDrainHook },
+        // Facade — class provider + token alias.
+        EventFlowService,
+        { provide: EVENT_FLOW, useExisting: EventFlowService },
+        // Framework handler — provider so DI can construct it. The
+        // `@JobHandler` decorator already auto-registers it in
+        // `JOB_HANDLER_REGISTRY` at module-load time, and its `jobs`
+        // row is upserted at `JobWorkerModule.onModuleInit`. We just
+        // need the class instantiated as a Nest provider so its DI
+        // deps (BRIDGE_DELIVERY_REPO, JOB_ORCHESTRATOR, EVENT_BUS,
+        // BRIDGE_REGISTRY, BRIDGE_MULTI_TENANT) resolve.
+        BridgeDeliveryHandler
+      ],
+      exports: [
+        EVENT_FLOW,
+        BRIDGE_DELIVERY_REPO,
+        BRIDGE_REGISTRY,
+        BRIDGE_MULTI_TENANT,
+        BRIDGE_MODULE_OPTIONS,
+        BRIDGE_OUTBOX_DRAIN_HOOK
+      ]
+    };
+  }
+  async onModuleInit() {
+    if (!this.workerOpts) return;
+    if (this.workerOpts.allPools) return;
+    const activePools = this.workerOpts.pools ?? [];
+    const missing = BRIDGE_RESERVED_POOLS.filter(
+      (p) => !activePools.includes(p)
+    );
+    if (missing.length > 0) {
+      throw new BridgeReservedPoolsNotPolledError(missing);
+    }
+  }
+};
+BridgeModule = __decorateClass([
+  Module({}),
+  __decorateParam(0, Optional()),
+  __decorateParam(0, Inject(JOB_WORKER_MODULE_OPTIONS))
+], BridgeModule);
+
+export {
+  BridgeModule
+};
+//# sourceMappingURL=chunk-IYNSRIGR.js.map

package/dist/chunk-IYNSRIGR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/bridge.module.ts"],"sourcesContent":["/**\n * BridgeModule — `DynamicModule.forRoot({ backend, multiTenant })`\n * factory that wires the entire bridge subsystem (BRIDGE-8, ADR-023\n * Phase 2).\n *\n * The bridge is the formalized seam between events (ADR-024) and jobs\n * (ADR-022). It is owned by neither subsystem and consumes their tokens\n * via DI. `BridgeModule` is the *combiner* — neither `EventsModule` nor\n * `JobsDomainModule` know about it.\n *\n * Consumer wiring (must be imported AFTER `EventsModule`,\n * `JobsDomainModule`, and `JobWorkerModule`):\n * ```ts\n * @Module({\n *   imports: [\n *     EventsModule.forRoot({ backend: 'drizzle' }),\n *     JobWorkerModule.forRoot({\n *       mode: 'embedded',\n *       backend: 'drizzle',\n *       pools: ['interactive', 'batch', ...BRIDGE_RESERVED_POOLS],\n *     }),\n *     BridgeModule.forRoot({ backend: 'drizzle', multiTenant: false }),\n *   ],\n * })\n * class AppModule {}\n * ```\n *\n * Boot-time check: `onModuleInit` inspects `JobWorkerModule`'s active\n * pools and throws `BridgeReservedPoolsNotPolledError` when any of the\n * three reserved bridge pools isn't being polled. Converts the\n * \"wrappers sit pending forever\" footgun into a fail-fast.\n *\n * Handler registration: ONE `@JobHandler('@framework/bridge_delivery',\n * ...)` decorator on `BridgeDeliveryHandler` auto-registers it in\n * `JOB_HANDLER_REGISTRY` at module-load time. We declare the class as a\n * Nest provider here so DI resolves its constructor deps; per-direction\n * routing happens via `job_run.pool='events_<direction>'` set by\n * `BridgeOutboxDrainHook` (BRIDGE-4) — workers polling each reserved\n * pool independently claim wrappers from their own pool and dispatch to\n * the same handler class. The reserved-pool validator exemption\n * (BRIDGE-5) lets the framework handler legitimately target a reserved\n * pool.\n */\nimport {\n  Inject,\n  Module,\n  Optional,\n  type DynamicModule,\n  type OnModuleInit,\n  type Provider,\n} from '@nestjs/common';\n\nimport {\n  JOB_WORKER_MODULE_OPTIONS,\n  type JobWorkerModuleOptions,\n} from '../jobs/job-worker.module';\n\nimport {\n  BRIDGE_DELIVERY_REPO,\n  BRIDGE_MODULE_OPTIONS,\n  BRIDGE_MULTI_TENANT,\n  BRIDGE_OUTBOX_DRAIN_HOOK,\n  BRIDGE_REGISTRY,\n  EVENT_FLOW,\n} from './bridge.tokens';\nimport { BridgeReservedPoolsNotPolledError } from './bridge-errors';\nimport { MemoryBridgeDeliveryRepo } from './bridge-delivery.memory-backend';\nimport { DrizzleBridgeDeliveryRepo } from './bridge-delivery.drizzle-backend';\nimport { BridgeOutboxDrainHook } from './bridge-outbox-drain-hook';\nimport { EventFlowService } from './event-flow.service';\nimport { BridgeDeliveryHandler } from './bridge-delivery-handler';\nimport { bridgeRegistry } from './generated/registry';\nimport type { BridgeRegistry } from './bridge.protocol';\nimport { BRIDGE_RESERVED_POOLS } from './reserved-pools';\n\nexport interface BridgeModuleOptions {\n  /**\n   * `'memory'` for unit tests (no Postgres), `'drizzle'` for production.\n   * Switches `BRIDGE_DELIVERY_REPO` between\n   * `MemoryBridgeDeliveryRepo` and `DrizzleBridgeDeliveryRepo`.\n   */\n  backend: 'memory' | 'drizzle';\n  /**\n   * Multi-tenancy opt-in. When `true`, the three enforcement sites\n   * (`EventFlowService.publishAndStart`, `BridgeDeliveryHandler.run`,\n   * `DrizzleBridgeDeliveryRepo.insertDelivery`) throw\n   * `MissingTenantIdError` when `tenantId === undefined`. Explicit\n   * `null` always passes (cross-tenant work). Defaults to `false`.\n   */\n  multiTenant?: boolean;\n  /**\n   * The codegen-emitted `Record<EventTypeName, BridgeTriggerEntry[]>` that\n   * drives outbox-drain trigger lookup (BRIDGE-4) and the facade's Case B\n   * dedup (BRIDGE-7).\n   *\n   * **Package mode (ADR-037).** When the runtime is imported from\n   * `@pattern-stack/codegen` (not vendored), the bundled\n   * `./generated/registry` is a frozen empty placeholder (`{}`) — a\n   * consumer's `@JobHandler.triggers` are scanned into a registry that lives\n   * in THEIR `src/generated/bridge-registry.ts`, which the package can't\n   * import. The generated subsystem barrel therefore threads that registry in\n   * here: `BridgeModule.forRoot({ ..., registry: bridgeRegistry })`. Omitted\n   * (vendored mode / tests) ⇒ falls back to the bundled `./generated/registry`,\n   * which in vendored mode IS the consumer's freshly-generated file.\n   *\n   * Without this, package-mode consumers' triggers never bind and the bridge\n   * routes nothing (the \"wrappers sit pending\" footgun's silent twin —\n   * nothing is ever enqueued in the first place).\n   */\n  registry?: BridgeRegistry;\n}\n\n@Module({})\nexport class BridgeModule implements OnModuleInit {\n  static forRoot(opts: BridgeModuleOptions): DynamicModule {\n    const repoProvider: Provider =\n      opts.backend === 'memory'\n        ? { provide: BRIDGE_DELIVERY_REPO, useClass: MemoryBridgeDeliveryRepo }\n        : { provide: BRIDGE_DELIVERY_REPO, useClass: DrizzleBridgeDeliveryRepo };\n\n    return {\n      module: BridgeModule,\n      global: true,\n      // BridgeModule consumes EVENT_BUS / JOB_ORCHESTRATOR / DRIZZLE\n      // from sibling subsystems via DI; no `imports` needed here. The\n      // consumer is responsible for wiring EventsModule + JobsDomainModule\n      // (or JobWorkerModule, which transitively imports the latter)\n      // BEFORE BridgeModule.\n      providers: [\n        { provide: BRIDGE_MODULE_OPTIONS, useValue: opts },\n        { provide: BRIDGE_MULTI_TENANT, useValue: opts.multiTenant ?? false },\n        // Package mode threads the consumer's generated registry through\n        // `opts.registry`; vendored mode omits it and we fall back to the\n        // bundled `./generated/registry` (which IS the consumer's generated\n        // file in a vendored tree). See `BridgeModuleOptions.registry`.\n        { provide: BRIDGE_REGISTRY, useValue: opts.registry ?? bridgeRegistry },\n        repoProvider,\n        // Drain hook — always wired; `DrizzleEventBus` consumes it via\n        // `@Optional()`, so non-bridge mounts simply see `undefined`.\n        { provide: BRIDGE_OUTBOX_DRAIN_HOOK, useClass: BridgeOutboxDrainHook },\n        // Facade — class provider + token alias.\n        EventFlowService,\n        { provide: EVENT_FLOW, useExisting: EventFlowService },\n        // Framework handler — provider so DI can construct it. The\n        // `@JobHandler` decorator already auto-registers it in\n        // `JOB_HANDLER_REGISTRY` at module-load time, and its `jobs`\n        // row is upserted at `JobWorkerModule.onModuleInit`. We just\n        // need the class instantiated as a Nest provider so its DI\n        // deps (BRIDGE_DELIVERY_REPO, JOB_ORCHESTRATOR, EVENT_BUS,\n        // BRIDGE_REGISTRY, BRIDGE_MULTI_TENANT) resolve.\n        BridgeDeliveryHandler,\n      ],\n      exports: [\n        EVENT_FLOW,\n        BRIDGE_DELIVERY_REPO,\n        BRIDGE_REGISTRY,\n        BRIDGE_MULTI_TENANT,\n        BRIDGE_MODULE_OPTIONS,\n        BRIDGE_OUTBOX_DRAIN_HOOK,\n      ],\n    };\n  }\n\n  /**\n   * `JOB_WORKER_MODULE_OPTIONS` is declared `@Optional()` so unit tests\n   * that mount `BridgeModule` alone (no `JobWorkerModule`) boot\n   * cleanly — the boot-time check skips when the token is undefined.\n   */\n  constructor(\n    @Optional()\n    @Inject(JOB_WORKER_MODULE_OPTIONS)\n    private readonly workerOpts?: JobWorkerModuleOptions,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    if (!this.workerOpts) return;\n    // BULLMQ-1 Phase 1 — `allPools: true` activates every pool (reserved\n    // `events_*` included), so the reserved-pool guarantee holds by\n    // construction. Short-circuit pass without inspecting the (typically\n    // omitted) explicit `pools` list.\n    if (this.workerOpts.allPools) return;\n    const activePools = this.workerOpts.pools ?? [];\n    const missing = BRIDGE_RESERVED_POOLS.filter(\n      (p) => !activePools.includes(p),\n    );\n    if (missing.length > 0) {\n      throw new BridgeReservedPoolsNotPolledError(missing);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AA+DA,IAAM,eAAN,MAA2C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuDhD,YAGmB,YACjB;AADiB;AAAA,EAChB;AAAA,EADgB;AAAA,EAzDnB,OAAO,QAAQ,MAA0C;AACvD,UAAM,eACJ,KAAK,YAAY,WACb,EAAE,SAAS,sBAAsB,UAAU,yBAAyB,IACpE,EAAE,SAAS,sBAAsB,UAAU,0BAA0B;AAE3E,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAMR,WAAW;AAAA,QACT,EAAE,SAAS,uBAAuB,UAAU,KAAK;AAAA,QACjD,EAAE,SAAS,qBAAqB,UAAU,KAAK,eAAe,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,QAKpE,EAAE,SAAS,iBAAiB,UAAU,KAAK,YAAY,eAAe;AAAA,QACtE;AAAA;AAAA;AAAA,QAGA,EAAE,SAAS,0BAA0B,UAAU,sBAAsB;AAAA;AAAA,QAErE;AAAA,QACA,EAAE,SAAS,YAAY,aAAa,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAQrD;AAAA,MACF;AAAA,MACA,SAAS;AAAA,QACP;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAaA,MAAM,eAA8B;AAClC,QAAI,CAAC,KAAK,WAAY;AAKtB,QAAI,KAAK,WAAW,SAAU;AAC9B,UAAM,cAAc,KAAK,WAAW,SAAS,CAAC;AAC9C,UAAM,UAAU,sBAAsB;AAAA,MACpC,CAAC,MAAM,CAAC,YAAY,SAAS,CAAC;AAAA,IAChC;AACA,QAAI,QAAQ,SAAS,GAAG;AACtB,YAAM,IAAI,kCAAkC,OAAO;AAAA,IACrD;AAAA,EACF;AACF;AA5Ea,eAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,EAyDL,4BAAS;AAAA,EACT,0BAAO,yBAAyB;AAAA,GAzDxB;","names":[]}

package/dist/chunk-J37YWU7Y.js

@@ -0,0 +1,19 @@
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/analytics/noop-backend.ts
+import { Injectable } from "@nestjs/common";
+var NoopAnalyticsBackend = class {
+  async execute(_cube, _measures, _dimensions, _where, _opts) {
+    return [];
+  }
+};
+NoopAnalyticsBackend = __decorateClass([
+  Injectable()
+], NoopAnalyticsBackend);
+
+export {
+  NoopAnalyticsBackend
+};
+//# sourceMappingURL=chunk-J37YWU7Y.js.map

package/dist/chunk-J37YWU7Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/analytics/noop-backend.ts"],"sourcesContent":["/**\n * NoopAnalyticsBackend — no-op backend for the analytics query port.\n *\n * Returns empty arrays for all queries. Use this backend when analytics\n * is disabled or in tests that don't need real analytics data.\n *\n * Provided by AnalyticsModule.forRoot({ backend: 'noop' }).\n */\nimport { Injectable } from '@nestjs/common';\nimport type {\n  AnalyticsQueryOpts,\n  IAnalyticsQuery,\n  ResultRow,\n} from './analytics-query.protocol';\n\n@Injectable()\nexport class NoopAnalyticsBackend implements IAnalyticsQuery {\n  async execute(\n    _cube: string,\n    _measures: string[],\n    _dimensions: string[],\n    _where?: Record<string, any>,\n    _opts?: AnalyticsQueryOpts,\n  ): Promise<ResultRow[]> {\n    return [];\n  }\n}\n"],"mappings":";;;;;AAQA,SAAS,kBAAkB;AAQpB,IAAM,uBAAN,MAAsD;AAAA,EAC3D,MAAM,QACJ,OACA,WACA,aACA,QACA,OACsB;AACtB,WAAO,CAAC;AAAA,EACV;AACF;AAVa,uBAAN;AAAA,EADN,WAAW;AAAA,GACC;","names":[]}