@fonderie/customers 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2220 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CustomerAddressModel: () => CustomerAddressModel,
+  CustomerEmailModel: () => CustomerEmailModel,
+  CustomerModel: () => CustomerModel,
+  CustomerNoteModel: () => CustomerNoteModel,
+  CustomerPhoneModel: () => CustomerPhoneModel,
+  CustomerTagModel: () => CustomerTagModel,
+  CustomersModule: () => CustomersModule,
+  EVENT_KEYS: () => EVENT_KEYS,
+  toAddressDTO: () => toAddressDTO,
+  toCustomerAddressDTO: () => toCustomerAddressDTO,
+  toCustomerDTO: () => toCustomerDTO,
+  toCustomerDetailDTO: () => toCustomerDetailDTO,
+  toCustomerEmailDTO: () => toCustomerEmailDTO,
+  toCustomerNoteDTO: () => toCustomerNoteDTO,
+  toCustomerPhoneDTO: () => toCustomerPhoneDTO,
+  toCustomerTagDTO: () => toCustomerTagDTO
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var EVENT_KEYS = {
+  customerCreated: "fonderie.customer.created",
+  customerUpdated: "fonderie.customer.updated",
+  customerDeleted: "fonderie.customer.deleted",
+  customerBlacklisted: "fonderie.customer.blacklisted",
+  customerUnblacklisted: "fonderie.customer.unblacklisted"
+};
+var DEFAULT_REFERENCE_CODE_PREFIX = "CLT";
+
+// src/dtos/customer.ts
+var import_core = require("@fonderie/core");
+var VALID_SEX = ["UNKNOWN", "MALE", "FEMALE"];
+function toCustomerDTO(c) {
+  return {
+    id: (0, import_core.stringOrEmpty)(c.id),
+    type: (0, import_core.stringOrEmpty)(c.type),
+    sex: VALID_SEX.includes(c.sex) ? c.sex : "UNKNOWN",
+    firstName: (0, import_core.stringOrEmpty)(c.firstName),
+    lastName: (0, import_core.stringOrEmpty)(c.lastName),
+    companyName: (0, import_core.stringOrEmpty)(c.companyName),
+    avatarUrl: (0, import_core.stringOrEmpty)(c.avatarUrl),
+    locale: (0, import_core.stringOrEmpty)(c.locale),
+    referenceCode: (0, import_core.stringOrEmpty)(c.referenceCode),
+    blacklisted: { status: (0, import_core.booleanOrFalse)(c.isBlacklisted), reason: c.blacklistReason ?? null },
+    createdBy: (0, import_core.stringOrEmpty)(c.createdBy),
+    createdAt: (0, import_core.dateOrEmpty)(c.createdAt),
+    updatedAt: (0, import_core.dateOrEmpty)(c.updatedAt)
+  };
+}
+function toCustomerRelationshipDTO(r) {
+  return {
+    id: (0, import_core.stringOrEmpty)(r.id),
+    relatedId: (0, import_core.stringOrEmpty)(r.relatedId),
+    relationship: (0, import_core.stringOrEmpty)(r.relationship),
+    isPrimary: (0, import_core.booleanOrFalse)(r.isPrimary),
+    createdAt: (0, import_core.dateOrEmpty)(r.createdAt)
+  };
+}
+function toCustomerShallowDTO(c) {
+  return {
+    ...toCustomerDTO(c),
+    emails: (0, import_core.arrayOrEmpty)(c.emails).map(toCustomerEmailDTO),
+    phones: (0, import_core.arrayOrEmpty)(c.phones).map(toCustomerPhoneDTO),
+    addresses: (0, import_core.arrayOrEmpty)(c.addresses).map(toCustomerAddressDTO),
+    notes: (0, import_core.arrayOrEmpty)(c.notes).map(toCustomerNoteDTO),
+    tags: (0, import_core.arrayOrEmpty)(c.tags)
+  };
+}
+function toCustomerRelationshipExpandedDTO(r) {
+  const { id: customerId, ...customerFields } = toCustomerShallowDTO(r.customer);
+  return {
+    id: (0, import_core.stringOrEmpty)(r.id),
+    customerId,
+    relationship: (0, import_core.stringOrEmpty)(r.relationship),
+    isPrimary: (0, import_core.booleanOrFalse)(r.isPrimary),
+    ...customerFields
+  };
+}
+function toCustomerDetailDTO(c) {
+  return {
+    ...toCustomerDTO(c),
+    emails: (0, import_core.arrayOrEmpty)(c.emails).map(toCustomerEmailDTO),
+    phones: (0, import_core.arrayOrEmpty)(c.phones).map(toCustomerPhoneDTO),
+    addresses: (0, import_core.arrayOrEmpty)(c.addresses).map(toCustomerAddressDTO),
+    notes: (0, import_core.arrayOrEmpty)(c.notes).map(toCustomerNoteDTO),
+    relationships: (0, import_core.arrayOrEmpty)(c.relationships).map(toCustomerRelationshipExpandedDTO),
+    tags: (0, import_core.arrayOrEmpty)(c.tags)
+  };
+}
+function toCustomerRelationshipExpandedD2DTO(r) {
+  const { id: customerId, ...customerFields } = toCustomerShallowDTO(r.customer);
+  return {
+    id: (0, import_core.stringOrEmpty)(r.id),
+    customerId,
+    relationship: (0, import_core.stringOrEmpty)(r.relationship),
+    isPrimary: (0, import_core.booleanOrFalse)(r.isPrimary),
+    ...customerFields,
+    relationships: (0, import_core.arrayOrEmpty)(r.customer.relationships).map(toCustomerRelationshipExpandedDTO)
+  };
+}
+function toCustomerDetailD2DTO(c) {
+  return {
+    ...toCustomerDTO(c),
+    emails: (0, import_core.arrayOrEmpty)(c.emails).map(toCustomerEmailDTO),
+    phones: (0, import_core.arrayOrEmpty)(c.phones).map(toCustomerPhoneDTO),
+    addresses: (0, import_core.arrayOrEmpty)(c.addresses).map(toCustomerAddressDTO),
+    notes: (0, import_core.arrayOrEmpty)(c.notes).map(toCustomerNoteDTO),
+    relationships: (0, import_core.arrayOrEmpty)(c.relationships).map(toCustomerRelationshipExpandedD2DTO),
+    tags: (0, import_core.arrayOrEmpty)(c.tags)
+  };
+}
+function toAddressDTO(a) {
+  return {
+    countryIso: (0, import_core.stringOrEmpty)(a.countryIso),
+    subdivision1Iso: (0, import_core.stringOrEmpty)(a.subdivision1Iso),
+    subdivision2Iso: (0, import_core.stringOrEmpty)(a.subdivision2Iso),
+    zipPostalCode: (0, import_core.stringOrEmpty)(a.zipPostalCode),
+    unit: (0, import_core.stringOrEmpty)(a.unit),
+    line1: (0, import_core.stringOrEmpty)(a.line1),
+    line2: (0, import_core.stringOrEmpty)(a.line2)
+  };
+}
+function toCustomerEmailDTO(e) {
+  return {
+    id: (0, import_core.stringOrEmpty)(e.id),
+    email: (0, import_core.stringOrEmpty)(e.email),
+    label: (0, import_core.stringOrEmpty)(e.label),
+    isPrimary: (0, import_core.booleanOrFalse)(e.isPrimary),
+    createdAt: (0, import_core.dateOrEmpty)(e.createdAt)
+  };
+}
+function toCustomerPhoneDTO(p) {
+  return {
+    id: (0, import_core.stringOrEmpty)(p.id),
+    phone: (0, import_core.stringOrEmpty)(p.phone),
+    label: (0, import_core.stringOrEmpty)(p.label),
+    isPrimary: (0, import_core.booleanOrFalse)(p.isPrimary),
+    createdAt: (0, import_core.dateOrEmpty)(p.createdAt)
+  };
+}
+function toCustomerAddressDTO(ca) {
+  return {
+    id: (0, import_core.stringOrEmpty)(ca.addrId),
+    label: (0, import_core.stringOrEmpty)(ca.label),
+    isPrimary: (0, import_core.booleanOrFalse)(ca.isPrimary),
+    address: toAddressDTO(ca.address)
+  };
+}
+function toCustomerNoteDTO(n) {
+  return {
+    id: (0, import_core.stringOrEmpty)(n.id),
+    authorId: (0, import_core.stringOrEmpty)(n.authorId),
+    body: (0, import_core.stringOrEmpty)(n.body),
+    createdAt: (0, import_core.dateOrEmpty)(n.createdAt),
+    updatedAt: (0, import_core.dateOrEmpty)(n.updatedAt)
+  };
+}
+function toCustomerTagDTO(t) {
+  return {
+    tag: (0, import_core.stringOrEmpty)(t.tag)
+  };
+}
+
+// src/models/customer.model.ts
+function groupByCustomer(rows) {
+  return rows.reduce((m, r) => {
+    if (!m.has(r.customerId)) m.set(r.customerId, []);
+    m.get(r.customerId).push(r);
+    return m;
+  }, /* @__PURE__ */ new Map());
+}
+var SELECT_CUSTOMER = `
+	id,
+	workspace_id   AS "workspaceId",
+	type,
+	sex,
+	first_name     AS "firstName",
+	last_name      AS "lastName",
+	company_name   AS "companyName",
+	avatar_url     AS "avatarUrl",
+	locale,
+	reference_code AS "referenceCode",
+	is_blacklisted    AS "isBlacklisted",
+	blacklist_reason  AS "blacklistReason",
+	created_by     AS "createdBy",
+	created_at     AS "createdAt",
+	updated_at     AS "updatedAt"
+`;
+var CustomerModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async allocateCode(workspaceId, prefix) {
+    const [row] = await this.store.query(
+      `INSERT INTO fonderie_customer_sequences (workspace_id, prefix, next_val)
+			 VALUES ($1, $2, 1)
+			 ON CONFLICT (workspace_id, prefix) DO UPDATE
+			   SET next_val = fonderie_customer_sequences.next_val + 1
+			 RETURNING next_val AS "nextVal"`,
+      [workspaceId, prefix]
+    );
+    return `${prefix}-${String(row.nextVal).padStart(4, "0")}`;
+  }
+  async list(opts) {
+    const conditions = ["workspace_id = $1"];
+    const params = [opts.workspaceId];
+    if (opts.blacklisted !== void 0) {
+      params.push(opts.blacklisted);
+      conditions.push(`is_blacklisted = $${params.length}`);
+    }
+    if (opts.search) {
+      params.push(`%${opts.search}%`);
+      const idx = params.length;
+      conditions.push(
+        `(first_name ILIKE $${idx} OR last_name ILIKE $${idx} OR company_name ILIKE $${idx} OR reference_code ILIKE $${idx})`
+      );
+    }
+    const limit = Math.min(opts.limit ?? 50, 200);
+    const offset = opts.offset ?? 0;
+    params.push(limit, offset);
+    const limitIdx = params.length - 1;
+    const offsetIdx = params.length;
+    return this.store.query(
+      `SELECT ${SELECT_CUSTOMER}
+			 FROM fonderie_customers
+			 WHERE ${conditions.join(" AND ")}
+			 ORDER BY created_at DESC
+			 LIMIT $${limitIdx} OFFSET $${offsetIdx}`,
+      params
+    );
+  }
+  async findById(id, workspaceId) {
+    const [row] = await this.store.query(
+      `SELECT ${SELECT_CUSTOMER}
+			 FROM fonderie_customers
+			 WHERE id = $1 AND workspace_id = $2`,
+      [id, workspaceId]
+    );
+    return row ?? null;
+  }
+  async findDetail(id, workspaceId, depth = 1) {
+    const [row] = await this.store.query(
+      `SELECT ${SELECT_CUSTOMER}
+			 FROM fonderie_customers
+			 WHERE id = $1 AND workspace_id = $2`,
+      [id, workspaceId]
+    );
+    if (!row) return null;
+    const [emailRows, phoneRows, addressRows, noteRows, relationshipRows, tagRows] = await Promise.all([
+      this.store.query(
+        `SELECT id,
+				        customer_id AS "customerId",
+				        email,
+				        label_id    AS "labelId",
+				        (SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+				        is_primary  AS "isPrimary",
+				        created_at  AS "createdAt"
+				 FROM fonderie_customer_emails
+				 WHERE customer_id = $1
+				 ORDER BY is_primary DESC, created_at ASC`,
+        [id]
+      ),
+      this.store.query(
+        `SELECT id,
+				        customer_id AS "customerId",
+				        phone,
+				        label_id    AS "labelId",
+				        (SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+				        is_primary  AS "isPrimary",
+				        created_at  AS "createdAt"
+				 FROM fonderie_customer_phones
+				 WHERE customer_id = $1
+				 ORDER BY is_primary DESC, created_at ASC`,
+        [id]
+      ),
+      this.store.query(
+        `SELECT ca.addr_id     AS "addrId",
+				        ca.customer_id AS "customerId",
+				        ca.label_id    AS "labelId",
+				        (SELECT value FROM fonderie_customer_labels WHERE id = ca.label_id) AS label,
+				        ca.is_primary  AS "isPrimary",
+				        jsonb_build_object(
+				          'id',              a.id,
+				          'countryIso',      a.country_iso,
+				          'subdivision1Iso', a.subdivision1_iso,
+				          'subdivision2Iso', a.subdivision2_iso,
+				          'zipPostalCode',   a.zip_postal_code,
+				          'unit',            a.unit,
+				          'line1',           a.line1,
+				          'line2',           a.line2
+				        ) AS address
+				 FROM fonderie_customer_addresses ca
+				 JOIN fonderie_addresses a ON a.id = ca.addr_id
+				 WHERE ca.customer_id = $1
+				 ORDER BY ca.is_primary DESC`,
+        [id]
+      ),
+      this.store.query(
+        `SELECT id,
+				        customer_id AS "customerId",
+				        author_id   AS "authorId",
+				        body,
+				        created_at  AS "createdAt",
+				        updated_at  AS "updatedAt"
+				 FROM fonderie_customer_notes
+				 WHERE customer_id = $1
+				 ORDER BY created_at DESC`,
+        [id]
+      ),
+      this.store.query(
+        `SELECT id,
+				        workspace_id AS "workspaceId",
+				        customer_id  AS "customerId",
+				        related_id   AS "relatedId",
+				        relationship,
+				        is_primary   AS "isPrimary",
+				        created_at   AS "createdAt"
+				 FROM fonderie_customer_relationships
+				 WHERE customer_id = $1
+				 ORDER BY is_primary DESC, created_at ASC`,
+        [id]
+      ),
+      this.store.query(
+        `SELECT tag FROM fonderie_customer_tags WHERE customer_id = $1 ORDER BY tag ASC`,
+        [id]
+      )
+    ]);
+    const relatedIds = relationshipRows.map((r) => r.relatedId);
+    let expandedRelationships = [];
+    if (relatedIds.length > 0) {
+      const [relCustomers, relEmails, relPhones, relAddresses, relNotes, relTags] = await Promise.all([
+        this.store.query(
+          `SELECT ${SELECT_CUSTOMER} FROM fonderie_customers WHERE id = ANY($1::uuid[]) AND workspace_id = $2`,
+          [relatedIds, workspaceId]
+        ),
+        this.store.query(
+          `SELECT id, customer_id AS "customerId", email, label_id AS "labelId",
+					        (SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+					        is_primary AS "isPrimary", created_at AS "createdAt"
+					 FROM fonderie_customer_emails WHERE customer_id = ANY($1::uuid[]) ORDER BY is_primary DESC, created_at ASC`,
+          [relatedIds]
+        ),
+        this.store.query(
+          `SELECT id, customer_id AS "customerId", phone, label_id AS "labelId",
+					        (SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+					        is_primary AS "isPrimary", created_at AS "createdAt"
+					 FROM fonderie_customer_phones WHERE customer_id = ANY($1::uuid[]) ORDER BY is_primary DESC, created_at ASC`,
+          [relatedIds]
+        ),
+        this.store.query(
+          `SELECT ca.addr_id     AS "addrId",
+					        ca.customer_id AS "customerId",
+					        ca.label_id    AS "labelId",
+					        (SELECT value FROM fonderie_customer_labels WHERE id = ca.label_id) AS label,
+					        ca.is_primary  AS "isPrimary",
+					        jsonb_build_object(
+					          'id',              a.id,
+					          'countryIso',      a.country_iso,
+					          'subdivision1Iso', a.subdivision1_iso,
+					          'subdivision2Iso', a.subdivision2_iso,
+					          'zipPostalCode',   a.zip_postal_code,
+					          'unit',            a.unit,
+					          'line1',           a.line1,
+					          'line2',           a.line2
+					        ) AS address
+					 FROM fonderie_customer_addresses ca
+					 JOIN fonderie_addresses a ON a.id = ca.addr_id
+					 WHERE ca.customer_id = ANY($1::uuid[])
+					 ORDER BY ca.is_primary DESC`,
+          [relatedIds]
+        ),
+        this.store.query(
+          `SELECT id, customer_id AS "customerId", author_id AS "authorId", body, created_at AS "createdAt", updated_at AS "updatedAt"
+					 FROM fonderie_customer_notes WHERE customer_id = ANY($1::uuid[]) ORDER BY created_at DESC`,
+          [relatedIds]
+        ),
+        this.store.query(
+          `SELECT customer_id AS "customerId", tag FROM fonderie_customer_tags WHERE customer_id = ANY($1::uuid[]) ORDER BY tag ASC`,
+          [relatedIds]
+        )
+      ]);
+      const customerMap = new Map(relCustomers.map((c) => [c.id, c]));
+      const emailMap = groupByCustomer(relEmails);
+      const phoneMap = groupByCustomer(relPhones);
+      const addrMap = groupByCustomer(relAddresses);
+      const noteMap = groupByCustomer(relNotes);
+      const tagMap = relTags.reduce((m, t) => {
+        if (!m.has(t.customerId)) m.set(t.customerId, []);
+        m.get(t.customerId).push(t.tag);
+        return m;
+      }, /* @__PURE__ */ new Map());
+      expandedRelationships = relationshipRows.map((rel) => ({
+        id: rel.id,
+        workspaceId: rel.workspaceId,
+        customerId: rel.customerId,
+        relationship: rel.relationship,
+        isPrimary: rel.isPrimary,
+        createdAt: rel.createdAt,
+        customer: {
+          ...customerMap.get(rel.relatedId) ?? { id: rel.relatedId },
+          emails: emailMap.get(rel.relatedId) ?? [],
+          phones: phoneMap.get(rel.relatedId) ?? [],
+          addresses: addrMap.get(rel.relatedId) ?? [],
+          notes: noteMap.get(rel.relatedId) ?? [],
+          tags: tagMap.get(rel.relatedId) ?? []
+        }
+      }));
+    }
+    if (depth >= 2 && expandedRelationships.length > 0) {
+      const visited = /* @__PURE__ */ new Set([id]);
+      const d1Ids = expandedRelationships.map((r) => r.customer.id);
+      const d2RelRows = await this.store.query(
+        `SELECT id,
+				        workspace_id AS "workspaceId",
+				        customer_id  AS "customerId",
+				        related_id   AS "relatedId",
+				        relationship,
+				        is_primary   AS "isPrimary",
+				        created_at   AS "createdAt"
+				 FROM fonderie_customer_relationships
+				 WHERE customer_id = ANY($1::uuid[])
+				 ORDER BY is_primary DESC, created_at ASC`,
+        [d1Ids]
+      );
+      const validD2Rows = d2RelRows.filter((r) => !visited.has(r.relatedId));
+      const d2Ids = [...new Set(validD2Rows.map((r) => r.relatedId))];
+      let d2CustomerMap = /* @__PURE__ */ new Map();
+      let d2EmailMap = /* @__PURE__ */ new Map();
+      let d2PhoneMap = /* @__PURE__ */ new Map();
+      let d2NoteMap = /* @__PURE__ */ new Map();
+      let d2TagMap = /* @__PURE__ */ new Map();
+      if (d2Ids.length > 0) {
+        const [d2Customers, d2Emails, d2Phones, d2Notes, d2Tags] = await Promise.all([
+          this.store.query(
+            `SELECT ${SELECT_CUSTOMER} FROM fonderie_customers WHERE id = ANY($1::uuid[]) AND workspace_id = $2`,
+            [d2Ids, workspaceId]
+          ),
+          this.store.query(
+            `SELECT id, customer_id AS "customerId", email, label_id AS "labelId",
+						        (SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+						        is_primary AS "isPrimary", created_at AS "createdAt"
+						 FROM fonderie_customer_emails WHERE customer_id = ANY($1::uuid[]) ORDER BY is_primary DESC, created_at ASC`,
+            [d2Ids]
+          ),
+          this.store.query(
+            `SELECT id, customer_id AS "customerId", phone, label_id AS "labelId",
+						        (SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+						        is_primary AS "isPrimary", created_at AS "createdAt"
+						 FROM fonderie_customer_phones WHERE customer_id = ANY($1::uuid[]) ORDER BY is_primary DESC, created_at ASC`,
+            [d2Ids]
+          ),
+          this.store.query(
+            `SELECT id, customer_id AS "customerId", author_id AS "authorId", body, created_at AS "createdAt", updated_at AS "updatedAt"
+						 FROM fonderie_customer_notes WHERE customer_id = ANY($1::uuid[]) ORDER BY created_at DESC`,
+            [d2Ids]
+          ),
+          this.store.query(
+            `SELECT customer_id AS "customerId", tag FROM fonderie_customer_tags WHERE customer_id = ANY($1::uuid[]) ORDER BY tag ASC`,
+            [d2Ids]
+          )
+        ]);
+        d2CustomerMap = new Map(d2Customers.map((c) => [c.id, c]));
+        d2EmailMap = groupByCustomer(d2Emails);
+        d2PhoneMap = groupByCustomer(d2Phones);
+        d2NoteMap = groupByCustomer(d2Notes);
+        d2TagMap = d2Tags.reduce((m, t) => {
+          if (!m.has(t.customerId)) m.set(t.customerId, []);
+          m.get(t.customerId).push(t.tag);
+          return m;
+        }, /* @__PURE__ */ new Map());
+      }
+      const d2Relationships = validD2Rows.map((d2rel) => ({
+        id: d2rel.id,
+        workspaceId: d2rel.workspaceId,
+        customerId: d2rel.customerId,
+        relationship: d2rel.relationship,
+        isPrimary: d2rel.isPrimary,
+        createdAt: d2rel.createdAt,
+        customer: {
+          ...d2CustomerMap.get(d2rel.relatedId) ?? { id: d2rel.relatedId },
+          emails: d2EmailMap.get(d2rel.relatedId) ?? [],
+          phones: d2PhoneMap.get(d2rel.relatedId) ?? [],
+          addresses: [],
+          notes: d2NoteMap.get(d2rel.relatedId) ?? [],
+          tags: d2TagMap.get(d2rel.relatedId) ?? []
+        }
+      }));
+      const d2RelsByD1Id = groupByCustomer(d2Relationships);
+      const d2ExpandedRelationships = expandedRelationships.map((rel) => ({
+        ...rel,
+        customer: {
+          ...rel.customer,
+          relationships: d2RelsByD1Id.get(rel.customer.id) ?? []
+        }
+      }));
+      return {
+        ...row,
+        emails: emailRows,
+        phones: phoneRows,
+        addresses: addressRows,
+        notes: noteRows,
+        relationships: d2ExpandedRelationships,
+        tags: tagRows.map((t) => t.tag)
+      };
+    }
+    return {
+      ...row,
+      // DB returns TEXT for label; cast to the narrow union that callers expect.
+      emails: emailRows,
+      phones: phoneRows,
+      addresses: addressRows,
+      notes: noteRows,
+      relationships: expandedRelationships,
+      tags: tagRows.map((t) => t.tag)
+    };
+  }
+  async create(opts) {
+    const referenceCode = opts.referenceCode ?? await this.allocateCode(opts.workspaceId, opts.referenceCodePrefix ?? DEFAULT_REFERENCE_CODE_PREFIX);
+    const [row] = await this.store.query(
+      `INSERT INTO fonderie_customers
+			   (workspace_id, type, sex, first_name, last_name, company_name, avatar_url, locale, reference_code, created_by)
+			 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+			 RETURNING ${SELECT_CUSTOMER}`,
+      [
+        opts.workspaceId,
+        opts.type ?? "individual",
+        opts.sex ?? "UNKNOWN",
+        opts.firstName ?? null,
+        opts.lastName ?? null,
+        opts.companyName ?? null,
+        opts.avatarUrl ?? null,
+        opts.locale ?? "en-US",
+        referenceCode,
+        opts.createdBy ?? null
+      ]
+    );
+    if (!row) throw new Error("Failed to create customer");
+    return row;
+  }
+  async update(id, workspaceId, opts, referenceCodePrefix = DEFAULT_REFERENCE_CODE_PREFIX) {
+    let autoCode;
+    if (!opts.referenceCode) {
+      const current = await this.findById(id, workspaceId);
+      if (!current) return null;
+      if (!current.referenceCode) {
+        autoCode = await this.allocateCode(workspaceId, referenceCodePrefix);
+      }
+    }
+    const sets = ["updated_at = now()"];
+    const params = [id, workspaceId];
+    if (opts.type !== void 0) {
+      params.push(opts.type);
+      sets.push(`type = $${params.length}`);
+    }
+    if (opts.sex !== void 0) {
+      params.push(opts.sex);
+      sets.push(`sex = $${params.length}`);
+    }
+    if (opts.firstName !== void 0) {
+      params.push(opts.firstName);
+      sets.push(`first_name = $${params.length}`);
+    }
+    if (opts.lastName !== void 0) {
+      params.push(opts.lastName);
+      sets.push(`last_name = $${params.length}`);
+    }
+    if (opts.companyName !== void 0) {
+      params.push(opts.companyName);
+      sets.push(`company_name = $${params.length}`);
+    }
+    if (opts.avatarUrl !== void 0) {
+      params.push(opts.avatarUrl);
+      sets.push(`avatar_url = $${params.length}`);
+    }
+    if (opts.locale !== void 0) {
+      params.push(opts.locale);
+      sets.push(`locale = $${params.length}`);
+    }
+    const resolvedCode = opts.referenceCode ?? autoCode;
+    if (resolvedCode !== void 0) {
+      params.push(resolvedCode);
+      sets.push(`reference_code = $${params.length}`);
+    }
+    const [row] = await this.store.query(
+      `UPDATE fonderie_customers
+			 SET ${sets.join(", ")}
+			 WHERE id = $1 AND workspace_id = $2
+			 RETURNING ${SELECT_CUSTOMER}`,
+      params
+    );
+    return row ?? null;
+  }
+  async delete(id, workspaceId) {
+    await Promise.all([
+      this.store.query(`DELETE FROM fonderie_customer_emails WHERE customer_id = $1`, [id]),
+      this.store.query(`DELETE FROM fonderie_customer_phones WHERE customer_id = $1`, [id]),
+      this.store.query(
+        `DELETE FROM fonderie_addresses WHERE id IN (
+					SELECT addr_id FROM fonderie_customer_addresses WHERE customer_id = $1
+				)`,
+        [id]
+      ),
+      this.store.query(`DELETE FROM fonderie_customer_notes WHERE customer_id = $1`, [id]),
+      this.store.query(`DELETE FROM fonderie_customer_tags WHERE customer_id = $1`, [id]),
+      this.store.query(
+        `DELETE FROM fonderie_customer_relationships WHERE customer_id = $1 OR related_id = $1`,
+        [id]
+      )
+    ]);
+    await this.store.query(`DELETE FROM fonderie_customers WHERE id = $1 AND workspace_id = $2`, [
+      id,
+      workspaceId
+    ]);
+  }
+  async blacklist(id, workspaceId, reason) {
+    await this.store.query(
+      `UPDATE fonderie_customers
+			 SET is_blacklisted = true, blacklist_reason = $3, updated_at = now()
+			 WHERE id = $1 AND workspace_id = $2`,
+      [id, workspaceId, reason ?? null]
+    );
+  }
+  async unblacklist(id, workspaceId) {
+    await this.store.query(
+      `UPDATE fonderie_customers
+			 SET is_blacklisted = false, blacklist_reason = null, updated_at = now()
+			 WHERE id = $1 AND workspace_id = $2`,
+      [id, workspaceId]
+    );
+  }
+};
+
+// src/models/customer-relationship.model.ts
+var CustomerRelationshipModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async list(customerId) {
+    return this.store.query(
+      `SELECT id,
+			        workspace_id  AS "workspaceId",
+			        customer_id   AS "customerId",
+			        related_id    AS "relatedId",
+			        relationship,
+			        is_primary    AS "isPrimary",
+			        created_at    AS "createdAt"
+			 FROM fonderie_customer_relationships
+			 WHERE customer_id = $1
+			 ORDER BY is_primary DESC, created_at ASC`,
+      [customerId]
+    );
+  }
+  async add(opts) {
+    return this.store.transaction(async (tx) => {
+      if (opts.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_relationships
+					 SET is_primary = false
+					 WHERE customer_id = $1`,
+          [opts.customerId]
+        );
+      }
+      const [row] = await tx.query(
+        `INSERT INTO fonderie_customer_relationships
+				   (workspace_id, customer_id, related_id, relationship, is_primary)
+				 VALUES ($1, $2, $3, $4, $5)
+				 ON CONFLICT (customer_id, related_id) DO UPDATE
+				   SET relationship = EXCLUDED.relationship,
+				       is_primary   = EXCLUDED.is_primary
+				 RETURNING
+				   id,
+				   workspace_id AS "workspaceId",
+				   customer_id  AS "customerId",
+				   related_id   AS "relatedId",
+				   relationship,
+				   is_primary   AS "isPrimary",
+				   created_at   AS "createdAt"`,
+        [opts.workspaceId, opts.customerId, opts.relatedId, opts.relationship, opts.isPrimary ?? false]
+      );
+      if (!row) throw new Error("Failed to create relationship");
+      return row;
+    });
+  }
+  async setPrimary(customerId, relatedId) {
+    await this.store.transaction(async (tx) => {
+      await tx.query(
+        `UPDATE fonderie_customer_relationships SET is_primary = false WHERE customer_id = $1`,
+        [customerId]
+      );
+      await tx.query(
+        `UPDATE fonderie_customer_relationships
+				 SET is_primary = true
+				 WHERE customer_id = $1 AND related_id = $2`,
+        [customerId, relatedId]
+      );
+    });
+  }
+  async remove(customerId, relatedId) {
+    await this.store.query(
+      `DELETE FROM fonderie_customer_relationships
+			 WHERE customer_id = $1 AND related_id = $2`,
+      [customerId, relatedId]
+    );
+  }
+};
+
+// src/models/customer-address.model.ts
+var SELECT_CUSTOMER_ADDRESS = `
+	ca.addr_id     AS "addrId",
+	ca.customer_id AS "customerId",
+	ca.label_id    AS "labelId",
+	(SELECT value FROM fonderie_customer_labels WHERE id = ca.label_id) AS label,
+	ca.is_primary  AS "isPrimary",
+	jsonb_build_object(
+		'id',              a.id,
+		'countryIso',      a.country_iso,
+		'subdivision1Iso', a.subdivision1_iso,
+		'subdivision2Iso', a.subdivision2_iso,
+		'zipPostalCode',   a.zip_postal_code,
+		'unit',            a.unit,
+		'line1',           a.line1,
+		'line2',           a.line2
+	) AS address
+`;
+var CustomerAddressModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  list(customerId) {
+    return this.store.query(
+      `SELECT ${SELECT_CUSTOMER_ADDRESS}
+			 FROM fonderie_customer_addresses ca
+			 JOIN fonderie_addresses a ON a.id = ca.addr_id
+			 WHERE ca.customer_id = $1
+			 ORDER BY ca.is_primary DESC`,
+      [customerId]
+    );
+  }
+  async add(opts) {
+    const [existing] = await this.store.query(
+      `SELECT ca.addr_id AS "addrId"
+			 FROM fonderie_customer_addresses ca
+			 JOIN fonderie_addresses a ON a.id = ca.addr_id
+			 WHERE ca.customer_id = $1
+			   AND a.country_iso        = $2
+			   AND a.zip_postal_code    = $3
+			   AND a.subdivision1_iso IS NOT DISTINCT FROM $4
+			   AND a.subdivision2_iso IS NOT DISTINCT FROM $5
+			   AND a.unit             IS NOT DISTINCT FROM $6
+			   AND a.line1            IS NOT DISTINCT FROM $7
+			   AND a.line2            IS NOT DISTINCT FROM $8
+			 LIMIT 1`,
+      [
+        opts.customerId,
+        opts.countryIso,
+        opts.zipPostalCode,
+        opts.subdivision1Iso ?? null,
+        opts.subdivision2Iso ?? null,
+        opts.unit ?? null,
+        opts.line1 ?? null,
+        opts.line2 ?? null
+      ]
+    );
+    if (existing) {
+      throw Object.assign(new Error("Duplicate address for this customer"), { code: "DUPLICATE_ADDRESS" });
+    }
+    return this.store.transaction(async (tx) => {
+      if (opts.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_addresses
+					 SET is_primary = false
+					 WHERE customer_id = $1`,
+          [opts.customerId]
+        );
+      }
+      const [addr] = await tx.query(
+        `INSERT INTO fonderie_addresses
+				   (id, country_iso, subdivision1_iso, subdivision2_iso, zip_postal_code, unit, line1, line2)
+				 VALUES (gen_random_uuid(), $1, $2, $3, $4, $5, $6, $7)
+				 RETURNING id`,
+        [
+          opts.countryIso,
+          opts.subdivision1Iso ?? null,
+          opts.subdivision2Iso ?? null,
+          opts.zipPostalCode,
+          opts.unit ?? null,
+          opts.line1 ?? null,
+          opts.line2 ?? null
+        ]
+      );
+      if (!addr) throw new Error("Failed to create address");
+      const [row] = await tx.query(
+        `INSERT INTO fonderie_customer_addresses (addr_id, customer_id, label_id, is_primary)
+				 VALUES ($1, $2, $3, $4)
+				 RETURNING
+				   addr_id     AS "addrId",
+				   customer_id AS "customerId",
+				   label_id    AS "labelId",
+				   NULL::text  AS label,
+				   is_primary  AS "isPrimary",
+				   NULL::jsonb AS address`,
+        [addr.id, opts.customerId, opts.labelId, opts.isPrimary ?? false]
+      );
+      if (!row) throw new Error("Failed to link address");
+      const [full] = await tx.query(
+        `SELECT ${SELECT_CUSTOMER_ADDRESS}
+				 FROM fonderie_customer_addresses ca
+				 JOIN fonderie_addresses a ON a.id = ca.addr_id
+				 WHERE ca.addr_id = $1 AND ca.customer_id = $2`,
+        [addr.id, opts.customerId]
+      );
+      if (!full) throw new Error("Failed to fetch created address");
+      return full;
+    });
+  }
+  async updateLabel(addrId, customerId, labelId) {
+    const [row] = await this.store.query(
+      `UPDATE fonderie_customer_addresses
+			 SET label_id = $3
+			 WHERE addr_id = $1 AND customer_id = $2
+			 RETURNING addr_id AS "addrId", customer_id AS "customerId", label_id AS "labelId", NULL::text AS label, is_primary AS "isPrimary", NULL::jsonb AS address`,
+      [addrId, customerId, labelId]
+    );
+    if (!row) throw Object.assign(new Error("Address not found"), { code: "NOT_FOUND" });
+    const [full] = await this.store.query(
+      `SELECT ${SELECT_CUSTOMER_ADDRESS}
+			 FROM fonderie_customer_addresses ca
+			 JOIN fonderie_addresses a ON a.id = ca.addr_id
+			 WHERE ca.addr_id = $1 AND ca.customer_id = $2`,
+      [addrId, customerId]
+    );
+    if (!full) throw new Error("Failed to fetch updated address");
+    return full;
+  }
+  async setPrimary(addrId, customerId) {
+    await this.store.transaction(async (tx) => {
+      await tx.query(
+        `UPDATE fonderie_customer_addresses SET is_primary = false WHERE customer_id = $1`,
+        [customerId]
+      );
+      await tx.query(
+        `UPDATE fonderie_customer_addresses SET is_primary = true WHERE addr_id = $1 AND customer_id = $2`,
+        [addrId, customerId]
+      );
+    });
+  }
+  async remove(addrId, customerId) {
+    await this.store.transaction(async (tx) => {
+      const [deleted] = await tx.query(
+        `DELETE FROM fonderie_customer_addresses
+				 WHERE addr_id = $1 AND customer_id = $2
+				 RETURNING is_primary AS "isPrimary"`,
+        [addrId, customerId]
+      );
+      await tx.query(`DELETE FROM fonderie_addresses WHERE id = $1`, [addrId]);
+      if (deleted?.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_addresses
+					 SET is_primary = true
+					 WHERE addr_id = (
+					   SELECT addr_id FROM fonderie_customer_addresses
+					   WHERE customer_id = $1
+					   ORDER BY addr_id ASC
+					   LIMIT 1
+					 )`,
+          [customerId]
+        );
+      }
+    });
+  }
+};
+
+// src/models/customer-email.model.ts
+var SELECT_EMAIL = `
+	id,
+	customer_id AS "customerId",
+	email,
+	label_id    AS "labelId",
+	(SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+	is_primary  AS "isPrimary",
+	created_at  AS "createdAt"
+`;
+var CustomerEmailModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  list(customerId) {
+    return this.store.query(
+      `SELECT ${SELECT_EMAIL}
+			 FROM fonderie_customer_emails
+			 WHERE customer_id = $1
+			 ORDER BY is_primary DESC, created_at ASC`,
+      [customerId]
+    );
+  }
+  async add(opts) {
+    return this.store.transaction(async (tx) => {
+      if (opts.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_emails SET is_primary = false WHERE customer_id = $1`,
+          [opts.customerId]
+        );
+      }
+      const [row] = await tx.query(
+        `INSERT INTO fonderie_customer_emails (id, customer_id, email, label_id, is_primary)
+				 VALUES (gen_random_uuid(), $1, $2, $3, $4)
+				 RETURNING ${SELECT_EMAIL}`,
+        [opts.customerId, opts.email, opts.labelId, opts.isPrimary ?? false]
+      );
+      if (!row) throw new Error("Failed to add customer email");
+      return row;
+    });
+  }
+  async updateLabel(emailId, customerId, labelId) {
+    const [row] = await this.store.query(
+      `UPDATE fonderie_customer_emails
+			 SET label_id = $3
+			 WHERE id = $1 AND customer_id = $2
+			 RETURNING ${SELECT_EMAIL}`,
+      [emailId, customerId, labelId]
+    );
+    if (!row) throw Object.assign(new Error("Email not found"), { code: "NOT_FOUND" });
+    return row;
+  }
+  async setPrimary(emailId, customerId) {
+    await this.store.transaction(async (tx) => {
+      await tx.query(
+        `UPDATE fonderie_customer_emails SET is_primary = false WHERE customer_id = $1`,
+        [customerId]
+      );
+      await tx.query(
+        `UPDATE fonderie_customer_emails SET is_primary = true WHERE id = $1 AND customer_id = $2`,
+        [emailId, customerId]
+      );
+    });
+  }
+  async remove(emailId, customerId) {
+    await this.store.transaction(async (tx) => {
+      const [deleted] = await tx.query(
+        `DELETE FROM fonderie_customer_emails
+				 WHERE id = $1 AND customer_id = $2
+				 RETURNING is_primary AS "isPrimary"`,
+        [emailId, customerId]
+      );
+      if (deleted?.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_emails
+					 SET is_primary = true
+					 WHERE id = (
+					   SELECT id FROM fonderie_customer_emails
+					   WHERE customer_id = $1
+					   ORDER BY created_at ASC
+					   LIMIT 1
+					 )`,
+          [customerId]
+        );
+      }
+    });
+  }
+};
+
+// src/models/customer-label.model.ts
+var CustomerLabelModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  list(type) {
+    return this.store.query(
+      `SELECT id, type, value, created_at AS "createdAt"
+			 FROM fonderie_customer_labels
+			 WHERE type = $1
+			 ORDER BY value ASC`,
+      [type]
+    );
+  }
+  remove(id) {
+    return this.store.query(
+      `DELETE FROM fonderie_customer_labels WHERE id = $1`,
+      [id]
+    ).then(() => void 0);
+  }
+  async findOrCreate(type, raw) {
+    const value = raw.trim().toLowerCase();
+    const [row] = await this.store.query(
+      `INSERT INTO fonderie_customer_labels (type, value)
+			 VALUES ($1, $2)
+			 ON CONFLICT (type, value) DO UPDATE SET value = EXCLUDED.value
+			 RETURNING id, type, value, created_at AS "createdAt"`,
+      [type, value]
+    );
+    if (!row) throw new Error("Failed to find or create label");
+    return row;
+  }
+};
+
+// src/models/customer-note.model.ts
+var SELECT_NOTE = `
+	id,
+	customer_id AS "customerId",
+	author_id   AS "authorId",
+	body,
+	created_at  AS "createdAt",
+	updated_at  AS "updatedAt"
+`;
+var CustomerNoteModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  list(customerId) {
+    return this.store.query(
+      `SELECT ${SELECT_NOTE}
+			 FROM fonderie_customer_notes
+			 WHERE customer_id = $1
+			 ORDER BY created_at DESC`,
+      [customerId]
+    );
+  }
+  async create(opts) {
+    const [row] = await this.store.query(
+      `INSERT INTO fonderie_customer_notes (id, customer_id, author_id, body)
+			 VALUES (gen_random_uuid(), $1, $2, $3)
+			 RETURNING ${SELECT_NOTE}`,
+      [opts.customerId, opts.authorId ?? null, opts.body]
+    );
+    if (!row) throw new Error("Failed to create note");
+    return row;
+  }
+  async update(noteId, customerId, body) {
+    const [row] = await this.store.query(
+      `UPDATE fonderie_customer_notes
+			 SET body = $1, updated_at = now()
+			 WHERE id = $2 AND customer_id = $3
+			 RETURNING ${SELECT_NOTE}`,
+      [body, noteId, customerId]
+    );
+    return row ?? null;
+  }
+  async delete(noteId, customerId) {
+    await this.store.query(
+      `DELETE FROM fonderie_customer_notes
+			 WHERE id = $1 AND customer_id = $2`,
+      [noteId, customerId]
+    );
+  }
+};
+
+// src/models/customer-phone.model.ts
+var SELECT_PHONE = `
+	id,
+	customer_id AS "customerId",
+	phone,
+	label_id    AS "labelId",
+	(SELECT value FROM fonderie_customer_labels WHERE id = label_id) AS label,
+	is_primary  AS "isPrimary",
+	created_at  AS "createdAt"
+`;
+var CustomerPhoneModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  list(customerId) {
+    return this.store.query(
+      `SELECT ${SELECT_PHONE}
+			 FROM fonderie_customer_phones
+			 WHERE customer_id = $1
+			 ORDER BY is_primary DESC, created_at ASC`,
+      [customerId]
+    );
+  }
+  async add(opts) {
+    return this.store.transaction(async (tx) => {
+      if (opts.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_phones SET is_primary = false WHERE customer_id = $1`,
+          [opts.customerId]
+        );
+      }
+      const [row] = await tx.query(
+        `INSERT INTO fonderie_customer_phones (id, customer_id, phone, label_id, is_primary)
+				 VALUES (gen_random_uuid(), $1, $2, $3, $4)
+				 RETURNING ${SELECT_PHONE}`,
+        [opts.customerId, opts.phone, opts.labelId, opts.isPrimary ?? false]
+      );
+      if (!row) throw new Error("Failed to add customer phone");
+      return row;
+    });
+  }
+  async updateLabel(phoneId, customerId, labelId) {
+    const [row] = await this.store.query(
+      `UPDATE fonderie_customer_phones
+			 SET label_id = $3
+			 WHERE id = $1 AND customer_id = $2
+			 RETURNING ${SELECT_PHONE}`,
+      [phoneId, customerId, labelId]
+    );
+    if (!row) throw Object.assign(new Error("Phone not found"), { code: "NOT_FOUND" });
+    return row;
+  }
+  async setPrimary(phoneId, customerId) {
+    await this.store.transaction(async (tx) => {
+      await tx.query(
+        `UPDATE fonderie_customer_phones SET is_primary = false WHERE customer_id = $1`,
+        [customerId]
+      );
+      await tx.query(
+        `UPDATE fonderie_customer_phones SET is_primary = true WHERE id = $1 AND customer_id = $2`,
+        [phoneId, customerId]
+      );
+    });
+  }
+  async remove(phoneId, customerId) {
+    await this.store.transaction(async (tx) => {
+      const [deleted] = await tx.query(
+        `DELETE FROM fonderie_customer_phones
+				 WHERE id = $1 AND customer_id = $2
+				 RETURNING is_primary AS "isPrimary"`,
+        [phoneId, customerId]
+      );
+      if (deleted?.isPrimary) {
+        await tx.query(
+          `UPDATE fonderie_customer_phones
+					 SET is_primary = true
+					 WHERE id = (
+					   SELECT id FROM fonderie_customer_phones
+					   WHERE customer_id = $1
+					   ORDER BY created_at ASC
+					   LIMIT 1
+					 )`,
+          [customerId]
+        );
+      }
+    });
+  }
+};
+
+// src/models/customer-tag.model.ts
+var CustomerTagModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async list(customerId) {
+    const rows = await this.store.query(
+      `SELECT tag FROM fonderie_customer_tags
+			 WHERE customer_id = $1
+			 ORDER BY tag ASC`,
+      [customerId]
+    );
+    return rows.map((r) => r.tag);
+  }
+  async add(customerId, tag) {
+    await this.store.query(
+      `INSERT INTO fonderie_customer_tags (customer_id, tag)
+			 VALUES ($1, $2)
+			 ON CONFLICT (customer_id, tag) DO NOTHING`,
+      [customerId, tag]
+    );
+  }
+  async remove(customerId, tag) {
+    await this.store.query(
+      `DELETE FROM fonderie_customer_tags
+			 WHERE customer_id = $1 AND tag = $2`,
+      [customerId, tag]
+    );
+  }
+};
+
+// src/routes.ts
+var import_middlewares = require("@fonderie/core/middlewares");
+var import_workspaces = require("@fonderie/workspaces");
+
+// src/controllers/customer.controller.ts
+var import_core2 = require("@fonderie/core");
+
+// src/utils.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+  return typeof value === "string" && UUID_RE.test(value);
+}
+
+// src/controllers/customer.controller.ts
+function customerController(store, config = {}, bus) {
+  const customers = new CustomerModel(store);
+  const prefix = (config.referenceCodePrefix ?? DEFAULT_REFERENCE_CODE_PREFIX).toUpperCase();
+  return {
+    async list(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const query = ctx.request.url ? new URL(ctx.request.url).searchParams : null;
+      const search = query?.get("search") ?? void 0;
+      const archived = query?.get("blacklisted");
+      const limit = Number(query?.get("limit") ?? 50);
+      const offset = Number(query?.get("offset") ?? 0);
+      const listOpts = {
+        workspaceId,
+        limit: Number.isFinite(limit) ? limit : 50,
+        offset: Number.isFinite(offset) ? offset : 0
+      };
+      if (search !== void 0) {
+        listOpts.search = search;
+      }
+      if (archived !== null && archived !== void 0) {
+        listOpts.blacklisted = archived === "true" || archived === "1";
+      }
+      const list = await customers.list(listOpts);
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMERS_FETCHED", "Customers retrieved successfully.", {
+        customers: list.map(toCustomerDTO)
+      });
+    },
+    async get(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const query = ctx.request.url ? new URL(ctx.request.url).searchParams : null;
+      const depth = query?.get("depth") === "1" ? 1 : 2;
+      if (depth === 2) {
+        const customer2 = await customers.findDetail(id, workspaceId, 2);
+        if (!customer2) return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMER_FETCHED", "Customer retrieved successfully.", toCustomerDetailD2DTO(customer2));
+      }
+      const customer = await customers.findDetail(id, workspaceId);
+      if (!customer) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMER_FETCHED", "Customer retrieved successfully.", toCustomerDetailDTO(customer));
+    },
+    async create(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const body = ctx.meta["body"];
+      const type = body?.["type"];
+      const sex = body?.["sex"];
+      const firstName = body?.["firstName"];
+      const lastName = body?.["lastName"];
+      const companyName = body?.["companyName"];
+      const avatarUrl = body?.["avatarUrl"];
+      const locale = body?.["locale"];
+      const referenceCode = body?.["referenceCode"];
+      if (type !== void 0 && type !== "individual" && type !== "business") {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.UNPROCESSABLE,
+          "INVALID_PARAMETER",
+          "type must be individual or business"
+        );
+      }
+      if (sex !== void 0 && sex !== "UNKNOWN" && sex !== "MALE" && sex !== "FEMALE") {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.UNPROCESSABLE,
+          "INVALID_PARAMETER",
+          "sex must be UNKNOWN, MALE, or FEMALE"
+        );
+      }
+      let customer;
+      try {
+        customer = await customers.create({
+          workspaceId,
+          type: typeof type === "string" ? type : "individual",
+          sex: typeof sex === "string" ? sex : "UNKNOWN",
+          firstName: typeof firstName === "string" ? firstName : null,
+          lastName: typeof lastName === "string" ? lastName : null,
+          companyName: typeof companyName === "string" ? companyName : null,
+          avatarUrl: typeof avatarUrl === "string" ? avatarUrl : null,
+          locale: typeof locale === "string" ? locale : "en-US",
+          referenceCode: typeof referenceCode === "string" ? referenceCode.toUpperCase() : void 0,
+          referenceCodePrefix: prefix,
+          createdBy: ctx.user?.id ?? null
+        });
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("idx_fc_reference_code")) {
+          return (0, import_core2.setApiResponse)(import_core2.HTTP.CONFLICT, "DUPLICATE_REFERENCE_CODE", "A customer with this reference code already exists");
+        }
+        throw err;
+      }
+      bus?.emit(EVENT_KEYS.customerCreated, {
+        customerId: customer.id,
+        workspaceId: customer.workspaceId
+      }).catch(() => {
+      });
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.CREATED, "CUSTOMER_CREATED", "Customer created successfully.", {
+        customer: toCustomerDTO(customer)
+      });
+    },
+    async update(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const body = ctx.meta["body"];
+      const opts = {};
+      if (body?.["type"] !== void 0) {
+        const t = body["type"];
+        if (t !== "individual" && t !== "business") {
+          return (0, import_core2.setApiResponse)(
+            import_core2.HTTP.UNPROCESSABLE,
+            "INVALID_PARAMETER",
+            "type must be individual or business"
+          );
+        }
+        opts.type = t;
+      }
+      if (body?.["sex"] !== void 0) {
+        const s = body["sex"];
+        if (s !== "UNKNOWN" && s !== "MALE" && s !== "FEMALE") {
+          return (0, import_core2.setApiResponse)(
+            import_core2.HTTP.UNPROCESSABLE,
+            "INVALID_PARAMETER",
+            "sex must be UNKNOWN, MALE, or FEMALE"
+          );
+        }
+        opts.sex = s;
+      }
+      if (body?.["firstName"] !== void 0) {
+        opts.firstName = typeof body["firstName"] === "string" ? body["firstName"] : null;
+      }
+      if (body?.["lastName"] !== void 0) {
+        opts.lastName = typeof body["lastName"] === "string" ? body["lastName"] : null;
+      }
+      if (body?.["companyName"] !== void 0) {
+        opts.companyName = typeof body["companyName"] === "string" ? body["companyName"] : null;
+      }
+      if (body?.["avatarUrl"] !== void 0) {
+        opts.avatarUrl = typeof body["avatarUrl"] === "string" ? body["avatarUrl"] : null;
+      }
+      if (body?.["locale"] !== void 0 && typeof body["locale"] === "string") {
+        opts.locale = body["locale"];
+      }
+      if (body?.["referenceCode"] !== void 0 && typeof body["referenceCode"] === "string") {
+        opts.referenceCode = body["referenceCode"].toUpperCase();
+      }
+      const customer = await customers.update(id, workspaceId, opts, prefix);
+      if (!customer) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      bus?.emit(EVENT_KEYS.customerUpdated, {
+        customerId: customer.id,
+        workspaceId: customer.workspaceId
+      }).catch(() => {
+      });
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMER_UPDATED", "Customer updated successfully.", {
+        customer: toCustomerDTO(customer)
+      });
+    },
+    async delete(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const existing = await customers.findById(id, workspaceId);
+      if (!existing) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      await customers.delete(id, workspaceId);
+      bus?.emit(EVENT_KEYS.customerDeleted, {
+        customerId: id,
+        workspaceId
+      }).catch(() => {
+      });
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMER_DELETED", "Customer deleted successfully.");
+    },
+    async blacklist(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const existing = await customers.findById(id, workspaceId);
+      if (!existing) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      const body = ctx.meta["body"];
+      const reason = typeof body?.["reason"] === "string" ? body["reason"].trim() || null : null;
+      await customers.blacklist(id, workspaceId, reason);
+      bus?.emit(EVENT_KEYS.customerBlacklisted, {
+        customerId: id,
+        workspaceId
+      }).catch(() => {
+      });
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMER_BLACKLISTED", "Customer blacklisted successfully.");
+    },
+    async unblacklist(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const existing = await customers.findById(id, workspaceId);
+      if (!existing) {
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      await customers.unblacklist(id, workspaceId);
+      bus?.emit(EVENT_KEYS.customerUnblacklisted, {
+        customerId: id,
+        workspaceId
+      }).catch(() => {
+      });
+      return (0, import_core2.setApiResponse)(import_core2.HTTP.OK, "CUSTOMER_UNBLACKLISTED", "Customer removed from blacklist successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-address.controller.ts
+var import_core3 = require("@fonderie/core");
+function customerAddressController(store) {
+  const customers = new CustomerModel(store);
+  const addresses = new CustomerAddressModel(store);
+  const labels = new CustomerLabelModel(store);
+  async function resolveCustomer(ctx) {
+    const workspaceId = ctx.workspace?.id;
+    if (!workspaceId) {
+      return {
+        error: (0, import_core3.setApiResponse)(
+          import_core3.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: (0, import_core3.setApiResponse)(import_core3.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found") };
+    }
+    return { customer, workspaceId };
+  }
+  return {
+    async list(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const list = await addresses.list(r.customer.id);
+      return (0, import_core3.setApiResponse)(import_core3.HTTP.OK, "ADDRESSES_FETCHED", "Addresses retrieved successfully.", {
+        addresses: list.map(toCustomerAddressDTO)
+      });
+    },
+    async add(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const body = ctx.meta["body"];
+      const countryIso = body?.["countryIso"];
+      const zipPostalCode = body?.["zipPostalCode"];
+      if (typeof countryIso !== "string" || countryIso.trim().length === 0) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "countryIso is required");
+      }
+      if (typeof zipPostalCode !== "string" || zipPostalCode.trim().length === 0) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "zipPostalCode is required");
+      }
+      const rawLabel = typeof body?.["label"] === "string" ? body["label"] : "service";
+      const { id: labelId } = await labels.findOrCreate("address", rawLabel);
+      let created;
+      try {
+        created = await addresses.add({
+          customerId: r.customer.id,
+          countryIso: countryIso.trim(),
+          zipPostalCode: zipPostalCode.trim(),
+          subdivision1Iso: typeof body?.["subdivision1Iso"] === "string" ? body["subdivision1Iso"] : null,
+          subdivision2Iso: typeof body?.["subdivision2Iso"] === "string" ? body["subdivision2Iso"] : null,
+          unit: typeof body?.["unit"] === "string" ? body["unit"] : null,
+          line1: typeof body?.["line1"] === "string" ? body["line1"] : null,
+          line2: typeof body?.["line2"] === "string" ? body["line2"] : null,
+          labelId,
+          isPrimary: body?.["isPrimary"] === true
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "DUPLICATE_ADDRESS") {
+          return (0, import_core3.setApiResponse)(import_core3.HTTP.CONFLICT, "DUPLICATE_ADDRESS", "This address is already linked to this customer");
+        }
+        throw err;
+      }
+      return (0, import_core3.setApiResponse)(import_core3.HTTP.CREATED, "ADDRESS_ADDED", "Address added successfully.", {
+        address: toCustomerAddressDTO(created)
+      });
+    },
+    async update(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const addrId = params?.["addrId"];
+      if (!isUuid(addrId)) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "addrId must be a valid UUID");
+      }
+      const body = ctx.meta["body"];
+      if (typeof body?.["label"] !== "string" || body["label"].trim().length === 0) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "label is required");
+      }
+      try {
+        const { id: labelId } = await labels.findOrCreate("address", body["label"].trim());
+        const updated = await addresses.updateLabel(addrId, r.customer.id, labelId);
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.OK, "ADDRESS_UPDATED", "Address updated successfully.", {
+          address: toCustomerAddressDTO(updated)
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "NOT_FOUND") {
+          return (0, import_core3.setApiResponse)(import_core3.HTTP.NOT_FOUND, "NOT_FOUND", "Address not found");
+        }
+        throw err;
+      }
+    },
+    async setPrimary(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const params = ctx.meta["params"];
+      const addrId = params?.["addrId"];
+      if (!isUuid(addrId)) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "addrId must be a valid UUID");
+      }
+      await addresses.setPrimary(addrId, r.customer.id);
+      return (0, import_core3.setApiResponse)(import_core3.HTTP.OK, "ADDRESS_PRIMARY_SET", "Primary address updated successfully.");
+    },
+    async remove(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const params = ctx.meta["params"];
+      const addrId = params?.["addrId"];
+      if (!isUuid(addrId)) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "addrId must be a valid UUID");
+      }
+      await addresses.remove(addrId, r.customer.id);
+      return (0, import_core3.setApiResponse)(import_core3.HTTP.OK, "ADDRESS_REMOVED", "Address removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-email.controller.ts
+var import_core4 = require("@fonderie/core");
+function customerEmailController(store) {
+  const customers = new CustomerModel(store);
+  const emails = new CustomerEmailModel(store);
+  const labels = new CustomerLabelModel(store);
+  async function resolveCustomer(ctx) {
+    const workspaceId = ctx.workspace?.id;
+    if (!workspaceId) {
+      return {
+        error: (0, import_core4.setApiResponse)(
+          import_core4.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: (0, import_core4.setApiResponse)(import_core4.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found") };
+    }
+    return { customer, workspaceId };
+  }
+  return {
+    async list(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const list = await emails.list(r.customer.id);
+      return (0, import_core4.setApiResponse)(import_core4.HTTP.OK, "EMAILS_FETCHED", "Emails retrieved successfully.", {
+        emails: list.map(toCustomerEmailDTO)
+      });
+    },
+    async add(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const body = ctx.meta["body"];
+      const email = body?.["email"];
+      if (typeof email !== "string" || email.trim().length === 0) {
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "email is required");
+      }
+      const rawLabel = typeof body?.["label"] === "string" ? body["label"] : "work";
+      const isPrimary = body?.["isPrimary"] === true;
+      const { id: labelId } = await labels.findOrCreate("email", rawLabel);
+      let created;
+      try {
+        created = await emails.add({
+          customerId: r.customer.id,
+          email: email.trim(),
+          labelId,
+          isPrimary
+        });
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("idx_fce_unique_email")) {
+          return (0, import_core4.setApiResponse)(import_core4.HTTP.CONFLICT, "DUPLICATE_EMAIL", "This email is already linked to this customer");
+        }
+        throw err;
+      }
+      return (0, import_core4.setApiResponse)(import_core4.HTTP.CREATED, "EMAIL_ADDED", "Email added successfully.", {
+        email: toCustomerEmailDTO(created)
+      });
+    },
+    async update(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const emailId = params?.["emailId"];
+      if (!isUuid(emailId)) {
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "emailId must be a valid UUID");
+      }
+      const body = ctx.meta["body"];
+      if (typeof body?.["label"] !== "string" || body["label"].trim().length === 0) {
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "label is required");
+      }
+      try {
+        const { id: labelId } = await labels.findOrCreate("email", body["label"].trim());
+        const updated = await emails.updateLabel(emailId, r.customer.id, labelId);
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.OK, "EMAIL_UPDATED", "Email updated successfully.", {
+          email: toCustomerEmailDTO(updated)
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "NOT_FOUND") {
+          return (0, import_core4.setApiResponse)(import_core4.HTTP.NOT_FOUND, "NOT_FOUND", "Email not found");
+        }
+        throw err;
+      }
+    },
+    async setPrimary(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const params = ctx.meta["params"];
+      const emailId = params?.["emailId"];
+      if (!isUuid(emailId)) {
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "emailId must be a valid UUID");
+      }
+      await emails.setPrimary(emailId, r.customer.id);
+      return (0, import_core4.setApiResponse)(import_core4.HTTP.OK, "EMAIL_PRIMARY_SET", "Primary email updated successfully.");
+    },
+    async remove(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const params = ctx.meta["params"];
+      const emailId = params?.["emailId"];
+      if (!isUuid(emailId)) {
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "emailId must be a valid UUID");
+      }
+      await emails.remove(emailId, r.customer.id);
+      return (0, import_core4.setApiResponse)(import_core4.HTTP.OK, "EMAIL_REMOVED", "Email removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-note.controller.ts
+var import_core5 = require("@fonderie/core");
+function customerNoteController(store) {
+  const customers = new CustomerModel(store);
+  const notes = new CustomerNoteModel(store);
+  async function resolveCustomer(ctx) {
+    const workspaceId = ctx.workspace?.id;
+    if (!workspaceId)
+      return {
+        error: (0, import_core5.setApiResponse)(
+          import_core5.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id))
+      return { error: (0, import_core5.setApiResponse)(import_core5.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer)
+      return { error: (0, import_core5.setApiResponse)(import_core5.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found") };
+    return { customer, workspaceId };
+  }
+  return {
+    async list(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const list = await notes.list(r.customer.id);
+      return (0, import_core5.setApiResponse)(import_core5.HTTP.OK, "NOTES_FETCHED", "Notes retrieved successfully.", {
+        notes: list.map(toCustomerNoteDTO)
+      });
+    },
+    async create(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const body = ctx.meta["body"];
+      const bodyText = body?.["body"];
+      if (typeof bodyText !== "string" || bodyText.trim().length === 0) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "body is required");
+      }
+      const note = await notes.create({
+        customerId: r.customer.id,
+        authorId: ctx.user?.id ?? null,
+        body: bodyText.trim()
+      });
+      return (0, import_core5.setApiResponse)(import_core5.HTTP.CREATED, "NOTE_CREATED", "Note created successfully.", {
+        note: toCustomerNoteDTO(note)
+      });
+    },
+    async update(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const noteId = params?.["noteId"];
+      if (!isUuid(noteId)) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "noteId must be a valid UUID");
+      }
+      const body = ctx.meta["body"];
+      const bodyText = body?.["body"];
+      if (typeof bodyText !== "string" || bodyText.trim().length === 0) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "body is required");
+      }
+      const note = await notes.update(noteId, r.customer.id, bodyText.trim());
+      if (!note) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.NOT_FOUND, "NOT_FOUND", "Note not found");
+      }
+      return (0, import_core5.setApiResponse)(import_core5.HTTP.OK, "NOTE_UPDATED", "Note updated successfully.", {
+        note: toCustomerNoteDTO(note)
+      });
+    },
+    async delete(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const noteId = params?.["noteId"];
+      if (!isUuid(noteId)) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "noteId must be a valid UUID");
+      }
+      await notes.delete(noteId, r.customer.id);
+      return (0, import_core5.setApiResponse)(import_core5.HTTP.OK, "NOTE_DELETED", "Note deleted successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-phone.controller.ts
+var import_core6 = require("@fonderie/core");
+function customerPhoneController(store) {
+  const customers = new CustomerModel(store);
+  const phones = new CustomerPhoneModel(store);
+  const labels = new CustomerLabelModel(store);
+  async function resolveCustomer(ctx) {
+    const workspaceId = ctx.workspace?.id;
+    if (!workspaceId) {
+      return {
+        error: (0, import_core6.setApiResponse)(
+          import_core6.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: (0, import_core6.setApiResponse)(import_core6.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: (0, import_core6.setApiResponse)(import_core6.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found") };
+    }
+    return { customer, workspaceId };
+  }
+  return {
+    async list(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const list = await phones.list(r.customer.id);
+      return (0, import_core6.setApiResponse)(import_core6.HTTP.OK, "PHONES_FETCHED", "Phones retrieved successfully.", {
+        phones: list.map(toCustomerPhoneDTO)
+      });
+    },
+    async add(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const body = ctx.meta["body"];
+      const phone = body?.["phone"];
+      if (typeof phone !== "string" || phone.trim().length === 0) {
+        return (0, import_core6.setApiResponse)(import_core6.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "phone is required");
+      }
+      const rawLabel = typeof body?.["label"] === "string" ? body["label"] : "mobile";
+      const isPrimary = body?.["isPrimary"] === true;
+      const { id: labelId } = await labels.findOrCreate("phone", rawLabel);
+      let created;
+      try {
+        created = await phones.add({
+          customerId: r.customer.id,
+          phone: phone.trim(),
+          labelId,
+          isPrimary
+        });
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("idx_fcp_unique_phone")) {
+          return (0, import_core6.setApiResponse)(import_core6.HTTP.CONFLICT, "DUPLICATE_PHONE", "This phone is already linked to this customer");
+        }
+        throw err;
+      }
+      return (0, import_core6.setApiResponse)(import_core6.HTTP.CREATED, "PHONE_ADDED", "Phone added successfully.", {
+        phone: toCustomerPhoneDTO(created)
+      });
+    },
+    async update(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const phoneId = params?.["phoneId"];
+      if (!isUuid(phoneId)) {
+        return (0, import_core6.setApiResponse)(import_core6.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "phoneId must be a valid UUID");
+      }
+      const body = ctx.meta["body"];
+      if (typeof body?.["label"] !== "string" || body["label"].trim().length === 0) {
+        return (0, import_core6.setApiResponse)(import_core6.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "label is required");
+      }
+      try {
+        const { id: labelId } = await labels.findOrCreate("phone", body["label"].trim());
+        const updated = await phones.updateLabel(phoneId, r.customer.id, labelId);
+        return (0, import_core6.setApiResponse)(import_core6.HTTP.OK, "PHONE_UPDATED", "Phone updated successfully.", {
+          phone: toCustomerPhoneDTO(updated)
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "NOT_FOUND") {
+          return (0, import_core6.setApiResponse)(import_core6.HTTP.NOT_FOUND, "NOT_FOUND", "Phone not found");
+        }
+        throw err;
+      }
+    },
+    async setPrimary(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const params = ctx.meta["params"];
+      const phoneId = params?.["phoneId"];
+      if (!isUuid(phoneId)) {
+        return (0, import_core6.setApiResponse)(import_core6.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "phoneId must be a valid UUID");
+      }
+      await phones.setPrimary(phoneId, r.customer.id);
+      return (0, import_core6.setApiResponse)(import_core6.HTTP.OK, "PHONE_PRIMARY_SET", "Primary phone updated successfully.");
+    },
+    async remove(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) {
+        return r.error;
+      }
+      const params = ctx.meta["params"];
+      const phoneId = params?.["phoneId"];
+      if (!isUuid(phoneId)) {
+        return (0, import_core6.setApiResponse)(import_core6.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "phoneId must be a valid UUID");
+      }
+      await phones.remove(phoneId, r.customer.id);
+      return (0, import_core6.setApiResponse)(import_core6.HTTP.OK, "PHONE_REMOVED", "Phone removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-tag.controller.ts
+var import_core7 = require("@fonderie/core");
+function customerTagController(store) {
+  const customers = new CustomerModel(store);
+  const tags = new CustomerTagModel(store);
+  async function resolveCustomer(ctx) {
+    const workspaceId = ctx.workspace?.id;
+    if (!workspaceId)
+      return {
+        error: (0, import_core7.setApiResponse)(
+          import_core7.HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id))
+      return { error: (0, import_core7.setApiResponse)(import_core7.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer)
+      return { error: (0, import_core7.setApiResponse)(import_core7.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found") };
+    return { customer, workspaceId };
+  }
+  return {
+    async list(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const list = await tags.list(r.customer.id);
+      return (0, import_core7.setApiResponse)(import_core7.HTTP.OK, "TAGS_FETCHED", "Tags retrieved successfully.", {
+        tags: list
+      });
+    },
+    async add(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const body = ctx.meta["body"];
+      const tag = body?.["tag"];
+      if (typeof tag !== "string" || tag.trim().length === 0) {
+        return (0, import_core7.setApiResponse)(import_core7.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "tag is required");
+      }
+      await tags.add(r.customer.id, tag.trim());
+      return (0, import_core7.setApiResponse)(import_core7.HTTP.CREATED, "TAG_ADDED", "Tag added successfully.");
+    },
+    async remove(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const tag = params?.["tag"];
+      if (!tag) {
+        return (0, import_core7.setApiResponse)(import_core7.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "tag is required");
+      }
+      await tags.remove(r.customer.id, tag);
+      return (0, import_core7.setApiResponse)(import_core7.HTTP.OK, "TAG_REMOVED", "Tag removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-label.controller.ts
+var import_core8 = require("@fonderie/core");
+var VALID_TYPES = ["phone", "email", "address"];
+function customerLabelController(store) {
+  const labels = new CustomerLabelModel(store);
+  return {
+    async list(ctx) {
+      const query = ctx.request.url ? new URL(ctx.request.url).searchParams : null;
+      const type = query?.get("type");
+      if (!type || !VALID_TYPES.includes(type)) {
+        return (0, import_core8.setApiResponse)(import_core8.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "type must be phone, email, or address");
+      }
+      const rows = await labels.list(type);
+      return (0, import_core8.setApiResponse)(import_core8.HTTP.OK, "LABELS_FETCHED", "Labels retrieved successfully.", { labels: rows });
+    },
+    async remove(ctx) {
+      const params = ctx.meta["params"];
+      const labelId = params?.["labelId"];
+      if (!isUuid(labelId)) {
+        return (0, import_core8.setApiResponse)(import_core8.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "labelId must be a valid UUID");
+      }
+      await labels.remove(labelId);
+      return (0, import_core8.setApiResponse)(import_core8.HTTP.OK, "LABEL_DELETED", "Label deleted successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-relationship.controller.ts
+var import_core9 = require("@fonderie/core");
+function customerRelationshipController(store) {
+  const customers = new CustomerModel(store);
+  const relationships = new CustomerRelationshipModel(store);
+  async function resolveCustomer(ctx) {
+    const workspaceId = ctx.workspace?.id;
+    if (!workspaceId) {
+      return {
+        error: (0, import_core9.setApiResponse)(import_core9.HTTP.BAD_REQUEST, "MISSING_WORKSPACE", "Workspace context is required")
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: (0, import_core9.setApiResponse)(import_core9.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: (0, import_core9.setApiResponse)(import_core9.HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found") };
+    }
+    return { customer, workspaceId };
+  }
+  return {
+    async list(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const list = await relationships.list(r.customer.id);
+      return (0, import_core9.setApiResponse)(import_core9.HTTP.OK, "RELATIONSHIPS_FETCHED", "Relationships retrieved successfully.", {
+        relationships: list.map(toCustomerRelationshipDTO)
+      });
+    },
+    async add(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const body = ctx.meta["body"];
+      const relatedId = body?.["relatedId"];
+      const relationship = body?.["relationship"];
+      if (!isUuid(relatedId)) {
+        return (0, import_core9.setApiResponse)(import_core9.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "relatedId must be a valid UUID");
+      }
+      if (typeof relationship !== "string" || relationship.trim().length === 0) {
+        return (0, import_core9.setApiResponse)(import_core9.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "relationship is required");
+      }
+      if (relatedId === r.customer.id) {
+        return (0, import_core9.setApiResponse)(import_core9.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "A customer cannot be related to itself");
+      }
+      const related = await customers.findById(relatedId, r.workspaceId);
+      if (!related) {
+        return (0, import_core9.setApiResponse)(import_core9.HTTP.NOT_FOUND, "NOT_FOUND", "Related customer not found");
+      }
+      const created = await relationships.add({
+        workspaceId: r.workspaceId,
+        customerId: r.customer.id,
+        relatedId,
+        relationship: relationship.trim(),
+        isPrimary: body?.["isPrimary"] === true
+      });
+      return (0, import_core9.setApiResponse)(import_core9.HTTP.CREATED, "RELATIONSHIP_ADDED", "Relationship added successfully.", {
+        relationship: toCustomerRelationshipDTO(created)
+      });
+    },
+    async setPrimary(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const relatedId = params?.["relatedId"];
+      if (!isUuid(relatedId)) {
+        return (0, import_core9.setApiResponse)(import_core9.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "relatedId must be a valid UUID");
+      }
+      await relationships.setPrimary(r.customer.id, relatedId);
+      return (0, import_core9.setApiResponse)(import_core9.HTTP.OK, "RELATIONSHIP_PRIMARY_SET", "Primary relationship updated successfully.");
+    },
+    async remove(ctx) {
+      const r = await resolveCustomer(ctx);
+      if ("error" in r) return r.error;
+      const params = ctx.meta["params"];
+      const relatedId = params?.["relatedId"];
+      if (!isUuid(relatedId)) {
+        return (0, import_core9.setApiResponse)(import_core9.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "relatedId must be a valid UUID");
+      }
+      await relationships.remove(r.customer.id, relatedId);
+      return (0, import_core9.setApiResponse)(import_core9.HTTP.OK, "RELATIONSHIP_REMOVED", "Relationship removed successfully.");
+    }
+  };
+}
+
+// src/routes.ts
+function buildCustomerRoutes(store, config, bus) {
+  const wsCtx = (0, import_workspaces.withWorkspace)(store);
+  const customer = customerController(store, config, bus);
+  const email = customerEmailController(store);
+  const phone = customerPhoneController(store);
+  const address = customerAddressController(store);
+  const note = customerNoteController(store);
+  const tag = customerTagController(store);
+  const relationship = customerRelationshipController(store);
+  const label = customerLabelController(store);
+  return [
+    // ── Labels ───────────────────────────────────────────────────────
+    ["GET", "/customers/labels", import_middlewares.requireAuth, wsCtx, label.list],
+    ["DELETE", "/customers/labels/:labelId", import_middlewares.requireAuth, wsCtx, label.remove],
+    // ── Core customer CRUD ───────────────────────────────────────────
+    ["GET", "/customers", import_middlewares.requireAuth, wsCtx, customer.list],
+    ["POST", "/customers", import_middlewares.requireAuth, wsCtx, customer.create],
+    ["GET", "/customers/:customerId", import_middlewares.requireAuth, wsCtx, customer.get],
+    ["PUT", "/customers/:customerId", import_middlewares.requireAuth, wsCtx, customer.update],
+    ["DELETE", "/customers/:customerId", import_middlewares.requireAuth, wsCtx, customer.delete],
+    ["POST", "/customers/:customerId/blacklist", import_middlewares.requireAuth, wsCtx, customer.blacklist],
+    ["POST", "/customers/:customerId/unblacklist", import_middlewares.requireAuth, wsCtx, customer.unblacklist],
+    // ── Emails ───────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/emails", import_middlewares.requireAuth, wsCtx, email.list],
+    ["POST", "/customers/:customerId/emails", import_middlewares.requireAuth, wsCtx, email.add],
+    ["PATCH", "/customers/:customerId/emails/:emailId", import_middlewares.requireAuth, wsCtx, email.update],
+    ["PUT", "/customers/:customerId/emails/:emailId/primary", import_middlewares.requireAuth, wsCtx, email.setPrimary],
+    ["DELETE", "/customers/:customerId/emails/:emailId", import_middlewares.requireAuth, wsCtx, email.remove],
+    // ── Phones ───────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/phones", import_middlewares.requireAuth, wsCtx, phone.list],
+    ["POST", "/customers/:customerId/phones", import_middlewares.requireAuth, wsCtx, phone.add],
+    ["PATCH", "/customers/:customerId/phones/:phoneId", import_middlewares.requireAuth, wsCtx, phone.update],
+    ["PUT", "/customers/:customerId/phones/:phoneId/primary", import_middlewares.requireAuth, wsCtx, phone.setPrimary],
+    ["DELETE", "/customers/:customerId/phones/:phoneId", import_middlewares.requireAuth, wsCtx, phone.remove],
+    // ── Addresses ────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/addresses", import_middlewares.requireAuth, wsCtx, address.list],
+    ["POST", "/customers/:customerId/addresses", import_middlewares.requireAuth, wsCtx, address.add],
+    ["PATCH", "/customers/:customerId/addresses/:addrId", import_middlewares.requireAuth, wsCtx, address.update],
+    ["PUT", "/customers/:customerId/addresses/:addrId/primary", import_middlewares.requireAuth, wsCtx, address.setPrimary],
+    ["DELETE", "/customers/:customerId/addresses/:addrId", import_middlewares.requireAuth, wsCtx, address.remove],
+    // ── Notes ────────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/notes", import_middlewares.requireAuth, wsCtx, note.list],
+    ["POST", "/customers/:customerId/notes", import_middlewares.requireAuth, wsCtx, note.create],
+    ["PUT", "/customers/:customerId/notes/:noteId", import_middlewares.requireAuth, wsCtx, note.update],
+    ["DELETE", "/customers/:customerId/notes/:noteId", import_middlewares.requireAuth, wsCtx, note.delete],
+    // ── Tags ─────────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/tags", import_middlewares.requireAuth, wsCtx, tag.list],
+    ["POST", "/customers/:customerId/tags", import_middlewares.requireAuth, wsCtx, tag.add],
+    ["DELETE", "/customers/:customerId/tags/:tag", import_middlewares.requireAuth, wsCtx, tag.remove],
+    // ── Relationships ────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/relationships", import_middlewares.requireAuth, wsCtx, relationship.list],
+    ["POST", "/customers/:customerId/relationships", import_middlewares.requireAuth, wsCtx, relationship.add],
+    ["PUT", "/customers/:customerId/relationships/:relatedId/primary", import_middlewares.requireAuth, wsCtx, relationship.setPrimary],
+    ["DELETE", "/customers/:customerId/relationships/:relatedId", import_middlewares.requireAuth, wsCtx, relationship.remove]
+  ];
+}
+
+// src/module.ts
+var CustomersModule = class {
+  constructor(store, config = {}, bus) {
+    this.store = store;
+    this.config = config;
+    this.bus = bus;
+  }
+  store;
+  config;
+  bus;
+  name = "@fonderie/customers";
+  deps = ["@fonderie/workspaces"];
+  install(app) {
+    const routes = buildCustomerRoutes(this.store, this.config, this.bus);
+    for (const [method, path, ...handlers] of routes) {
+      app.addRoute(method, path, ...handlers);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomerAddressModel,
+  CustomerEmailModel,
+  CustomerModel,
+  CustomerNoteModel,
+  CustomerPhoneModel,
+  CustomerTagModel,
+  CustomersModule,
+  EVENT_KEYS,
+  toAddressDTO,
+  toCustomerAddressDTO,
+  toCustomerDTO,
+  toCustomerDetailDTO,
+  toCustomerEmailDTO,
+  toCustomerNoteDTO,
+  toCustomerPhoneDTO,
+  toCustomerTagDTO
+});
+//# sourceMappingURL=index.cjs.map