@pattern-stack/codegen 0.2.0

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

@@ -0,0 +1,617 @@
+// runtime/base-classes/base-repository.ts
+import { eq, inArray, isNull, sql } from "drizzle-orm";
+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
+  };
+  db;
+  constructor(db) {
+    this.db = 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().where(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().where(inArray(this.table["id"], ids));
+    return rows;
+  }
+  /**
+   * List entities with optional filtering, pagination, and ordering.
+   */
+  async list(options) {
+    let query = this.baseQuery();
+    if (options?.where) {
+      query = query.where(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"]));
+    }
+    if (where) {
+      conditions.push(where);
+    }
+    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 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) {
+    const data = this.withTimestamps(input, "create");
+    const rows = await this.db.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) {
+    const data = this.withTimestamps(input, "update");
+    const rows = await this.db.update(this.table).set(data).where(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) {
+    if (this.behaviors.softDelete) {
+      await this.db.update(this.table).set({ deletedAt: /* @__PURE__ */ new Date() }).where(eq(this.table["id"], id));
+    } else {
+      await this.db.delete(this.table).where(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) {
+    return Promise.all(inputs.map((input) => this.create(input)));
+  }
+  // ============================================================================
+  // Protected Helpers
+  // ============================================================================
+  /**
+   * Base SELECT query that automatically excludes soft-deleted rows
+   * when softDelete behavior is enabled.
+   */
+  baseQuery() {
+    const query = this.db.select().from(this.table).$dynamic();
+    if (this.behaviors.softDelete) {
+      return query.where(isNull(this.table["deletedAt"]));
+    }
+    return query;
+  }
+  /**
+   * 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 };
+  }
+};
+
+// 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) {
+      await eventBus.publish(events[0]);
+    } 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) {
+    const result = await this.repository.create(input);
+    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) {
+    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);
+    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) {
+    await this.repository.delete(id);
+    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/synced-entity-repository.ts
+import { eq as eq2, inArray as inArray2 } from "drizzle-orm";
+var SyncedEntityRepository = 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;
+  }
+  /**
+   * Sync upsert — bulk insert-or-update from external CRM data.
+   * Concrete repositories must implement with the appropriate conflict target.
+   */
+  async syncUpsert(_inputs) {
+    throw new Error("syncUpsert not implemented \u2014 override in concrete repository");
+  }
+  /**
+   * 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/activity-entity-repository.ts
+import { eq as eq3, 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(eq3(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));
+    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);
+    return rows;
+  }
+};
+
+// runtime/base-classes/metadata-entity-repository.ts
+import { eq as eq4, and, 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, conflictTarget) {
+    if (inputs.length === 0) return [];
+    if (!conflictTarget) {
+      return super.upsertMany(inputs);
+    }
+    const data = inputs.map(
+      (input) => this.withTimestamps(input, "create")
+    );
+    const rows = await this.db.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(
+      and(
+        eq4(this.table["entityId"], entityId),
+        eq4(this.table["entityType"], entityType)
+      )
+    );
+    return rows;
+  }
+  /**
+   * List all metadata records for an entity.
+   */
+  async listByEntityId(entityId) {
+    const rows = await this.baseQuery().where(eq4(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"]));
+    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/synced-entity-service.ts
+var SyncedEntityService = 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) {
+    return this.repository.upsertMany(inputs, 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;
+}
+export {
+  ActivityEntityRepository,
+  ActivityEntityService,
+  BaseFindByIdUseCase,
+  BaseListUseCase,
+  BaseRepository,
+  BaseService,
+  KnowledgeEntityRepository,
+  KnowledgeEntityService,
+  MetadataEntityRepository,
+  MetadataEntityService,
+  SyncedEntityRepository,
+  SyncedEntityService,
+  WithAnalytics,
+  buildChangeEvents,
+  buildLifecycleEvent,
+  diffSnapshots,
+  emitSafely,
+  entitySnapshot
+};
+//# sourceMappingURL=index.js.map