@voyantjs/crm 0.2.0 → 0.3.1

package/dist/service/accounts.js

@@ -1,509 +1,6 @@
-import { identityAddresses, identityContactPoints } from "@voyantjs/identity/schema";
-import { identityService } from "@voyantjs/identity/service";
-import { and, desc, eq, gte, ilike, inArray, lte, or, sql } from "drizzle-orm";
-import { communicationLog, organizationNotes, organizations, people, personNotes, segments, } from "../schema.js";
-import { formatAddress, isManagedBySource, normalizeContactValue, paginate, toNullableTrimmed, } from "./helpers.js";
-const organizationEntityType = "organization";
-const personEntityType = "person";
-const personBaseIdentitySource = "crm.person.base";
-function personBaseFields(data) {
-    return {
-        organizationId: data.organizationId,
-        firstName: data.firstName,
-        lastName: data.lastName,
-        jobTitle: data.jobTitle,
-        relation: data.relation,
-        preferredLanguage: data.preferredLanguage,
-        preferredCurrency: data.preferredCurrency,
-        ownerId: data.ownerId,
-        status: data.status,
-        source: data.source,
-        sourceRef: data.sourceRef,
-        tags: data.tags,
-        birthday: data.birthday,
-        notes: data.notes,
-    };
-}
-async function syncPersonIdentity(db, personId, data) {
-    const existingContactPoints = await identityService.listContactPointsForEntity(db, personEntityType, personId);
-    const existingAddresses = await identityService.listAddressesForEntity(db, personEntityType, personId);
-    const managedContactPoints = existingContactPoints.filter((point) => isManagedBySource(point.metadata, personBaseIdentitySource));
-    const managedAddress = existingAddresses.find((address) => isManagedBySource(address.metadata, personBaseIdentitySource));
-    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: personEntityType,
-            entityId: personId,
-            kind,
-            label: kind === "website" ? "website" : "primary",
-            value,
-            normalizedValue: normalizeContactValue(kind, value),
-            isPrimary: true,
-            metadata: { managedBy: personBaseIdentitySource },
-        };
-        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);
-        }
-        return;
-    }
-    const addressPayload = {
-        entityType: personEntityType,
-        entityId: personId,
-        label: "primary",
-        fullText: addressLine,
-        line1: addressLine,
-        city,
-        country,
-        isPrimary: true,
-        metadata: { managedBy: personBaseIdentitySource },
-    };
-    if (managedAddress) {
-        await identityService.updateAddress(db, managedAddress.id, addressPayload);
-    }
-    else {
-        await identityService.createAddress(db, addressPayload);
-    }
-}
-async function deletePersonIdentity(db, personId) {
-    const [contactPoints, addresses] = await Promise.all([
-        identityService.listContactPointsForEntity(db, personEntityType, personId),
-        identityService.listAddressesForEntity(db, personEntityType, personId),
-    ]);
-    await Promise.all([
-        ...contactPoints.map((point) => identityService.deleteContactPoint(db, point.id)),
-        ...addresses.map((address) => identityService.deleteAddress(db, address.id)),
-    ]);
-}
-async function hydratePeople(db, rows) {
-    if (rows.length === 0) {
-        return rows.map((row) => ({
-            ...row,
-            email: null,
-            phone: null,
-            website: null,
-            address: null,
-            city: null,
-            country: null,
-        }));
-    }
-    const ids = rows.map((row) => row.id);
-    const [contactPoints, addresses] = await Promise.all([
-        db
-            .select()
-            .from(identityContactPoints)
-            .where(and(eq(identityContactPoints.entityType, personEntityType), inArray(identityContactPoints.entityId, ids))),
-        db
-            .select()
-            .from(identityAddresses)
-            .where(and(eq(identityAddresses.entityType, personEntityType), inArray(identityAddresses.entityId, ids))),
-    ]);
-    const contactPointMap = new Map();
-    const addressMap = 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);
-    }
-    return rows.map((row) => {
-        const entityContactPoints = contactPointMap.get(row.id) ?? [];
-        const entityAddresses = addressMap.get(row.id) ?? [];
-        const findPrimaryContactPoint = (kind) => entityContactPoints.find((point) => point.kind === kind && point.isPrimary) ??
-            entityContactPoints.find((point) => point.kind === kind) ??
-            null;
-        const primaryAddress = entityAddresses.find((address) => address.isPrimary) ?? entityAddresses[0] ?? null;
-        return {
-            ...row,
-            email: findPrimaryContactPoint("email")?.value ?? null,
-            phone: findPrimaryContactPoint("phone")?.value ?? null,
-            website: findPrimaryContactPoint("website")?.value ?? null,
-            address: primaryAddress ? formatAddress(primaryAddress) : null,
-            city: primaryAddress?.city ?? null,
-            country: primaryAddress?.country ?? null,
-        };
-    });
-}
+import { organizationAccountsService } from "./accounts-organizations.js";
+import { peopleAccountsService } from "./accounts-people.js";
 export const accountsService = {
-    async listOrganizations(db, query) {
-        const conditions = [];
-        if (query.ownerId)
-            conditions.push(eq(organizations.ownerId, query.ownerId));
-        if (query.relation)
-            conditions.push(eq(organizations.relation, query.relation));
-        if (query.status)
-            conditions.push(eq(organizations.status, query.status));
-        if (query.search) {
-            const term = `%${query.search}%`;
-            conditions.push(or(ilike(organizations.name, term), ilike(organizations.legalName, term), ilike(organizations.website, term)));
-        }
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(organizations)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(desc(organizations.updatedAt)), db.select({ count: sql `count(*)::int` }).from(organizations).where(where), query.limit, query.offset);
-    },
-    async getOrganizationById(db, id) {
-        const [row] = await db.select().from(organizations).where(eq(organizations.id, id)).limit(1);
-        return row ?? null;
-    },
-    async createOrganization(db, data) {
-        const [row] = await db.insert(organizations).values(data).returning();
-        return row;
-    },
-    async updateOrganization(db, id, data) {
-        const [row] = await db
-            .update(organizations)
-            .set({ ...data, updatedAt: new Date() })
-            .where(eq(organizations.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOrganization(db, id) {
-        const [row] = await db
-            .delete(organizations)
-            .where(eq(organizations.id, id))
-            .returning({ id: organizations.id });
-        return row ?? null;
-    },
-    async listPeople(db, query) {
-        const conditions = [];
-        if (query.organizationId)
-            conditions.push(eq(people.organizationId, query.organizationId));
-        if (query.ownerId)
-            conditions.push(eq(people.ownerId, query.ownerId));
-        if (query.relation)
-            conditions.push(eq(people.relation, query.relation));
-        if (query.status)
-            conditions.push(eq(people.status, query.status));
-        if (query.search) {
-            const term = `%${query.search}%`;
-            conditions.push(or(ilike(people.firstName, term), ilike(people.lastName, term), ilike(people.jobTitle, term)));
-        }
-        const where = conditions.length ? and(...conditions) : undefined;
-        const result = await paginate(db
-            .select()
-            .from(people)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(desc(people.updatedAt)), db.select({ count: sql `count(*)::int` }).from(people).where(where), query.limit, query.offset);
-        return {
-            ...result,
-            data: await hydratePeople(db, result.data),
-        };
-    },
-    async getPersonById(db, id) {
-        const [row] = await db.select().from(people).where(eq(people.id, id)).limit(1);
-        if (!row)
-            return null;
-        const [hydrated] = await hydratePeople(db, [row]);
-        return hydrated ?? null;
-    },
-    async createPerson(db, data) {
-        const [row] = await db
-            .insert(people)
-            .values({
-            ...personBaseFields(data),
-            firstName: data.firstName,
-            lastName: data.lastName,
-        })
-            .returning();
-        if (!row) {
-            throw new Error("Failed to create person");
-        }
-        await syncPersonIdentity(db, row.id, data);
-        return this.getPersonById(db, row.id);
-    },
-    async updatePerson(db, id, data) {
-        const existing = await this.getPersonById(db, id);
-        if (!existing)
-            return null;
-        await db
-            .update(people)
-            .set({ ...personBaseFields(data), updatedAt: new Date() })
-            .where(eq(people.id, id));
-        await syncPersonIdentity(db, id, {
-            email: data.email === undefined ? existing.email : data.email,
-            phone: data.phone === undefined ? existing.phone : data.phone,
-            website: data.website === undefined ? existing.website : data.website,
-            address: data.address === undefined ? existing.address : data.address,
-            city: data.city === undefined ? existing.city : data.city,
-            country: data.country === undefined ? existing.country : data.country,
-        });
-        return this.getPersonById(db, id);
-    },
-    async deletePerson(db, id) {
-        await deletePersonIdentity(db, id);
-        const [row] = await db.delete(people).where(eq(people.id, id)).returning({ id: people.id });
-        return row ?? null;
-    },
-    // --- Contact methods & addresses (explicit CRUD via identity) ---
-    listContactMethods(db, entityType, entityId) {
-        return identityService.listContactPointsForEntity(db, entityType === "organization" ? organizationEntityType : personEntityType, entityId);
-    },
-    async createContactMethod(db, entityType, entityId, data) {
-        return identityService.createContactPoint(db, {
-            ...data,
-            entityType: entityType === "organization" ? organizationEntityType : personEntityType,
-            entityId,
-        });
-    },
-    async updateContactMethod(db, id, data) {
-        return identityService.updateContactPoint(db, id, data);
-    },
-    async deleteContactMethod(db, id) {
-        return identityService.deleteContactPoint(db, id);
-    },
-    listAddresses(db, entityType, entityId) {
-        return identityService.listAddressesForEntity(db, entityType === "organization" ? organizationEntityType : personEntityType, entityId);
-    },
-    async createAddress(db, entityType, entityId, data) {
-        return identityService.createAddress(db, {
-            ...data,
-            entityType: entityType === "organization" ? organizationEntityType : personEntityType,
-            entityId,
-        });
-    },
-    async updateAddress(db, id, data) {
-        return identityService.updateAddress(db, id, data);
-    },
-    async deleteAddress(db, id) {
-        return identityService.deleteAddress(db, id);
-    },
-    // --- Person notes ---
-    listPersonNotes(db, personId) {
-        return db
-            .select()
-            .from(personNotes)
-            .where(eq(personNotes.personId, personId))
-            .orderBy(personNotes.createdAt);
-    },
-    async createPersonNote(db, personId, userId, data) {
-        const [existing] = await db
-            .select({ id: people.id })
-            .from(people)
-            .where(eq(people.id, personId))
-            .limit(1);
-        if (!existing)
-            return null;
-        const [row] = await db
-            .insert(personNotes)
-            .values({ personId, authorId: userId, content: data.content })
-            .returning();
-        return row;
-    },
-    // --- Organization notes ---
-    listOrganizationNotes(db, organizationId) {
-        return db
-            .select()
-            .from(organizationNotes)
-            .where(eq(organizationNotes.organizationId, organizationId))
-            .orderBy(organizationNotes.createdAt);
-    },
-    async createOrganizationNote(db, organizationId, userId, data) {
-        const [existing] = await db
-            .select({ id: organizations.id })
-            .from(organizations)
-            .where(eq(organizations.id, organizationId))
-            .limit(1);
-        if (!existing)
-            return null;
-        const [row] = await db
-            .insert(organizationNotes)
-            .values({ organizationId, authorId: userId, content: data.content })
-            .returning();
-        return row;
-    },
-    async updatePersonNote(db, id, content) {
-        const [row] = await db
-            .update(personNotes)
-            .set({ content })
-            .where(eq(personNotes.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deletePersonNote(db, id) {
-        const [row] = await db.delete(personNotes).where(eq(personNotes.id, id)).returning();
-        return row ?? null;
-    },
-    async updateOrganizationNote(db, id, content) {
-        const [row] = await db
-            .update(organizationNotes)
-            .set({ content })
-            .where(eq(organizationNotes.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOrganizationNote(db, id) {
-        const [row] = await db.delete(organizationNotes).where(eq(organizationNotes.id, id)).returning();
-        return row ?? null;
-    },
-    // --- Communication log ---
-    async listCommunications(db, personId, query) {
-        const conditions = [eq(communicationLog.personId, personId)];
-        if (query.channel)
-            conditions.push(eq(communicationLog.channel, query.channel));
-        if (query.direction)
-            conditions.push(eq(communicationLog.direction, query.direction));
-        if (query.dateFrom)
-            conditions.push(gte(communicationLog.createdAt, new Date(query.dateFrom)));
-        if (query.dateTo)
-            conditions.push(lte(communicationLog.createdAt, new Date(query.dateTo)));
-        return db
-            .select()
-            .from(communicationLog)
-            .where(and(...conditions))
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(desc(communicationLog.createdAt));
-    },
-    async createCommunication(db, personId, data) {
-        const [existing] = await db
-            .select({ id: people.id })
-            .from(people)
-            .where(eq(people.id, personId))
-            .limit(1);
-        if (!existing)
-            return null;
-        const [row] = await db
-            .insert(communicationLog)
-            .values({
-            personId,
-            organizationId: data.organizationId ?? null,
-            channel: data.channel,
-            direction: data.direction,
-            subject: data.subject ?? null,
-            content: data.content ?? null,
-            sentAt: data.sentAt ? new Date(data.sentAt) : null,
-        })
-            .returning();
-        return row;
-    },
-    // --- Segments ---
-    listSegments(db) {
-        return db.select().from(segments).orderBy(segments.createdAt);
-    },
-    async createSegment(db, data) {
-        const [row] = await db.insert(segments).values(data).returning();
-        return row;
-    },
-    async deleteSegment(db, segmentId) {
-        const [row] = await db
-            .delete(segments)
-            .where(eq(segments.id, segmentId))
-            .returning({ id: segments.id });
-        return row ?? null;
-    },
-    // --- CSV export/import ---
-    async exportPeopleCsv(db) {
-        const rows = await hydratePeople(db, await db.select().from(people).orderBy(people.createdAt));
-        const headers = [
-            "id",
-            "firstName",
-            "lastName",
-            "jobTitle",
-            "relation",
-            "preferredLanguage",
-            "preferredCurrency",
-            "email",
-            "phone",
-            "website",
-            "address",
-            "city",
-            "country",
-            "organizationId",
-        ];
-        const csvLines = [headers.join(",")];
-        for (const row of rows) {
-            const values = headers.map((header) => {
-                const value = row[header];
-                if (value === null || value === undefined)
-                    return "";
-                const stringValue = String(value);
-                return stringValue.includes(",") || stringValue.includes('"') || stringValue.includes("\n")
-                    ? `"${stringValue.replace(/"/g, '""')}"`
-                    : stringValue;
-            });
-            csvLines.push(values.join(","));
-        }
-        return csvLines.join("\n");
-    },
-    async importPeopleCsv(db, csvText) {
-        const lines = csvText.split("\n").filter((line) => line.trim());
-        if (lines.length < 2) {
-            return { error: "CSV must have a header row and at least one data row" };
-        }
-        const headers = lines[0].split(",").map((header) => header.trim());
-        const rows = [];
-        for (let i = 1; i < lines.length; i++) {
-            const values = lines[i].split(",").map((value) => value.trim());
-            const row = {};
-            for (let j = 0; j < headers.length; j++) {
-                const header = headers[j];
-                const value = values[j];
-                if (header && value) {
-                    row[header] = value;
-                }
-            }
-            rows.push(row);
-        }
-        const imported = [];
-        const errors = [];
-        for (let i = 0; i < rows.length; i++) {
-            const row = rows[i];
-            const result = (await import("../validation.js")).insertPersonSchema.safeParse({
-                firstName: row.firstName || "",
-                lastName: row.lastName || "",
-                jobTitle: row.jobTitle || null,
-                relation: row.relation || null,
-                preferredLanguage: row.preferredLanguage || null,
-                preferredCurrency: row.preferredCurrency || null,
-                email: row.email || null,
-                phone: row.phone || null,
-                website: row.website || null,
-                address: row.address || null,
-                city: row.city || null,
-                country: row.country || null,
-                organizationId: row.organizationId || null,
-                tags: [],
-            });
-            if (!result.success) {
-                errors.push({ row: i + 2, error: result.error.message });
-                continue;
-            }
-            imported.push(await this.createPerson(db, result.data));
-        }
-        return { imported: imported.length, errors };
-    },
+    ...organizationAccountsService,
+    ...peopleAccountsService,
 };