@pattern-stack/codegen 0.15.1 → 0.15.2

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":"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","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-I6MG4M3F.js

@@ -0,0 +1,201 @@
+import {
+  MissingTenantIdError
+} from "./chunk-T4BIIU5E.js";
+import {
+  clampLimit,
+  decodeKeysetCursor,
+  encodeKeysetCursor,
+  toJobRunSummary
+} from "./chunk-L3LZWWSX.js";
+import {
+  JOBS_MULTI_TENANT,
+  JOB_ORCHESTRATOR
+} from "./chunk-BIO6F7YI.js";
+import {
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
+import { Inject, Injectable } from "@nestjs/common";
+import { and, asc, desc, eq, gte, inArray, isNull, lt, or, sql } from "drizzle-orm";
+var NON_TERMINAL_STATUSES = [
+  "pending",
+  "running",
+  "waiting"
+];
+var DrizzleJobRunService = class {
+  constructor(db, orchestrator, multiTenant) {
+    this.db = db;
+    this.orchestrator = orchestrator;
+    this.multiTenant = multiTenant;
+  }
+  db;
+  orchestrator;
+  multiTenant;
+  /**
+   * JOB-8 — produce the tenant WHERE fragment (or `null` to opt out).
+   * Returns `null` when multi-tenancy is off (caller skips the predicate).
+   * Throws `MissingTenantIdError` when on + `undefined`.
+   * When on + explicit `null`, filters `tenant_id IS NULL`.
+   */
+  tenantCondition(method, tenantId) {
+    if (!this.multiTenant) return null;
+    if (tenantId === void 0) throw new MissingTenantIdError(method);
+    return tenantId === null ? isNull(jobRuns.tenantId) : eq(jobRuns.tenantId, tenantId);
+  }
+  async listForScope(entityType, entityId, opts = {}) {
+    const conditions = [
+      eq(jobRuns.scopeEntityType, entityType),
+      eq(jobRuns.scopeEntityId, entityId)
+    ];
+    const tenantCond = this.tenantCondition("listForScope", opts.tenantId);
+    if (tenantCond) conditions.push(tenantCond);
+    if (opts.status) {
+      if (Array.isArray(opts.status)) {
+        conditions.push(inArray(jobRuns.status, opts.status));
+      } else {
+        conditions.push(eq(jobRuns.status, opts.status));
+      }
+    }
+    if (opts.jobType) {
+      conditions.push(eq(jobRuns.jobType, opts.jobType));
+    }
+    const orderCol = (() => {
+      switch (opts.orderBy) {
+        case "created_at asc":
+          return asc(jobRuns.createdAt);
+        case "run_at desc":
+          return desc(jobRuns.runAt);
+        case "run_at asc":
+          return asc(jobRuns.runAt);
+        case "created_at desc":
+        default:
+          return desc(jobRuns.createdAt);
+      }
+    })();
+    let q = this.db.select().from(jobRuns).where(and(...conditions)).orderBy(orderCol).$dynamic();
+    if (typeof opts.limit === "number") {
+      q = q.limit(opts.limit);
+    }
+    if (typeof opts.offset === "number") {
+      q = q.offset(opts.offset);
+    }
+    const rows = await q;
+    return rows;
+  }
+  async cancelForScope(entityType, entityId, opts = {}) {
+    const tenantCond = this.tenantCondition("cancelForScope", opts.tenantId);
+    const conditions = [
+      eq(jobRuns.scopeEntityType, entityType),
+      eq(jobRuns.scopeEntityId, entityId),
+      inArray(jobRuns.status, NON_TERMINAL_STATUSES)
+    ];
+    if (tenantCond) conditions.push(tenantCond);
+    const rows = await this.db.select({ id: jobRuns.id }).from(jobRuns).where(and(...conditions));
+    for (const { id } of rows) {
+      await this.orchestrator.cancel(id, {
+        cascade: true,
+        tenantId: opts.tenantId
+      });
+    }
+  }
+  async rescheduleForScope(entityType, entityId, newRunAt, opts = {}) {
+    const tenantCond = this.tenantCondition("rescheduleForScope", opts.tenantId);
+    const conditions = [
+      eq(jobRuns.scopeEntityType, entityType),
+      eq(jobRuns.scopeEntityId, entityId),
+      eq(jobRuns.status, "pending")
+    ];
+    if (tenantCond) conditions.push(tenantCond);
+    await this.db.update(jobRuns).set({ runAt: newRunAt, updatedAt: /* @__PURE__ */ new Date() }).where(and(...conditions));
+  }
+  async countByPoolAndStatus(tenantId) {
+    const tenantCond = this.tenantCondition("countByPoolAndStatus", tenantId);
+    const rows = await this.db.select({
+      pool: jobRuns.pool,
+      status: jobRuns.status,
+      count: sql`count(*)::int`.as("count")
+    }).from(jobRuns).where(tenantCond ?? void 0).groupBy(jobRuns.pool, jobRuns.status);
+    return rows.map((r) => ({
+      pool: r.pool,
+      status: r.status,
+      count: Number(r.count)
+    }));
+  }
+  async listRecentFailed(limit, tenantId) {
+    const conditions = [eq(jobRuns.status, "failed")];
+    const tenantCond = this.tenantCondition("listRecentFailed", tenantId);
+    if (tenantCond) conditions.push(tenantCond);
+    const rows = await this.db.select().from(jobRuns).where(and(...conditions)).orderBy(desc(jobRuns.finishedAt), desc(jobRuns.updatedAt)).limit(limit);
+    return rows.map((r) => ({
+      runId: r.id,
+      jobType: r.jobType,
+      pool: r.pool,
+      scopeEntityType: r.scopeEntityType,
+      scopeEntityId: r.scopeEntityId,
+      tenantId: r.tenantId,
+      attempts: r.attempts,
+      errorMessage: r.error?.message ?? null,
+      failedAt: r.finishedAt ?? r.updatedAt,
+      createdAt: r.createdAt
+    }));
+  }
+  async listJobRuns(query = {}) {
+    const limit = clampLimit(query.limit);
+    const conditions = [];
+    const tenantCond = this.tenantCondition("listJobRuns", query.tenantId);
+    if (tenantCond) conditions.push(tenantCond);
+    if (query.poolId) conditions.push(eq(jobRuns.pool, query.poolId));
+    if (query.rootRunId) conditions.push(eq(jobRuns.rootRunId, query.rootRunId));
+    if (query.status) conditions.push(eq(jobRuns.status, query.status));
+    if (query.since) conditions.push(gte(jobRuns.createdAt, query.since));
+    if (query.cursor) {
+      const keyset = decodeKeysetCursor(query.cursor);
+      if (keyset) {
+        conditions.push(
+          or(
+            lt(jobRuns.createdAt, keyset.createdAt),
+            and(
+              eq(jobRuns.createdAt, keyset.createdAt),
+              lt(jobRuns.id, keyset.id)
+            )
+          )
+        );
+      }
+    }
+    const rows = await this.db.select().from(jobRuns).where(conditions.length > 0 ? and(...conditions) : void 0).orderBy(desc(jobRuns.createdAt), desc(jobRuns.id)).limit(limit + 1);
+    const hasMore = rows.length > limit;
+    const page = hasMore ? rows.slice(0, limit) : rows;
+    const items = page.map(toJobRunSummary);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeKeysetCursor({ createdAt: last.createdAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
+  /**
+   * Internal helper used by cascade paths (not on the public protocol).
+   * Exposed as a public method on the concrete class so infrastructure
+   * code (cascade tests, debug tools) can call it without a cast.
+   */
+  async findByRootRunId(rootRunId) {
+    const rows = await this.db.select().from(jobRuns).where(eq(jobRuns.rootRunId, rootRunId));
+    return rows;
+  }
+};
+DrizzleJobRunService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE)),
+  __decorateParam(1, Inject(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject(JOBS_MULTI_TENANT))
+], DrizzleJobRunService);
+
+export {
+  DrizzleJobRunService
+};
+//# sourceMappingURL=chunk-I6MG4M3F.js.map

package/dist/chunk-I6MG4M3F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-run-service.drizzle-backend.ts"],"sourcesContent":["/**\n * DrizzleJobRunService — scope-oriented reads and bulk operations against\n * `job_run` (ADR-022, JOB-3).\n *\n * Separate from the orchestrator because the access pattern differs: this\n * service scans by `(scope_entity_type, scope_entity_id)` via\n * `idx_job_run_scope`, whereas orchestrator mutates individual runs by id.\n */\nimport { Inject, Injectable } from '@nestjs/common';\nimport { and, asc, desc, eq, gte, inArray, isNull, lt, or, sql } from 'drizzle-orm';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DRIZZLE } from '../../constants/tokens';\nimport { jobRuns, type JobRunRow } from './job-orchestration.schema';\nimport type { JobRun } from './job-orchestrator.protocol';\nimport type {\n  IJobRunService,\n  ListForScopeOptions,\n  CancelForScopeOptions,\n  RescheduleForScopeOptions,\n  PoolStatusCount,\n  JobRunFailure,\n  ListJobRunsQuery,\n  JobRunPage,\n  JobRunSummary,\n} from './job-run-service.protocol';\nimport {\n  clampLimit,\n  decodeKeysetCursor,\n  encodeKeysetCursor,\n  toJobRunSummary,\n} from './job-run-keyset-cursor';\nimport type { IJobOrchestrator } from './job-orchestrator.protocol';\nimport { JOB_ORCHESTRATOR, JOBS_MULTI_TENANT } from './jobs-domain.tokens';\nimport { MissingTenantIdError } from './jobs-errors';\n\nconst NON_TERMINAL_STATUSES: JobRunRow['status'][] = [\n  'pending',\n  'running',\n  'waiting',\n];\n\n@Injectable()\nexport class DrizzleJobRunService implements IJobRunService {\n  constructor(\n    @Inject(DRIZZLE) private readonly db: DrizzleClient,\n    @Inject(JOB_ORCHESTRATOR) private readonly orchestrator: IJobOrchestrator,\n    @Inject(JOBS_MULTI_TENANT) private readonly multiTenant: boolean,\n  ) {}\n\n  /**\n   * JOB-8 — produce the tenant WHERE fragment (or `null` to opt out).\n   * Returns `null` when multi-tenancy is off (caller skips the predicate).\n   * Throws `MissingTenantIdError` when on + `undefined`.\n   * When on + explicit `null`, filters `tenant_id IS NULL`.\n   */\n  private tenantCondition(\n    method: string,\n    tenantId: string | null | undefined,\n  ) {\n    if (!this.multiTenant) return null;\n    if (tenantId === undefined) throw new MissingTenantIdError(method);\n    return tenantId === null\n      ? isNull(jobRuns.tenantId)\n      : eq(jobRuns.tenantId, tenantId);\n  }\n\n  async listForScope(\n    entityType: string,\n    entityId: string,\n    opts: ListForScopeOptions = {},\n  ): Promise<JobRun[]> {\n    const conditions = [\n      eq(jobRuns.scopeEntityType, entityType),\n      eq(jobRuns.scopeEntityId, entityId),\n    ];\n    const tenantCond = this.tenantCondition('listForScope', opts.tenantId);\n    if (tenantCond) conditions.push(tenantCond);\n    if (opts.status) {\n      if (Array.isArray(opts.status)) {\n        conditions.push(inArray(jobRuns.status, opts.status));\n      } else {\n        conditions.push(eq(jobRuns.status, opts.status));\n      }\n    }\n    if (opts.jobType) {\n      conditions.push(eq(jobRuns.jobType, opts.jobType));\n    }\n\n    const orderCol = (() => {\n      switch (opts.orderBy) {\n        case 'created_at asc':\n          return asc(jobRuns.createdAt);\n        case 'run_at desc':\n          return desc(jobRuns.runAt);\n        case 'run_at asc':\n          return asc(jobRuns.runAt);\n        case 'created_at desc':\n        default:\n          return desc(jobRuns.createdAt);\n      }\n    })();\n\n    let q = this.db\n      .select()\n      .from(jobRuns)\n      .where(and(...conditions))\n      .orderBy(orderCol)\n      .$dynamic();\n\n    if (typeof opts.limit === 'number') {\n      q = q.limit(opts.limit);\n    }\n    if (typeof opts.offset === 'number') {\n      q = q.offset(opts.offset);\n    }\n\n    const rows = await q;\n    return rows as JobRun[];\n  }\n\n  async cancelForScope(\n    entityType: string,\n    entityId: string,\n    opts: CancelForScopeOptions = {},\n  ): Promise<void> {\n    const tenantCond = this.tenantCondition('cancelForScope', opts.tenantId);\n    const conditions = [\n      eq(jobRuns.scopeEntityType, entityType),\n      eq(jobRuns.scopeEntityId, entityId),\n      inArray(jobRuns.status, NON_TERMINAL_STATUSES),\n    ];\n    if (tenantCond) conditions.push(tenantCond);\n\n    const rows = await this.db\n      .select({ id: jobRuns.id })\n      .from(jobRuns)\n      .where(and(...conditions));\n\n    for (const { id } of rows) {\n      // Propagate the tenant gate into cascade-cancel. The scope query has\n      // already narrowed to this tenant; passing `tenantId` through keeps\n      // the orchestrator's per-row guard consistent under multi-tenant mode.\n      await this.orchestrator.cancel(id, {\n        cascade: true,\n        tenantId: opts.tenantId,\n      });\n    }\n  }\n\n  async rescheduleForScope(\n    entityType: string,\n    entityId: string,\n    newRunAt: Date,\n    opts: RescheduleForScopeOptions = {},\n  ): Promise<void> {\n    const tenantCond = this.tenantCondition('rescheduleForScope', opts.tenantId);\n    const conditions = [\n      eq(jobRuns.scopeEntityType, entityType),\n      eq(jobRuns.scopeEntityId, entityId),\n      eq(jobRuns.status, 'pending'),\n    ];\n    if (tenantCond) conditions.push(tenantCond);\n\n    await this.db\n      .update(jobRuns)\n      .set({ runAt: newRunAt, updatedAt: new Date() })\n      .where(and(...conditions));\n  }\n\n  async countByPoolAndStatus(\n    tenantId?: string | null,\n  ): Promise<PoolStatusCount[]> {\n    const tenantCond = this.tenantCondition('countByPoolAndStatus', tenantId);\n    const rows = await this.db\n      .select({\n        pool: jobRuns.pool,\n        status: jobRuns.status,\n        count: sql<number>`count(*)::int`.as('count'),\n      })\n      .from(jobRuns)\n      .where(tenantCond ?? undefined)\n      .groupBy(jobRuns.pool, jobRuns.status);\n\n    return rows.map((r) => ({\n      pool: r.pool,\n      status: r.status,\n      count: Number(r.count),\n    }));\n  }\n\n  async listRecentFailed(\n    limit: number,\n    tenantId?: string | null,\n  ): Promise<JobRunFailure[]> {\n    const conditions = [eq(jobRuns.status, 'failed' as const)];\n    const tenantCond = this.tenantCondition('listRecentFailed', tenantId);\n    if (tenantCond) conditions.push(tenantCond);\n\n    const rows = await this.db\n      .select()\n      .from(jobRuns)\n      .where(and(...conditions))\n      .orderBy(desc(jobRuns.finishedAt), desc(jobRuns.updatedAt))\n      .limit(limit);\n\n    return rows.map((r) => ({\n      runId: r.id,\n      jobType: r.jobType,\n      pool: r.pool,\n      scopeEntityType: r.scopeEntityType,\n      scopeEntityId: r.scopeEntityId,\n      tenantId: r.tenantId,\n      attempts: r.attempts,\n      errorMessage: r.error?.message ?? null,\n      failedAt: r.finishedAt ?? r.updatedAt,\n      createdAt: r.createdAt,\n    }));\n  }\n\n  async listJobRuns(query: ListJobRunsQuery = {}): Promise<JobRunPage> {\n    const limit = clampLimit(query.limit);\n    const conditions = [];\n\n    const tenantCond = this.tenantCondition('listJobRuns', query.tenantId);\n    if (tenantCond) conditions.push(tenantCond);\n    if (query.poolId) conditions.push(eq(jobRuns.pool, query.poolId));\n    if (query.rootRunId) conditions.push(eq(jobRuns.rootRunId, query.rootRunId));\n    if (query.status) conditions.push(eq(jobRuns.status, query.status));\n    if (query.since) conditions.push(gte(jobRuns.createdAt, query.since));\n\n    // Keyset seek: WHERE (created_at, id) < (cursorCreatedAt, cursorId),\n    // expanded into a SARGable OR so the same `created_at` index is used.\n    if (query.cursor) {\n      const keyset = decodeKeysetCursor(query.cursor);\n      if (keyset) {\n        conditions.push(\n          or(\n            lt(jobRuns.createdAt, keyset.createdAt),\n            and(\n              eq(jobRuns.createdAt, keyset.createdAt),\n              lt(jobRuns.id, keyset.id),\n            ),\n          )!,\n        );\n      }\n    }\n\n    // Fetch one extra row to determine whether a next page exists without a\n    // separate COUNT.\n    const rows = await this.db\n      .select()\n      .from(jobRuns)\n      .where(conditions.length > 0 ? and(...conditions) : undefined)\n      .orderBy(desc(jobRuns.createdAt), desc(jobRuns.id))\n      .limit(limit + 1);\n\n    const hasMore = rows.length > limit;\n    const page = hasMore ? rows.slice(0, limit) : rows;\n    const items = page.map(toJobRunSummary);\n    const last = page[page.length - 1];\n    const nextCursor =\n      hasMore && last\n        ? encodeKeysetCursor({ createdAt: last.createdAt, id: last.id })\n        : null;\n\n    return { items, nextCursor };\n  }\n\n  /**\n   * Internal helper used by cascade paths (not on the public protocol).\n   * Exposed as a public method on the concrete class so infrastructure\n   * code (cascade tests, debug tools) can call it without a cast.\n   */\n  async findByRootRunId(rootRunId: string): Promise<JobRun[]> {\n    const rows = await this.db\n      .select()\n      .from(jobRuns)\n      .where(eq(jobRuns.rootRunId, rootRunId));\n    return rows as JobRun[];\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,QAAQ,kBAAkB;AACnC,SAAS,KAAK,KAAK,MAAM,IAAI,KAAK,SAAS,QAAQ,IAAI,IAAI,WAAW;AA0BtE,IAAM,wBAA+C;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AACF;AAGO,IAAM,uBAAN,MAAqD;AAAA,EAC1D,YACoC,IACS,cACC,aAC5C;AAHkC;AACS;AACC;AAAA,EAC3C;AAAA,EAHiC;AAAA,EACS;AAAA,EACC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAStC,gBACN,QACA,UACA;AACA,QAAI,CAAC,KAAK,YAAa,QAAO;AAC9B,QAAI,aAAa,OAAW,OAAM,IAAI,qBAAqB,MAAM;AACjE,WAAO,aAAa,OAChB,OAAO,QAAQ,QAAQ,IACvB,GAAG,QAAQ,UAAU,QAAQ;AAAA,EACnC;AAAA,EAEA,MAAM,aACJ,YACA,UACA,OAA4B,CAAC,GACV;AACnB,UAAM,aAAa;AAAA,MACjB,GAAG,QAAQ,iBAAiB,UAAU;AAAA,MACtC,GAAG,QAAQ,eAAe,QAAQ;AAAA,IACpC;AACA,UAAM,aAAa,KAAK,gBAAgB,gBAAgB,KAAK,QAAQ;AACrE,QAAI,WAAY,YAAW,KAAK,UAAU;AAC1C,QAAI,KAAK,QAAQ;AACf,UAAI,MAAM,QAAQ,KAAK,MAAM,GAAG;AAC9B,mBAAW,KAAK,QAAQ,QAAQ,QAAQ,KAAK,MAAM,CAAC;AAAA,MACtD,OAAO;AACL,mBAAW,KAAK,GAAG,QAAQ,QAAQ,KAAK,MAAM,CAAC;AAAA,MACjD;AAAA,IACF;AACA,QAAI,KAAK,SAAS;AAChB,iBAAW,KAAK,GAAG,QAAQ,SAAS,KAAK,OAAO,CAAC;AAAA,IACnD;AAEA,UAAM,YAAY,MAAM;AACtB,cAAQ,KAAK,SAAS;AAAA,QACpB,KAAK;AACH,iBAAO,IAAI,QAAQ,SAAS;AAAA,QAC9B,KAAK;AACH,iBAAO,KAAK,QAAQ,KAAK;AAAA,QAC3B,KAAK;AACH,iBAAO,IAAI,QAAQ,KAAK;AAAA,QAC1B,KAAK;AAAA,QACL;AACE,iBAAO,KAAK,QAAQ,SAAS;AAAA,MACjC;AAAA,IACF,GAAG;AAEH,QAAI,IAAI,KAAK,GACV,OAAO,EACP,KAAK,OAAO,EACZ,MAAM,IAAI,GAAG,UAAU,CAAC,EACxB,QAAQ,QAAQ,EAChB,SAAS;AAEZ,QAAI,OAAO,KAAK,UAAU,UAAU;AAClC,UAAI,EAAE,MAAM,KAAK,KAAK;AAAA,IACxB;AACA,QAAI,OAAO,KAAK,WAAW,UAAU;AACnC,UAAI,EAAE,OAAO,KAAK,MAAM;AAAA,IAC1B;AAEA,UAAM,OAAO,MAAM;AACnB,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,eACJ,YACA,UACA,OAA8B,CAAC,GAChB;AACf,UAAM,aAAa,KAAK,gBAAgB,kBAAkB,KAAK,QAAQ;AACvE,UAAM,aAAa;AAAA,MACjB,GAAG,QAAQ,iBAAiB,UAAU;AAAA,MACtC,GAAG,QAAQ,eAAe,QAAQ;AAAA,MAClC,QAAQ,QAAQ,QAAQ,qBAAqB;AAAA,IAC/C;AACA,QAAI,WAAY,YAAW,KAAK,UAAU;AAE1C,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO,EAAE,IAAI,QAAQ,GAAG,CAAC,EACzB,KAAK,OAAO,EACZ,MAAM,IAAI,GAAG,UAAU,CAAC;AAE3B,eAAW,EAAE,GAAG,KAAK,MAAM;AAIzB,YAAM,KAAK,aAAa,OAAO,IAAI;AAAA,QACjC,SAAS;AAAA,QACT,UAAU,KAAK;AAAA,MACjB,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,MAAM,mBACJ,YACA,UACA,UACA,OAAkC,CAAC,GACpB;AACf,UAAM,aAAa,KAAK,gBAAgB,sBAAsB,KAAK,QAAQ;AAC3E,UAAM,aAAa;AAAA,MACjB,GAAG,QAAQ,iBAAiB,UAAU;AAAA,MACtC,GAAG,QAAQ,eAAe,QAAQ;AAAA,MAClC,GAAG,QAAQ,QAAQ,SAAS;AAAA,IAC9B;AACA,QAAI,WAAY,YAAW,KAAK,UAAU;AAE1C,UAAM,KAAK,GACR,OAAO,OAAO,EACd,IAAI,EAAE,OAAO,UAAU,WAAW,oBAAI,KAAK,EAAE,CAAC,EAC9C,MAAM,IAAI,GAAG,UAAU,CAAC;AAAA,EAC7B;AAAA,EAEA,MAAM,qBACJ,UAC4B;AAC5B,UAAM,aAAa,KAAK,gBAAgB,wBAAwB,QAAQ;AACxE,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO;AAAA,MACN,MAAM,QAAQ;AAAA,MACd,QAAQ,QAAQ;AAAA,MAChB,OAAO,mBAA2B,GAAG,OAAO;AAAA,IAC9C,CAAC,EACA,KAAK,OAAO,EACZ,MAAM,cAAc,MAAS,EAC7B,QAAQ,QAAQ,MAAM,QAAQ,MAAM;AAEvC,WAAO,KAAK,IAAI,CAAC,OAAO;AAAA,MACtB,MAAM,EAAE;AAAA,MACR,QAAQ,EAAE;AAAA,MACV,OAAO,OAAO,EAAE,KAAK;AAAA,IACvB,EAAE;AAAA,EACJ;AAAA,EAEA,MAAM,iBACJ,OACA,UAC0B;AAC1B,UAAM,aAAa,CAAC,GAAG,QAAQ,QAAQ,QAAiB,CAAC;AACzD,UAAM,aAAa,KAAK,gBAAgB,oBAAoB,QAAQ;AACpE,QAAI,WAAY,YAAW,KAAK,UAAU;AAE1C,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO,EACP,KAAK,OAAO,EACZ,MAAM,IAAI,GAAG,UAAU,CAAC,EACxB,QAAQ,KAAK,QAAQ,UAAU,GAAG,KAAK,QAAQ,SAAS,CAAC,EACzD,MAAM,KAAK;AAEd,WAAO,KAAK,IAAI,CAAC,OAAO;AAAA,MACtB,OAAO,EAAE;AAAA,MACT,SAAS,EAAE;AAAA,MACX,MAAM,EAAE;AAAA,MACR,iBAAiB,EAAE;AAAA,MACnB,eAAe,EAAE;AAAA,MACjB,UAAU,EAAE;AAAA,MACZ,UAAU,EAAE;AAAA,MACZ,cAAc,EAAE,OAAO,WAAW;AAAA,MAClC,UAAU,EAAE,cAAc,EAAE;AAAA,MAC5B,WAAW,EAAE;AAAA,IACf,EAAE;AAAA,EACJ;AAAA,EAEA,MAAM,YAAY,QAA0B,CAAC,GAAwB;AACnE,UAAM,QAAQ,WAAW,MAAM,KAAK;AACpC,UAAM,aAAa,CAAC;AAEpB,UAAM,aAAa,KAAK,gBAAgB,eAAe,MAAM,QAAQ;AACrE,QAAI,WAAY,YAAW,KAAK,UAAU;AAC1C,QAAI,MAAM,OAAQ,YAAW,KAAK,GAAG,QAAQ,MAAM,MAAM,MAAM,CAAC;AAChE,QAAI,MAAM,UAAW,YAAW,KAAK,GAAG,QAAQ,WAAW,MAAM,SAAS,CAAC;AAC3E,QAAI,MAAM,OAAQ,YAAW,KAAK,GAAG,QAAQ,QAAQ,MAAM,MAAM,CAAC;AAClE,QAAI,MAAM,MAAO,YAAW,KAAK,IAAI,QAAQ,WAAW,MAAM,KAAK,CAAC;AAIpE,QAAI,MAAM,QAAQ;AAChB,YAAM,SAAS,mBAAmB,MAAM,MAAM;AAC9C,UAAI,QAAQ;AACV,mBAAW;AAAA,UACT;AAAA,YACE,GAAG,QAAQ,WAAW,OAAO,SAAS;AAAA,YACtC;AAAA,cACE,GAAG,QAAQ,WAAW,OAAO,SAAS;AAAA,cACtC,GAAG,QAAQ,IAAI,OAAO,EAAE;AAAA,YAC1B;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAIA,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO,EACP,KAAK,OAAO,EACZ,MAAM,WAAW,SAAS,IAAI,IAAI,GAAG,UAAU,IAAI,MAAS,EAC5D,QAAQ,KAAK,QAAQ,SAAS,GAAG,KAAK,QAAQ,EAAE,CAAC,EACjD,MAAM,QAAQ,CAAC;AAElB,UAAM,UAAU,KAAK,SAAS;AAC9B,UAAM,OAAO,UAAU,KAAK,MAAM,GAAG,KAAK,IAAI;AAC9C,UAAM,QAAQ,KAAK,IAAI,eAAe;AACtC,UAAM,OAAO,KAAK,KAAK,SAAS,CAAC;AACjC,UAAM,aACJ,WAAW,OACP,mBAAmB,EAAE,WAAW,KAAK,WAAW,IAAI,KAAK,GAAG,CAAC,IAC7D;AAEN,WAAO,EAAE,OAAO,WAAW;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,gBAAgB,WAAsC;AAC1D,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO,EACP,KAAK,OAAO,EACZ,MAAM,GAAG,QAAQ,WAAW,SAAS,CAAC;AACzC,WAAO;AAAA,EACT;AACF;AA9Oa,uBAAN;AAAA,EADN,WAAW;AAAA,EAGP,0BAAO,OAAO;AAAA,EACd,0BAAO,gBAAgB;AAAA,EACvB,0BAAO,iBAAiB;AAAA,GAJhB;","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-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":[]}