@pattern-stack/codegen 0.15.1 → 0.15.3

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

@@ -1,1079 +1,62 @@
-// runtime/base-classes/base-repository.ts
-import { and, eq, inArray, isNull, sql } from "drizzle-orm";
-
-// runtime/base-classes/tenant-context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var als = new AsyncLocalStorage();
-function withRequester(ctx, fn) {
-  return als.run(ctx, fn);
-}
-function requireRequester() {
-  const ctx = als.getStore();
-  if (!ctx) {
-    throw new Error(
-      "No requester context active. Wrap the entry point in withRequester({ userId, organizationId }, fn). See tenant-context.ts."
-    );
-  }
-  return ctx;
-}
-function tryGetRequester() {
-  return als.getStore();
-}
-function requireRequesterScope() {
-  return requireRequester().scope ?? "user";
-}
-function withUserScope(userId, organizationId, fn) {
-  return withRequester({ userId, organizationId, scope: "user" }, fn);
-}
-function withOrgScope(userId, organizationId, orgUserIds, fn) {
-  return withRequester(
-    { userId, organizationId, scope: "org", orgUserIds },
-    fn
-  );
-}
-function withSuperuserScope(userId, fn) {
-  return withRequester(
-    { userId, organizationId: null, scope: "superuser" },
-    fn
-  );
-}
-
-// runtime/base-classes/base-repository.ts
-var BaseRepository = class {
-  // eslint-disable-line @typescript-eslint/no-explicit-any
-  /**
-   * Behavior flags controlling automatic behavior injection.
-   * Override in concrete repositories to enable behaviors.
-   */
-  behaviors = {
-    timestamps: false,
-    softDelete: false,
-    userTracking: false
-  };
-  /**
-   * Ambient tenant-scope enforcement for `userTracking` repos (see
-   * `scopePredicate`). Only has effect when `behaviors.userTracking === true`.
-   *
-   * - `'lenient'` (default): when no ambient requester context is active,
-   *   reads/writes are NOT scoped — preserves pre-scoping behavior, so adopting
-   *   ambient scoping is additive. Scoping kicks in automatically once a
-   *   boundary installs `withRequester(...)`.
-   * - `'strict'`: a missing ambient context throws (`requireRequester`),
-   *   making a forgotten boundary fail loud instead of silently returning
-   *   cross-tenant rows. Recommended for new multi-tenant consumers — override
-   *   in a concrete repo or a family base class.
-   */
-  scopeEnforcement = "lenient";
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  /**
-   * Pick the runner for a write: the caller-supplied transaction handle
-   * if present, otherwise the repository's own client. Keeps the `tx`
-   * parameter purely additive — callers without a transaction call as
-   * before. Used by the write methods below + consumer overrides (e.g.
-   * the generated `upsertCurrentValues` on EAV value tables).
-   */
-  runner(tx) {
-    return tx ?? this.db;
-  }
-  // ============================================================================
-  // Read Operations
-  // ============================================================================
-  /**
-   * Find a single entity by its primary key.
-   * Returns null if not found (or soft-deleted when softDelete=true).
-   */
-  async findById(id) {
-    const rows = await this.baseQuery(eq(this.table["id"], id)).limit(1);
-    return rows[0] ?? null;
-  }
-  /**
-   * Find multiple entities by their primary keys.
-   * Returns empty array immediately for empty input (avoids DB errors).
-   */
-  async findByIds(ids) {
-    if (ids.length === 0) return [];
-    const rows = await this.baseQuery(inArray(this.table["id"], ids));
-    return rows;
-  }
-  /**
-   * List entities with optional filtering, pagination, and ordering.
-   */
-  async list(options) {
-    let query = this.baseQuery(options?.where);
-    if (options?.orderBy) {
-      query = query.orderBy(options.orderBy);
-    }
-    if (options?.limit !== void 0) {
-      query = query.limit(options.limit);
-    }
-    if (options?.offset !== void 0) {
-      query = query.offset(options.offset);
-    }
-    const rows = await query;
-    return rows;
-  }
-  /**
-   * Count entities matching an optional WHERE clause.
-   * Soft-deleted rows are always excluded when softDelete=true.
-   */
-  async count(where) {
-    let query = this.db.select({ count: sql`cast(count(*) as integer)` }).from(this.table);
-    const conditions = [];
-    if (this.behaviors.softDelete) {
-      conditions.push(isNull(this.table["deletedAt"]));
-    }
-    const scope = this.scopePredicate();
-    if (scope) {
-      conditions.push(scope);
-    }
-    if (where) {
-      conditions.push(where);
-    }
-    if (conditions.length === 1) {
-      query = query.where(conditions[0]);
-    } else if (conditions.length > 1) {
-      query = query.where(and(...conditions));
-    }
-    const rows = await query;
-    return rows[0]?.count ?? 0;
-  }
-  /**
-   * Check whether an entity with the given id exists.
-   */
-  async exists(id) {
-    const result = await this.findById(id);
-    return result !== null;
-  }
-  // ============================================================================
-  // Write Operations
-  // ============================================================================
-  /**
-   * Insert a new entity. Timestamps are auto-injected when timestamps=true.
-   */
-  async create(input, tx) {
-    const data = this.withTimestamps(input, "create");
-    const rows = await this.runner(tx).insert(this.table).values(data).returning();
-    return rows[0];
-  }
-  /**
-   * Update an existing entity by id. updatedAt is auto-injected when timestamps=true.
-   * Returns the updated entity.
-   */
-  async update(id, input, tx) {
-    const data = this.withTimestamps(input, "update");
-    const rows = await this.runner(tx).update(this.table).set(data).where(this.scopeAnd(eq(this.table["id"], id))).returning();
-    return rows[0];
-  }
-  /**
-   * Delete an entity by id.
-   * - softDelete=true: sets deletedAt to current timestamp
-   * - softDelete=false: hard-deletes the row
-   */
-  async delete(id, tx) {
-    const runner = this.runner(tx);
-    if (this.behaviors.softDelete) {
-      await runner.update(this.table).set({ deletedAt: /* @__PURE__ */ new Date() }).where(this.scopeAnd(eq(this.table["id"], id)));
-    } else {
-      await runner.delete(this.table).where(this.scopeAnd(eq(this.table["id"], id)));
-    }
-  }
-  /**
-   * Insert or update multiple entities.
-   * Default naive implementation — family repositories override with
-   * proper conflict-target upsert (e.g., CrmEntityRepository).
-   */
-  async upsertMany(inputs, tx) {
-    return Promise.all(inputs.map((input) => this.create(input, tx)));
-  }
-  // ============================================================================
-  // Protected Helpers
-  // ============================================================================
-  /**
-   * Base SELECT query that automatically applies the ambient guards —
-   * soft-delete exclusion (when `softDelete`) and tenant scope (when
-   * `userTracking` + an active requester context) — combined with an optional
-   * caller `extra` predicate into a SINGLE `WHERE`.
-   *
-   * Pass the leaf predicate as `extra` rather than chaining a second
-   * `.where(...)`: Drizzle's `.where()` OVERRIDES (does not AND) a prior
-   * `.where()` on a `$dynamic()` query, so a chained call would silently drop
-   * the soft-delete and scope guards. `baseQuery(extra)` is the safe form.
-   */
-  baseQuery(extra) {
-    const query = this.db.select().from(this.table).$dynamic();
-    const where = this.scopeAnd(extra, { softDelete: this.behaviors.softDelete });
-    return where ? query.where(where) : query;
-  }
-  /**
-   * Build the ambient tenant-scope predicate for this repo's table.
-   *
-   * Returns `undefined` (no scoping) when:
-   *   - `behaviors.userTracking` is false (repo is not user-owned), or
-   *   - no ambient requester context is active AND `scopeEnforcement` is
-   *     `'lenient'` (the default — preserves pre-scoping behavior).
-   *
-   * When a requester context is active, scopes by `user_id` per the ambient
-   * scope: `'user'` → `user_id = ctx.userId`; `'org'` → `user_id IN
-   * ctx.orgUserIds` (empty list matches nothing — fail-closed); `'superuser'`
-   * → no filter. See `tenant-context.ts` for the boundary-install contract.
-   */
-  scopePredicate() {
-    if (!this.behaviors.userTracking) return void 0;
-    const ctx = this.scopeEnforcement === "strict" ? requireRequester() : tryGetRequester();
-    if (!ctx) return void 0;
-    const scope = ctx.scope ?? "user";
-    switch (scope) {
-      case "superuser":
-        return void 0;
-      case "org":
-        return ctx.orgUserIds && ctx.orgUserIds.length > 0 ? inArray(this.table["userId"], ctx.orgUserIds) : sql`false`;
-      case "user":
-      default:
-        return eq(this.table["userId"], ctx.userId);
-    }
-  }
-  /**
-   * Combine the ambient scope predicate (and, optionally, the soft-delete
-   * guard) with a caller `extra` predicate into one `SQL`. Returns `undefined`
-   * when nothing applies. Used by read + by-id write paths so a single
-   * `.where(...)` carries every guard.
-   */
-  scopeAnd(extra, opts) {
-    const conditions = [];
-    if (opts?.softDelete) conditions.push(isNull(this.table["deletedAt"]));
-    const scope = this.scopePredicate();
-    if (scope) conditions.push(scope);
-    if (extra) conditions.push(extra);
-    if (conditions.length === 0) return void 0;
-    if (conditions.length === 1) return conditions[0];
-    return and(...conditions);
-  }
-  /**
-   * Merge timestamp fields into an input object.
-   * - mode='create': adds createdAt and updatedAt
-   * - mode='update': adds updatedAt only
-   *
-   * No-op when timestamps behavior is disabled.
-   */
-  withTimestamps(input, mode) {
-    if (!this.behaviors.timestamps) return input;
-    const now = /* @__PURE__ */ new Date();
-    if (mode === "create") {
-      return { ...input, createdAt: now, updatedAt: now };
-    }
-    return { ...input, updatedAt: now };
-  }
-  /**
-   * Build a WHERE clause fragment that restricts results to rows whose
-   * parent (identified by a belongs_to FK) is not soft-deleted.
-   *
-   * Use this in custom repository methods when you need "rows reachable
-   * from an active parent". The default findAll / findById behavior is
-   * NOT changed by this helper — opt in explicitly where needed.
-   *
-   * ADR-021 — Soft-delete cascade: Option A (filter at query time).
-   * `on_delete` FK rules do not fire for soft-deletes; use this helper
-   * instead of expecting cascade semantics on the DB level.
-   *
-   * Example:
-   *   async listActiveMessages(): Promise<Message[]> {
-   *     return this.list({
-   *       where: this.activeParentFilter(conversations, this.table['conversationId']),
-   *     });
-   *   }
-   *
-   * @param parentTable  The Drizzle table object for the parent entity.
-   * @param parentFkColumn  The FK column on this (child) table that references parent.id.
-   */
-  activeParentFilter(parentTable, parentFkColumn) {
-    return sql`EXISTS (
-      SELECT 1 FROM ${parentTable} p
-      WHERE p.id = ${parentFkColumn}
-        AND p.deleted_at IS NULL
-    )`;
-  }
-};
-
-// runtime/base-classes/lifecycle-events.ts
-import { randomUUID } from "crypto";
-var SYSTEM_FIELDS = /* @__PURE__ */ new Set([
-  "id",
-  "createdAt",
-  "updatedAt",
-  "deletedAt"
-]);
-function entitySnapshot(entity) {
-  const snap = {};
-  for (const [key, value] of Object.entries(entity)) {
-    if (!SYSTEM_FIELDS.has(key)) {
-      snap[key] = value;
-    }
-  }
-  return snap;
-}
-function diffSnapshots(before, after) {
-  const changes = [];
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
-  for (const key of allKeys) {
-    if (SYSTEM_FIELDS.has(key)) continue;
-    const oldVal = before[key];
-    const newVal = after[key];
-    if (oldVal !== newVal && JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
-      changes.push({ field: key, oldValue: oldVal, newValue: newVal });
-    }
-  }
-  return changes;
-}
-function buildLifecycleEvent(entityName, action, entityId, snapshot) {
-  return {
-    id: randomUUID(),
-    type: `${entityName}.${action}`,
-    aggregateId: entityId,
-    aggregateType: entityName,
-    payload: snapshot ? { snapshot } : {},
-    occurredAt: /* @__PURE__ */ new Date(),
-    metadata: { category: "lifecycle" }
-  };
-}
-function buildChangeEvents(entityName, entityId, changes) {
-  return changes.map((c) => ({
-    id: randomUUID(),
-    type: `${entityName}.field_changed`,
-    aggregateId: entityId,
-    aggregateType: entityName,
-    payload: {
-      fieldName: c.field,
-      oldValue: c.oldValue,
-      newValue: c.newValue
-    },
-    occurredAt: /* @__PURE__ */ new Date(),
-    metadata: { category: "change" }
-  }));
-}
-async function emitSafely(eventBus, events) {
-  if (!eventBus || events.length === 0) return;
-  try {
-    if (events.length === 1) {
-      const only = events[0];
-      if (!only) return;
-      await eventBus.publish(only);
-    } else {
-      await eventBus.publishMany(events);
-    }
-  } catch {
-    console.warn(`[lifecycle-events] failed to emit ${events.length} event(s)`);
-  }
-}
-
-// runtime/base-classes/base-service.ts
-var BaseService = class {
-  constructor(repository) {
-    this.repository = repository;
-  }
-  repository;
-  /**
-   * Entity name for event types (e.g., 'account' → 'account.created').
-   * Set by generated services. If empty, lifecycle events are skipped.
-   */
-  entityName;
-  /**
-   * Event bus for lifecycle/change event emission.
-   * Injected via @Inject(EVENT_BUS) @Optional() on generated services.
-   * If undefined (no events subsystem installed), emission is silently skipped.
-   */
-  eventBus;
-  /**
-   * Whether to emit lifecycle events. Default: true.
-   * Override to false in entity YAML via behaviors or in the service class.
-   */
-  emitLifecycleEvents = true;
-  /**
-   * Find a single entity by its primary key.
-   * Returns null if not found.
-   */
-  findById(id) {
-    return this.repository.findById(id);
-  }
-  /**
-   * Find multiple entities by their primary keys.
-   */
-  findByIds(ids) {
-    return this.repository.findByIds(ids);
-  }
-  /**
-   * List entities with optional filtering/pagination options.
-   */
-  list(options) {
-    return this.repository.list(options);
-  }
-  /**
-   * Count entities matching an optional filter.
-   */
-  count(where) {
-    return this.repository.count(where);
-  }
-  /**
-   * Check whether an entity with the given id exists.
-   */
-  exists(id) {
-    return this.repository.exists(id);
-  }
-  /**
-   * Insert a new entity.
-   * Emits a LIFECYCLE 'created' event with entity snapshot.
-   */
-  async create(input, tx) {
-    const result = await this.repository.create(input, tx);
-    if (this._shouldEmit()) {
-      const snap = entitySnapshot(result);
-      const id = result.id;
-      const event = buildLifecycleEvent(this.entityName, "created", id, snap);
-      void emitSafely(this.eventBus, [event]);
-    }
-    return result;
-  }
-  /**
-   * Update an existing entity by id.
-   * Emits a LIFECYCLE 'updated' event + CHANGE events for each modified field.
-   */
-  async update(id, input, tx) {
-    let before;
-    if (this._shouldEmit()) {
-      const existing = await this.repository.findById(id);
-      if (existing) {
-        before = entitySnapshot(existing);
-      }
-    }
-    const result = await this.repository.update(id, input, tx);
-    if (this._shouldEmit()) {
-      const after = entitySnapshot(result);
-      const events = [
-        buildLifecycleEvent(this.entityName, "updated", id, after)
-      ];
-      if (before) {
-        const changes = diffSnapshots(before, after);
-        if (changes.length > 0) {
-          events.push(...buildChangeEvents(this.entityName, id, changes));
-        }
-      }
-      void emitSafely(this.eventBus, events);
-    }
-    return result;
-  }
-  /**
-   * Delete an entity by id.
-   * Emits a LIFECYCLE 'deleted' event.
-   */
-  async delete(id, tx) {
-    await this.repository.delete(id, tx);
-    if (this._shouldEmit()) {
-      const event = buildLifecycleEvent(this.entityName, "deleted", id);
-      void emitSafely(this.eventBus, [event]);
-    }
-  }
-  /** Check whether lifecycle event emission is active. */
-  _shouldEmit() {
-    return Boolean(
-      this.emitLifecycleEvents && this.entityName && this.eventBus
-    );
-  }
-};
-
-// runtime/base-classes/base-read-use-cases.ts
-var BaseFindByIdUseCase = class {
-  constructor(service) {
-    this.service = service;
-  }
-  service;
-  /**
-   * Find a single entity by its primary key.
-   * Returns null if not found.
-   */
-  execute(id) {
-    return this.service.findById(id);
-  }
-};
-var BaseListUseCase = class {
-  constructor(service) {
-    this.service = service;
-  }
-  service;
-  /**
-   * List all entities (no filters).
-   * Controllers that need filtered lists should use a dedicated use case.
-   */
-  execute() {
-    return this.service.list();
-  }
-};
-
-// runtime/base-classes/integrated-entity-repository.ts
-import { and as and2, eq as eq2, inArray as inArray2 } from "drizzle-orm";
-var IntegratedEntityRepository = class extends BaseRepository {
-  /**
-   * Find a single entity by its external CRM identifier.
-   */
-  async findByExternalId(externalId) {
-    const rows = await this.baseQuery().where(eq2(this.table["externalId"], externalId)).limit(1);
-    return rows[0] ?? null;
-  }
-  /**
-   * Find multiple entities by external CRM identifiers.
-   */
-  async findManyByExternalIds(externalIds) {
-    if (externalIds.length === 0) return [];
-    const rows = await this.baseQuery().where(inArray2(this.table["externalId"], externalIds));
-    return rows;
-  }
-  /**
-   * Find all entities owned by a specific user.
-   */
-  async findAllByUserId(userId) {
-    const rows = await this.baseQuery().where(eq2(this.table["userId"], userId));
-    return rows;
-  }
-  // ==========================================================================
-  // Inbound integration (#374) — canonical→Drizzle write + provider-scoped FK
-  // resolution + EAV dual-write seam, all inside a SINGLE transaction.
-  // Driven entirely by `this.integrationConfig`; the per-entity shape lives there.
-  // ==========================================================================
-  /**
-   * Upsert ONE entity by its `(provider, externalId)` identity, in a single
-   * transaction:
-   *   1. resolve each `integrationConfig.fkResolvers` FK (provider-scoped). Strict
-   *      resolvers throw on unresolved; non-strict leave the column null.
-   *   2. insert-or-update the canonical columns via `onConflictDoUpdate` on the
-   *      `conflictTarget`. Resolved FKs are only written into `set` when
-   *      non-null this run (no-clobber).
-   *   3. EAV dual-write of `write.fields` via `writeCustomFields` when
-   *      `integrationConfig.eav` and the bag is non-empty (same tx).
-   *
-   * Idempotent: a second call with the same identity updates in place. Returns
-   * the canonical projection (so the orchestrator records `local_id`).
-   *
-   * @param write     canonical fields + parent external ids + custom-field bag
-   * @param provider  adapter/provider label persisted + used to scope lookups
-   * @param tx        optional outer transaction; when omitted we open our own
-   */
-  async integrationUpsertOne(write, provider, tx) {
-    const cfg = this.integrationConfig;
-    const w = write;
-    const run = async (db) => {
-      const resolvedFks = {};
-      for (const fk of cfg.fkResolvers) {
-        resolvedFks[fk.column] = await this.resolveFk(db, fk, w[fk.writeKey], provider);
-      }
-      const now = /* @__PURE__ */ new Date();
-      const copyThrough = {};
-      for (const col of cfg.writeColumns) copyThrough[col] = w[col];
-      const values = {
-        externalId: w["externalId"],
-        provider,
-        ...copyThrough,
-        ...resolvedFks,
-        ...this.behaviors.timestamps ? { updatedAt: now } : {}
-      };
-      const set = {
-        ...copyThrough,
-        ...this.behaviors.timestamps ? { updatedAt: now } : {}
-      };
-      for (const fk of cfg.fkResolvers) {
-        if (resolvedFks[fk.column] !== null) set[fk.column] = resolvedFks[fk.column];
-      }
-      const rows = await db.insert(this.table).values(values).onConflictDoUpdate({
-        target: cfg.conflictTarget.map((c) => this.table[c]),
-        set
-      }).returning();
-      const saved = rows[0];
-      const fields = w["fields"];
-      if (cfg.eav && fields && Object.keys(fields).length > 0) {
-        await this.writeCustomFields(
-          db,
-          saved["id"],
-          w["userId"],
-          fields
-        );
-      }
-      return this.toProjection(saved);
-    };
-    return tx ? run(tx) : this.db.transaction((t) => run(t));
-  }
-  /**
-   * Canonical-projected lookup by external id (differ-ready). Returns `null`
-   * when no local row exists. Provider-scoped so a HubSpot id can't match a
-   * Salesforce row.
-   */
-  async findByExternalIdProjected(externalId, provider) {
-    const rows = await this.db.select().from(this.table).where(
-      and2(
-        eq2(this.table["provider"], provider),
-        eq2(this.table["externalId"], externalId)
-      )
-    ).limit(1);
-    const row = rows[0];
-    return row ? this.toProjection(row) : null;
-  }
-  /**
-   * Integration "delete" by external id, provider-scoped. When `softDelete: true`,
-   * sets `deletedAt`. When `softDelete: false`, tombstone-by-clearing: null out
-   * `external_id`/`provider` so the row no longer matches future inbound
-   * changes while preserving local-id references. Returns `{ id }` or `null`.
-   */
-  async softDeleteByExternalId(externalId, provider, tx) {
-    const db = this.runner(tx);
-    const set = this.integrationConfig.softDelete ? { deletedAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date() } : { externalId: null, provider: null, updatedAt: /* @__PURE__ */ new Date() };
-    const rows = await db.update(this.table).set(set).where(
-      and2(
-        eq2(this.table["provider"], provider),
-        eq2(this.table["externalId"], externalId)
-      )
-    ).returning({ id: this.table["id"] });
-    return rows[0] ? { id: rows[0].id } : null;
-  }
-  /**
-   * Batch integration upsert — concretizes the former abstract stub. Delegates to
-   * `integrationUpsertOne` per input inside one transaction. Inputs are raw partial
-   * rows: provider is read from each input's own `provider` column; rows
-   * missing `externalId`/`provider` are skipped.
-   */
-  async integrationUpsert(inputs) {
-    if (inputs.length === 0) return [];
-    return this.db.transaction(async (tx) => {
-      const out = [];
-      for (const input of inputs) {
-        const rec = input;
-        if (!rec["externalId"] || !rec["provider"]) continue;
-        const proj = await this.integrationUpsertOne(
-          input,
-          rec["provider"],
-          tx
-        );
-        const id = proj["id"];
-        const row = await tx.select().from(this.table).where(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
-   * `integrationConfig.projectionColumns`. Override only for synthesized projections
-   * (e.g. junctions); entities use this verbatim.
-   */
-  toProjection(row) {
-    const r = row;
-    const out = {};
-    for (const col of this.integrationConfig.projectionColumns) out[col] = r[col];
-    return out;
-  }
-  /**
-   * EAV dual-write seam (#374, live path lands in #124). No-op by default;
-   * `eav: true` entities emit a concrete override that injects
-   * `FieldValueService` and delegates to `upsertFieldsTransactional` so the
-   * dual-write joins the same tx (`db`). Kept as an explicit hook so the base
-   * stays portable (the FieldValueService dependency is eav-only).
-   */
-  async writeCustomFields(_db, _entityId, _userId, _fields) {
-  }
-  /**
-   * Resolve one FK from a parent external id (provider-scoped). `self` resolves
-   * against `this.table`. Strict resolvers throw when unresolved; non-strict
-   * return null. A null/absent write value short-circuits to null.
-   */
-  async resolveFk(db, fk, rawExternalId, provider) {
-    const parentExternalId = rawExternalId;
-    if (!parentExternalId) {
-      if (fk.strict) {
-        throw new Error(
-          `${this.constructor.name}.integrationUpsertOne: missing required parent external id for '${fk.column}' (writeKey '${fk.writeKey}')`
-        );
-      }
-      return null;
-    }
-    const refTable = fk.refTable === "self" ? this.table : fk.refTable;
-    const rows = await db.select({ id: refTable["id"] }).from(refTable).where(
-      and2(
-        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}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${fk.column}' \u2014 parent not integrated yet`
-      );
-    }
-    return id;
-  }
-  /**
-   * Find entities visible to a user (ownership + sharing rules).
-   * Concrete repositories must implement with visibility logic.
-   */
-  async findVisibleByUserId(_userId) {
-    throw new Error("findVisibleByUserId not implemented \u2014 override in concrete repository");
-  }
-};
-
-// runtime/base-classes/junction-integration-repository.ts
-import { and as and3, eq as eq3 } from "drizzle-orm";
-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;
-   *   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 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`;
-    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.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);
-    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 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.integrationConfig;
-    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>IntegrationProjection` interface (id + leftId + rightId + role? +
-   * createdAt + updatedAt). Junction projections are purely structural, so this
-   * is fully generic over `integrationConfig` — no per-junction override is emitted.
-   */
-  toProjection(row, write, _provider) {
-    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`];
-    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.integrationConfig;
-    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 and3(...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}.integrationUpsertOne: unresolved parent '${parentExternalId}' (provider '${provider}') for '${column}' \u2014 parent not integrated 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(
-      and3(
-        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 eq4, between, desc } from "drizzle-orm";
-var ActivityEntityRepository = class extends BaseRepository {
-  /**
-   * Find activities within a date range (inclusive).
-   */
-  async findByDateRange(start, end) {
-    const rows = await this.baseQuery().where(between(this.table["occurredAt"], start, end));
-    return rows;
-  }
-  /**
-   * Find all activities for a specific user.
-   */
-  async findByUserId(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(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(eq4(this.table["opportunityId"], opportunityId)).orderBy(desc(this.table["occurredAt"])).limit(limit);
-    return rows;
-  }
-};
-
-// runtime/base-classes/metadata-entity-repository.ts
-import { eq as eq5, and as and4, desc as desc2 } from "drizzle-orm";
-var MetadataEntityRepository = class extends BaseRepository {
-  /**
-   * Bulk upsert with a caller-specified conflict target.
-   * Uses Drizzle's onConflictDoUpdate to merge records.
-   */
-  async upsertMany(inputs, tx, options) {
-    if (inputs.length === 0) return [];
-    const conflictTarget = options?.conflictTarget;
-    if (!conflictTarget) {
-      return super.upsertMany(inputs, tx);
-    }
-    const data = inputs.map(
-      (input) => this.withTimestamps(input, "create")
-    );
-    const rows = await this.runner(tx).insert(this.table).values(data).onConflictDoUpdate({
-      target: this.table[conflictTarget],
-      set: data[0]
-      // eslint-disable-line @typescript-eslint/no-explicit-any
-    }).returning();
-    return rows;
-  }
-  /**
-   * Find metadata by entity ID and entity type (compound lookup).
-   */
-  async findByEntityIdAndType(entityId, entityType) {
-    const rows = await this.baseQuery().where(
-      and4(
-        eq5(this.table["entityId"], entityId),
-        eq5(this.table["entityType"], entityType)
-      )
-    );
-    return rows;
-  }
-  /**
-   * List all metadata records for an entity.
-   */
-  async listByEntityId(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(eq5(this.table["entityId"], entityId)).orderBy(desc2(this.table["validFrom"]));
-    return rows;
-  }
-};
-
-// runtime/base-classes/knowledge-entity-repository.ts
-var KnowledgeEntityRepository = class extends BaseRepository {
-  // pgvector-dependent methods will be added when the extension is available:
-  //   semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch
-};
-
-// runtime/base-classes/integrated-entity-service.ts
-var IntegratedEntityService = class extends BaseService {
-  /**
-   * Find a single entity by its external CRM identifier.
-   */
-  findByExternalId(externalId) {
-    return this.repository.findByExternalId(externalId);
-  }
-  /**
-   * Find multiple entities by external CRM identifiers.
-   */
-  findManyByExternalIds(externalIds) {
-    return this.repository.findManyByExternalIds(externalIds);
-  }
-  /**
-   * Find all entities owned by a specific user.
-   */
-  findAllByUser(userId) {
-    return this.repository.findAllByUserId(userId);
-  }
-  /**
-   * Find entities visible to a user (ownership + sharing rules).
-   * Concrete services may override with domain-specific visibility logic.
-   */
-  findVisibleByUser(userId) {
-    return this.repository.findVisibleByUserId(userId);
-  }
-};
-
-// runtime/base-classes/activity-entity-service.ts
-var ActivityEntityService = class extends BaseService {
-  /**
-   * Find activities within a date range (inclusive).
-   */
-  findByDateRange(start, end) {
-    return this.repository.findByDateRange(start, end);
-  }
-  /**
-   * Find all activities for a specific user.
-   */
-  findByUser(userId) {
-    return this.repository.findByUserId(userId);
-  }
-  /**
-   * Find all activities for a specific opportunity.
-   */
-  findByOpportunity(opportunityId) {
-    return this.repository.findByOpportunityId(opportunityId);
-  }
-  /**
-   * Find the most recent activities for an opportunity.
-   */
-  findRecent(opportunityId, limit) {
-    return this.repository.findRecentByOpportunityId(opportunityId, limit);
-  }
-};
-
-// runtime/base-classes/metadata-entity-service.ts
-var MetadataEntityService = class extends BaseService {
-  /**
-   * Find metadata records by entity ID and entity type (EAV polymorphic lookup).
-   */
-  findByEntityIdAndType(entityId, entityType) {
-    return this.repository.findByEntityIdAndType(entityId, entityType);
-  }
-  /**
-   * List all metadata records for an entity.
-   */
-  listByEntity(entityId) {
-    return this.repository.listByEntityId(entityId);
-  }
-  /**
-   * List metadata history for an entity, ordered by validFrom desc.
-   */
-  listHistory(entityId) {
-    return this.repository.listHistoryByEntityId(entityId);
-  }
-  /**
-   * Bulk upsert metadata values.
-   */
-  upsertValues(inputs, conflictTarget, tx) {
-    return this.repository.upsertMany(inputs, tx, { conflictTarget });
-  }
-};
-
-// runtime/base-classes/knowledge-entity-service.ts
-var KnowledgeEntityService = class extends BaseService {
-  // pgvector-dependent methods will be added when the extension is available:
-  //   semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch
-};
-
-// runtime/base-classes/with-analytics.ts
-function WithAnalytics(Base) {
-  class WithAnalyticsMixin extends Base {
-    analytics;
-  }
-  return WithAnalyticsMixin;
-}
+import {
+  MetadataEntityRepository
+} from "../../chunk-7KOW6PU6.js";
+import {
+  MetadataEntityService
+} from "../../chunk-RFH7N6EP.js";
+import {
+  WithAnalytics
+} from "../../chunk-IBGER4YK.js";
+import {
+  IntegratedEntityRepository
+} from "../../chunk-OTDN3OUQ.js";
+import {
+  IntegratedEntityService
+} from "../../chunk-2VHZ7EKC.js";
+import {
+  JunctionIntegrationRepository,
+  buildCompositeExternalId,
+  parseCompositeExternalId
+} from "../../chunk-2FTZLDBP.js";
+import {
+  KnowledgeEntityRepository
+} from "../../chunk-NN7XZEGF.js";
+import {
+  KnowledgeEntityService
+} from "../../chunk-AS3NAZB6.js";
+import {
+  ActivityEntityRepository
+} from "../../chunk-XCEI7NUH.js";
+import {
+  ActivityEntityService
+} from "../../chunk-BOPZWRJK.js";
+import {
+  BaseFindByIdUseCase,
+  BaseListUseCase
+} from "../../chunk-EXVDJMIY.js";
+import {
+  BaseRepository
+} from "../../chunk-J6KZS54B.js";
+import {
+  BaseService
+} from "../../chunk-W72PRNJY.js";
+import {
+  buildChangeEvents,
+  buildLifecycleEvent,
+  diffSnapshots,
+  emitSafely,
+  entitySnapshot
+} from "../../chunk-KYR3B3OW.js";
+import {
+  requireRequester,
+  requireRequesterScope,
+  tryGetRequester,
+  withOrgScope,
+  withRequester,
+  withSuperuserScope,
+  withUserScope
+} from "../../chunk-ZUKFQL6E.js";
+import "../../chunk-2E224ZSN.js";
 export {
   ActivityEntityRepository,
   ActivityEntityService,