@fonderie/customers 1.0.0

package/dist/index.js

@@ -0,0 +1,2178 @@
+// 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
+import { arrayOrEmpty, booleanOrFalse, dateOrEmpty, stringOrEmpty } from "@fonderie/core";
+var VALID_SEX = ["UNKNOWN", "MALE", "FEMALE"];
+function toCustomerDTO(c) {
+  return {
+    id: stringOrEmpty(c.id),
+    type: stringOrEmpty(c.type),
+    sex: VALID_SEX.includes(c.sex) ? c.sex : "UNKNOWN",
+    firstName: stringOrEmpty(c.firstName),
+    lastName: stringOrEmpty(c.lastName),
+    companyName: stringOrEmpty(c.companyName),
+    avatarUrl: stringOrEmpty(c.avatarUrl),
+    locale: stringOrEmpty(c.locale),
+    referenceCode: stringOrEmpty(c.referenceCode),
+    blacklisted: { status: booleanOrFalse(c.isBlacklisted), reason: c.blacklistReason ?? null },
+    createdBy: stringOrEmpty(c.createdBy),
+    createdAt: dateOrEmpty(c.createdAt),
+    updatedAt: dateOrEmpty(c.updatedAt)
+  };
+}
+function toCustomerRelationshipDTO(r) {
+  return {
+    id: stringOrEmpty(r.id),
+    relatedId: stringOrEmpty(r.relatedId),
+    relationship: stringOrEmpty(r.relationship),
+    isPrimary: booleanOrFalse(r.isPrimary),
+    createdAt: dateOrEmpty(r.createdAt)
+  };
+}
+function toCustomerShallowDTO(c) {
+  return {
+    ...toCustomerDTO(c),
+    emails: arrayOrEmpty(c.emails).map(toCustomerEmailDTO),
+    phones: arrayOrEmpty(c.phones).map(toCustomerPhoneDTO),
+    addresses: arrayOrEmpty(c.addresses).map(toCustomerAddressDTO),
+    notes: arrayOrEmpty(c.notes).map(toCustomerNoteDTO),
+    tags: arrayOrEmpty(c.tags)
+  };
+}
+function toCustomerRelationshipExpandedDTO(r) {
+  const { id: customerId, ...customerFields } = toCustomerShallowDTO(r.customer);
+  return {
+    id: stringOrEmpty(r.id),
+    customerId,
+    relationship: stringOrEmpty(r.relationship),
+    isPrimary: booleanOrFalse(r.isPrimary),
+    ...customerFields
+  };
+}
+function toCustomerDetailDTO(c) {
+  return {
+    ...toCustomerDTO(c),
+    emails: arrayOrEmpty(c.emails).map(toCustomerEmailDTO),
+    phones: arrayOrEmpty(c.phones).map(toCustomerPhoneDTO),
+    addresses: arrayOrEmpty(c.addresses).map(toCustomerAddressDTO),
+    notes: arrayOrEmpty(c.notes).map(toCustomerNoteDTO),
+    relationships: arrayOrEmpty(c.relationships).map(toCustomerRelationshipExpandedDTO),
+    tags: arrayOrEmpty(c.tags)
+  };
+}
+function toCustomerRelationshipExpandedD2DTO(r) {
+  const { id: customerId, ...customerFields } = toCustomerShallowDTO(r.customer);
+  return {
+    id: stringOrEmpty(r.id),
+    customerId,
+    relationship: stringOrEmpty(r.relationship),
+    isPrimary: booleanOrFalse(r.isPrimary),
+    ...customerFields,
+    relationships: arrayOrEmpty(r.customer.relationships).map(toCustomerRelationshipExpandedDTO)
+  };
+}
+function toCustomerDetailD2DTO(c) {
+  return {
+    ...toCustomerDTO(c),
+    emails: arrayOrEmpty(c.emails).map(toCustomerEmailDTO),
+    phones: arrayOrEmpty(c.phones).map(toCustomerPhoneDTO),
+    addresses: arrayOrEmpty(c.addresses).map(toCustomerAddressDTO),
+    notes: arrayOrEmpty(c.notes).map(toCustomerNoteDTO),
+    relationships: arrayOrEmpty(c.relationships).map(toCustomerRelationshipExpandedD2DTO),
+    tags: arrayOrEmpty(c.tags)
+  };
+}
+function toAddressDTO(a) {
+  return {
+    countryIso: stringOrEmpty(a.countryIso),
+    subdivision1Iso: stringOrEmpty(a.subdivision1Iso),
+    subdivision2Iso: stringOrEmpty(a.subdivision2Iso),
+    zipPostalCode: stringOrEmpty(a.zipPostalCode),
+    unit: stringOrEmpty(a.unit),
+    line1: stringOrEmpty(a.line1),
+    line2: stringOrEmpty(a.line2)
+  };
+}
+function toCustomerEmailDTO(e) {
+  return {
+    id: stringOrEmpty(e.id),
+    email: stringOrEmpty(e.email),
+    label: stringOrEmpty(e.label),
+    isPrimary: booleanOrFalse(e.isPrimary),
+    createdAt: dateOrEmpty(e.createdAt)
+  };
+}
+function toCustomerPhoneDTO(p) {
+  return {
+    id: stringOrEmpty(p.id),
+    phone: stringOrEmpty(p.phone),
+    label: stringOrEmpty(p.label),
+    isPrimary: booleanOrFalse(p.isPrimary),
+    createdAt: dateOrEmpty(p.createdAt)
+  };
+}
+function toCustomerAddressDTO(ca) {
+  return {
+    id: stringOrEmpty(ca.addrId),
+    label: stringOrEmpty(ca.label),
+    isPrimary: booleanOrFalse(ca.isPrimary),
+    address: toAddressDTO(ca.address)
+  };
+}
+function toCustomerNoteDTO(n) {
+  return {
+    id: stringOrEmpty(n.id),
+    authorId: stringOrEmpty(n.authorId),
+    body: stringOrEmpty(n.body),
+    createdAt: dateOrEmpty(n.createdAt),
+    updatedAt: dateOrEmpty(n.updatedAt)
+  };
+}
+function toCustomerTagDTO(t) {
+  return {
+    tag: 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
+import { requireAuth } from "@fonderie/core/middlewares";
+import { withWorkspace } from "@fonderie/workspaces";
+
+// src/controllers/customer.controller.ts
+import { HTTP, setApiResponse } from "@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 setApiResponse(
+          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 setApiResponse(HTTP.OK, "CUSTOMERS_FETCHED", "Customers retrieved successfully.", {
+        customers: list.map(toCustomerDTO)
+      });
+    },
+    async get(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return setApiResponse(
+          HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return setApiResponse(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 setApiResponse(HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+        return setApiResponse(HTTP.OK, "CUSTOMER_FETCHED", "Customer retrieved successfully.", toCustomerDetailD2DTO(customer2));
+      }
+      const customer = await customers.findDetail(id, workspaceId);
+      if (!customer) {
+        return setApiResponse(HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      return setApiResponse(HTTP.OK, "CUSTOMER_FETCHED", "Customer retrieved successfully.", toCustomerDetailDTO(customer));
+    },
+    async create(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return setApiResponse(
+          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 setApiResponse(
+          HTTP.UNPROCESSABLE,
+          "INVALID_PARAMETER",
+          "type must be individual or business"
+        );
+      }
+      if (sex !== void 0 && sex !== "UNKNOWN" && sex !== "MALE" && sex !== "FEMALE") {
+        return setApiResponse(
+          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 setApiResponse(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 setApiResponse(HTTP.CREATED, "CUSTOMER_CREATED", "Customer created successfully.", {
+        customer: toCustomerDTO(customer)
+      });
+    },
+    async update(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return setApiResponse(
+          HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return setApiResponse(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 setApiResponse(
+            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 setApiResponse(
+            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 setApiResponse(HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      bus?.emit(EVENT_KEYS.customerUpdated, {
+        customerId: customer.id,
+        workspaceId: customer.workspaceId
+      }).catch(() => {
+      });
+      return setApiResponse(HTTP.OK, "CUSTOMER_UPDATED", "Customer updated successfully.", {
+        customer: toCustomerDTO(customer)
+      });
+    },
+    async delete(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return setApiResponse(
+          HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return setApiResponse(HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const existing = await customers.findById(id, workspaceId);
+      if (!existing) {
+        return setApiResponse(HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      await customers.delete(id, workspaceId);
+      bus?.emit(EVENT_KEYS.customerDeleted, {
+        customerId: id,
+        workspaceId
+      }).catch(() => {
+      });
+      return setApiResponse(HTTP.OK, "CUSTOMER_DELETED", "Customer deleted successfully.");
+    },
+    async blacklist(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return setApiResponse(
+          HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return setApiResponse(HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const existing = await customers.findById(id, workspaceId);
+      if (!existing) {
+        return setApiResponse(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 setApiResponse(HTTP.OK, "CUSTOMER_BLACKLISTED", "Customer blacklisted successfully.");
+    },
+    async unblacklist(ctx) {
+      const workspaceId = ctx.workspace?.id;
+      if (!workspaceId) {
+        return setApiResponse(
+          HTTP.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        );
+      }
+      const params = ctx.meta["params"];
+      const id = params?.["customerId"];
+      if (!isUuid(id)) {
+        return setApiResponse(HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID");
+      }
+      const existing = await customers.findById(id, workspaceId);
+      if (!existing) {
+        return setApiResponse(HTTP.NOT_FOUND, "NOT_FOUND", "Customer not found");
+      }
+      await customers.unblacklist(id, workspaceId);
+      bus?.emit(EVENT_KEYS.customerUnblacklisted, {
+        customerId: id,
+        workspaceId
+      }).catch(() => {
+      });
+      return setApiResponse(HTTP.OK, "CUSTOMER_UNBLACKLISTED", "Customer removed from blacklist successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-address.controller.ts
+import { HTTP as HTTP2, setApiResponse as setApiResponse2 } from "@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: setApiResponse2(
+          HTTP2.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: setApiResponse2(HTTP2.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.UNPROCESSABLE, "INVALID_PARAMETER", "countryIso is required");
+      }
+      if (typeof zipPostalCode !== "string" || zipPostalCode.trim().length === 0) {
+        return setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.CONFLICT, "DUPLICATE_ADDRESS", "This address is already linked to this customer");
+        }
+        throw err;
+      }
+      return setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.OK, "ADDRESS_UPDATED", "Address updated successfully.", {
+          address: toCustomerAddressDTO(updated)
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "NOT_FOUND") {
+          return setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.UNPROCESSABLE, "INVALID_PARAMETER", "addrId must be a valid UUID");
+      }
+      await addresses.setPrimary(addrId, r.customer.id);
+      return setApiResponse2(HTTP2.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 setApiResponse2(HTTP2.UNPROCESSABLE, "INVALID_PARAMETER", "addrId must be a valid UUID");
+      }
+      await addresses.remove(addrId, r.customer.id);
+      return setApiResponse2(HTTP2.OK, "ADDRESS_REMOVED", "Address removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-email.controller.ts
+import { HTTP as HTTP3, setApiResponse as setApiResponse3 } from "@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: setApiResponse3(
+          HTTP3.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: setApiResponse3(HTTP3.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.CONFLICT, "DUPLICATE_EMAIL", "This email is already linked to this customer");
+        }
+        throw err;
+      }
+      return setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.OK, "EMAIL_UPDATED", "Email updated successfully.", {
+          email: toCustomerEmailDTO(updated)
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "NOT_FOUND") {
+          return setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.UNPROCESSABLE, "INVALID_PARAMETER", "emailId must be a valid UUID");
+      }
+      await emails.setPrimary(emailId, r.customer.id);
+      return setApiResponse3(HTTP3.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 setApiResponse3(HTTP3.UNPROCESSABLE, "INVALID_PARAMETER", "emailId must be a valid UUID");
+      }
+      await emails.remove(emailId, r.customer.id);
+      return setApiResponse3(HTTP3.OK, "EMAIL_REMOVED", "Email removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-note.controller.ts
+import { HTTP as HTTP4, setApiResponse as setApiResponse4 } from "@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: setApiResponse4(
+          HTTP4.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id))
+      return { error: setApiResponse4(HTTP4.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer)
+      return { error: setApiResponse4(HTTP4.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 setApiResponse4(HTTP4.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 setApiResponse4(HTTP4.UNPROCESSABLE, "INVALID_PARAMETER", "body is required");
+      }
+      const note = await notes.create({
+        customerId: r.customer.id,
+        authorId: ctx.user?.id ?? null,
+        body: bodyText.trim()
+      });
+      return setApiResponse4(HTTP4.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 setApiResponse4(HTTP4.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 setApiResponse4(HTTP4.UNPROCESSABLE, "INVALID_PARAMETER", "body is required");
+      }
+      const note = await notes.update(noteId, r.customer.id, bodyText.trim());
+      if (!note) {
+        return setApiResponse4(HTTP4.NOT_FOUND, "NOT_FOUND", "Note not found");
+      }
+      return setApiResponse4(HTTP4.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 setApiResponse4(HTTP4.UNPROCESSABLE, "INVALID_PARAMETER", "noteId must be a valid UUID");
+      }
+      await notes.delete(noteId, r.customer.id);
+      return setApiResponse4(HTTP4.OK, "NOTE_DELETED", "Note deleted successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-phone.controller.ts
+import { HTTP as HTTP5, setApiResponse as setApiResponse5 } from "@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: setApiResponse5(
+          HTTP5.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: setApiResponse5(HTTP5.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.CONFLICT, "DUPLICATE_PHONE", "This phone is already linked to this customer");
+        }
+        throw err;
+      }
+      return setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.OK, "PHONE_UPDATED", "Phone updated successfully.", {
+          phone: toCustomerPhoneDTO(updated)
+        });
+      } catch (err) {
+        if (err instanceof Error && err.code === "NOT_FOUND") {
+          return setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.UNPROCESSABLE, "INVALID_PARAMETER", "phoneId must be a valid UUID");
+      }
+      await phones.setPrimary(phoneId, r.customer.id);
+      return setApiResponse5(HTTP5.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 setApiResponse5(HTTP5.UNPROCESSABLE, "INVALID_PARAMETER", "phoneId must be a valid UUID");
+      }
+      await phones.remove(phoneId, r.customer.id);
+      return setApiResponse5(HTTP5.OK, "PHONE_REMOVED", "Phone removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-tag.controller.ts
+import { HTTP as HTTP6, setApiResponse as setApiResponse6 } from "@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: setApiResponse6(
+          HTTP6.BAD_REQUEST,
+          "MISSING_WORKSPACE",
+          "Workspace context is required"
+        )
+      };
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id))
+      return { error: setApiResponse6(HTTP6.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer)
+      return { error: setApiResponse6(HTTP6.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 setApiResponse6(HTTP6.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 setApiResponse6(HTTP6.UNPROCESSABLE, "INVALID_PARAMETER", "tag is required");
+      }
+      await tags.add(r.customer.id, tag.trim());
+      return setApiResponse6(HTTP6.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 setApiResponse6(HTTP6.UNPROCESSABLE, "INVALID_PARAMETER", "tag is required");
+      }
+      await tags.remove(r.customer.id, tag);
+      return setApiResponse6(HTTP6.OK, "TAG_REMOVED", "Tag removed successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-label.controller.ts
+import { HTTP as HTTP7, setApiResponse as setApiResponse7 } from "@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 setApiResponse7(HTTP7.UNPROCESSABLE, "INVALID_PARAMETER", "type must be phone, email, or address");
+      }
+      const rows = await labels.list(type);
+      return setApiResponse7(HTTP7.OK, "LABELS_FETCHED", "Labels retrieved successfully.", { labels: rows });
+    },
+    async remove(ctx) {
+      const params = ctx.meta["params"];
+      const labelId = params?.["labelId"];
+      if (!isUuid(labelId)) {
+        return setApiResponse7(HTTP7.UNPROCESSABLE, "INVALID_PARAMETER", "labelId must be a valid UUID");
+      }
+      await labels.remove(labelId);
+      return setApiResponse7(HTTP7.OK, "LABEL_DELETED", "Label deleted successfully.");
+    }
+  };
+}
+
+// src/controllers/customer-relationship.controller.ts
+import { HTTP as HTTP8, setApiResponse as setApiResponse8 } from "@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: setApiResponse8(HTTP8.BAD_REQUEST, "MISSING_WORKSPACE", "Workspace context is required")
+      };
+    }
+    const params = ctx.meta["params"];
+    const id = params?.["customerId"];
+    if (!isUuid(id)) {
+      return { error: setApiResponse8(HTTP8.UNPROCESSABLE, "INVALID_PARAMETER", "customerId must be a valid UUID") };
+    }
+    const customer = await customers.findById(id, workspaceId);
+    if (!customer) {
+      return { error: setApiResponse8(HTTP8.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 setApiResponse8(HTTP8.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 setApiResponse8(HTTP8.UNPROCESSABLE, "INVALID_PARAMETER", "relatedId must be a valid UUID");
+      }
+      if (typeof relationship !== "string" || relationship.trim().length === 0) {
+        return setApiResponse8(HTTP8.UNPROCESSABLE, "INVALID_PARAMETER", "relationship is required");
+      }
+      if (relatedId === r.customer.id) {
+        return setApiResponse8(HTTP8.UNPROCESSABLE, "INVALID_PARAMETER", "A customer cannot be related to itself");
+      }
+      const related = await customers.findById(relatedId, r.workspaceId);
+      if (!related) {
+        return setApiResponse8(HTTP8.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 setApiResponse8(HTTP8.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 setApiResponse8(HTTP8.UNPROCESSABLE, "INVALID_PARAMETER", "relatedId must be a valid UUID");
+      }
+      await relationships.setPrimary(r.customer.id, relatedId);
+      return setApiResponse8(HTTP8.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 setApiResponse8(HTTP8.UNPROCESSABLE, "INVALID_PARAMETER", "relatedId must be a valid UUID");
+      }
+      await relationships.remove(r.customer.id, relatedId);
+      return setApiResponse8(HTTP8.OK, "RELATIONSHIP_REMOVED", "Relationship removed successfully.");
+    }
+  };
+}
+
+// src/routes.ts
+function buildCustomerRoutes(store, config, bus) {
+  const wsCtx = 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", requireAuth, wsCtx, label.list],
+    ["DELETE", "/customers/labels/:labelId", requireAuth, wsCtx, label.remove],
+    // ── Core customer CRUD ───────────────────────────────────────────
+    ["GET", "/customers", requireAuth, wsCtx, customer.list],
+    ["POST", "/customers", requireAuth, wsCtx, customer.create],
+    ["GET", "/customers/:customerId", requireAuth, wsCtx, customer.get],
+    ["PUT", "/customers/:customerId", requireAuth, wsCtx, customer.update],
+    ["DELETE", "/customers/:customerId", requireAuth, wsCtx, customer.delete],
+    ["POST", "/customers/:customerId/blacklist", requireAuth, wsCtx, customer.blacklist],
+    ["POST", "/customers/:customerId/unblacklist", requireAuth, wsCtx, customer.unblacklist],
+    // ── Emails ───────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/emails", requireAuth, wsCtx, email.list],
+    ["POST", "/customers/:customerId/emails", requireAuth, wsCtx, email.add],
+    ["PATCH", "/customers/:customerId/emails/:emailId", requireAuth, wsCtx, email.update],
+    ["PUT", "/customers/:customerId/emails/:emailId/primary", requireAuth, wsCtx, email.setPrimary],
+    ["DELETE", "/customers/:customerId/emails/:emailId", requireAuth, wsCtx, email.remove],
+    // ── Phones ───────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/phones", requireAuth, wsCtx, phone.list],
+    ["POST", "/customers/:customerId/phones", requireAuth, wsCtx, phone.add],
+    ["PATCH", "/customers/:customerId/phones/:phoneId", requireAuth, wsCtx, phone.update],
+    ["PUT", "/customers/:customerId/phones/:phoneId/primary", requireAuth, wsCtx, phone.setPrimary],
+    ["DELETE", "/customers/:customerId/phones/:phoneId", requireAuth, wsCtx, phone.remove],
+    // ── Addresses ────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/addresses", requireAuth, wsCtx, address.list],
+    ["POST", "/customers/:customerId/addresses", requireAuth, wsCtx, address.add],
+    ["PATCH", "/customers/:customerId/addresses/:addrId", requireAuth, wsCtx, address.update],
+    ["PUT", "/customers/:customerId/addresses/:addrId/primary", requireAuth, wsCtx, address.setPrimary],
+    ["DELETE", "/customers/:customerId/addresses/:addrId", requireAuth, wsCtx, address.remove],
+    // ── Notes ────────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/notes", requireAuth, wsCtx, note.list],
+    ["POST", "/customers/:customerId/notes", requireAuth, wsCtx, note.create],
+    ["PUT", "/customers/:customerId/notes/:noteId", requireAuth, wsCtx, note.update],
+    ["DELETE", "/customers/:customerId/notes/:noteId", requireAuth, wsCtx, note.delete],
+    // ── Tags ─────────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/tags", requireAuth, wsCtx, tag.list],
+    ["POST", "/customers/:customerId/tags", requireAuth, wsCtx, tag.add],
+    ["DELETE", "/customers/:customerId/tags/:tag", requireAuth, wsCtx, tag.remove],
+    // ── Relationships ────────────────────────────────────────────────────
+    ["GET", "/customers/:customerId/relationships", requireAuth, wsCtx, relationship.list],
+    ["POST", "/customers/:customerId/relationships", requireAuth, wsCtx, relationship.add],
+    ["PUT", "/customers/:customerId/relationships/:relatedId/primary", requireAuth, wsCtx, relationship.setPrimary],
+    ["DELETE", "/customers/:customerId/relationships/:relatedId", 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);
+    }
+  }
+};
+export {
+  CustomerAddressModel,
+  CustomerEmailModel,
+  CustomerModel,
+  CustomerNoteModel,
+  CustomerPhoneModel,
+  CustomerTagModel,
+  CustomersModule,
+  EVENT_KEYS,
+  toAddressDTO,
+  toCustomerAddressDTO,
+  toCustomerDTO,
+  toCustomerDetailDTO,
+  toCustomerEmailDTO,
+  toCustomerNoteDTO,
+  toCustomerPhoneDTO,
+  toCustomerTagDTO
+};
+//# sourceMappingURL=index.js.map