@pattern-stack/codegen 0.15.1 → 0.15.3

package/dist/chunk-OTDN3OUQ.js

@@ -0,0 +1,215 @@
+import {
+  BaseRepository
+} from "./chunk-J6KZS54B.js";
+
+// runtime/base-classes/integrated-entity-repository.ts
+import { and, eq, inArray } from "drizzle-orm";
+var IntegratedEntityRepository = class extends BaseRepository {
+  /**
+   * Find a single entity by its external CRM identifier.
+   */
+  async findByExternalId(externalId) {
+    const rows = await this.baseQuery().where(eq(this.table["externalId"], externalId)).limit(1);
+    return rows[0] ?? null;
+  }
+  /**
+   * Find multiple entities by external CRM identifiers.
+   */
+  async findManyByExternalIds(externalIds) {
+    if (externalIds.length === 0) return [];
+    const rows = await this.baseQuery().where(inArray(this.table["externalId"], externalIds));
+    return rows;
+  }
+  /**
+   * Find all entities owned by a specific user.
+   */
+  async findAllByUserId(userId) {
+    const rows = await this.baseQuery().where(eq(this.table["userId"], userId));
+    return rows;
+  }
+  // ==========================================================================
+  // Inbound integration (#374) — canonical→Drizzle write + provider-scoped FK
+  // resolution + EAV dual-write seam, all inside a SINGLE transaction.
+  // Driven entirely by `this.integrationConfig`; the per-entity shape lives there.
+  // ==========================================================================
+  /**
+   * Upsert ONE entity by its `(provider, externalId)` identity, in a single
+   * transaction:
+   *   1. resolve each `integrationConfig.fkResolvers` FK (provider-scoped). Strict
+   *      resolvers throw on unresolved; non-strict leave the column null.
+   *   2. insert-or-update the canonical columns via `onConflictDoUpdate` on the
+   *      `conflictTarget`. Resolved FKs are only written into `set` when
+   *      non-null this run (no-clobber).
+   *   3. EAV dual-write of `write.fields` via `writeCustomFields` when
+   *      `integrationConfig.eav` and the bag is non-empty (same tx).
+   *
+   * Idempotent: a second call with the same identity updates in place. Returns
+   * the canonical projection (so the orchestrator records `local_id`).
+   *
+   * @param write     canonical fields + parent external ids + custom-field bag
+   * @param provider  adapter/provider label persisted + used to scope lookups
+   * @param tx        optional outer transaction; when omitted we open our own
+   */
+  async integrationUpsertOne(write, provider, tx) {
+    const cfg = this.integrationConfig;
+    const w = write;
+    const run = async (db) => {
+      const resolvedFks = {};
+      for (const fk of cfg.fkResolvers) {
+        resolvedFks[fk.column] = await this.resolveFk(db, fk, w[fk.writeKey], provider);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const copyThrough = {};
+      for (const col of cfg.writeColumns) copyThrough[col] = w[col];
+      const values = {
+        externalId: w["externalId"],
+        provider,
+        ...copyThrough,
+        ...resolvedFks,
+        ...this.behaviors.timestamps ? { updatedAt: now } : {}
+      };
+      const set = {
+        ...copyThrough,
+        ...this.behaviors.timestamps ? { updatedAt: now } : {}
+      };
+      for (const fk of cfg.fkResolvers) {
+        if (resolvedFks[fk.column] !== null) set[fk.column] = resolvedFks[fk.column];
+      }
+      const rows = await db.insert(this.table).values(values).onConflictDoUpdate({
+        target: cfg.conflictTarget.map((c) => this.table[c]),
+        set
+      }).returning();
+      const saved = rows[0];
+      const fields = w["fields"];
+      if (cfg.eav && fields && Object.keys(fields).length > 0) {
+        await this.writeCustomFields(
+          db,
+          saved["id"],
+          w["userId"],
+          fields
+        );
+      }
+      return this.toProjection(saved);
+    };
+    return tx ? run(tx) : this.db.transaction((t) => run(t));
+  }
+  /**
+   * Canonical-projected lookup by external id (differ-ready). Returns `null`
+   * when no local row exists. Provider-scoped so a HubSpot id can't match a
+   * Salesforce row.
+   */
+  async findByExternalIdProjected(externalId, provider) {
+    const rows = await this.db.select().from(this.table).where(
+      and(
+        eq(this.table["provider"], provider),
+        eq(this.table["externalId"], externalId)
+      )
+    ).limit(1);
+    const row = rows[0];
+    return row ? this.toProjection(row) : null;
+  }
+  /**
+   * Integration "delete" by external id, provider-scoped. When `softDelete: true`,
+   * sets `deletedAt`. When `softDelete: false`, tombstone-by-clearing: null out
+   * `external_id`/`provider` so the row no longer matches future inbound
+   * changes while preserving local-id references. Returns `{ id }` or `null`.
+   */
+  async softDeleteByExternalId(externalId, provider, tx) {
+    const db = this.runner(tx);
+    const set = this.integrationConfig.softDelete ? { deletedAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date() } : { externalId: null, provider: null, updatedAt: /* @__PURE__ */ new Date() };
+    const rows = await db.update(this.table).set(set).where(
+      and(
+        eq(this.table["provider"], provider),
+        eq(this.table["externalId"], externalId)
+      )
+    ).returning({ id: this.table["id"] });
+    return rows[0] ? { id: rows[0].id } : null;
+  }
+  /**
+   * Batch integration upsert — concretizes the former abstract stub. Delegates to
+   * `integrationUpsertOne` per input inside one transaction. Inputs are raw partial
+   * rows: provider is read from each input's own `provider` column; rows
+   * missing `externalId`/`provider` are skipped.
+   */
+  async integrationUpsert(inputs) {
+    if (inputs.length === 0) return [];
+    return this.db.transaction(async (tx) => {
+      const out = [];
+      for (const input of inputs) {
+        const rec = input;
+        if (!rec["externalId"] || !rec["provider"]) continue;
+        const proj = await this.integrationUpsertOne(
+          input,
+          rec["provider"],
+          tx
+        );
+        const id = proj["id"];
+        const row = await tx.select().from(this.table).where(eq(this.table["id"], id)).limit(1);
+        out.push(row[0]);
+      }
+      return out;
+    });
+  }
+  /**
+   * Project a raw row to the canonical differ shape — a generic pick over
+   * `integrationConfig.projectionColumns`. Override only for synthesized projections
+   * (e.g. junctions); entities use this verbatim.
+   */
+  toProjection(row) {
+    const r = row;
+    const out = {};
+    for (const col of this.integrationConfig.projectionColumns) out[col] = r[col];
+    return out;
+  }
+  /**
+   * EAV dual-write seam (#374, live path lands in #124). No-op by default;
+   * `eav: true` entities emit a concrete override that injects
+   * `FieldValueService` and delegates to `upsertFieldsTransactional` so the
+   * dual-write joins the same tx (`db`). Kept as an explicit hook so the base
+   * stays portable (the FieldValueService dependency is eav-only).
+   */
+  async writeCustomFields(_db, _entityId, _userId, _fields) {
+  }
+  /**
+   * Resolve one FK from a parent external id (provider-scoped). `self` resolves
+   * against `this.table`. Strict resolvers throw when unresolved; non-strict
+   * return null. A null/absent write value short-circuits to null.
+   */
+  async resolveFk(db, fk, rawExternalId, provider) {
+    const parentExternalId = rawExternalId;
+    if (!parentExternalId) {
+      if (fk.strict) {
+        throw new Error(
+          `${this.constructor.name}.integrationUpsertOne: missing required parent external id for '${fk.column}' (writeKey '${fk.writeKey}')`
+        );
+      }
+      return null;
+    }
+    const refTable = fk.refTable === "self" ? this.table : fk.refTable;
+    const rows = await db.select({ id: refTable["id"] }).from(refTable).where(
+      and(
+        eq(refTable["provider"], provider),
+        eq(refTable["externalId"], parentExternalId)
+      )
+    ).limit(1);
+    const id = rows[0]?.id ?? null;
+    if (id === null && fk.strict) {
+      throw new Error(
+        `${this.constructor.name}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${fk.column}' \u2014 parent not integrated yet`
+      );
+    }
+    return id;
+  }
+  /**
+   * Find entities visible to a user (ownership + sharing rules).
+   * Concrete repositories must implement with visibility logic.
+   */
+  async findVisibleByUserId(_userId) {
+    throw new Error("findVisibleByUserId not implemented \u2014 override in concrete repository");
+  }
+};
+
+export {
+  IntegratedEntityRepository
+};
+//# sourceMappingURL=chunk-OTDN3OUQ.js.map

package/dist/chunk-OTDN3OUQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/integrated-entity-repository.ts"],"sourcesContent":["/**\n * IntegratedEntityRepository<TEntity, TIntegrationWrite, TIntegrationProjection>\n *\n * Family-specific base for Integrated entities (contacts, accounts, opportunities).\n * Adds external ID lookups, user-scoped queries, and the generic inbound-integration\n * write surface (canonical→Drizzle upsert + provider-scoped FK resolution +\n * EAV dual-write seam), driven by the concrete repo's `integrationConfig`.\n *\n * The type params default so pre-existing single-param subclasses keep\n * compiling; `pattern: Integrated` repos declare all three plus `integrationConfig`.\n */\nimport { and, eq, inArray } from 'drizzle-orm';\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nimport type { PgTableWithColumns } from 'drizzle-orm/pg-core';\nimport type { DrizzleTx } from '../types/drizzle';\nimport { BaseRepository } from './base-repository';\nimport type { IntegrationUpsertConfig, IntegrationFkResolver } from './integration-upsert-config';\n\nexport abstract class IntegratedEntityRepository<\n  TEntity,\n  TIntegrationWrite = Partial<TEntity>,\n  TIntegrationProjection = TEntity,\n> extends BaseRepository<TEntity> {\n  /**\n   * Declarative integration write surface. Concrete (`pattern: Integrated`) repositories\n   * declare this — the template emits it from the entity's fields + FKs.\n   */\n  protected abstract readonly integrationConfig: IntegrationUpsertConfig;\n\n  /**\n   * Find a single entity by its external CRM identifier.\n   */\n  async findByExternalId(externalId: string): Promise<TEntity | null> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['externalId'], externalId))\n      .limit(1);\n    return (rows[0] as TEntity) ?? null;\n  }\n\n  /**\n   * Find multiple entities by external CRM identifiers.\n   */\n  async findManyByExternalIds(externalIds: string[]): Promise<TEntity[]> {\n    if (externalIds.length === 0) return [];\n    const rows = await this.baseQuery()\n      .where(inArray(this.table['externalId'], externalIds));\n    return rows as TEntity[];\n  }\n\n  /**\n   * Find all entities owned by a specific user.\n   */\n  async findAllByUserId(userId: string): Promise<TEntity[]> {\n    const rows = await this.baseQuery()\n      .where(eq(this.table['userId'], userId));\n    return rows as TEntity[];\n  }\n\n  // ==========================================================================\n  // Inbound integration (#374) — canonical→Drizzle write + provider-scoped FK\n  // resolution + EAV dual-write seam, all inside a SINGLE transaction.\n  // Driven entirely by `this.integrationConfig`; the per-entity shape lives there.\n  // ==========================================================================\n\n  /**\n   * Upsert ONE entity by its `(provider, externalId)` identity, in a single\n   * transaction:\n   *   1. resolve each `integrationConfig.fkResolvers` FK (provider-scoped). Strict\n   *      resolvers throw on unresolved; non-strict leave the column null.\n   *   2. insert-or-update the canonical columns via `onConflictDoUpdate` on the\n   *      `conflictTarget`. Resolved FKs are only written into `set` when\n   *      non-null this run (no-clobber).\n   *   3. EAV dual-write of `write.fields` via `writeCustomFields` when\n   *      `integrationConfig.eav` and the bag is non-empty (same tx).\n   *\n   * Idempotent: a second call with the same identity updates in place. Returns\n   * the canonical projection (so the orchestrator records `local_id`).\n   *\n   * @param write     canonical fields + parent external ids + custom-field bag\n   * @param provider  adapter/provider label persisted + used to scope lookups\n   * @param tx        optional outer transaction; when omitted we open our own\n   */\n  async integrationUpsertOne(\n    write: TIntegrationWrite,\n    provider: string,\n    tx?: DrizzleTx,\n  ): Promise<TIntegrationProjection> {\n    const cfg = this.integrationConfig;\n    const w = write as Record<string, unknown>;\n\n    const run = async (db: DrizzleTx): Promise<TIntegrationProjection> => {\n      // 1. FK resolution (provider-scoped). Strict → throw; else opportunistic null.\n      const resolvedFks: Record<string, string | null> = {};\n      for (const fk of cfg.fkResolvers) {\n        resolvedFks[fk.column] = await this.resolveFk(db, fk, w[fk.writeKey], provider);\n      }\n\n      // 2. Canonical → Drizzle insert-or-update by the conflict target.\n      const now = new Date();\n      const copyThrough: Record<string, unknown> = {};\n      for (const col of cfg.writeColumns) copyThrough[col] = w[col];\n\n      const values: Record<string, unknown> = {\n        externalId: w['externalId'],\n        provider,\n        ...copyThrough,\n        ...resolvedFks,\n        ...(this.behaviors.timestamps ? { updatedAt: now } : {}),\n      };\n\n      // `set` excludes the identity (externalId/provider). Resolved FKs are\n      // only written when non-null this run — never clobber a previously\n      // resolved parent with null on a later run that dropped the ref.\n      const set: Record<string, unknown> = {\n        ...copyThrough,\n        ...(this.behaviors.timestamps ? { updatedAt: now } : {}),\n      };\n      for (const fk of cfg.fkResolvers) {\n        if (resolvedFks[fk.column] !== null) set[fk.column] = resolvedFks[fk.column];\n      }\n\n      const rows = await db\n        .insert(this.table)\n        .values(values as never)\n        .onConflictDoUpdate({\n          target: cfg.conflictTarget.map((c: string) => this.table[c]),\n          set: set as never,\n        })\n        .returning();\n\n      const saved = rows[0] as Record<string, unknown>;\n\n      // 3. EAV dual-write seam — same tx. No-op unless the entity opts in.\n      const fields = w['fields'] as Record<string, unknown> | undefined;\n      if (cfg.eav && fields && Object.keys(fields).length > 0) {\n        await this.writeCustomFields(\n          db,\n          saved['id'] as string,\n          w['userId'] as string,\n          fields,\n        );\n      }\n\n      return this.toProjection(saved as TEntity);\n    };\n\n    return tx ? run(tx) : this.db.transaction((t) => run(t));\n  }\n\n  /**\n   * Canonical-projected lookup by external id (differ-ready). Returns `null`\n   * when no local row exists. Provider-scoped so a HubSpot id can't match a\n   * Salesforce row.\n   */\n  async findByExternalIdProjected(\n    externalId: string,\n    provider: string,\n  ): Promise<TIntegrationProjection | null> {\n    const rows = await this.db\n      .select()\n      .from(this.table)\n      .where(\n        and(\n          eq(this.table['provider'], provider),\n          eq(this.table['externalId'], externalId),\n        ),\n      )\n      .limit(1);\n    const row = rows[0] as TEntity | undefined;\n    return row ? this.toProjection(row) : null;\n  }\n\n  /**\n   * Integration \"delete\" by external id, provider-scoped. When `softDelete: true`,\n   * sets `deletedAt`. When `softDelete: false`, tombstone-by-clearing: null out\n   * `external_id`/`provider` so the row no longer matches future inbound\n   * changes while preserving local-id references. Returns `{ id }` or `null`.\n   */\n  async softDeleteByExternalId(\n    externalId: string,\n    provider: string,\n    tx?: DrizzleTx,\n  ): Promise<{ id: string } | null> {\n    const db = this.runner(tx);\n    const set = this.integrationConfig.softDelete\n      ? { deletedAt: new Date(), updatedAt: new Date() }\n      : { externalId: null, provider: null, updatedAt: new Date() };\n    const rows = await db\n      .update(this.table)\n      .set(set as never)\n      .where(\n        and(\n          eq(this.table['provider'], provider),\n          eq(this.table['externalId'], externalId),\n        ),\n      )\n      .returning({ id: this.table['id'] });\n    return rows[0] ? { id: rows[0].id as string } : null;\n  }\n\n  /**\n   * Batch integration upsert — concretizes the former abstract stub. Delegates to\n   * `integrationUpsertOne` per input inside one transaction. Inputs are raw partial\n   * rows: provider is read from each input's own `provider` column; rows\n   * missing `externalId`/`provider` are skipped.\n   */\n  async integrationUpsert(inputs: Array<Partial<TEntity>>): Promise<TEntity[]> {\n    if (inputs.length === 0) return [];\n    return this.db.transaction(async (tx) => {\n      const out: TEntity[] = [];\n      for (const input of inputs) {\n        const rec = input as Record<string, unknown>;\n        if (!rec['externalId'] || !rec['provider']) continue;\n        const proj = await this.integrationUpsertOne(\n          input as unknown as TIntegrationWrite,\n          rec['provider'] as string,\n          tx,\n        );\n        const id = (proj as Record<string, unknown>)['id'] as string;\n        const row = await tx\n          .select()\n          .from(this.table)\n          .where(eq(this.table['id'], id))\n          .limit(1);\n        out.push(row[0] as TEntity);\n      }\n      return out;\n    });\n  }\n\n  /**\n   * Project a raw row to the canonical differ shape — a generic pick over\n   * `integrationConfig.projectionColumns`. Override only for synthesized projections\n   * (e.g. junctions); entities use this verbatim.\n   */\n  protected toProjection(row: TEntity): TIntegrationProjection {\n    const r = row as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const col of this.integrationConfig.projectionColumns) out[col] = r[col];\n    return out as TIntegrationProjection;\n  }\n\n  /**\n   * EAV dual-write seam (#374, live path lands in #124). No-op by default;\n   * `eav: true` entities emit a concrete override that injects\n   * `FieldValueService` and delegates to `upsertFieldsTransactional` so the\n   * dual-write joins the same tx (`db`). Kept as an explicit hook so the base\n   * stays portable (the FieldValueService dependency is eav-only).\n   */\n  protected async writeCustomFields(\n    _db: DrizzleTx,\n    _entityId: string,\n    _userId: string,\n    _fields: Record<string, unknown>,\n  ): Promise<void> {\n    // Intentionally empty until the entity opts into EAV.\n  }\n\n  /**\n   * Resolve one FK from a parent external id (provider-scoped). `self` resolves\n   * against `this.table`. Strict resolvers throw when unresolved; non-strict\n   * return null. A null/absent write value short-circuits to null.\n   */\n  private async resolveFk(\n    db: DrizzleTx,\n    fk: IntegrationFkResolver,\n    rawExternalId: unknown,\n    provider: string,\n  ): Promise<string | null> {\n    const parentExternalId = rawExternalId as string | null | undefined;\n    if (!parentExternalId) {\n      if (fk.strict) {\n        throw new Error(\n          `${this.constructor.name}.integrationUpsertOne: missing required parent ` +\n            `external id for '${fk.column}' (writeKey '${fk.writeKey}')`,\n        );\n      }\n      return null;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const refTable: PgTableWithColumns<any> =\n      fk.refTable === 'self' ? this.table : fk.refTable;\n    const rows = await db\n      .select({ id: refTable['id'] })\n      .from(refTable)\n      .where(\n        and(\n          eq(refTable['provider'], provider),\n          eq(refTable['externalId'], parentExternalId),\n        ),\n      )\n      .limit(1);\n    const id = (rows[0]?.id as string | undefined) ?? null;\n    if (id === null && fk.strict) {\n      throw new Error(\n        `${this.constructor.name}.integrationUpsertOne: unresolved parent ` +\n          `'${parentExternalId}' (provider '${provider}') for '${fk.column}' — ` +\n          `parent not integrated yet`,\n      );\n    }\n    return id;\n  }\n\n  /**\n   * Find entities visible to a user (ownership + sharing rules).\n   * Concrete repositories must implement with visibility logic.\n   */\n  async findVisibleByUserId(_userId: string): Promise<TEntity[]> {\n    throw new Error('findVisibleByUserId not implemented — override in concrete repository');\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-PNZSGAB2.js

