@pattern-stack/codegen 0.10.1 → 0.12.0

package/dist/runtime/subsystems/integration/integration-run-recorder.drizzle-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../runtime/subsystems/integration/integration-run-recorder.drizzle-backend.ts","../../../../runtime/constants/tokens.ts","../../../../runtime/subsystems/integration/integration-audit.schema.ts","../../../../runtime/subsystems/integration/integration-field-diff.protocol.ts","../../../../runtime/subsystems/integration/integration.tokens.ts","../../../../runtime/subsystems/integration/integration-errors.ts"],"sourcesContent":["/**\n * DrizzleIntegrationRunRecorder — Drizzle-backed `IIntegrationRunRecorder` (SYNC-4).\n *\n * Generic write path only — extracted from the source app's\n * `IntegrationRunRecorderService`, minus CRM-specific convenience methods. Those\n * stay consumer-owned; the subsystem ships the substrate.\n *\n * ## Responsibilities\n *\n *   - `startRun`     — INSERT integration_runs row in status='running', returns id.\n *   - `recordItem`   — validates `changedFields` via `FieldDiffSchema.parse`\n *                      BEFORE the INSERT; a malformed shape throws before\n *                      any DB call fires. Enforces the ADR-0003 contract at\n *                      the write boundary.\n *   - `completeRun`  — UPDATE integration_runs with terminal status, counts,\n *                      cursor_after, duration_ms, completed_at.\n *\n * ## Multi-tenancy\n *\n * When `INTEGRATION_MULTI_TENANT` is true (SYNC-6):\n *   - `startRun` and `recordItem` require non-null `tenantId` on input.\n *     Enforcement goes through the shared `assertTenantId` helper so the\n *     error message shape matches the orchestrator entry point + the\n *     cursor-store backends.\n *   - `completeRun` does NOT re-check tenancy — the run id was returned\n *     by `startRun` which already enforced it, and run ids are uuids that\n *     aren't guessable cross-tenant. Matches JOB-3's pattern of trusting\n *     the run-id for downstream mutations.\n */\nimport { Inject, Injectable, Optional } from '@nestjs/common';\nimport { and, desc, eq, type SQL } from 'drizzle-orm';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DRIZZLE } from '../../constants/tokens';\nimport type {\n  CompleteRunInput,\n  IIntegrationRunRecorder,\n  RecordItemInput,\n  StartRunInput,\n  IntegrationRunSummary,\n} from './integration-run-recorder.protocol';\nimport { integrationRuns, integrationRunItems, integrationSubscriptions } from './integration-audit.schema';\nimport { FieldDiffSchema } from './integration-field-diff.protocol';\nimport { INTEGRATION_MULTI_TENANT } from './integration.tokens';\nimport { assertTenantId } from './integration-errors';\n\n@Injectable()\nexport class DrizzleIntegrationRunRecorder implements IIntegrationRunRecorder {\n  private readonly multiTenant: boolean;\n\n  constructor(\n    @Inject(DRIZZLE) private readonly db: DrizzleClient,\n    @Optional() @Inject(INTEGRATION_MULTI_TENANT) multiTenant?: boolean,\n  ) {\n    this.multiTenant = multiTenant ?? false;\n  }\n\n  async startRun(input: StartRunInput): Promise<{ id: string }> {\n    assertTenantId(input.tenantId, {\n      multiTenant: this.multiTenant,\n      operation: 'startRun',\n    });\n\n    const rows = await this.db\n      .insert(integrationRuns)\n      .values({\n        subscriptionId: input.subscriptionId,\n        direction: input.direction,\n        action: input.action,\n        status: 'running',\n        cursorBefore: input.cursorBefore ?? null,\n        tenantId: input.tenantId ?? null,\n      })\n      .returning({ id: integrationRuns.id });\n\n    const id = rows[0]?.id;\n    if (!id) {\n      // Drizzle's insert().returning() contract: at least one row is\n      // returned for every successful INSERT. A missing id would indicate\n      // a driver misbehavior; throw loudly rather than return bogus data.\n      throw new Error('DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id');\n    }\n    return { id };\n  }\n\n  async recordItem(input: RecordItemInput): Promise<void> {\n    assertTenantId(input.tenantId, {\n      multiTenant: this.multiTenant,\n      operation: 'recordItem',\n    });\n\n    // ADR-0003 contract enforcement — reject malformed changedFields\n    // before the DB call fires. `parse` throws a ZodError; callers see\n    // the validation failure, not a DB constraint error.\n    FieldDiffSchema.parse(input.changedFields);\n\n    await this.db.insert(integrationRunItems).values({\n      integrationRunId: input.integrationRunId,\n      entityType: input.entityType,\n      externalId: input.externalId,\n      localId: input.localId ?? null,\n      operation: input.operation,\n      status: input.status,\n      changedFields: input.changedFields,\n      title: input.title ?? null,\n      error: input.error ?? null,\n      tenantId: input.tenantId ?? null,\n    });\n  }\n\n  async listRecent(\n    limit: number,\n    subscriptionId?: string,\n    tenantId?: string | null,\n  ): Promise<IntegrationRunSummary[]> {\n    assertTenantId(tenantId, {\n      multiTenant: this.multiTenant,\n      operation: 'listRecent',\n    });\n\n    // JOIN against integration_subscriptions to resolve `connection_id` per run.\n    // `integration_runs.subscription_id` is a non-null FK so INNER JOIN is correct;\n    // there should be no orphaned runs.\n    const conditions: SQL[] = [];\n    if (subscriptionId !== undefined) {\n      conditions.push(eq(integrationRuns.subscriptionId, subscriptionId));\n    }\n    if (this.multiTenant) {\n      conditions.push(eq(integrationRuns.tenantId, tenantId as string));\n    }\n    const where =\n      conditions.length === 0\n        ? undefined\n        : conditions.length === 1\n          ? conditions[0]\n          : and(...conditions);\n\n    const rows = await this.db\n      .select({\n        id: integrationRuns.id,\n        subscriptionId: integrationRuns.subscriptionId,\n        connectionId: integrationSubscriptions.connectionId,\n        status: integrationRuns.status,\n        startedAt: integrationRuns.startedAt,\n        completedAt: integrationRuns.completedAt,\n        recordsProcessed: integrationRuns.recordsProcessed,\n        tenantId: integrationRuns.tenantId,\n      })\n      .from(integrationRuns)\n      .innerJoin(\n        integrationSubscriptions,\n        eq(integrationRuns.subscriptionId, integrationSubscriptions.id),\n      )\n      .where(where)\n      .orderBy(desc(integrationRuns.startedAt))\n      .limit(limit);\n\n    return rows.map((row) => ({\n      id: row.id,\n      subscriptionId: row.subscriptionId,\n      connectionId: row.connectionId,\n      status: row.status,\n      startedAt: row.startedAt,\n      completedAt: row.completedAt,\n      recordsProcessed: row.recordsProcessed,\n      tenantId: row.tenantId,\n    }));\n  }\n\n  async completeRun(runId: string, input: CompleteRunInput): Promise<void> {\n    await this.db\n      .update(integrationRuns)\n      .set({\n        status: input.status,\n        recordsFound: input.recordsFound,\n        recordsProcessed: input.recordsProcessed,\n        cursorAfter: input.cursorAfter ?? null,\n        durationMs: input.durationMs,\n        error: input.error ?? null,\n        completedAt: new Date(),\n      })\n      .where(eq(integrationRuns.id, runId));\n  }\n}\n","/**\n * NestJS injection tokens\n *\n * Used with @Inject() decorator in concrete repository constructors.\n */\n\n/**\n * Injection token for the Drizzle ORM database client.\n *\n * Usage in concrete repositories:\n * ```typescript\n * constructor(@Inject(DRIZZLE) db: DrizzleClient) { super(db); }\n * ```\n */\nexport const DRIZZLE = 'DRIZZLE' as const;\n\n/**\n * Injection token for the event bus (IEventBus).\n *\n * Optional — only resolved when EventsModule.forRoot() is registered.\n * BaseService uses this with @Optional() to emit lifecycle events\n * without requiring the events subsystem to be installed.\n *\n * Usage in services/use cases:\n * ```typescript\n * @Optional() @Inject(EVENT_BUS) eventBus?: IEventBus\n * ```\n */\nexport const EVENT_BUS = 'EVENT_BUS' as const;\n","/**\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","/**\n * Integration subsystem — field-diff protocol (port)\n *\n * `IFieldDiffer<T>` is the pluggable differ seam. The default implementation\n * (`DeepEqualDiffer`, ships in SYNC-5) walks every field except an ignore\n * list; CDC-aware differs can skip comparison for fields the provider didn't\n * flag as changed.\n *\n * `FieldDiffSchema` is the structural enforcement of the `changed_fields`\n * column per ADR-0003 — enforced at write time by the recorder service so\n * consumers can rely on the shape in downstream queries.\n */\nimport { z } from 'zod';\n\n// ============================================================================\n// FieldDiff shape — the ADR-0003 contract\n// ============================================================================\n\n/**\n * Structured per-field change. Enforced shape for `integration_run_items.changed_fields`.\n *\n * `created` items set `from: null, to: <value>` for every non-null field.\n * `deleted` items set `from: <value>, to: null`.\n * `noop` items carry `{}`.\n */\nexport const FieldDiffValueSchema = z.object({\n  from: z.unknown(),\n  to: z.unknown(),\n});\n\nexport const FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);\n\nexport type FieldDiffValue = z.infer<typeof FieldDiffValueSchema>;\nexport type FieldDiff = z.infer<typeof FieldDiffSchema>;\n\n/** Result of comparing a new record against its existing local state. */\nexport type DiffResult = FieldDiff | 'noop';\n\n// ============================================================================\n// IFieldDiffer\n// ============================================================================\n\n/**\n * Pluggable differ. Default ships in SYNC-5 as `DeepEqualDiffer<T>` —\n * deep-equal over every field except an ignore list (`updated_at` and other\n * row metadata). CDC-aware differs restrict comparison to\n * `providerChangedFields` when supplied.\n */\nexport interface IFieldDiffer<T> {\n  /**\n   * @param existing — current local state, or `null` when the record is new\n   * @param incoming — the canonical record coming from the adapter\n   * @param providerChangedFields — optional hint from CDC-capable sources;\n   *   when present, differ may restrict the comparison to these fields\n   */\n  diff(\n    existing: T | null,\n    incoming: T,\n    providerChangedFields?: string[],\n  ): DiffResult;\n}\n","/**\n * Integration subsystem — DI tokens\n *\n * String constants (not Symbols) so they match by value across import\n * boundaries — same convention as the events subsystem (`EVENT_BUS`). The\n * jobs subsystem uses Symbols for its analogous tokens; events and integration\n * stay internally consistent with strings.\n *\n * Usage in use cases:\n * ```ts\n * constructor(\n *   @Inject(INTEGRATION_CHANGE_SOURCE) private readonly source: IChangeSource<CanonicalOpportunity>,\n *   @Inject(INTEGRATION_CURSOR_STORE)  private readonly cursors: ICursorStore,\n *   @Inject(INTEGRATION_FIELD_DIFFER)  private readonly differ: IFieldDiffer<CanonicalOpportunity>,\n *   @Inject(INTEGRATION_SINK)          private readonly sink: IIntegrationSink<CanonicalOpportunity>,\n *   @Inject(INTEGRATION_RUN_RECORDER)  private readonly recorder: IIntegrationRunRecorder,\n * ) {}\n * ```\n *\n * Concrete bindings are registered by `IntegrationModule.forRoot(...)` (SYNC-6).\n */\n\nexport const INTEGRATION_CHANGE_SOURCE = 'INTEGRATION_CHANGE_SOURCE' as const;\nexport const INTEGRATION_CURSOR_STORE = 'INTEGRATION_CURSOR_STORE' as const;\nexport const INTEGRATION_FIELD_DIFFER = 'INTEGRATION_FIELD_DIFFER' as const;\nexport const INTEGRATION_SINK = 'INTEGRATION_SINK' as const;\n\n/**\n * Run-recorder token (SYNC-5). Backed by `IIntegrationRunRecorder`. Drizzle impl\n * lands in SYNC-4; tests provide inline fakes.\n */\nexport const INTEGRATION_RUN_RECORDER = 'INTEGRATION_RUN_RECORDER' as const;\n\n/**\n * Injection token for the resolved `IntegrationModuleOptions` object (SYNC-6).\n *\n * Backends that need to observe module configuration (e.g. `multiTenant`\n * flag, pool filters) inject via this token. Provided automatically by\n * `IntegrationModule.forRoot(...)` / `IntegrationModule.forRootAsync(...)`.\n */\nexport const INTEGRATION_MODULE_OPTIONS = 'INTEGRATION_MODULE_OPTIONS' as const;\n\n/**\n * Injection token for the resolved multi-tenancy flag (SYNC-6).\n *\n * Provided by `IntegrationModule.forRoot(...)` as `options.multiTenant ?? false`.\n * Consumed by `ExecuteIntegrationUseCase` to enforce the tenantId-is-required rule.\n */\nexport const INTEGRATION_MULTI_TENANT = 'INTEGRATION_MULTI_TENANT' as const;\n\n/**\n * Injection token for the entity-keyed `IEntityChangeSourceRegistry` (C7,\n * #336). Bound to the codegen-emitted aggregator that folds per-provider\n * adapter contributions into one registry (RFC-0001 §3, emitted by Track D\n * D3/D4).\n *\n * A string constant, not `Symbol.for(...)`, to match this subsystem's token\n * convention (see file header). The originating issue's code block proposed a\n * `Symbol.for('@pattern-stack/codegen.entity-change-source-registry')` key,\n * predating the sync→integration consolidation onto string tokens; kept as a\n * string here for internal consistency with the other INTEGRATION_* tokens.\n */\nexport const ENTITY_CHANGE_SOURCE_REGISTRY = 'ENTITY_CHANGE_SOURCE_REGISTRY' as const;\n","/**\n * Typed errors + shared boundary helpers for the integration subsystem.\n *\n * Classes (not bare Error) so consumers can `instanceof` them in catch\n * blocks and exception filters can map them to HTTP codes.\n *\n * Mirrors the shape of `events-errors.ts` and `jobs-errors.ts`.\n */\n\n/**\n * Thrown by the Drizzle cursor-store / run-recorder backends AND by the\n * orchestrator entry point when `INTEGRATION_MULTI_TENANT` is enabled but the\n * caller did not supply a non-null `tenantId`. Strict enforcement at the\n * boundary — explicit `null` still throws.\n *\n * Disable multi-tenancy on the module (`multiTenant: false`, the default)\n * to opt out of the requirement entirely.\n *\n * `operation` identifies the call site (e.g. `'cursor.put'`,\n * `'startRun'`, `'execute'`) so the stack-trace message points at the\n * specific boundary that rejected the input.\n */\nexport class MissingTenantIdError extends Error {\n  override readonly name = 'MissingTenantIdError';\n  constructor(operation: string) {\n    super(\n      `Missing tenantId for integration operation '${operation}'. IntegrationModule is ` +\n        `configured with multiTenant: true — every call must include a ` +\n        `non-null tenantId. Either pass the tenantId or disable multi-` +\n        `tenancy on the module.`,\n    );\n  }\n}\n\n/**\n * Shared boundary guard — used at the orchestrator entry AND inside the\n * Drizzle backends. Keeping the check in one function guarantees every\n * `MissingTenantIdError` carries the same message shape regardless of the\n * site that raised it, which makes it easier for consumers to pattern-\n * match on the error in logs/metrics.\n *\n * When `multiTenant` is false, the function is a no-op — `tenantId` may\n * be anything (including `undefined`). When true, `undefined` or `null`\n * throws.\n */\nexport function assertTenantId(\n  tenantId: string | null | undefined,\n  options: { multiTenant: boolean; operation: string },\n): asserts tenantId is string {\n  if (!options.multiTenant) return;\n  if (tenantId === undefined || tenantId === null) {\n    throw new MissingTenantIdError(options.operation);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/runtime/subsystems/{sync/sync-run-recorder.memory-backend.d.ts → integration/integration-run-recorder.memory-backend.d.ts}

@@ -1,27 +1,27 @@
-import { ISyncRunRecorder, RecordItemInput, StartRunInput, CompleteRunInput, SyncRunSummary } from './sync-run-recorder.protocol.js';
-import './sync-field-diff.protocol.js';
+import { IIntegrationRunRecorder, RecordItemInput, StartRunInput, CompleteRunInput, IntegrationRunSummary } from './integration-run-recorder.protocol.js';
+import './integration-field-diff.protocol.js';
 import 'zod';
 
 /**
  * Optional per-subscription metadata a test can seed on the memory backend
- * so `listRecent` can surface `integrationId`. The memory recorder's write
+ * so `listRecent` can surface `connectionId`. The memory recorder's write
  * path never persists subscription rows (it only stores runs + items), so
- * `listRecent` has no way to derive `integrationId` on its own. Tests that
+ * `listRecent` has no way to derive `connectionId` on its own. Tests that
  * care about the field should populate `subscriptions` before calling
  * `listRecent`; calls that don't seed get an empty string and a stable
  * shape (see `listRecent` below).
  */
-interface MemorySyncSubscription {
-    integrationId: string;
+interface MemoryIntegrationSubscription {
+    connectionId: string;
     adapter: string;
     domain: string;
     externalRef: string | null;
-    lastSyncAt?: Date | null;
+    lastIntegrationAt?: Date | null;
     updatedAt: Date;
 }
 /**
  * Concrete run row as held in memory. Shape mirrors the interesting
- * columns on `sync_runs` so assertions read like DB queries.
+ * columns on `integration_runs` so assertions read like DB queries.
  */
 interface MemoryRunRecord {
     id: string;
@@ -39,32 +39,32 @@ interface MemoryRunRecord {
     startedAt: Date;
     completedAt: Date | null;
 }
-declare class MemoryRunRecorder implements ISyncRunRecorder {
+declare class MemoryRunRecorder implements IIntegrationRunRecorder {
     /**
      * All started runs keyed by id. Public so tests can inspect lifecycle
      * transitions without poking through recording methods.
      */
     readonly runs: Map<string, MemoryRunRecord>;
     /**
-     * Items keyed by `sync_run_id`, array order matches insertion order —
-     * mirrors the timeline the `(sync_run_id, created_at)` index produces
+     * Items keyed by `integration_run_id`, array order matches insertion order —
+     * mirrors the timeline the `(integration_run_id, created_at)` index produces
      * in Postgres.
      */
     readonly items: Map<string, RecordItemInput[]>;
     /**
      * Seedable subscription metadata — tests populate this to make
-     * `listRecent` return meaningful `integrationId` values. The memory
+     * `listRecent` return meaningful `connectionId` values. The memory
      * backend doesn't track subscriptions on its own (only runs + items), so
      * this map is the intentional extension point: tests write entries for
      * the subscription ids they use, production code never touches it.
      */
-    readonly subscriptions: Map<string, MemorySyncSubscription>;
+    readonly subscriptions: Map<string, MemoryIntegrationSubscription>;
     startRun(input: StartRunInput): Promise<{
         id: string;
     }>;
     recordItem(input: RecordItemInput): Promise<void>;
     completeRun(runId: string, input: CompleteRunInput): Promise<void>;
-    listRecent(limit: number, subscriptionId?: string, _tenantId?: string | null): Promise<SyncRunSummary[]>;
+    listRecent(limit: number, subscriptionId?: string, _tenantId?: string | null): Promise<IntegrationRunSummary[]>;
     /** Reset state. Tests call this in `beforeEach`. */
     clear(): void;
     /** All runs for a subscription, newest first. Timeline reads. */
@@ -73,4 +73,4 @@ declare class MemoryRunRecorder implements ISyncRunRecorder {
     getItemsForRun(runId: string): RecordItemInput[];
 }
 
-export { type MemoryRunRecord, MemoryRunRecorder, type MemorySyncSubscription };
+export { type MemoryIntegrationSubscription, type MemoryRunRecord, MemoryRunRecorder };

package/dist/runtime/subsystems/{sync/sync-run-recorder.memory-backend.js → integration/integration-run-recorder.memory-backend.js}

@@ -9,10 +9,10 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 
-// runtime/subsystems/sync/sync-run-recorder.memory-backend.ts
+// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
 import { Injectable } from "@nestjs/common";
 
-// runtime/subsystems/sync/sync-field-diff.protocol.ts
+// runtime/subsystems/integration/integration-field-diff.protocol.ts
 import { z } from "zod";
 var FieldDiffValueSchema = z.object({
   from: z.unknown(),
@@ -20,7 +20,7 @@ var FieldDiffValueSchema = z.object({
 });
 var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
 
-// runtime/subsystems/sync/sync-run-recorder.memory-backend.ts
+// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
 var MemoryRunRecorder = class {
   /**
    * All started runs keyed by id. Public so tests can inspect lifecycle
@@ -28,14 +28,14 @@ var MemoryRunRecorder = class {
    */
   runs = /* @__PURE__ */ new Map();
   /**
-   * Items keyed by `sync_run_id`, array order matches insertion order —
-   * mirrors the timeline the `(sync_run_id, created_at)` index produces
+   * Items keyed by `integration_run_id`, array order matches insertion order —
+   * mirrors the timeline the `(integration_run_id, created_at)` index produces
    * in Postgres.
    */
   items = /* @__PURE__ */ new Map();
   /**
    * Seedable subscription metadata — tests populate this to make
-   * `listRecent` return meaningful `integrationId` values. The memory
+   * `listRecent` return meaningful `connectionId` values. The memory
    * backend doesn't track subscriptions on its own (only runs + items), so
    * this map is the intentional extension point: tests write entries for
    * the subscription ids they use, production code never touches it.
@@ -64,10 +64,10 @@ var MemoryRunRecorder = class {
   }
   async recordItem(input) {
     FieldDiffSchema.parse(input.changedFields);
-    const bucket = this.items.get(input.syncRunId);
+    const bucket = this.items.get(input.integrationRunId);
     if (!bucket) {
       throw new Error(
-        `MemoryRunRecorder.recordItem: no run started for id '${input.syncRunId}'. Call startRun(...) first.`
+        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
       );
     }
     bucket.push(input);
@@ -93,10 +93,10 @@ var MemoryRunRecorder = class {
     return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).map((r) => ({
       id: r.id,
       subscriptionId: r.subscriptionId,
-      // integrationId is only knowable if the test seeded subscriptions
+      // connectionId is only knowable if the test seeded subscriptions
       // metadata; empty string otherwise. The Drizzle backend resolves
       // it via JOIN, which is the production path.
-      integrationId: this.subscriptions.get(r.subscriptionId)?.integrationId ?? "",
+      connectionId: this.subscriptions.get(r.subscriptionId)?.connectionId ?? "",
       status: r.status,
       startedAt: r.startedAt,
       completedAt: r.completedAt,
@@ -126,4 +126,4 @@ MemoryRunRecorder = __decorateClass([
 export {
   MemoryRunRecorder
 };
-//# sourceMappingURL=sync-run-recorder.memory-backend.js.map
+//# sourceMappingURL=integration-run-recorder.memory-backend.js.map

package/dist/runtime/subsystems/integration/integration-run-recorder.memory-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../runtime/subsystems/integration/integration-run-recorder.memory-backend.ts","../../../../runtime/subsystems/integration/integration-field-diff.protocol.ts"],"sourcesContent":["/**\n * MemoryRunRecorder — in-memory backend for `IIntegrationRunRecorder` (SYNC-6).\n *\n * Test double so `IntegrationModule.forRoot({ backend: 'memory' })` is genuinely\n * end-to-end runnable without Postgres. Mirrors the role of\n * `MemoryCursorStore`: plain keyed state, `clear()` helper for\n * `beforeEach` resets, public inspection surface so tests can assert on\n * the recorded run + item timeline without scraping logs.\n *\n * Validates `changedFields` through `FieldDiffSchema.parse` on every\n * `recordItem` call — same ADR-0003 contract as the Drizzle backend. An\n * in-memory recorder that skipped the validation would be a silently\n * weaker contract than production.\n *\n * `startRun` generates a uuid via `crypto.randomUUID()` (Node 19+ / Bun).\n * We don't import `uuid` because the subsystem has no other use for it.\n *\n * ## Multi-tenancy\n *\n * `tenantId` is accepted (and recorded on the in-memory row so tests can\n * assert it) but enforcement lives at the module boundary. The memory\n * backend intentionally does not throw on missing `tenantId` — that's\n * the orchestrator's job when `multiTenant=true` (SYNC-6). A permissive\n * memory recorder lets tests exercise error paths where the orchestrator\n * short-circuits before ever reaching the recorder.\n */\nimport { Injectable } from '@nestjs/common';\nimport type {\n  CompleteRunInput,\n  IIntegrationRunRecorder,\n  RecordItemInput,\n  StartRunInput,\n  IntegrationRunSummary,\n} from './integration-run-recorder.protocol';\nimport { FieldDiffSchema } from './integration-field-diff.protocol';\n\n/**\n * Optional per-subscription metadata a test can seed on the memory backend\n * so `listRecent` can surface `connectionId`. The memory recorder's write\n * path never persists subscription rows (it only stores runs + items), so\n * `listRecent` has no way to derive `connectionId` on its own. Tests that\n * care about the field should populate `subscriptions` before calling\n * `listRecent`; calls that don't seed get an empty string and a stable\n * shape (see `listRecent` below).\n */\nexport interface MemoryIntegrationSubscription {\n  connectionId: string;\n  adapter: string;\n  domain: string;\n  externalRef: string | null;\n  lastIntegrationAt?: Date | null;\n  updatedAt: Date;\n}\n\n/**\n * Concrete run row as held in memory. Shape mirrors the interesting\n * columns on `integration_runs` so assertions read like DB queries.\n */\nexport interface MemoryRunRecord {\n  id: string;\n  subscriptionId: string;\n  direction: 'inbound' | 'outbound';\n  action: 'poll' | 'cdc' | 'webhook' | 'manual' | 'writeback';\n  status: 'running' | 'success' | 'no_changes' | 'failed';\n  cursorBefore: unknown | null;\n  cursorAfter: unknown | null;\n  recordsFound: number;\n  recordsProcessed: number;\n  durationMs: number | null;\n  error: string | null;\n  tenantId: string | null;\n  startedAt: Date;\n  completedAt: Date | null;\n}\n\n@Injectable()\nexport class MemoryRunRecorder implements IIntegrationRunRecorder {\n  /**\n   * All started runs keyed by id. Public so tests can inspect lifecycle\n   * transitions without poking through recording methods.\n   */\n  readonly runs: Map<string, MemoryRunRecord> = new Map();\n\n  /**\n   * Items keyed by `integration_run_id`, array order matches insertion order —\n   * mirrors the timeline the `(integration_run_id, created_at)` index produces\n   * in Postgres.\n   */\n  readonly items: Map<string, RecordItemInput[]> = new Map();\n\n  /**\n   * Seedable subscription metadata — tests populate this to make\n   * `listRecent` return meaningful `connectionId` values. The memory\n   * backend doesn't track subscriptions on its own (only runs + items), so\n   * this map is the intentional extension point: tests write entries for\n   * the subscription ids they use, production code never touches it.\n   */\n  readonly subscriptions: Map<string, MemoryIntegrationSubscription> = new Map();\n\n  async startRun(input: StartRunInput): Promise<{ id: string }> {\n    const id = crypto.randomUUID();\n    this.runs.set(id, {\n      id,\n      subscriptionId: input.subscriptionId,\n      direction: input.direction,\n      action: input.action,\n      status: 'running',\n      cursorBefore: input.cursorBefore ?? null,\n      cursorAfter: null,\n      recordsFound: 0,\n      recordsProcessed: 0,\n      durationMs: null,\n      error: null,\n      tenantId: input.tenantId ?? null,\n      startedAt: new Date(),\n      completedAt: null,\n    });\n    this.items.set(id, []);\n    return { id };\n  }\n\n  async recordItem(input: RecordItemInput): Promise<void> {\n    // Same ADR-0003 contract as the Drizzle backend.\n    FieldDiffSchema.parse(input.changedFields);\n\n    const bucket = this.items.get(input.integrationRunId);\n    if (!bucket) {\n      throw new Error(\n        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. ` +\n          `Call startRun(...) first.`,\n      );\n    }\n    bucket.push(input);\n  }\n\n  async completeRun(runId: string, input: CompleteRunInput): Promise<void> {\n    const run = this.runs.get(runId);\n    if (!run) {\n      throw new Error(\n        `MemoryRunRecorder.completeRun: no run started for id '${runId}'.`,\n      );\n    }\n    run.status = input.status;\n    run.recordsFound = input.recordsFound;\n    run.recordsProcessed = input.recordsProcessed;\n    run.cursorAfter = input.cursorAfter ?? null;\n    run.durationMs = input.durationMs;\n    run.error = input.error ?? null;\n    run.completedAt = new Date();\n  }\n\n  async listRecent(\n    limit: number,\n    subscriptionId?: string,\n    _tenantId?: string | null,\n  ): Promise<IntegrationRunSummary[]> {\n    // Memory backend accepts tenantId for contract symmetry but does not\n    // filter on it — state is process-local and cross-tenant isolation is\n    // not meaningful here (matches MemoryCursorStore behavior).\n    const all = Array.from(this.runs.values());\n    const filtered =\n      subscriptionId === undefined\n        ? all\n        : all.filter((r) => r.subscriptionId === subscriptionId);\n    return filtered\n      .sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime())\n      .slice(0, limit)\n      .map((r) => ({\n        id: r.id,\n        subscriptionId: r.subscriptionId,\n        // connectionId is only knowable if the test seeded subscriptions\n        // metadata; empty string otherwise. The Drizzle backend resolves\n        // it via JOIN, which is the production path.\n        connectionId:\n          this.subscriptions.get(r.subscriptionId)?.connectionId ?? '',\n        status: r.status,\n        startedAt: r.startedAt,\n        completedAt: r.completedAt,\n        recordsProcessed: r.recordsProcessed,\n        tenantId: r.tenantId,\n      }));\n  }\n\n  /** Reset state. Tests call this in `beforeEach`. */\n  clear(): void {\n    this.runs.clear();\n    this.items.clear();\n    this.subscriptions.clear();\n  }\n\n  // ─── test ergonomics ─────────────────────────────────────────────────\n\n  /** All runs for a subscription, newest first. Timeline reads. */\n  getRunsForSubscription(subscriptionId: string): MemoryRunRecord[] {\n    return Array.from(this.runs.values())\n      .filter((r) => r.subscriptionId === subscriptionId)\n      .sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());\n  }\n\n  /** All item rows for a run, insertion-ordered. */\n  getItemsForRun(runId: string): RecordItemInput[] {\n    return this.items.get(runId) ?? [];\n  }\n}\n","/**\n * Integration subsystem — field-diff protocol (port)\n *\n * `IFieldDiffer<T>` is the pluggable differ seam. The default implementation\n * (`DeepEqualDiffer`, ships in SYNC-5) walks every field except an ignore\n * list; CDC-aware differs can skip comparison for fields the provider didn't\n * flag as changed.\n *\n * `FieldDiffSchema` is the structural enforcement of the `changed_fields`\n * column per ADR-0003 — enforced at write time by the recorder service so\n * consumers can rely on the shape in downstream queries.\n */\nimport { z } from 'zod';\n\n// ============================================================================\n// FieldDiff shape — the ADR-0003 contract\n// ============================================================================\n\n/**\n * Structured per-field change. Enforced shape for `integration_run_items.changed_fields`.\n *\n * `created` items set `from: null, to: <value>` for every non-null field.\n * `deleted` items set `from: <value>, to: null`.\n * `noop` items carry `{}`.\n */\nexport const FieldDiffValueSchema = z.object({\n  from: z.unknown(),\n  to: z.unknown(),\n});\n\nexport const FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);\n\nexport type FieldDiffValue = z.infer<typeof FieldDiffValueSchema>;\nexport type FieldDiff = z.infer<typeof FieldDiffSchema>;\n\n/** Result of comparing a new record against its existing local state. */\nexport type DiffResult = FieldDiff | 'noop';\n\n// ============================================================================\n// IFieldDiffer\n// ============================================================================\n\n/**\n * Pluggable differ. Default ships in SYNC-5 as `DeepEqualDiffer<T>` —\n * deep-equal over every field except an ignore list (`updated_at` and other\n * row metadata). CDC-aware differs restrict comparison to\n * `providerChangedFields` when supplied.\n */\nexport interface IFieldDiffer<T> {\n  /**\n   * @param existing — current local state, or `null` when the record is new\n   * @param incoming — the canonical record coming from the adapter\n   * @param providerChangedFields — optional hint from CDC-capable sources;\n   *   when present, differ may restrict the comparison to these fields\n   */\n  diff(\n    existing: T | null,\n    incoming: T,\n    providerChangedFields?: string[],\n  ): DiffResult;\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAS,kBAAkB;;;ACd3B,SAAS,SAAS;AAaX,IAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,MAAM,EAAE,QAAQ;AAAA,EAChB,IAAI,EAAE,QAAQ;AAChB,CAAC;AAEM,IAAM,kBAAkB,EAAE,OAAO,EAAE,OAAO,GAAG,oBAAoB;;;AD8CjE,IAAM,oBAAN,MAA2D;AAAA;AAAA;AAAA;AAAA;AAAA,EAKvD,OAAqC,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO7C,QAAwC,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAShD,gBAA4D,oBAAI,IAAI;AAAA,EAE7E,MAAM,SAAS,OAA+C;AAC5D,UAAM,KAAK,OAAO,WAAW;AAC7B,SAAK,KAAK,IAAI,IAAI;AAAA,MAChB;AAAA,MACA,gBAAgB,MAAM;AAAA,MACtB,WAAW,MAAM;AAAA,MACjB,QAAQ,MAAM;AAAA,MACd,QAAQ;AAAA,MACR,cAAc,MAAM,gBAAgB;AAAA,MACpC,aAAa;AAAA,MACb,cAAc;AAAA,MACd,kBAAkB;AAAA,MAClB,YAAY;AAAA,MACZ,OAAO;AAAA,MACP,UAAU,MAAM,YAAY;AAAA,MAC5B,WAAW,oBAAI,KAAK;AAAA,MACpB,aAAa;AAAA,IACf,CAAC;AACD,SAAK,MAAM,IAAI,IAAI,CAAC,CAAC;AACrB,WAAO,EAAE,GAAG;AAAA,EACd;AAAA,EAEA,MAAM,WAAW,OAAuC;AAEtD,oBAAgB,MAAM,MAAM,aAAa;AAEzC,UAAM,SAAS,KAAK,MAAM,IAAI,MAAM,gBAAgB;AACpD,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI;AAAA,QACR,wDAAwD,MAAM,gBAAgB;AAAA,MAEhF;AAAA,IACF;AACA,WAAO,KAAK,KAAK;AAAA,EACnB;AAAA,EAEA,MAAM,YAAY,OAAe,OAAwC;AACvE,UAAM,MAAM,KAAK,KAAK,IAAI,KAAK;AAC/B,QAAI,CAAC,KAAK;AACR,YAAM,IAAI;AAAA,QACR,yDAAyD,KAAK;AAAA,MAChE;AAAA,IACF;AACA,QAAI,SAAS,MAAM;AACnB,QAAI,eAAe,MAAM;AACzB,QAAI,mBAAmB,MAAM;AAC7B,QAAI,cAAc,MAAM,eAAe;AACvC,QAAI,aAAa,MAAM;AACvB,QAAI,QAAQ,MAAM,SAAS;AAC3B,QAAI,cAAc,oBAAI,KAAK;AAAA,EAC7B;AAAA,EAEA,MAAM,WACJ,OACA,gBACA,WACkC;AAIlC,UAAM,MAAM,MAAM,KAAK,KAAK,KAAK,OAAO,CAAC;AACzC,UAAM,WACJ,mBAAmB,SACf,MACA,IAAI,OAAO,CAAC,MAAM,EAAE,mBAAmB,cAAc;AAC3D,WAAO,SACJ,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,QAAQ,IAAI,EAAE,UAAU,QAAQ,CAAC,EAC5D,MAAM,GAAG,KAAK,EACd,IAAI,CAAC,OAAO;AAAA,MACX,IAAI,EAAE;AAAA,MACN,gBAAgB,EAAE;AAAA;AAAA;AAAA;AAAA,MAIlB,cACE,KAAK,cAAc,IAAI,EAAE,cAAc,GAAG,gBAAgB;AAAA,MAC5D,QAAQ,EAAE;AAAA,MACV,WAAW,EAAE;AAAA,MACb,aAAa,EAAE;AAAA,MACf,kBAAkB,EAAE;AAAA,MACpB,UAAU,EAAE;AAAA,IACd,EAAE;AAAA,EACN;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,KAAK,MAAM;AAChB,SAAK,MAAM,MAAM;AACjB,SAAK,cAAc,MAAM;AAAA,EAC3B;AAAA;AAAA;AAAA,EAKA,uBAAuB,gBAA2C;AAChE,WAAO,MAAM,KAAK,KAAK,KAAK,OAAO,CAAC,EACjC,OAAO,CAAC,MAAM,EAAE,mBAAmB,cAAc,EACjD,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,QAAQ,IAAI,EAAE,UAAU,QAAQ,CAAC;AAAA,EACjE;AAAA;AAAA,EAGA,eAAe,OAAkC;AAC/C,WAAO,KAAK,MAAM,IAAI,KAAK,KAAK,CAAC;AAAA,EACnC;AACF;AA/Ha,oBAAN;AAAA,EADN,WAAW;AAAA,GACC;","names":[]}

package/dist/runtime/subsystems/{sync/sync-run-recorder.protocol.d.ts → integration/integration-run-recorder.protocol.d.ts}

@@ -1,15 +1,15 @@
-import { FieldDiff } from './sync-field-diff.protocol.js';
+import { FieldDiff } from './integration-field-diff.protocol.js';
 import 'zod';
 
 /**
- * Sync subsystem — run-recorder protocol (port)
+ * Integration subsystem — run-recorder protocol (port)
  *
- * `ISyncRunRecorder` is the write side of the audit log. `ExecuteSyncUseCase`
+ * `IIntegrationRunRecorder` is the write side of the audit log. `ExecuteIntegrationUseCase`
  * (SYNC-5) calls `startRun` at the top of the loop, `recordItem` for each
  * processed change, and `completeRun` in a `finally` block so a run always
  * reaches a terminal status.
  *
- * The Drizzle backend (SYNC-4) persists against `sync_runs` / `sync_run_items`
+ * The Drizzle backend (SYNC-4) persists against `integration_runs` / `integration_run_items`
  * from the SYNC-1 schema. Tests use lightweight in-memory fakes — no
  * dedicated memory backend ships; the surface is small enough that inline
  * fakes keep the intent local to each spec.
@@ -21,7 +21,7 @@ import 'zod';
  * always a `FieldDiff`.
  */
 
-/** Args for `startRun`. Mirrors the non-nullable columns on `sync_runs`. */
+/** Args for `startRun`. Mirrors the non-nullable columns on `integration_runs`. */
 interface StartRunInput {
     readonly subscriptionId: string;
     readonly direction: 'inbound' | 'outbound';
@@ -29,15 +29,15 @@ interface StartRunInput {
     /** Cursor snapshot at run start, or `null` if this is the first run. */
     readonly cursorBefore: unknown | null;
     /**
-     * Tenant id when `SYNC_MULTI_TENANT` is enabled. The recorder's own
+     * Tenant id when `INTEGRATION_MULTI_TENANT` is enabled. The recorder's own
      * boundary rule (SYNC-6) enforces non-null when the flag is on;
-     * orchestrator passes it through from `ExecuteSyncInput.tenantId`.
+     * orchestrator passes it through from `ExecuteIntegrationInput.tenantId`.
      */
     readonly tenantId?: string | null;
 }
-/** Args for `recordItem`. Mirrors the non-nullable columns on `sync_run_items`. */
+/** Args for `recordItem`. Mirrors the non-nullable columns on `integration_run_items`. */
 interface RecordItemInput {
-    readonly syncRunId: string;
+    readonly integrationRunId: string;
     readonly entityType: string;
     readonly externalId: string;
     readonly localId?: string | null;
@@ -62,36 +62,36 @@ interface CompleteRunInput {
     readonly error?: string | null;
 }
 /**
- * Denormalized view of one `sync_runs` row, JOINed against
- * `sync_subscriptions` to surface `integrationId` in a single read. Consumed
+ * Denormalized view of one `integration_runs` row, JOINed against
+ * `integration_subscriptions` to surface `connectionId` in a single read. Consumed
  * by the OBS-5 observability composer (epic #195).
  *
- * `recordsProcessed` is the denormalized column on `sync_runs` — it does NOT
- * count `sync_run_items` rows. A correlated subquery per run would be
+ * `recordsProcessed` is the denormalized column on `integration_runs` — it does NOT
+ * count `integration_run_items` rows. A correlated subquery per run would be
  * required for a true item count; deferred as a follow-up if needed.
  *
- * Memory backends can't know `integrationId` without subscription metadata
+ * Memory backends can't know `connectionId` without subscription metadata
  * — see each memory backend for the seedable `subscriptions` side-map that
  * tests populate. When metadata is missing, memory backends emit an empty
  * string so the shape stays stable (documented in the memory backend).
  */
-interface SyncRunSummary {
+interface IntegrationRunSummary {
     readonly id: string;
     readonly subscriptionId: string;
     /** Resolved by Drizzle via JOIN; empty string from memory if not seeded. */
-    readonly integrationId: string;
+    readonly connectionId: string;
     readonly status: 'running' | 'success' | 'no_changes' | 'failed';
     readonly startedAt: Date;
     readonly completedAt: Date | null;
     readonly recordsProcessed: number;
     readonly tenantId: string | null;
 }
-interface ISyncRunRecorder {
-    /** Opens a new `sync_runs` row in `status = 'running'`. Returns the run id. */
+interface IIntegrationRunRecorder {
+    /** Opens a new `integration_runs` row in `status = 'running'`. Returns the run id. */
     startRun(input: StartRunInput): Promise<{
         id: string;
     }>;
-    /** Appends one `sync_run_items` row. Throws if `changedFields` is malformed. */
+    /** Appends one `integration_run_items` row. Throws if `changedFields` is malformed. */
     recordItem(input: RecordItemInput): Promise<void>;
     /**
      * Finalizes the run. Must be called from a `finally` block so an in-flight
@@ -100,20 +100,20 @@ interface ISyncRunRecorder {
      */
     completeRun(runId: string, input: CompleteRunInput): Promise<void>;
     /**
-     * Recent `sync_runs` rows ordered by `started_at DESC`, capped at `limit`.
+     * Recent `integration_runs` rows ordered by `started_at DESC`, capped at `limit`.
      *
-     * Filter is `subscriptionId` — the natural FK on `sync_runs`. An
-     * integration-wide view requires filtering on `sync_subscriptions.integration_id`
+     * Filter is `subscriptionId` — the natural FK on `integration_runs`. An
+     * integration-wide view requires filtering on `integration_subscriptions.connection_id`
      * through the JOIN and is deferred as a follow-up (epic #195 OBS-4 spec).
      *
      * @param limit           hard cap on rows returned (no implicit default)
      * @param subscriptionId  optional FK filter; omit for cross-subscription view
      * @param tenantId        required by Drizzle backend when
-     *                        `SYNC_MULTI_TENANT` is on (throws
+     *                        `INTEGRATION_MULTI_TENANT` is on (throws
      *                        `MissingTenantIdError` otherwise); memory backend
      *                        accepts but ignores
      */
-    listRecent(limit: number, subscriptionId?: string, tenantId?: string | null): Promise<SyncRunSummary[]>;
+    listRecent(limit: number, subscriptionId?: string, tenantId?: string | null): Promise<IntegrationRunSummary[]>;
 }
 
-export type { CompleteRunInput, ISyncRunRecorder, RecordItemInput, StartRunInput, SyncRunSummary };
+export type { CompleteRunInput, IIntegrationRunRecorder, IntegrationRunSummary, RecordItemInput, StartRunInput };

package/dist/runtime/subsystems/integration/integration-run-recorder.protocol.js

@@ -0,0 +1 @@
+//# sourceMappingURL=integration-run-recorder.protocol.js.map

package/dist/runtime/subsystems/{sync/sync-sink.protocol.d.ts → integration/integration-sink.protocol.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Sync subsystem — sync-sink protocol (port)
+ * Integration subsystem — integration-sink protocol (port)
  *
  * Write surface for the generic orchestrator. One per canonical entity type.
  *
@@ -13,7 +13,7 @@
  * Implementations compose the entity's service + (when the entity has EAV)
  * `FieldValueService` inside a single transaction. ADR-13-revised.
  */
-interface ISyncSink<TCanonical> {
+interface IIntegrationSink<TCanonical> {
     /**
      * Canonical-shaped view of local state, or `null` when no local row exists.
      * Called once per change to source the diff's "before" side.
@@ -28,11 +28,11 @@ interface ISyncSink<TCanonical> {
      *   - tolerate re-entry (same record twice in a window = no-op)
      *
      * Returns the local row id and the canonical projection of the saved row
-     * (so the orchestrator can record it on `sync_run_items.local_id`).
+     * (so the orchestrator can record it on `integration_run_items.local_id`).
      *
      * `provider` is the adapter domain string (e.g. `'salesforce-crm'`,
      * `'hubspot-crm'`) persisted on the DB row. Passed from
-     * `ExecuteSyncInput.provider`.
+     * `ExecuteIntegrationInput.provider`.
      */
     upsertByExternalId(userId: string, record: TCanonical, provider: string): Promise<{
         id: string;
@@ -53,4 +53,4 @@ interface ISyncSink<TCanonical> {
     readonly reprojectsOnNoop?: boolean;
 }
 
-export type { ISyncSink };
+export type { IIntegrationSink };

package/dist/runtime/subsystems/integration/integration-sink.protocol.js

@@ -0,0 +1 @@
+//# sourceMappingURL=integration-sink.protocol.js.map

package/dist/runtime/subsystems/{sync/sync.module.d.ts → integration/integration.module.d.ts}

@@ -1,33 +1,33 @@
 import { DynamicModule } from '@nestjs/common';
 
 /**
- * SyncModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory
- * wiring the sync subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).
+ * IntegrationModule — `DynamicModule.forRoot({ backend, multiTenant? })` factory
+ * wiring the integration subsystem's substrate (SYNC-6, ADR-008 subsystem pattern).
  *
  * ## What this module provides
  *
- *   - `SYNC_CURSOR_STORE`    — Drizzle or Memory cursor store
- *   - `SYNC_RUN_RECORDER`    — Drizzle or Memory run recorder
- *   - `SYNC_FIELD_DIFFER`    — default `DeepEqualDiffer`
- *   - `SYNC_MULTI_TENANT`    — resolved boolean flag (defaults to false)
- *   - `SYNC_MODULE_OPTIONS`  — the options object itself, for backends
+ *   - `INTEGRATION_CURSOR_STORE`    — Drizzle or Memory cursor store
+ *   - `INTEGRATION_RUN_RECORDER`    — Drizzle or Memory run recorder
+ *   - `INTEGRATION_FIELD_DIFFER`    — default `DeepEqualDiffer`
+ *   - `INTEGRATION_MULTI_TENANT`    — resolved boolean flag (defaults to false)
+ *   - `INTEGRATION_MODULE_OPTIONS`  — the options object itself, for backends
  *     that need to inspect config at construction time
  *
  * ## What this module does NOT provide
  *
- *   - `SYNC_CHANGE_SOURCE` — per-provider per-entity; consumer binds in
- *     their feature module (e.g. `OpportunitySyncModule` provides a
+ *   - `INTEGRATION_CHANGE_SOURCE` — per-provider per-entity; consumer binds in
+ *     their feature module (e.g. `OpportunityIntegrationModule` provides a
  *     `SalesforceOpportunityChangeSource`). Loopback suppression — when
  *     needed — is composed into the primitive's middleware chain via
  *     `createLoopbackMiddleware(store)` (#226-5 / ADR-033); the
  *     orchestrator no longer accepts a fingerprint store directly.
- *   - `SYNC_SINK` — per canonical entity; consumer binds in their feature
+ *   - `INTEGRATION_SINK` — per canonical entity; consumer binds in their feature
  *     module.
- *   - `ExecuteSyncUseCase` — registered by the feature module alongside
+ *   - `ExecuteIntegrationUseCase` — registered by the feature module alongside
  *     its source + sink bindings. Providing the orchestrator here would
- *     force Nest to resolve SYNC_CHANGE_SOURCE + SYNC_SINK at module
+ *     force Nest to resolve INTEGRATION_CHANGE_SOURCE + INTEGRATION_SINK at module
  *     compile time, which fails when the feature module hasn't been
- *     imported yet. Consumers register `ExecuteSyncUseCase` in the same
+ *     imported yet. Consumers register `ExecuteIntegrationUseCase` in the same
  *     `providers` array as their source + sink so resolution is local
  *     to where all three are bound.
  *
@@ -40,7 +40,7 @@ import { DynamicModule } from '@nestjs/common';
  * ```ts
  * // AppModule — single source of truth for backend + multi-tenancy.
  * @Module({
- *   imports: [SyncModule.forRoot({ backend: 'drizzle' })],
+ *   imports: [IntegrationModule.forRoot({ backend: 'drizzle' })],
  * })
  * export class AppModule {}
  *
@@ -48,23 +48,23 @@ import { DynamicModule } from '@nestjs/common';
  * // orchestrator for free.
  * @Module({
  *   providers: [
- *     { provide: SYNC_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },
- *     { provide: SYNC_SINK,          useClass: OpportunitySyncSink },
- *     ExecuteSyncUseCase,
+ *     { provide: INTEGRATION_CHANGE_SOURCE, useClass: SalesforceOpportunitySource },
+ *     { provide: INTEGRATION_SINK,          useClass: OpportunityIntegrationSink },
+ *     ExecuteIntegrationUseCase,
  *   ],
  * })
- * export class OpportunitySyncModule {
+ * export class OpportunityIntegrationModule {
  *   constructor(
- *     private readonly execute: ExecuteSyncUseCase<CanonicalOpportunity>,
+ *     private readonly execute: ExecuteIntegrationUseCase<CanonicalOpportunity>,
  *   ) {}
  * }
  * ```
  *
  * `global: true` means feature modules do not need to re-import
- * `SyncModule` — the substrate tokens are available project-wide.
+ * `IntegrationModule` — the substrate tokens are available project-wide.
  */
 
-interface SyncModuleOptions {
+interface IntegrationModuleOptions {
     /**
      * Backend selection. `drizzle` wires the Postgres cursor store +
      * run-log recorder; `memory` wires in-memory doubles suitable for
@@ -89,8 +89,8 @@ interface SyncModuleOptions {
      */
     multiTenant?: boolean;
 }
-declare class SyncModule {
-    static forRoot(options: SyncModuleOptions): DynamicModule;
+declare class IntegrationModule {
+    static forRoot(options: IntegrationModuleOptions): DynamicModule;
 }
 
-export { SyncModule, type SyncModuleOptions };
+export { IntegrationModule, type IntegrationModuleOptions };