@pattern-stack/codegen 0.7.5 → 0.7.7

package/dist/runtime/base-classes/index.d.ts

@@ -2,7 +2,9 @@ export { BaseRepository, BehaviorConfig, ListOptions } from './base-repository.j
 export { BaseService, IBaseRepository } from './base-service.js';
 export { EventCategory, buildChangeEvents, buildLifecycleEvent, diffSnapshots, emitSafely, entitySnapshot } from './lifecycle-events.js';
 export { BaseFindByIdUseCase, BaseListUseCase, IFindByIdService, IListService } from './base-read-use-cases.js';
+export { SyncFkResolver, SyncUpsertConfig } from './sync-upsert-config.js';
 export { SyncedEntityRepository } from './synced-entity-repository.js';
+export { JunctionSyncConfig, JunctionSyncRepository, buildCompositeExternalId, parseCompositeExternalId } from './junction-sync-repository.js';
 export { ActivityEntityRepository } from './activity-entity-repository.js';
 export { MetadataEntityRepository } from './metadata-entity-repository.js';
 export { KnowledgeEntityRepository } from './knowledge-entity-repository.js';

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

@@ -81,8 +81,8 @@ var BaseRepository = class {
     if (conditions.length === 1) {
       query = query.where(conditions[0]);
     } else if (conditions.length > 1) {
-      const { and: and2 } = await import("drizzle-orm");
-      query = query.where(and2(...conditions));
+      const { and: and4 } = await import("drizzle-orm");
+      query = query.where(and4(...conditions));
     }
     const rows = await query;
     return rows[0]?.count ?? 0;
@@ -409,7 +409,7 @@ var BaseListUseCase = class {
 };
 
 // runtime/base-classes/synced-entity-repository.ts
-import { eq as eq2, inArray as inArray2 } from "drizzle-orm";
+import { and, eq as eq2, inArray as inArray2 } from "drizzle-orm";
 var SyncedEntityRepository = class extends BaseRepository {
   /**
    * Find a single entity by its external CRM identifier.
@@ -433,12 +433,178 @@ var SyncedEntityRepository = class extends BaseRepository {
     const rows = await this.baseQuery().where(eq2(this.table["userId"], userId));
     return rows;
   }
+  // ==========================================================================
+  // Inbound sync (#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.
+  // ==========================================================================
+  /**
+   * Upsert ONE entity by its `(provider, externalId)` identity, in a single
+   * transaction:
+   *   1. resolve each `syncConfig.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).
+   *
+   * 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 syncUpsertOne(write, provider, tx) {
+    const cfg = this.syncConfig;
+    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));
+  }
   /**
-   * Sync upsert — bulk insert-or-update from external CRM data.
-   * Concrete repositories must implement with the appropriate conflict target.
+   * 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 syncUpsert(_inputs) {
-    throw new Error("syncUpsert not implemented \u2014 override in concrete repository");
+  async findByExternalIdProjected(externalId, provider) {
+    const rows = await this.db.select().from(this.table).where(
+      and(
+        eq2(this.table["provider"], provider),
+        eq2(this.table["externalId"], externalId)
+      )
+    ).limit(1);
+    const row = rows[0];
+    return row ? this.toProjection(row) : null;
+  }
+  /**
+   * Sync "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 rows = await db.update(this.table).set(set).where(
+      and(
+        eq2(this.table["provider"], provider),
+        eq2(this.table["externalId"], externalId)
+      )
+    ).returning({ id: this.table["id"] });
+    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
+   * rows: provider is read from each input's own `provider` column; rows
+   * missing `externalId`/`provider` are skipped.
+   */
+  async syncUpsert(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(
+          input,
+          rec["provider"],
+          tx
+        );
+        const id = proj["id"];
+        const row = await tx.select().from(this.table).where(eq2(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
+   * `syncConfig.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];
+    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}.syncUpsertOne: 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(
+        eq2(refTable["provider"], provider),
+        eq2(refTable["externalId"], parentExternalId)
+      )
+    ).limit(1);
+    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`
+      );
+    }
+    return id;
   }
   /**
    * Find entities visible to a user (ownership + sharing rules).
@@ -449,8 +615,177 @@ var SyncedEntityRepository = class extends BaseRepository {
   }
 };
 
+// runtime/base-classes/junction-sync-repository.ts
+import { and as and2, eq as eq3 } from "drizzle-orm";
+var JunctionSyncRepository = 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;
+   *   2. resolve the REQUIRED right FK (provider-scoped) — STRICT: missing → throws;
+   *   3. insert-or-update on the `(left, right[, role])` conflict target.
+   *
+   * Idempotent. Returns the composite externalId as the projection `id`.
+   *
+   * @param write     parent external ids (`<left>ExternalId`/`<right>ExternalId`)
+   *                  + optional `role` + `userId`
+   * @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;
+    const w = write;
+    const leftWriteKey = `${cfg.left.column.replace(/Id$/, "")}ExternalId`;
+    const rightWriteKey = `${cfg.right.column.replace(/Id$/, "")}ExternalId`;
+    const run = async (db) => {
+      const leftId = await this.resolveStrict(
+        db,
+        cfg.left.refTable,
+        w[leftWriteKey],
+        provider,
+        cfg.left.column
+      );
+      const rightId = await this.resolveStrict(
+        db,
+        cfg.right.refTable,
+        w[rightWriteKey],
+        provider,
+        cfg.right.column
+      );
+      const now = /* @__PURE__ */ new Date();
+      const role = cfg.roleColumn ? w["role"] : void 0;
+      const values = {
+        [cfg.left.column]: leftId,
+        [cfg.right.column]: rightId,
+        ...cfg.roleColumn ? { [cfg.roleColumn]: role } : {},
+        ...this.behaviors.timestamps ? { updatedAt: now } : {}
+      };
+      const target = cfg.roleColumn ? [this.table[cfg.left.column], this.table[cfg.right.column], this.table[cfg.roleColumn]] : [this.table[cfg.left.column], this.table[cfg.right.column]];
+      const rows = await db.insert(this.table).values(values).onConflictDoUpdate({
+        target,
+        set: { ...this.behaviors.timestamps ? { updatedAt: now } : {} }
+      }).returning();
+      const saved = rows[0];
+      return this.toProjection(saved, w, provider);
+    };
+    return tx ? run(tx) : this.db.transaction((t) => run(t));
+  }
+  /**
+   * Canonical-projected lookup by the COMPOSITE externalId, differ-ready. Parses
+   * the composite, resolves BOTH parents NON-throwing (→ null), then selects by
+   * the identity tuple. Returns `null` on malformed composite / unresolved
+   * parent / no row (a missing "before" side is a create from the differ's view).
+   */
+  async findByExternalIdProjected(externalId, provider) {
+    const cfg = this.syncConfig;
+    const parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);
+    if (!parsed) return null;
+    const leftId = await this.resolveLoose(this.db, cfg.left.refTable, parsed.left, provider);
+    if (leftId === null) return null;
+    const rightId = await this.resolveLoose(this.db, cfg.right.refTable, parsed.right, provider);
+    if (rightId === null) return null;
+    const rows = await this.db.select().from(this.table).where(this.identityWhere(leftId, rightId, parsed.role)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    const w = {
+      [`${cfg.left.column.replace(/Id$/, "")}ExternalId`]: parsed.left,
+      [`${cfg.right.column.replace(/Id$/, "")}ExternalId`]: parsed.right,
+      ...cfg.roleColumn ? { role: parsed.role } : {},
+      userId: ""
+    };
+    return this.toProjection(row, w, provider);
+  }
+  /**
+   * Hard-delete the junction by composite externalId. Junctions have no
+   * `deleted_at` and no external-linkage columns to clear, so a sync "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 parsed = parseCompositeExternalId(externalId, cfg.roleColumn !== null);
+    if (!parsed) return null;
+    const db = this.runner(tx);
+    const leftId = await this.resolveLoose(db, cfg.left.refTable, parsed.left, provider);
+    if (leftId === null) return null;
+    const rightId = await this.resolveLoose(db, cfg.right.refTable, parsed.right, provider);
+    if (rightId === null) return null;
+    const rows = await db.delete(this.table).where(this.identityWhere(leftId, rightId, parsed.role)).returning({ id: this.table[cfg.left.column] });
+    return rows[0] ? { id: externalId } : null;
+  }
+  /**
+   * 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? +
+   * createdAt + updatedAt). Junction projections are purely structural, so this
+   * is fully generic over `syncConfig` — no per-junction override is emitted.
+   */
+  toProjection(row, write, _provider) {
+    const cfg = this.syncConfig;
+    const r = row;
+    const leftExt = write[`${cfg.left.column.replace(/Id$/, "")}ExternalId`];
+    const rightExt = write[`${cfg.right.column.replace(/Id$/, "")}ExternalId`];
+    const role = cfg.roleColumn ? r[cfg.roleColumn] : void 0;
+    const out = {
+      id: buildCompositeExternalId(leftExt, rightExt, role),
+      [cfg.left.column]: r[cfg.left.column],
+      [cfg.right.column]: r[cfg.right.column]
+    };
+    if (cfg.roleColumn) out[cfg.roleColumn] = r[cfg.roleColumn];
+    out["createdAt"] = r["createdAt"];
+    out["updatedAt"] = r["updatedAt"];
+    return out;
+  }
+  /** Build the identity WHERE clause `(left, right[, role])`. */
+  identityWhere(leftId, rightId, role) {
+    const cfg = this.syncConfig;
+    const conds = [
+      eq3(this.table[cfg.left.column], leftId),
+      eq3(this.table[cfg.right.column], rightId)
+    ];
+    if (cfg.roleColumn && role !== void 0) {
+      conds.push(eq3(this.table[cfg.roleColumn], role));
+    }
+    return and2(...conds);
+  }
+  /** Resolve a parent id (provider-scoped), throwing when unresolved. */
+  async resolveStrict(db, refTable, parentExternalId, provider, column) {
+    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`
+      );
+    }
+    return id;
+  }
+  /** Resolve a parent id (provider-scoped), returning null when unresolved. */
+  async resolveLoose(db, refTable, parentExternalId, provider) {
+    if (!parentExternalId) return null;
+    const rows = await db.select({ id: refTable["id"] }).from(refTable).where(
+      and2(
+        eq3(refTable["provider"], provider),
+        eq3(refTable["externalId"], parentExternalId)
+      )
+    ).limit(1);
+    return rows[0]?.id ?? null;
+  }
+};
+function buildCompositeExternalId(leftExternalId, rightExternalId, role) {
+  return role !== void 0 ? `${leftExternalId}::${rightExternalId}::${role}` : `${leftExternalId}::${rightExternalId}`;
+}
+function parseCompositeExternalId(externalId, withRole) {
+  const parts = externalId.split("::");
+  const expected = withRole ? 3 : 2;
+  if (parts.length !== expected || parts.some((p) => p.length === 0)) return null;
+  return {
+    left: parts[0],
+    right: parts[1],
+    role: withRole ? parts[2] : void 0
+  };
+}
+
 // runtime/base-classes/activity-entity-repository.ts
-import { eq as eq3, between, desc } from "drizzle-orm";
+import { eq as eq4, between, desc } from "drizzle-orm";
 var ActivityEntityRepository = class extends BaseRepository {
   /**
    * Find activities within a date range (inclusive).
@@ -463,27 +798,27 @@ var ActivityEntityRepository = class extends BaseRepository {
    * Find all activities for a specific user.
    */
   async findByUserId(userId) {
-    const rows = await this.baseQuery().where(eq3(this.table["userId"], userId));
+    const rows = await this.baseQuery().where(eq4(this.table["userId"], userId));
     return rows;
   }
   /**
    * Find all activities for a specific opportunity.
    */
   async findByOpportunityId(opportunityId) {
-    const rows = await this.baseQuery().where(eq3(this.table["opportunityId"], opportunityId));
+    const rows = await this.baseQuery().where(eq4(this.table["opportunityId"], opportunityId));
     return rows;
   }
   /**
    * Find the most recent activities for an opportunity, ordered by occurredAt desc.
    */
   async findRecentByOpportunityId(opportunityId, limit = 10) {
-    const rows = await this.baseQuery().where(eq3(this.table["opportunityId"], opportunityId)).orderBy(desc(this.table["occurredAt"])).limit(limit);
+    const rows = await this.baseQuery().where(eq4(this.table["opportunityId"], opportunityId)).orderBy(desc(this.table["occurredAt"])).limit(limit);
     return rows;
   }
 };
 
 // runtime/base-classes/metadata-entity-repository.ts
-import { eq as eq4, and, desc as desc2 } from "drizzle-orm";
+import { eq as eq5, and as and3, desc as desc2 } from "drizzle-orm";
 var MetadataEntityRepository = class extends BaseRepository {
   /**
    * Bulk upsert with a caller-specified conflict target.
@@ -510,9 +845,9 @@ var MetadataEntityRepository = class extends BaseRepository {
    */
   async findByEntityIdAndType(entityId, entityType) {
     const rows = await this.baseQuery().where(
-      and(
-        eq4(this.table["entityId"], entityId),
-        eq4(this.table["entityType"], entityType)
+      and3(
+        eq5(this.table["entityId"], entityId),
+        eq5(this.table["entityType"], entityType)
       )
     );
     return rows;
@@ -521,14 +856,14 @@ var MetadataEntityRepository = class extends BaseRepository {
    * List all metadata records for an entity.
    */
   async listByEntityId(entityId) {
-    const rows = await this.baseQuery().where(eq4(this.table["entityId"], entityId));
+    const rows = await this.baseQuery().where(eq5(this.table["entityId"], entityId));
     return rows;
   }
   /**
    * List metadata history for an entity, ordered by validFrom descending.
    */
   async listHistoryByEntityId(entityId) {
-    const rows = await this.baseQuery().where(eq4(this.table["entityId"], entityId)).orderBy(desc2(this.table["validFrom"]));
+    const rows = await this.baseQuery().where(eq5(this.table["entityId"], entityId)).orderBy(desc2(this.table["validFrom"]));
     return rows;
   }
 };
@@ -644,6 +979,7 @@ export {
   BaseListUseCase,
   BaseRepository,
   BaseService,
+  JunctionSyncRepository,
   KnowledgeEntityRepository,
   KnowledgeEntityService,
   MetadataEntityRepository,
@@ -652,9 +988,11 @@ export {
   SyncedEntityService,
   WithAnalytics,
   buildChangeEvents,
+  buildCompositeExternalId,
   buildLifecycleEvent,
   diffSnapshots,
   emitSafely,
-  entitySnapshot
+  entitySnapshot,
+  parseCompositeExternalId
 };
 //# sourceMappingURL=index.js.map