@@ -0,0 +1,114 @@
+import {
+  MemoryJobStore
+} from "./chunk-SNQ3TOWP.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/jobs/job-step-service.memory-backend.ts
+import { randomUUID } from "crypto";
+import { Inject, Injectable } from "@nestjs/common";
+var MemoryJobStepService = class {
+  // ADR-037 (package-mode DI): explicit `@Inject(MemoryJobStore)` — the
+  // published bundle carries no `design:paramtypes`, so a by-type inject
+  // would resolve to `undefined` in package mode.
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async findStep(runId, stepId) {
+    const rows = this.store.steps.get(runId);
+    if (!rows) return null;
+    const match = rows.find(
+      (r) => r.stepId === stepId && r.status === "completed"
+    );
+    return match ?? null;
+  }
+  async recordStep(input) {
+    const rows = this.getOrCreateRows(input.jobRunId);
+    const existingIdx = rows.findIndex((r) => r.stepId === input.stepId);
+    const normalisedInput = input.input ?? null;
+    const normalisedOutput = input.output ?? null;
+    if (existingIdx >= 0) {
+      const prev = rows[existingIdx];
+      const next = {
+        ...prev,
+        status: input.status,
+        input: normalisedInput ?? prev.input,
+        output: normalisedOutput ?? prev.output,
+        error: input.error ?? prev.error,
+        attempts: input.attempts ?? prev.attempts,
+        startedAt: input.startedAt ?? prev.startedAt,
+        finishedAt: input.finishedAt ?? prev.finishedAt
+      };
+      rows[existingIdx] = next;
+      return next;
+    }
+    const seq = input.seq ?? this.nextSeq(rows);
+    const row = {
+      id: randomUUID(),
+      jobRunId: input.jobRunId,
+      stepId: input.stepId,
+      kind: input.kind,
+      seq,
+      status: input.status,
+      input: normalisedInput,
+      output: normalisedOutput,
+      error: input.error ?? null,
+      attempts: input.attempts ?? 0,
+      startedAt: input.startedAt ?? null,
+      finishedAt: input.finishedAt ?? null
+    };
+    rows.push(row);
+    return row;
+  }
+  /**
+   * Replay helper — wipe every step row for a run. Mirrors the `scratch`
+   * replay mode of the Drizzle backend (`DELETE FROM job_step WHERE job_run_id = …`).
+   */
+  clearStepsForRun(runId) {
+    this.store.steps.delete(runId);
+  }
+  /**
+   * Remove every non-`completed` row for the run. Memoized (`completed`)
+   * rows are preserved — this is the `last_checkpoint` / `last_step`
+   * semantics the Drizzle backend implements via
+   * `DELETE … WHERE status != 'completed'`. Both replay modes route here
+   * (Phase 1 collapses `last_step` onto this behaviour; see JOB-3 notes).
+   */
+  clearIncompleteSteps(runId) {
+    const rows = this.store.steps.get(runId);
+    if (!rows) return;
+    const kept = rows.filter((r) => r.status === "completed");
+    if (kept.length === 0) {
+      this.store.steps.delete(runId);
+    } else {
+      this.store.steps.set(runId, kept);
+    }
+  }
+  getOrCreateRows(runId) {
+    let rows = this.store.steps.get(runId);
+    if (!rows) {
+      rows = [];
+      this.store.steps.set(runId, rows);
+    }
+    return rows;
+  }
+  nextSeq(rows) {
+    let max = 0;
+    for (const r of rows) {
+      if (r.seq > max) max = r.seq;
+    }
+    return max + 1;
+  }
+};
+MemoryJobStepService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(MemoryJobStore))
+], MemoryJobStepService);
+
+export {
+  MemoryJobStepService
+};
+//# sourceMappingURL=chunk-PNZSGAB2.js.map

