@voyantjs/crm 0.1.1 → 0.3.0

package/dist/service/accounts-people.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-people.d.ts","sourceRoot":"","sources":["../../src/service/accounts-people.ts"],"names":[],"mappings":"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"}

package/dist/service/accounts-people.js

@@ -0,0 +1,311 @@
+import { identityService } from "@voyantjs/identity/service";
+import { and, desc, eq, gte, ilike, lte, or, sql } from "drizzle-orm";
+import { communicationLog, organizationNotes, organizations, people, personNotes, segments, } from "../schema.js";
+import { deletePersonIdentity, hydratePeople, organizationEntityType, personBaseFields, personEntityType, syncPersonIdentity, } from "./accounts-shared.js";
+import { paginate } from "./helpers.js";
+export const peopleAccountsService = {
+    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;
+    },
+    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);
+    },
+    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;
+    },
+    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;
+    },
+    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;
+    },
+    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;
+    },
+    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 };
+    },
+};

package/dist/service/accounts-shared.d.ts

@@ -0,0 +1,54 @@
+import type { insertAddressSchema, insertContactPointSchema, updateAddressSchema, updateContactPointSchema } from "@voyantjs/identity/validation";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { communicationListQuerySchema, insertCommunicationLogSchema, insertOrganizationNoteSchema, insertOrganizationSchema, insertPersonNoteSchema, insertPersonSchema, insertSegmentSchema, organizationListQuerySchema, personListQuerySchema, updateOrganizationSchema, updatePersonSchema } from "../validation.js";
+export type OrganizationListQuery = z.infer<typeof organizationListQuerySchema>;
+export type CreateOrganizationInput = z.infer<typeof insertOrganizationSchema>;
+export type UpdateOrganizationInput = z.infer<typeof updateOrganizationSchema>;
+export type PersonListQuery = z.infer<typeof personListQuerySchema>;
+export type CreatePersonInput = z.infer<typeof insertPersonSchema>;
+export type UpdatePersonInput = z.infer<typeof updatePersonSchema>;
+export type CreateContactPointInput = z.infer<typeof insertContactPointSchema>;
+export type UpdateContactPointInput = z.infer<typeof updateContactPointSchema>;
+export type CreateAddressInput = z.infer<typeof insertAddressSchema>;
+export type UpdateAddressInput = z.infer<typeof updateAddressSchema>;
+export type CreatePersonNoteInput = z.infer<typeof insertPersonNoteSchema>;
+export type CreateOrganizationNoteInput = z.infer<typeof insertOrganizationNoteSchema>;
+export type CreateCommunicationLogInput = z.infer<typeof insertCommunicationLogSchema>;
+export type CommunicationListQuery = z.infer<typeof communicationListQuerySchema>;
+export type CreateSegmentInput = z.infer<typeof insertSegmentSchema>;
+export declare const organizationEntityType = "organization";
+export declare const personEntityType = "person";
+export declare const personBaseIdentitySource = "crm.person.base";
+type PersonIdentityInput = Pick<CreatePersonInput, "email" | "phone" | "website" | "address" | "city" | "country">;
+export type PersonHydratedFields = {
+    email: string | null;
+    phone: string | null;
+    website: string | null;
+    address: string | null;
+    city: string | null;
+    country: string | null;
+};
+export declare function personBaseFields(data: CreatePersonInput | UpdatePersonInput): {
+    organizationId: string | null | undefined;
+    firstName: string | undefined;
+    lastName: string | undefined;
+    jobTitle: string | null | undefined;
+    relation: "partner" | "supplier" | "other" | "client" | null | undefined;
+    preferredLanguage: string | null | undefined;
+    preferredCurrency: string | null | undefined;
+    ownerId: string | null | undefined;
+    status: "active" | "inactive" | "archived" | undefined;
+    source: string | null | undefined;
+    sourceRef: string | null | undefined;
+    tags: string[] | undefined;
+    birthday: string | null | undefined;
+    notes: string | null | undefined;
+};
+export declare function syncPersonIdentity(db: PostgresJsDatabase, personId: string, data: PersonIdentityInput): Promise<void>;
+export declare function deletePersonIdentity(db: PostgresJsDatabase, personId: string): Promise<void>;
+export declare function hydratePeople<T extends {
+    id: string;
+}>(db: PostgresJsDatabase, rows: T[]): Promise<Array<T & PersonHydratedFields>>;
+export {};
+//# sourceMappingURL=accounts-shared.d.ts.map

package/dist/service/accounts-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-shared.d.ts","sourceRoot":"","sources":["../../src/service/accounts-shared.ts"],"names":[],"mappings":"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"}

package/dist/service/accounts-shared.js

@@ -0,0 +1,152 @@
+import { identityAddresses, identityContactPoints } from "@voyantjs/identity/schema";
+import { identityService } from "@voyantjs/identity/service";
+import { and, eq, inArray } from "drizzle-orm";
+import { formatAddress, isManagedBySource, normalizeContactValue, toNullableTrimmed, } from "./helpers.js";
+export const organizationEntityType = "organization";
+export const personEntityType = "person";
+export const personBaseIdentitySource = "crm.person.base";
+export 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,
+    };
+}
+export 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);
+    }
+}
+export 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)),
+    ]);
+}
+export 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,
+        };
+    });
+}