@voyantjs/suppliers 0.2.0 → 0.3.0

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACd,eAAe,EACf,aAAa,EACb,cAAc,EACf,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,UAAU,EACV,aAAa,EACb,cAAc,EACd,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,SAAS,EACT,YAAY,EACZ,cAAc,EACd,UAAU,EACV,aAAa,EACd,MAAM,yBAAyB,CAAA;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC5B,CAAA"}

package/dist/service.js

@@ -1,602 +1,38 @@
-import { identityAddresses, identityContactPoints, identityNamedContacts, } from "@voyantjs/identity/schema";
-import { identityService } from "@voyantjs/identity/service";
-import { and, asc, desc, eq, gte, inArray, lte, sql } from "drizzle-orm";
-import { supplierAvailability, supplierContracts, supplierNotes, supplierRates, supplierServices, suppliers, } from "./schema.js";
-const supplierEntityType = "supplier";
-const supplierBaseIdentitySource = "suppliers.base";
-const supplierPrimaryNamedContactSource = "suppliers.primary_contact";
-function normalizeContactValue(kind, value) {
-    if (kind === "email") {
-        return value.trim().toLowerCase();
-    }
-    if (kind === "website") {
-        return value.trim().toLowerCase();
-    }
-    return value.trim();
-}
-function isManagedBySource(metadata, source) {
-    return metadata?.managedBy === source;
-}
-function toNullableTrimmed(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : null;
-}
-function formatAddress(address) {
-    if (address.fullText) {
-        return address.fullText;
-    }
-    const parts = [
-        address.line1,
-        address.line2,
-        address.city,
-        address.region,
-        address.postalCode,
-        address.country,
-    ].filter(Boolean);
-    return parts.length > 0 ? parts.join(", ") : null;
-}
-async function syncSupplierIdentity(db, supplierId, data) {
-    const existingContactPoints = await identityService.listContactPointsForEntity(db, supplierEntityType, supplierId);
-    const existingAddresses = await identityService.listAddressesForEntity(db, supplierEntityType, supplierId);
-    const existingNamedContacts = await identityService.listNamedContactsForEntity(db, supplierEntityType, supplierId);
-    const managedContactPoints = existingContactPoints.filter((point) => isManagedBySource(point.metadata, supplierBaseIdentitySource));
-    const managedAddress = existingAddresses.find((address) => isManagedBySource(address.metadata, supplierBaseIdentitySource));
-    const managedPrimaryContact = existingNamedContacts.find((contact) => isManagedBySource(contact.metadata, supplierPrimaryNamedContactSource));
-    for (const [kind, rawValue] of Object.entries({
-        email: data.email,
-        phone: data.phone,
-        website: data.website,
-    })) {
-        const value = toNullableTrimmed(rawValue);
-        const existing = managedContactPoints.find((point) => point.kind === kind) ??
-            existingContactPoints.find((point) => point.kind === kind && point.isPrimary);
-        if (!value) {
-            if (existing) {
-                await identityService.deleteContactPoint(db, existing.id);
-            }
-            continue;
-        }
-        const payload = {
-            entityType: supplierEntityType,
-            entityId: supplierId,
-            kind,
-            label: kind === "website" ? "website" : "primary",
-            value,
-            normalizedValue: normalizeContactValue(kind, value),
-            isPrimary: true,
-            metadata: {
-                managedBy: supplierBaseIdentitySource,
-            },
-        };
-        if (existing) {
-            await identityService.updateContactPoint(db, existing.id, payload);
-        }
-        else {
-            await identityService.createContactPoint(db, payload);
-        }
-    }
-    const addressLine = toNullableTrimmed(data.address);
-    const city = toNullableTrimmed(data.city);
-    const country = toNullableTrimmed(data.country);
-    const hasAddress = Boolean(addressLine || city || country);
-    if (!hasAddress) {
-        if (managedAddress) {
-            await identityService.deleteAddress(db, managedAddress.id);
-        }
-    }
-    else {
-        const addressPayload = {
-            entityType: supplierEntityType,
-            entityId: supplierId,
-            label: "primary",
-            fullText: addressLine,
-            line1: addressLine,
-            city,
-            country,
-            isPrimary: true,
-            metadata: {
-                managedBy: supplierBaseIdentitySource,
-            },
-        };
-        if (managedAddress) {
-            await identityService.updateAddress(db, managedAddress.id, addressPayload);
-        }
-        else {
-            await identityService.createAddress(db, addressPayload);
-        }
-    }
-    const contactName = toNullableTrimmed(data.contactName);
-    const contactEmail = toNullableTrimmed(data.contactEmail);
-    const contactPhone = toNullableTrimmed(data.contactPhone);
-    const hasPrimaryContact = Boolean(contactName || contactEmail || contactPhone);
-    if (!hasPrimaryContact) {
-        if (managedPrimaryContact) {
-            await identityService.deleteNamedContact(db, managedPrimaryContact.id);
-        }
-        return;
-    }
-    const namedContactPayload = {
-        entityType: supplierEntityType,
-        entityId: supplierId,
-        role: "primary",
-        name: contactName ?? contactEmail ?? contactPhone ?? "Primary contact",
-        email: contactEmail,
-        phone: contactPhone,
-        isPrimary: true,
-        metadata: {
-            managedBy: supplierPrimaryNamedContactSource,
-        },
-    };
-    if (managedPrimaryContact) {
-        await identityService.updateNamedContact(db, managedPrimaryContact.id, namedContactPayload);
-    }
-    else {
-        await identityService.createNamedContact(db, namedContactPayload);
-    }
-}
-async function hydrateSuppliers(db, rows) {
-    if (rows.length === 0) {
-        return rows.map((row) => ({
-            ...row,
-            email: null,
-            phone: null,
-            website: null,
-            address: null,
-            city: null,
-            country: null,
-            contactName: null,
-            contactEmail: null,
-            contactPhone: null,
-        }));
-    }
-    const ids = rows.map((row) => row.id);
-    const [contactPoints, addresses, namedContacts] = await Promise.all([
-        db
-            .select()
-            .from(identityContactPoints)
-            .where(and(eq(identityContactPoints.entityType, supplierEntityType), inArray(identityContactPoints.entityId, ids))),
-        db
-            .select()
-            .from(identityAddresses)
-            .where(and(eq(identityAddresses.entityType, supplierEntityType), inArray(identityAddresses.entityId, ids))),
-        db
-            .select()
-            .from(identityNamedContacts)
-            .where(and(eq(identityNamedContacts.entityType, supplierEntityType), inArray(identityNamedContacts.entityId, ids))),
-    ]);
-    const contactPointMap = new Map();
-    const addressMap = new Map();
-    const namedContactMap = new Map();
-    for (const point of contactPoints) {
-        const bucket = contactPointMap.get(point.entityId) ?? [];
-        bucket.push(point);
-        contactPointMap.set(point.entityId, bucket);
-    }
-    for (const address of addresses) {
-        const bucket = addressMap.get(address.entityId) ?? [];
-        bucket.push(address);
-        addressMap.set(address.entityId, bucket);
-    }
-    for (const contact of namedContacts) {
-        const bucket = namedContactMap.get(contact.entityId) ?? [];
-        bucket.push(contact);
-        namedContactMap.set(contact.entityId, bucket);
-    }
-    return rows.map((row) => {
-        const entityContactPoints = contactPointMap.get(row.id) ?? [];
-        const entityAddresses = addressMap.get(row.id) ?? [];
-        const entityNamedContacts = namedContactMap.get(row.id) ?? [];
-        const pickContactValue = (kind) => entityContactPoints.find((point) => point.kind === kind && point.isPrimary)?.value ??
-            entityContactPoints.find((point) => point.kind === kind)?.value ??
-            null;
-        const primaryAddress = entityAddresses.find((address) => address.isPrimary) ?? entityAddresses[0] ?? null;
-        const primaryContact = entityNamedContacts.find((contact) => contact.isPrimary) ?? entityNamedContacts[0] ?? null;
-        return {
-            ...row,
-            email: pickContactValue("email"),
-            phone: pickContactValue("phone"),
-            website: pickContactValue("website"),
-            address: primaryAddress ? formatAddress(primaryAddress) : null,
-            city: primaryAddress?.city ?? null,
-            country: primaryAddress?.country ?? null,
-            contactName: primaryContact?.name ?? null,
-            contactEmail: primaryContact?.email ?? null,
-            contactPhone: primaryContact?.phone ?? null,
-        };
-    });
-}
+import { createSupplier, deleteSupplier, getSupplierById, listSuppliers, updateSupplier, } from "./service-core.js";
+import { createAddress, createContactPoint, createNamedContact, deleteAddress, deleteContactPoint, deleteNamedContact, listAddresses, listContactPoints, listNamedContacts, updateAddress, updateContactPoint, updateNamedContact, } from "./service-identity.js";
+import { createAvailability, createContract, createNote, createRate, createService, deleteContract, deleteRate, deleteService, listAvailability, listContracts, listNotes, listRates, listServices, updateContract, updateRate, updateService, } from "./service-operations.js";
 export const suppliersService = {
-    async listSuppliers(db, query) {
-        const conditions = [];
-        if (query.type) {
-            conditions.push(eq(suppliers.type, query.type));
-        }
-        if (query.status) {
-            conditions.push(eq(suppliers.status, query.status));
-        }
-        if (query.primaryFacilityId) {
-            conditions.push(eq(suppliers.primaryFacilityId, query.primaryFacilityId));
-        }
-        if (query.search) {
-            const term = `%${query.search}%`;
-            conditions.push(sql `(
-          ${suppliers.name} ilike ${term}
-          or
-          exists (
-            select 1
-            from ${identityContactPoints}
-            where ${identityContactPoints.entityType} = ${supplierEntityType}
-              and ${identityContactPoints.entityId} = ${suppliers.id}
-              and (
-                ${identityContactPoints.value} ilike ${term}
-                or ${identityContactPoints.normalizedValue} ilike ${term}
-              )
-          )
-          or exists (
-            select 1
-            from ${identityNamedContacts}
-            where ${identityNamedContacts.entityType} = ${supplierEntityType}
-              and ${identityNamedContacts.entityId} = ${suppliers.id}
-              and (
-                ${identityNamedContacts.name} ilike ${term}
-                or ${identityNamedContacts.email} ilike ${term}
-                or ${identityNamedContacts.phone} ilike ${term}
-              )
-          )
-          or exists (
-            select 1
-            from ${identityAddresses}
-            where ${identityAddresses.entityType} = ${supplierEntityType}
-              and ${identityAddresses.entityId} = ${suppliers.id}
-              and (
-                ${identityAddresses.fullText} ilike ${term}
-                or ${identityAddresses.city} ilike ${term}
-                or ${identityAddresses.country} ilike ${term}
-              )
-          )
-        )`);
-        }
-        const where = conditions.length > 0 ? and(...conditions) : undefined;
-        const [rows, countResult] = await Promise.all([
-            db
-                .select()
-                .from(suppliers)
-                .where(where)
-                .limit(query.limit)
-                .offset(query.offset)
-                .orderBy(suppliers.createdAt),
-            db.select({ count: sql `count(*)::int` }).from(suppliers).where(where),
-        ]);
-        return {
-            data: await hydrateSuppliers(db, rows),
-            total: countResult[0]?.count ?? 0,
-            limit: query.limit,
-            offset: query.offset,
-        };
-    },
-    async getSupplierById(db, id) {
-        const [row] = await db.select().from(suppliers).where(eq(suppliers.id, id)).limit(1);
-        if (!row) {
-            return null;
-        }
-        const [hydrated] = await hydrateSuppliers(db, [row]);
-        return hydrated ?? null;
-    },
-    async createSupplier(db, data) {
-        const { email, phone, website, address, city, country, contactName, contactEmail, contactPhone, ...supplierValues } = data;
-        const [row] = await db.insert(suppliers).values(supplierValues).returning();
-        if (!row) {
-            throw new Error("Failed to create supplier");
-        }
-        await syncSupplierIdentity(db, row.id, {
-            email,
-            phone,
-            website,
-            address,
-            city,
-            country,
-            contactName,
-            contactEmail,
-            contactPhone,
-        });
-        return {
-            ...row,
-            email: email ?? null,
-            phone: phone ?? null,
-            website: website ?? null,
-            address: address ?? null,
-            city: city ?? null,
-            country: country ?? null,
-            contactName: contactName ?? null,
-            contactEmail: contactEmail ?? null,
-            contactPhone: contactPhone ?? null,
-        };
-    },
-    async updateSupplier(db, id, data) {
-        const existing = await this.getSupplierById(db, id);
-        if (!existing) {
-            return null;
-        }
-        const { email, phone, website, address, city, country, contactName, contactEmail, contactPhone, ...supplierValues } = data;
-        const [row] = await db
-            .update(suppliers)
-            .set({ ...supplierValues, updatedAt: new Date() })
-            .where(eq(suppliers.id, id))
-            .returning();
-        if (!row) {
-            return null;
-        }
-        await syncSupplierIdentity(db, id, {
-            email: email ?? existing.email,
-            phone: phone ?? existing.phone,
-            website: website ?? existing.website,
-            address: address ?? existing.address,
-            city: city ?? existing.city,
-            country: country ?? existing.country,
-            contactName: contactName ?? existing.contactName,
-            contactEmail: contactEmail ?? existing.contactEmail,
-            contactPhone: contactPhone ?? existing.contactPhone,
-        });
-        return {
-            ...row,
-            email: email ?? existing.email,
-            phone: phone ?? existing.phone,
-            website: website ?? existing.website,
-            address: address ?? existing.address,
-            city: city ?? existing.city,
-            country: country ?? existing.country,
-            contactName: contactName ?? existing.contactName,
-            contactEmail: contactEmail ?? existing.contactEmail,
-            contactPhone: contactPhone ?? existing.contactPhone,
-        };
-    },
-    async deleteSupplier(db, id) {
-        const [row] = await db
-            .delete(suppliers)
-            .where(eq(suppliers.id, id))
-            .returning({ id: suppliers.id });
-        return row ?? null;
-    },
-    listContactPoints(db, supplierId) {
-        return identityService.listContactPointsForEntity(db, supplierEntityType, supplierId);
-    },
-    listNamedContacts(db, supplierId) {
-        return identityService.listNamedContactsForEntity(db, supplierEntityType, supplierId);
-    },
-    async createNamedContact(db, supplierId, data) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        return identityService.createNamedContact(db, {
-            ...data,
-            entityType: supplierEntityType,
-            entityId: supplierId,
-        });
-    },
-    updateNamedContact(db, contactId, data) {
-        return identityService.updateNamedContact(db, contactId, data);
-    },
-    deleteNamedContact(db, contactId) {
-        return identityService.deleteNamedContact(db, contactId);
-    },
-    async createContactPoint(db, supplierId, data) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        return identityService.createContactPoint(db, {
-            ...data,
-            entityType: supplierEntityType,
-            entityId: supplierId,
-        });
-    },
-    updateContactPoint(db, contactPointId, data) {
-        return identityService.updateContactPoint(db, contactPointId, data);
-    },
-    deleteContactPoint(db, contactPointId) {
-        return identityService.deleteContactPoint(db, contactPointId);
-    },
-    listAddresses(db, supplierId) {
-        return identityService.listAddressesForEntity(db, supplierEntityType, supplierId);
-    },
-    async createAddress(db, supplierId, data) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        return identityService.createAddress(db, {
-            ...data,
-            entityType: supplierEntityType,
-            entityId: supplierId,
-        });
-    },
-    updateAddress(db, addressId, data) {
-        return identityService.updateAddress(db, addressId, data);
-    },
-    deleteAddress(db, addressId) {
-        return identityService.deleteAddress(db, addressId);
-    },
-    listServices(db, supplierId) {
-        return db
-            .select()
-            .from(supplierServices)
-            .where(eq(supplierServices.supplierId, supplierId))
-            .orderBy(supplierServices.createdAt);
-    },
-    async createService(db, supplierId, data) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        const [row] = await db
-            .insert(supplierServices)
-            .values({ ...data, supplierId })
-            .returning();
-        return row ?? null;
-    },
-    async updateService(db, serviceId, data) {
-        const [row] = await db
-            .update(supplierServices)
-            .set({ ...data, updatedAt: new Date() })
-            .where(eq(supplierServices.id, serviceId))
-            .returning();
-        return row ?? null;
-    },
-    async deleteService(db, serviceId) {
-        const [row] = await db
-            .delete(supplierServices)
-            .where(eq(supplierServices.id, serviceId))
-            .returning({ id: supplierServices.id });
-        return row ?? null;
-    },
-    listRates(db, serviceId) {
-        return db
-            .select()
-            .from(supplierRates)
-            .where(eq(supplierRates.serviceId, serviceId))
-            .orderBy(supplierRates.createdAt);
-    },
-    async createRate(db, serviceId, data) {
-        const [service] = await db
-            .select({ id: supplierServices.id })
-            .from(supplierServices)
-            .where(eq(supplierServices.id, serviceId))
-            .limit(1);
-        if (!service) {
-            return null;
-        }
-        const [row] = await db
-            .insert(supplierRates)
-            .values({ ...data, serviceId })
-            .returning();
-        return row;
-    },
-    async updateRate(db, rateId, data) {
-        const [row] = await db
-            .update(supplierRates)
-            .set(data)
-            .where(eq(supplierRates.id, rateId))
-            .returning();
-        return row ?? null;
-    },
-    async deleteRate(db, rateId) {
-        const [row] = await db
-            .delete(supplierRates)
-            .where(eq(supplierRates.id, rateId))
-            .returning({ id: supplierRates.id });
-        return row ?? null;
-    },
-    listNotes(db, supplierId) {
-        return db
-            .select()
-            .from(supplierNotes)
-            .where(eq(supplierNotes.supplierId, supplierId))
-            .orderBy(supplierNotes.createdAt);
-    },
-    async createNote(db, supplierId, userId, data) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        const [row] = await db
-            .insert(supplierNotes)
-            .values({
-            supplierId,
-            authorId: userId,
-            content: data.content,
-        })
-            .returning();
-        return row;
-    },
-    async listAvailability(db, supplierId, query) {
-        const conditions = [eq(supplierAvailability.supplierId, supplierId)];
-        if (query.from) {
-            conditions.push(gte(supplierAvailability.date, query.from));
-        }
-        if (query.to) {
-            conditions.push(lte(supplierAvailability.date, query.to));
-        }
-        return db
-            .select()
-            .from(supplierAvailability)
-            .where(and(...conditions))
-            .orderBy(asc(supplierAvailability.date));
-    },
-    async createAvailability(db, supplierId, entries) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        return db
-            .insert(supplierAvailability)
-            .values(entries.map((entry) => ({
-            supplierId,
-            date: entry.date,
-            available: entry.available,
-            notes: entry.notes ?? null,
-        })))
-            .returning();
-    },
-    listContracts(db, supplierId) {
-        return db
-            .select()
-            .from(supplierContracts)
-            .where(eq(supplierContracts.supplierId, supplierId))
-            .orderBy(desc(supplierContracts.createdAt));
-    },
-    async createContract(db, supplierId, data) {
-        const [supplier] = await db
-            .select({ id: suppliers.id })
-            .from(suppliers)
-            .where(eq(suppliers.id, supplierId))
-            .limit(1);
-        if (!supplier) {
-            return null;
-        }
-        const [row] = await db
-            .insert(supplierContracts)
-            .values({ ...data, supplierId })
-            .returning();
-        return row;
-    },
-    async updateContract(db, contractId, data) {
-        const [row] = await db
-            .update(supplierContracts)
-            .set({ ...data, updatedAt: new Date() })
-            .where(eq(supplierContracts.id, contractId))
-            .returning();
-        return row ?? null;
-    },
-    async deleteContract(db, contractId) {
-        const [row] = await db
-            .delete(supplierContracts)
-            .where(eq(supplierContracts.id, contractId))
-            .returning({ id: supplierContracts.id });
-        return row ?? null;
-    },
+    listSuppliers,
+    getSupplierById,
+    createSupplier,
+    updateSupplier,
+    deleteSupplier,
+    listContactPoints,
+    listNamedContacts,
+    createNamedContact,
+    updateNamedContact,
+    deleteNamedContact,
+    createContactPoint,
+    updateContactPoint,
+    deleteContactPoint,
+    listAddresses,
+    createAddress,
+    updateAddress,
+    deleteAddress,
+    listServices,
+    createService,
+    updateService,
+    deleteService,
+    listRates,
+    createRate,
+    updateRate,
+    deleteRate,
+    listNotes,
+    createNote,
+    listAvailability,
+    createAvailability,
+    listContracts,
+    createContract,
+    updateContract,
+    deleteContract,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/suppliers",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "exports": {
@@ -25,11 +25,11 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyantjs/core": "0.2.0",
-    "@voyantjs/db": "0.2.0",
-    "@voyantjs/facilities": "0.2.0",
-    "@voyantjs/hono": "0.2.0",
-    "@voyantjs/identity": "0.2.0"
+    "@voyantjs/core": "0.3.0",
+    "@voyantjs/db": "0.3.0",
+    "@voyantjs/facilities": "0.3.0",
+    "@voyantjs/hono": "0.3.0",
+    "@voyantjs/identity": "0.3.0"
   },
   "devDependencies": {
     "typescript": "^6.0.2",