package/dist/chunk-PNZSGAB2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-step-service.memory-backend.ts"],"sourcesContent":["/**\n * MemoryJobStepService — in-memory implementation of `IJobStepService`\n * (ADR-022, JOB-4).\n *\n * Mirrors `DrizzleJobStepService` but against plain Maps. `findStep` only\n * returns `completed` rows (memoization cache hit); anything non-completed\n * is invisible so the ctx.step fn re-runs on replay / retry exactly like\n * the Drizzle backend (which deletes non-completed rows on replay).\n */\nimport { randomUUID } from 'node:crypto';\nimport { Inject, Injectable } from '@nestjs/common';\nimport type { JobStepRow } from './job-orchestration.schema';\nimport type {\n  IJobStepService,\n  JobStep,\n  RecordStepInput,\n} from './job-step-service.protocol';\nimport { MemoryJobStore } from './memory-job-store';\n\n@Injectable()\nexport class MemoryJobStepService implements IJobStepService {\n  // ADR-037 (package-mode DI): explicit `@Inject(MemoryJobStore)` — the\n  // published bundle carries no `design:paramtypes`, so a by-type inject\n  // would resolve to `undefined` in package mode.\n  constructor(\n    @Inject(MemoryJobStore) private readonly store: MemoryJobStore,\n  ) {}\n\n  async findStep(runId: string, stepId: string): Promise<JobStep | null> {\n    const rows = this.store.steps.get(runId);\n    if (!rows) return null;\n    const match = rows.find(\n      (r) => r.stepId === stepId && r.status === 'completed',\n    );\n    return (match ?? null) as JobStep | null;\n  }\n\n  async recordStep(input: RecordStepInput): Promise<JobStep> {\n    const rows = this.getOrCreateRows(input.jobRunId);\n    const existingIdx = rows.findIndex((r) => r.stepId === input.stepId);\n\n    const normalisedInput =\n      (input.input ?? null) as Record<string, unknown> | null;\n    const normalisedOutput =\n      (input.output ?? null) as Record<string, unknown> | null;\n\n    if (existingIdx >= 0) {\n      const prev = rows[existingIdx]!;\n      const next: JobStepRow = {\n        ...prev,\n        status: input.status,\n        input: normalisedInput ?? prev.input,\n        output: normalisedOutput ?? prev.output,\n        error: input.error ?? prev.error,\n        attempts: input.attempts ?? prev.attempts,\n        startedAt: input.startedAt ?? prev.startedAt,\n        finishedAt: input.finishedAt ?? prev.finishedAt,\n      };\n      rows[existingIdx] = next;\n      return next as JobStep;\n    }\n\n    const seq = input.seq ?? this.nextSeq(rows);\n    const row: JobStepRow = {\n      id: randomUUID(),\n      jobRunId: input.jobRunId,\n      stepId: input.stepId,\n      kind: input.kind,\n      seq,\n      status: input.status,\n      input: normalisedInput,\n      output: normalisedOutput,\n      error: input.error ?? null,\n      attempts: input.attempts ?? 0,\n      startedAt: input.startedAt ?? null,\n      finishedAt: input.finishedAt ?? null,\n    };\n    rows.push(row);\n    return row as JobStep;\n  }\n\n  /**\n   * Replay helper — wipe every step row for a run. Mirrors the `scratch`\n   * replay mode of the Drizzle backend (`DELETE FROM job_step WHERE job_run_id = …`).\n   */\n  clearStepsForRun(runId: string): void {\n    this.store.steps.delete(runId);\n  }\n\n  /**\n   * Remove every non-`completed` row for the run. Memoized (`completed`)\n   * rows are preserved — this is the `last_checkpoint` / `last_step`\n   * semantics the Drizzle backend implements via\n   * `DELETE … WHERE status != 'completed'`. Both replay modes route here\n   * (Phase 1 collapses `last_step` onto this behaviour; see JOB-3 notes).\n   */\n  clearIncompleteSteps(runId: string): void {\n    const rows = this.store.steps.get(runId);\n    if (!rows) return;\n    const kept = rows.filter((r) => r.status === 'completed');\n    if (kept.length === 0) {\n      this.store.steps.delete(runId);\n    } else {\n      this.store.steps.set(runId, kept);\n    }\n  }\n\n  private getOrCreateRows(runId: string): JobStepRow[] {\n    let rows = this.store.steps.get(runId);\n    if (!rows) {\n      rows = [];\n      this.store.steps.set(runId, rows);\n    }\n    return rows;\n  }\n\n  private nextSeq(rows: JobStepRow[]): number {\n    let max = 0;\n    for (const r of rows) {\n      if (r.seq > max) max = r.seq;\n    }\n    return max + 1;\n  }\n}\n"],"mappings":";;;;;;;;;AASA,SAAS,kBAAkB;AAC3B,SAAS,QAAQ,kBAAkB;AAU5B,IAAM,uBAAN,MAAsD;AAAA;AAAA;AAAA;AAAA,EAI3D,YAC2C,OACzC;AADyC;AAAA,EACxC;AAAA,EADwC;AAAA,EAG3C,MAAM,SAAS,OAAe,QAAyC;AACrE,UAAM,OAAO,KAAK,MAAM,MAAM,IAAI,KAAK;AACvC,QAAI,CAAC,KAAM,QAAO;AAClB,UAAM,QAAQ,KAAK;AAAA,MACjB,CAAC,MAAM,EAAE,WAAW,UAAU,EAAE,WAAW;AAAA,IAC7C;AACA,WAAQ,SAAS;AAAA,EACnB;AAAA,EAEA,MAAM,WAAW,OAA0C;AACzD,UAAM,OAAO,KAAK,gBAAgB,MAAM,QAAQ;AAChD,UAAM,cAAc,KAAK,UAAU,CAAC,MAAM,EAAE,WAAW,MAAM,MAAM;AAEnE,UAAM,kBACH,MAAM,SAAS;AAClB,UAAM,mBACH,MAAM,UAAU;AAEnB,QAAI,eAAe,GAAG;AACpB,YAAM,OAAO,KAAK,WAAW;AAC7B,YAAM,OAAmB;AAAA,QACvB,GAAG;AAAA,QACH,QAAQ,MAAM;AAAA,QACd,OAAO,mBAAmB,KAAK;AAAA,QAC/B,QAAQ,oBAAoB,KAAK;AAAA,QACjC,OAAO,MAAM,SAAS,KAAK;AAAA,QAC3B,UAAU,MAAM,YAAY,KAAK;AAAA,QACjC,WAAW,MAAM,aAAa,KAAK;AAAA,QACnC,YAAY,MAAM,cAAc,KAAK;AAAA,MACvC;AACA,WAAK,WAAW,IAAI;AACpB,aAAO;AAAA,IACT;AAEA,UAAM,MAAM,MAAM,OAAO,KAAK,QAAQ,IAAI;AAC1C,UAAM,MAAkB;AAAA,MACtB,IAAI,WAAW;AAAA,MACf,UAAU,MAAM;AAAA,MAChB,QAAQ,MAAM;AAAA,MACd,MAAM,MAAM;AAAA,MACZ;AAAA,MACA,QAAQ,MAAM;AAAA,MACd,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,OAAO,MAAM,SAAS;AAAA,MACtB,UAAU,MAAM,YAAY;AAAA,MAC5B,WAAW,MAAM,aAAa;AAAA,MAC9B,YAAY,MAAM,cAAc;AAAA,IAClC;AACA,SAAK,KAAK,GAAG;AACb,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,iBAAiB,OAAqB;AACpC,SAAK,MAAM,MAAM,OAAO,KAAK;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,qBAAqB,OAAqB;AACxC,UAAM,OAAO,KAAK,MAAM,MAAM,IAAI,KAAK;AACvC,QAAI,CAAC,KAAM;AACX,UAAM,OAAO,KAAK,OAAO,CAAC,MAAM,EAAE,WAAW,WAAW;AACxD,QAAI,KAAK,WAAW,GAAG;AACrB,WAAK,MAAM,MAAM,OAAO,KAAK;AAAA,IAC/B,OAAO;AACL,WAAK,MAAM,MAAM,IAAI,OAAO,IAAI;AAAA,IAClC;AAAA,EACF;AAAA,EAEQ,gBAAgB,OAA6B;AACnD,QAAI,OAAO,KAAK,MAAM,MAAM,IAAI,KAAK;AACrC,QAAI,CAAC,MAAM;AACT,aAAO,CAAC;AACR,WAAK,MAAM,MAAM,IAAI,OAAO,IAAI;AAAA,IAClC;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,QAAQ,MAA4B;AAC1C,QAAI,MAAM;AACV,eAAW,KAAK,MAAM;AACpB,UAAI,EAAE,MAAM,IAAK,OAAM,EAAE;AAAA,IAC3B;AACA,WAAO,MAAM;AAAA,EACf;AACF;AAvGa,uBAAN;AAAA,EADN,WAAW;AAAA,EAMP,0BAAO,cAAc;AAAA,GALb;","names":[]}

package/dist/chunk-PRWIX6UW.js

@@ -0,0 +1,21 @@
+// runtime/subsystems/integration/loopback.middleware.ts
+function createLoopbackMiddleware(store) {
+  return (next) => {
+    return async function* (subscription, cursor) {
+      for await (const change of next(subscription, cursor)) {
+        const isEcho = await store.isEchoOfOwnWrite(
+          subscription.domain,
+          change.externalId,
+          change.record
+        );
+        if (isEcho) continue;
+        yield change;
+      }
+    };
+  };
+}
+
+export {
+  createLoopbackMiddleware
+};
+//# sourceMappingURL=chunk-PRWIX6UW.js.map

package/dist/chunk-PRWIX6UW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/loopback.middleware.ts"],"sourcesContent":["/**\n * Integration subsystem — loopback `ChangeMiddleware` factory (#226-5, ADR-033).\n *\n * Replaces the prior orchestrator-side `@Optional() INTEGRATION_LOOPBACK_FINGERPRINT_STORE`\n * branch. Consumers that need to suppress echoes of their own outbound\n * writes compose `createLoopbackMiddleware(store)` into a primitive's\n * middleware chain — typically alongside `PollChangeSource<T>` — instead\n * of injecting a store into the orchestrator.\n *\n * Why middleware, not orchestrator branch:\n *   - keeps the orchestrator port-agnostic (no per-mode special cases);\n *   - lets primitives compose loopback with redaction / throttling /\n *     other cross-cutting wrappers in a single chain;\n *   - lets consumers pick per-source whether loopback is wired (some\n *     entities have outbound writeback, others don't) without DI gymnastics.\n *\n * Behavior:\n *   - For every change yielded by the inner iterator, call\n *     `store.isEchoOfOwnWrite(subscription.domain, change.externalId, change.record)`.\n *   - If the store returns `true`, the change is dropped (not yielded).\n *   - Otherwise the change is passed through untouched.\n *\n * The middleware does not record audit rows for suppressed changes —\n * the orchestrator no longer learns about them. This is the deliberate\n * trade: loopback echoes are noise, not signal; their prior `skipped+noop`\n * audit rows existed only because the orchestrator was the suppression\n * site. Consumers wanting visibility into suppression counts can wrap\n * their store or layer a counting middleware alongside this one.\n */\n\nimport type { Change } from './integration-change-source.protocol';\nimport type {\n  ChangeIterator,\n  ChangeMiddleware,\n} from './integration-middleware.protocol';\nimport type { ILoopbackFingerprintStore } from './integration-loopback.protocol';\n\n/**\n * Build a `ChangeMiddleware<T>` that suppresses changes whose fingerprint\n * matches a recent local write according to the supplied store.\n *\n * Composition — first middleware in the array is outermost. Consumers\n * typically place loopback as the outermost layer so suppressed changes\n * never reach downstream middleware (redaction, transforms, etc.).\n */\nexport function createLoopbackMiddleware<T>(\n  store: ILoopbackFingerprintStore<T>,\n): ChangeMiddleware<T> {\n  return (next: ChangeIterator<T>): ChangeIterator<T> => {\n    return async function* (subscription, cursor): AsyncIterable<Change<T>> {\n      for await (const change of next(subscription, cursor)) {\n        const isEcho = await store.isEchoOfOwnWrite(\n          subscription.domain,\n          change.externalId,\n          change.record,\n        );\n        if (isEcho) continue;\n        yield change;\n      }\n    };\n  };\n}\n"],"mappings":";AA6CO,SAAS,yBACd,OACqB;AACrB,SAAO,CAAC,SAA+C;AACrD,WAAO,iBAAiB,cAAc,QAAkC;AACtE,uBAAiB,UAAU,KAAK,cAAc,MAAM,GAAG;AACrD,cAAM,SAAS,MAAM,MAAM;AAAA,UACzB,aAAa;AAAA,UACb,OAAO;AAAA,UACP,OAAO;AAAA,QACT;AACA,YAAI,OAAQ;AACZ,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-PSXUNOVU.js

@@ -0,0 +1,7 @@
+// runtime/shared/openapi/registry.tokens.ts
+var OPENAPI_REGISTRY = "OPENAPI_REGISTRY";
+
+export {
+  OPENAPI_REGISTRY
+};
+//# sourceMappingURL=chunk-PSXUNOVU.js.map

package/dist/chunk-PSXUNOVU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/shared/openapi/registry.tokens.ts"],"sourcesContent":["/**\n * Injection token for the OpenAPI registry (OPENAPI-1).\n *\n * String constant (not a Symbol) so it matches by value across import\n * boundaries — same convention as `ANALYTICS_QUERY` in analytics and\n * `EVENT_BUS` / `BRIDGE_DELIVERY_REPO` in events / bridge. The OPENAPI-1\n * spec sketched a Symbol, but the repo-wide convention wins — codebase\n * consistency matters more than the spec's initial guess.\n *\n * Consumed by generated DTO providers (OPENAPI-2), controllers\n * (OPENAPI-3), and the Swagger bootstrap (OPENAPI-4).\n */\nexport const OPENAPI_REGISTRY = 'OPENAPI_REGISTRY' as const;\n"],"mappings":";AAYO,IAAM,mBAAmB;","names":[]}

package/dist/chunk-QLTJSCE6.js

@@ -0,0 +1,44 @@
+import {
+  OAuthStateError
+} from "./chunk-BPARRK6F.js";
+
+// runtime/subsystems/auth/backends/state-store.memory-backend.ts
+import { randomBytes } from "crypto";
+var MemoryOAuthStateStore = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  now;
+  generateToken;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? 10 * 60 * 1e3;
+    this.now = opts.now ?? (() => Date.now());
+    this.generateToken = opts.generateToken ?? (() => randomBytes(32).toString("base64url"));
+  }
+  async generate(record) {
+    const state = this.generateToken();
+    this.store.set(state, {
+      record: { ...record },
+      expiresAt: this.now() + this.ttlMs
+    });
+    return state;
+  }
+  async consume(state) {
+    const slot = this.store.get(state);
+    if (!slot) {
+      throw new OAuthStateError(
+        `OAuth state token unknown or already consumed`,
+        "missing"
+      );
+    }
+    this.store.delete(state);
+    if (slot.expiresAt <= this.now()) {
+      throw new OAuthStateError(`OAuth state token expired`, "expired");
+    }
+    return slot.record;
+  }
+};
+
+export {
+  MemoryOAuthStateStore
+};
+//# sourceMappingURL=chunk-QLTJSCE6.js.map

