@pattern-stack/codegen 0.10.0 → 0.11.0

package/dist/runtime/base-classes/index.js

@@ -510,9 +510,9 @@ var BaseListUseCase = class {
   }
 };
 
-// runtime/base-classes/synced-entity-repository.ts
+// runtime/base-classes/integrated-entity-repository.ts
 import { and as and2, eq as eq2, inArray as inArray2 } from "drizzle-orm";
-var SyncedEntityRepository = class extends BaseRepository {
+var IntegratedEntityRepository = class extends BaseRepository {
   /**
    * Find a single entity by its external CRM identifier.
    */
@@ -536,20 +536,20 @@ var SyncedEntityRepository = class extends BaseRepository {
     return rows;
   }
   // ==========================================================================
-  // Inbound sync (#374) — canonical→Drizzle write + provider-scoped FK
+  // Inbound integration (#374) — canonical→Drizzle write + provider-scoped FK
   // resolution + EAV dual-write seam, all inside a SINGLE transaction.
-  // Driven entirely by `this.syncConfig`; the per-entity shape lives there.
+  // 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 `syncConfig.fkResolvers` FK (provider-scoped). Strict
+   *   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
-   *      `syncConfig.eav` and the bag is non-empty (same tx).
+   *      `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`).
@@ -558,8 +558,8 @@ var SyncedEntityRepository = class extends BaseRepository {
    * @param provider  adapter/provider label persisted + used to scope lookups
    * @param tx        optional outer transaction; when omitted we open our own
    */
-  async syncUpsertOne(write, provider, tx) {
-    const cfg = this.syncConfig;
+  async integrationUpsertOne(write, provider, tx) {
+    const cfg = this.integrationConfig;
     const w = write;
     const run = async (db) => {
       const resolvedFks = {};
@@ -617,14 +617,14 @@ var SyncedEntityRepository = class extends BaseRepository {
     return row ? this.toProjection(row) : null;
   }
   /**
-   * Sync "delete" by external id, provider-scoped. When `softDelete: true`,
+   * 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.syncConfig.softDelete ? { deletedAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date() } : { externalId: null, provider: null, updatedAt: /* @__PURE__ */ new Date() };
+    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(
       and2(
         eq2(this.table["provider"], provider),
@@ -634,19 +634,19 @@ var SyncedEntityRepository = class extends BaseRepository {
     return rows[0] ? { id: rows[0].id } : null;
   }
   /**
-   * Batch sync upsert — concretizes the former abstract stub. Delegates to
-   * `syncUpsertOne` per input inside one transaction. Inputs are raw partial
+   * 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 syncUpsert(inputs) {
+  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.syncUpsertOne(
+        const proj = await this.integrationUpsertOne(
           input,
           rec["provider"],
           tx
@@ -660,13 +660,13 @@ var SyncedEntityRepository = class extends BaseRepository {
   }
   /**
    * Project a raw row to the canonical differ shape — a generic pick over
-   * `syncConfig.projectionColumns`. Override only for synthesized projections
+   * `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.syncConfig.projectionColumns) out[col] = r[col];
+    for (const col of this.integrationConfig.projectionColumns) out[col] = r[col];
     return out;
   }
   /**
@@ -688,7 +688,7 @@ var SyncedEntityRepository = class extends BaseRepository {
     if (!parentExternalId) {
       if (fk.strict) {
         throw new Error(
-          `${this.constructor.name}.syncUpsertOne: missing required parent external id for '${fk.column}' (writeKey '${fk.writeKey}')`
+          `${this.constructor.name}.integrationUpsertOne: missing required parent external id for '${fk.column}' (writeKey '${fk.writeKey}')`
         );
       }
       return null;
@@ -703,7 +703,7 @@ var SyncedEntityRepository = class extends BaseRepository {
     const id = rows[0]?.id ?? null;
     if (id === null && fk.strict) {
       throw new Error(
-        `${this.constructor.name}.syncUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${fk.column}' \u2014 parent not synced yet`
+        `${this.constructor.name}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${fk.column}' \u2014 parent not integrated yet`
       );
     }
     return id;
@@ -717,9 +717,9 @@ var SyncedEntityRepository = class extends BaseRepository {
   }
 };
 
-// runtime/base-classes/junction-sync-repository.ts
+// runtime/base-classes/junction-integration-repository.ts
 import { and as and3, eq as eq3 } from "drizzle-orm";
-var JunctionSyncRepository = class extends BaseRepository {
+var JunctionIntegrationRepository = class extends BaseRepository {
   /**
    * Upsert ONE junction row by its composite identity, in a single transaction:
    *   1. resolve the REQUIRED left FK (provider-scoped) — STRICT: missing → throws;
@@ -733,8 +733,8 @@ var JunctionSyncRepository = class extends BaseRepository {
    * @param provider  adapter/provider label used to scope the parent lookups
    * @param tx        optional outer transaction; when omitted we open our own
    */
-  async syncUpsertOne(write, provider, tx) {
-    const cfg = this.syncConfig;
+  async integrationUpsertOne(write, provider, tx) {
+    const cfg = this.integrationConfig;
     const w = write;
     const leftWriteKey = `${cfg.left.column.replace(/Id$/, "")}ExternalId`;
     const rightWriteKey = `${cfg.right.column.replace(/Id$/, "")}ExternalId`;
@@ -778,7 +778,7 @@ var JunctionSyncRepository = class extends BaseRepository {
    * parent / no row (a missing "before" side is a create from the differ's view).
    */
   async findByExternalIdProjected(externalId, provider) {
-    const cfg = this.syncConfig;
+    const cfg = this.integrationConfig;
     const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);
     if (!parsed) return null;
     const leftId = await this.resolveLoose(this.db, cfg.left.refTable, parsed.left, provider);
@@ -798,12 +798,12 @@ var JunctionSyncRepository = class extends BaseRepository {
   }
   /**
    * Hard-delete the junction by composite externalId. Junctions have no
-   * `deleted_at` and no external-linkage columns to clear, so a sync "delete"
+   * `deleted_at` and no external-linkage columns to clear, so a integration "delete"
    * removes the row. Resolves both parents NON-throwing, then deletes by the
    * identity tuple. Returns the composite id, or `null` when nothing matched.
    */
   async softDeleteByExternalId(externalId, provider, tx) {
-    const cfg = this.syncConfig;
+    const cfg = this.integrationConfig;
     const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);
     if (!parsed) return null;
     const db = this.runner(tx);
@@ -818,12 +818,12 @@ var JunctionSyncRepository = class extends BaseRepository {
    * Project a raw junction row to the differ shape: the COMPOSITE externalId
    * `id` (junctions have no surrogate id) plus the local FK columns, role (when
    * role-bearing) and timestamps — matching the emitted
-   * `<Junction>SyncProjection` interface (id + leftId + rightId + role? +
+   * `<Junction>IntegrationProjection` interface (id + leftId + rightId + role? +
    * createdAt + updatedAt). Junction projections are purely structural, so this
-   * is fully generic over `syncConfig` — no per-junction override is emitted.
+   * is fully generic over `integrationConfig` — no per-junction override is emitted.
    */
   toProjection(row, write, _provider) {
-    const cfg = this.syncConfig;
+    const cfg = this.integrationConfig;
     const r = row;
     const leftExt = write[`${cfg.left.column.replace(/Id$/, "")}ExternalId`];
     const rightExt = write[`${cfg.right.column.replace(/Id$/, "")}ExternalId`];
@@ -840,7 +840,7 @@ var JunctionSyncRepository = class extends BaseRepository {
   }
   /** Build the identity WHERE clause `(left, right[, role])`. */
   identityWhere(leftId, rightId, role) {
-    const cfg = this.syncConfig;
+    const cfg = this.integrationConfig;
     const conds = [
       eq3(this.table[cfg.left.column], leftId),
       eq3(this.table[cfg.right.column], rightId)
@@ -855,7 +855,7 @@ var JunctionSyncRepository = class extends BaseRepository {
     const id = await this.resolveLoose(db, refTable, parentExternalId, provider);
     if (!id) {
       throw new Error(
-        `${this.constructor.name}.syncUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${column}' \u2014 parent not synced yet`
+        `${this.constructor.name}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${column}' \u2014 parent not integrated yet`
       );
     }
     return id;
@@ -976,8 +976,8 @@ var KnowledgeEntityRepository = class extends BaseRepository {
   //   semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch
 };
 
-// runtime/base-classes/synced-entity-service.ts
-var SyncedEntityService = class extends BaseService {
+// runtime/base-classes/integrated-entity-service.ts
+var IntegratedEntityService = class extends BaseService {
   /**
    * Find a single entity by its external CRM identifier.
    */
@@ -1081,13 +1081,13 @@ export {
   BaseListUseCase,
   BaseRepository,
   BaseService,
-  JunctionSyncRepository,
+  IntegratedEntityRepository,
+  IntegratedEntityService,
+  JunctionIntegrationRepository,
   KnowledgeEntityRepository,
   KnowledgeEntityService,
   MetadataEntityRepository,
   MetadataEntityService,
-  SyncedEntityRepository,
-  SyncedEntityService,
   WithAnalytics,
   buildChangeEvents,
   buildCompositeExternalId,