@voyant-travel/identity 0.119.1

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,oBAAoB,4HAU/B,CAAA;AAEF,eAAO,MAAM,gBAAgB,6HAS3B,CAAA;AAEF,eAAO,MAAM,oBAAoB,gKAW/B,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCjC,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC7B,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCjC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC5E,MAAM,MAAM,uBAAuB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC/E,MAAM,MAAM,eAAe,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAA;AACnE,MAAM,MAAM,kBAAkB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAA;AACtE,MAAM,MAAM,oBAAoB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC5E,MAAM,MAAM,uBAAuB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA"}

package/dist/schema.js

@@ -0,0 +1,102 @@
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, doublePrecision, index, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+export const contactPointKindEnum = pgEnum("contact_point_kind", [
+    "email",
+    "phone",
+    "mobile",
+    "whatsapp",
+    "website",
+    "sms",
+    "fax",
+    "social",
+    "other",
+]);
+export const addressLabelEnum = pgEnum("address_label", [
+    "primary",
+    "billing",
+    "shipping",
+    "mailing",
+    "meeting",
+    "service",
+    "legal",
+    "other",
+]);
+export const namedContactRoleEnum = pgEnum("named_contact_role", [
+    "general",
+    "primary",
+    "reservations",
+    "operations",
+    "front_desk",
+    "sales",
+    "emergency",
+    "accounting",
+    "legal",
+    "other",
+]);
+export const identityContactPoints = pgTable("identity_contact_points", {
+    id: typeId("identity_contact_points"),
+    entityType: text("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    kind: contactPointKindEnum("kind").notNull(),
+    label: text("label"),
+    value: text("value").notNull(),
+    normalizedValue: text("normalized_value"),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_identity_contact_points_entity").on(table.entityType, table.entityId),
+    index("idx_identity_contact_points_entity_primary_created").on(table.entityType, table.entityId, table.isPrimary, table.createdAt),
+    index("idx_identity_contact_points_entity_kind_primary_created").on(table.entityType, table.entityId, table.kind, table.isPrimary, table.createdAt),
+    index("idx_identity_contact_points_kind").on(table.kind),
+    index("idx_identity_contact_points_normalized").on(table.normalizedValue),
+    uniqueIndex("uidx_identity_contact_points_entity_kind_value").on(table.entityType, table.entityId, table.kind, table.value),
+]);
+export const identityAddresses = pgTable("identity_addresses", {
+    id: typeId("identity_addresses"),
+    entityType: text("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    label: addressLabelEnum("label").notNull().default("other"),
+    fullText: text("full_text"),
+    line1: text("line_1"),
+    line2: text("line_2"),
+    city: text("city"),
+    region: text("region"),
+    postalCode: text("postal_code"),
+    country: text("country"),
+    latitude: doublePrecision("latitude"),
+    longitude: doublePrecision("longitude"),
+    timezone: text("timezone"),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_identity_addresses_entity").on(table.entityType, table.entityId),
+    index("idx_identity_addresses_entity_primary_created").on(table.entityType, table.entityId, table.isPrimary, table.createdAt),
+    index("idx_identity_addresses_label").on(table.label),
+]);
+export const identityNamedContacts = pgTable("identity_named_contacts", {
+    id: typeId("identity_named_contacts"),
+    entityType: text("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    role: namedContactRoleEnum("role").notNull().default("general"),
+    name: text("name").notNull(),
+    title: text("title"),
+    email: text("email"),
+    phone: text("phone"),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_identity_named_contacts_entity").on(table.entityType, table.entityId),
+    index("idx_identity_named_contacts_entity_primary_created").on(table.entityType, table.entityId, table.isPrimary, table.createdAt),
+    index("idx_identity_named_contacts_entity_role_primary_created").on(table.entityType, table.entityId, table.role, table.isPrimary, table.createdAt),
+    index("idx_identity_named_contacts_role").on(table.role),
+    index("idx_identity_named_contacts_primary").on(table.isPrimary),
+]);

package/dist/service.d.ts

@@ -0,0 +1,290 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { addressListQuerySchema, contactPointListQuerySchema, insertAddressSchema, insertContactPointSchema, insertNamedContactSchema, namedContactListQuerySchema, updateAddressSchema, updateContactPointSchema, updateNamedContactSchema } from "./validation.js";
+type ContactPointListQuery = z.infer<typeof contactPointListQuerySchema>;
+type CreateContactPointInput = z.infer<typeof insertContactPointSchema>;
+type UpdateContactPointInput = z.infer<typeof updateContactPointSchema>;
+type AddressListQuery = z.infer<typeof addressListQuerySchema>;
+type CreateAddressInput = z.infer<typeof insertAddressSchema>;
+type UpdateAddressInput = z.infer<typeof updateAddressSchema>;
+type NamedContactListQuery = z.infer<typeof namedContactListQuerySchema>;
+type CreateNamedContactInput = z.infer<typeof insertNamedContactSchema>;
+type UpdateNamedContactInput = z.infer<typeof updateNamedContactSchema>;
+export declare const identityService: {
+    listContactPoints(db: PostgresJsDatabase, query: ContactPointListQuery): Promise<{
+        data: {
+            id: string;
+            entityType: string;
+            entityId: string;
+            kind: "other" | "email" | "phone" | "mobile" | "whatsapp" | "website" | "sms" | "fax" | "social";
+            label: string | null;
+            value: string;
+            normalizedValue: string | null;
+            isPrimary: boolean;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    listContactPointsForEntity(db: PostgresJsDatabase, entityType: string, entityId: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        kind: "other" | "email" | "phone" | "mobile" | "whatsapp" | "website" | "sms" | "fax" | "social";
+        label: string | null;
+        value: string;
+        normalizedValue: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    getContactPointById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        kind: "other" | "email" | "phone" | "mobile" | "whatsapp" | "website" | "sms" | "fax" | "social";
+        label: string | null;
+        value: string;
+        normalizedValue: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createContactPoint(db: PostgresJsDatabase, data: CreateContactPointInput): Promise<{
+        value: string;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: Date;
+        notes: string | null;
+        updatedAt: Date;
+        entityType: string;
+        entityId: string;
+        kind: "other" | "email" | "phone" | "mobile" | "whatsapp" | "website" | "sms" | "fax" | "social";
+        label: string | null;
+        normalizedValue: string | null;
+        isPrimary: boolean;
+    } | null>;
+    updateContactPoint(db: PostgresJsDatabase, id: string, data: UpdateContactPointInput): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        kind: "other" | "email" | "phone" | "mobile" | "whatsapp" | "website" | "sms" | "fax" | "social";
+        label: string | null;
+        value: string;
+        normalizedValue: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteContactPoint(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listAddresses(db: PostgresJsDatabase, query: AddressListQuery): Promise<{
+        data: {
+            id: string;
+            entityType: string;
+            entityId: string;
+            label: "service" | "primary" | "other" | "billing" | "shipping" | "mailing" | "meeting" | "legal";
+            fullText: string | null;
+            line1: string | null;
+            line2: string | null;
+            city: string | null;
+            region: string | null;
+            postalCode: string | null;
+            country: string | null;
+            latitude: number | null;
+            longitude: number | null;
+            timezone: string | null;
+            isPrimary: boolean;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    listAddressesForEntity(db: PostgresJsDatabase, entityType: string, entityId: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        label: "service" | "primary" | "other" | "billing" | "shipping" | "mailing" | "meeting" | "legal";
+        fullText: string | null;
+        line1: string | null;
+        line2: string | null;
+        city: string | null;
+        region: string | null;
+        postalCode: string | null;
+        country: string | null;
+        latitude: number | null;
+        longitude: number | null;
+        timezone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    getAddressById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        label: "service" | "primary" | "other" | "billing" | "shipping" | "mailing" | "meeting" | "legal";
+        fullText: string | null;
+        line1: string | null;
+        line2: string | null;
+        city: string | null;
+        region: string | null;
+        postalCode: string | null;
+        country: string | null;
+        latitude: number | null;
+        longitude: number | null;
+        timezone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createAddress(db: PostgresJsDatabase, data: CreateAddressInput): Promise<{
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: Date;
+        notes: string | null;
+        updatedAt: Date;
+        entityType: string;
+        entityId: string;
+        label: "service" | "primary" | "other" | "billing" | "shipping" | "mailing" | "meeting" | "legal";
+        isPrimary: boolean;
+        fullText: string | null;
+        line1: string | null;
+        line2: string | null;
+        city: string | null;
+        region: string | null;
+        postalCode: string | null;
+        country: string | null;
+        latitude: number | null;
+        longitude: number | null;
+        timezone: string | null;
+    } | null>;
+    updateAddress(db: PostgresJsDatabase, id: string, data: UpdateAddressInput): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        label: "service" | "primary" | "other" | "billing" | "shipping" | "mailing" | "meeting" | "legal";
+        fullText: string | null;
+        line1: string | null;
+        line2: string | null;
+        city: string | null;
+        region: string | null;
+        postalCode: string | null;
+        country: string | null;
+        latitude: number | null;
+        longitude: number | null;
+        timezone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteAddress(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listNamedContacts(db: PostgresJsDatabase, query: NamedContactListQuery): Promise<{
+        data: {
+            id: string;
+            entityType: string;
+            entityId: string;
+            role: "primary" | "other" | "operations" | "legal" | "general" | "reservations" | "front_desk" | "sales" | "emergency" | "accounting";
+            name: string;
+            title: string | null;
+            email: string | null;
+            phone: string | null;
+            isPrimary: boolean;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    listNamedContactsForEntity(db: PostgresJsDatabase, entityType: string, entityId: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        role: "primary" | "other" | "operations" | "legal" | "general" | "reservations" | "front_desk" | "sales" | "emergency" | "accounting";
+        name: string;
+        title: string | null;
+        email: string | null;
+        phone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    getNamedContactById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        role: "primary" | "other" | "operations" | "legal" | "general" | "reservations" | "front_desk" | "sales" | "emergency" | "accounting";
+        name: string;
+        title: string | null;
+        email: string | null;
+        phone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createNamedContact(db: PostgresJsDatabase, data: CreateNamedContactInput): Promise<{
+        metadata: Record<string, unknown> | null;
+        id: string;
+        name: string;
+        createdAt: Date;
+        notes: string | null;
+        email: string | null;
+        updatedAt: Date;
+        phone: string | null;
+        entityType: string;
+        entityId: string;
+        isPrimary: boolean;
+        role: "primary" | "other" | "operations" | "legal" | "general" | "reservations" | "front_desk" | "sales" | "emergency" | "accounting";
+        title: string | null;
+    } | null>;
+    updateNamedContact(db: PostgresJsDatabase, id: string, data: UpdateNamedContactInput): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        role: "primary" | "other" | "operations" | "legal" | "general" | "reservations" | "front_desk" | "sales" | "emergency" | "accounting";
+        name: string;
+        title: string | null;
+        email: string | null;
+        phone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteNamedContact(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC3B,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,iBAAiB,CAAA;AAExB,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACxE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC9D,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACxE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAgEvE,eAAO,MAAM,eAAe;0BACE,kBAAkB,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;mCA+BvC,kBAAkB,cAAc,MAAM,YAAY,MAAM;;;;;;;;;;;;;;4BAa/D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;2BAS/B,kBAAkB,QAAQ,uBAAuB;;;;;;;;;;;;;;2BAajD,kBAAkB,MAAM,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;2BAyB7D,kBAAkB,MAAM,MAAM;;;sBAQnC,kBAAkB,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;+BA8BlC,kBAAkB,cAAc,MAAM,YAAY,MAAM;;;;;;;;;;;;;;;;;;;;;uBAUhE,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;sBAS/B,kBAAkB,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;sBAY5C,kBAAkB,MAAM,MAAM,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;sBAuBxD,kBAAkB,MAAM,MAAM;;;0BAQ1B,kBAAkB,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;mCAoCvC,kBAAkB,cAAc,MAAM,YAAY,MAAM;;;;;;;;;;;;;;;4BAa/D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;2BAS/B,kBAAkB,QAAQ,uBAAuB;;;;;;;;;;;;;;;2BAYjD,kBAAkB,MAAM,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;;2BAuB7D,kBAAkB,MAAM,MAAM;;;CAO5D,CAAA"}

package/dist/service.js

@@ -0,0 +1,284 @@
+import { and, desc, eq, ne, sql } from "drizzle-orm";
+import { identityAddresses, identityContactPoints, identityNamedContacts } from "./schema.js";
+async function paginate(rowsQuery, countQuery, limit, offset) {
+    const [data, countResult] = await Promise.all([rowsQuery, countQuery]);
+    return { data, total: countResult[0]?.count ?? 0, limit, offset };
+}
+async function ensurePrimaryContactPoint(db, params) {
+    const conditions = [
+        eq(identityContactPoints.entityType, params.entityType),
+        eq(identityContactPoints.entityId, params.entityId),
+        eq(identityContactPoints.kind, params.kind),
+    ];
+    if (params.id)
+        conditions.push(ne(identityContactPoints.id, params.id));
+    await db
+        .update(identityContactPoints)
+        .set({ isPrimary: false, updatedAt: new Date() })
+        .where(and(...conditions));
+}
+async function ensurePrimaryAddress(db, params) {
+    const conditions = [
+        eq(identityAddresses.entityType, params.entityType),
+        eq(identityAddresses.entityId, params.entityId),
+    ];
+    if (params.id)
+        conditions.push(ne(identityAddresses.id, params.id));
+    await db
+        .update(identityAddresses)
+        .set({ isPrimary: false, updatedAt: new Date() })
+        .where(and(...conditions));
+}
+async function ensurePrimaryNamedContact(db, params) {
+    const conditions = [
+        eq(identityNamedContacts.entityType, params.entityType),
+        eq(identityNamedContacts.entityId, params.entityId),
+    ];
+    if (params.id)
+        conditions.push(ne(identityNamedContacts.id, params.id));
+    await db
+        .update(identityNamedContacts)
+        .set({ isPrimary: false, updatedAt: new Date() })
+        .where(and(...conditions));
+}
+export const identityService = {
+    async listContactPoints(db, query) {
+        const conditions = [];
+        if (query.entityType)
+            conditions.push(eq(identityContactPoints.entityType, query.entityType));
+        if (query.entityId)
+            conditions.push(eq(identityContactPoints.entityId, query.entityId));
+        if (query.kind)
+            conditions.push(eq(identityContactPoints.kind, query.kind));
+        if (query.isPrimary !== undefined) {
+            conditions.push(eq(identityContactPoints.isPrimary, query.isPrimary));
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(
+            // agent-quality: raw-sql reviewed -- owner: identity; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `(${identityContactPoints.value} ILIKE ${term} OR ${identityContactPoints.normalizedValue} ILIKE ${term})`);
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(identityContactPoints)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(identityContactPoints.isPrimary), identityContactPoints.createdAt), db.select({ count: sql `count(*)::int` }).from(identityContactPoints).where(where), query.limit, query.offset);
+    },
+    async listContactPointsForEntity(db, entityType, entityId) {
+        return db
+            .select()
+            .from(identityContactPoints)
+            .where(and(eq(identityContactPoints.entityType, entityType), eq(identityContactPoints.entityId, entityId)))
+            .orderBy(desc(identityContactPoints.isPrimary), identityContactPoints.createdAt);
+    },
+    async getContactPointById(db, id) {
+        const [row] = await db
+            .select()
+            .from(identityContactPoints)
+            .where(eq(identityContactPoints.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createContactPoint(db, data) {
+        if (data.isPrimary) {
+            await ensurePrimaryContactPoint(db, {
+                entityType: data.entityType,
+                entityId: data.entityId,
+                kind: data.kind,
+            });
+        }
+        const [row] = await db.insert(identityContactPoints).values(data).returning();
+        return row ?? null;
+    },
+    async updateContactPoint(db, id, data) {
+        const existing = await this.getContactPointById(db, id);
+        if (!existing)
+            return null;
+        const nextEntityType = data.entityType ?? existing.entityType;
+        const nextEntityId = data.entityId ?? existing.entityId;
+        const nextKind = data.kind ?? existing.kind;
+        if (data.isPrimary) {
+            await ensurePrimaryContactPoint(db, {
+                id,
+                entityType: nextEntityType,
+                entityId: nextEntityId,
+                kind: nextKind,
+            });
+        }
+        const [row] = await db
+            .update(identityContactPoints)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(identityContactPoints.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteContactPoint(db, id) {
+        const [row] = await db
+            .delete(identityContactPoints)
+            .where(eq(identityContactPoints.id, id))
+            .returning({ id: identityContactPoints.id });
+        return row ?? null;
+    },
+    async listAddresses(db, query) {
+        const conditions = [];
+        if (query.entityType)
+            conditions.push(eq(identityAddresses.entityType, query.entityType));
+        if (query.entityId)
+            conditions.push(eq(identityAddresses.entityId, query.entityId));
+        if (query.label)
+            conditions.push(eq(identityAddresses.label, query.label));
+        if (query.isPrimary !== undefined)
+            conditions.push(eq(identityAddresses.isPrimary, query.isPrimary));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(
+            // agent-quality: raw-sql reviewed -- owner: identity; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `(${identityAddresses.fullText} ILIKE ${term} OR ${identityAddresses.line1} ILIKE ${term} OR ${identityAddresses.city} ILIKE ${term})`);
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(identityAddresses)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(identityAddresses.isPrimary), identityAddresses.createdAt), db.select({ count: sql `count(*)::int` }).from(identityAddresses).where(where), query.limit, query.offset);
+    },
+    async listAddressesForEntity(db, entityType, entityId) {
+        return db
+            .select()
+            .from(identityAddresses)
+            .where(and(eq(identityAddresses.entityType, entityType), eq(identityAddresses.entityId, entityId)))
+            .orderBy(desc(identityAddresses.isPrimary), identityAddresses.createdAt);
+    },
+    async getAddressById(db, id) {
+        const [row] = await db
+            .select()
+            .from(identityAddresses)
+            .where(eq(identityAddresses.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createAddress(db, data) {
+        if (data.isPrimary) {
+            await ensurePrimaryAddress(db, {
+                entityType: data.entityType,
+                entityId: data.entityId,
+            });
+        }
+        const [row] = await db.insert(identityAddresses).values(data).returning();
+        return row ?? null;
+    },
+    async updateAddress(db, id, data) {
+        const existing = await this.getAddressById(db, id);
+        if (!existing)
+            return null;
+        const nextEntityType = data.entityType ?? existing.entityType;
+        const nextEntityId = data.entityId ?? existing.entityId;
+        if (data.isPrimary) {
+            await ensurePrimaryAddress(db, {
+                id,
+                entityType: nextEntityType,
+                entityId: nextEntityId,
+            });
+        }
+        const [row] = await db
+            .update(identityAddresses)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(identityAddresses.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteAddress(db, id) {
+        const [row] = await db
+            .delete(identityAddresses)
+            .where(eq(identityAddresses.id, id))
+            .returning({ id: identityAddresses.id });
+        return row ?? null;
+    },
+    async listNamedContacts(db, query) {
+        const conditions = [];
+        if (query.entityType)
+            conditions.push(eq(identityNamedContacts.entityType, query.entityType));
+        if (query.entityId)
+            conditions.push(eq(identityNamedContacts.entityId, query.entityId));
+        if (query.role)
+            conditions.push(eq(identityNamedContacts.role, query.role));
+        if (query.isPrimary !== undefined) {
+            conditions.push(eq(identityNamedContacts.isPrimary, query.isPrimary));
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(sql `(
+          ${identityNamedContacts.name} ILIKE ${term}
+          OR ${identityNamedContacts.title} ILIKE ${term}
+          OR ${identityNamedContacts.email} ILIKE ${term}
+          OR ${identityNamedContacts.phone} ILIKE ${term}
+        )`);
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(identityNamedContacts)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(identityNamedContacts.isPrimary), identityNamedContacts.createdAt), db.select({ count: sql `count(*)::int` }).from(identityNamedContacts).where(where), query.limit, query.offset);
+    },
+    async listNamedContactsForEntity(db, entityType, entityId) {
+        return db
+            .select()
+            .from(identityNamedContacts)
+            .where(and(eq(identityNamedContacts.entityType, entityType), eq(identityNamedContacts.entityId, entityId)))
+            .orderBy(desc(identityNamedContacts.isPrimary), identityNamedContacts.createdAt);
+    },
+    async getNamedContactById(db, id) {
+        const [row] = await db
+            .select()
+            .from(identityNamedContacts)
+            .where(eq(identityNamedContacts.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createNamedContact(db, data) {
+        if (data.isPrimary) {
+            await ensurePrimaryNamedContact(db, {
+                entityType: data.entityType,
+                entityId: data.entityId,
+            });
+        }
+        const [row] = await db.insert(identityNamedContacts).values(data).returning();
+        return row ?? null;
+    },
+    async updateNamedContact(db, id, data) {
+        const existing = await this.getNamedContactById(db, id);
+        if (!existing)
+            return null;
+        const nextEntityType = data.entityType ?? existing.entityType;
+        const nextEntityId = data.entityId ?? existing.entityId;
+        if (data.isPrimary) {
+            await ensurePrimaryNamedContact(db, {
+                id,
+                entityType: nextEntityType,
+                entityId: nextEntityId,
+            });
+        }
+        const [row] = await db
+            .update(identityNamedContacts)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(identityNamedContacts.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteNamedContact(db, id) {
+        const [row] = await db
+            .delete(identityNamedContacts)
+            .where(eq(identityNamedContacts.id, id))
+            .returning({ id: identityNamedContacts.id });
+        return row ?? null;
+    },
+};