package/dist/chunk-QLTJSCE6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/backends/state-store.memory-backend.ts"],"sourcesContent":["/**\n * In-memory `IOAuthStateStore` backend.\n *\n * Single-process store — Map<state, { record, expiresAt }>. Suitable for\n * tests and single-worker dev. Production deployments select the drizzle\n * backend so state survives restarts and is shared across workers.\n *\n * Single-use semantics:\n *   - `generate(record)` mints a 256-bit random token (base64url, opaque).\n *   - `consume(state)` deletes the entry on read. A second call with the\n *     same state throws `OAuthStateError('replay')`.\n *   - Expired entries also throw (`'expired'`); the entry is deleted as a\n *     side effect so a later replay still surfaces correctly.\n *\n * TTL defaults to 10 minutes — long enough for a user to complete the\n * provider's consent screen, short enough that abandoned states age out.\n */\nimport { randomBytes } from 'node:crypto';\nimport {\n  type IOAuthStateStore,\n  type OAuthStateRecord,\n  OAuthStateError,\n} from '../protocols/oauth-state-store';\n\nexport interface MemoryOAuthStateStoreOptions {\n  /** TTL in ms. Default 10 minutes. */\n  ttlMs?: number;\n  /** Injectable clock for tests. Default `Date.now`. */\n  now?: () => number;\n  /** Injectable token generator for tests. Default 32-byte base64url. */\n  generateToken?: () => string;\n}\n\ninterface Slot {\n  record: OAuthStateRecord;\n  expiresAt: number;\n}\n\nexport class MemoryOAuthStateStore implements IOAuthStateStore {\n  private readonly store = new Map<string, Slot>();\n  private readonly ttlMs: number;\n  private readonly now: () => number;\n  private readonly generateToken: () => string;\n\n  constructor(opts: MemoryOAuthStateStoreOptions = {}) {\n    this.ttlMs = opts.ttlMs ?? 10 * 60 * 1000;\n    this.now = opts.now ?? (() => Date.now());\n    this.generateToken =\n      opts.generateToken ?? (() => randomBytes(32).toString('base64url'));\n  }\n\n  async generate(record: OAuthStateRecord): Promise<string> {\n    const state = this.generateToken();\n    this.store.set(state, {\n      record: { ...record },\n      expiresAt: this.now() + this.ttlMs,\n    });\n    return state;\n  }\n\n  async consume(state: string): Promise<OAuthStateRecord> {\n    const slot = this.store.get(state);\n    if (!slot) {\n      throw new OAuthStateError(\n        `OAuth state token unknown or already consumed`,\n        'missing',\n      );\n    }\n    // Delete first so a concurrent consume can't replay.\n    this.store.delete(state);\n    if (slot.expiresAt <= this.now()) {\n      throw new OAuthStateError(`OAuth state token expired`, 'expired');\n    }\n    return slot.record;\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,mBAAmB;AAqBrB,IAAM,wBAAN,MAAwD;AAAA,EAC5C,QAAQ,oBAAI,IAAkB;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EAEjB,YAAY,OAAqC,CAAC,GAAG;AACnD,SAAK,QAAQ,KAAK,SAAS,KAAK,KAAK;AACrC,SAAK,MAAM,KAAK,QAAQ,MAAM,KAAK,IAAI;AACvC,SAAK,gBACH,KAAK,kBAAkB,MAAM,YAAY,EAAE,EAAE,SAAS,WAAW;AAAA,EACrE;AAAA,EAEA,MAAM,SAAS,QAA2C;AACxD,UAAM,QAAQ,KAAK,cAAc;AACjC,SAAK,MAAM,IAAI,OAAO;AAAA,MACpB,QAAQ,EAAE,GAAG,OAAO;AAAA,MACpB,WAAW,KAAK,IAAI,IAAI,KAAK;AAAA,IAC/B,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,QAAQ,OAA0C;AACtD,UAAM,OAAO,KAAK,MAAM,IAAI,KAAK;AACjC,QAAI,CAAC,MAAM;AACT,YAAM,IAAI;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,SAAK,MAAM,OAAO,KAAK;AACvB,QAAI,KAAK,aAAa,KAAK,IAAI,GAAG;AAChC,YAAM,IAAI,gBAAgB,6BAA6B,SAAS;AAAA,IAClE;AACA,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}