@voyant-travel/relationships 0.119.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/service/accounts.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,uBAAuB,CAAA;AAE9B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM3B,CAAA;AAED,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAClF,YAAY,EACV,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/service/accounts.js

@@ -0,0 +1,13 @@
+import { accountMergeService } from "./accounts-merge.js";
+import { organizationAccountsService } from "./accounts-organizations.js";
+import { peopleAccountsService } from "./accounts-people.js";
+import { findPersonByContactPoint, personNameFromContact, upsertPersonFromContact, } from "./accounts-resolve.js";
+export const accountsService = {
+    ...organizationAccountsService,
+    ...peopleAccountsService,
+    ...accountMergeService,
+    findPersonByContactPoint,
+    upsertPersonFromContact,
+};
+export { accountMergeService, RelationshipsMergeError } from "./accounts-merge.js";
+export { findPersonByContactPoint, personNameFromContact, upsertPersonFromContact };

package/dist/service/activities.d.ts

@@ -0,0 +1,486 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { activityListQuerySchema, insertActivityLinkSchema, insertActivityParticipantSchema, insertActivitySchema, updateActivitySchema } from "../validation.js";
+type ActivityListQuery = z.infer<typeof activityListQuerySchema>;
+type CreateActivityInput = z.infer<typeof insertActivitySchema>;
+type UpdateActivityInput = z.infer<typeof updateActivitySchema>;
+type CreateActivityLinkInput = z.infer<typeof insertActivityLinkSchema>;
+type CreateActivityParticipantInput = z.infer<typeof insertActivityParticipantSchema>;
+export declare const activitiesService: {
+    listActivities(db: PostgresJsDatabase, query: ActivityListQuery): Promise<{
+        data: {
+            id: string;
+            subject: string;
+            type: "email" | "meeting" | "call" | "task" | "follow_up" | "note";
+            ownerId: string | null;
+            status: "cancelled" | "done" | "planned";
+            dueAt: Date | null;
+            completedAt: Date | null;
+            location: string | null;
+            description: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getActivityById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        subject: string;
+        type: "email" | "meeting" | "call" | "task" | "follow_up" | "note";
+        ownerId: string | null;
+        status: "cancelled" | "done" | "planned";
+        dueAt: Date | null;
+        completedAt: Date | null;
+        location: string | null;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createActivity(db: PostgresJsDatabase, data: CreateActivityInput): Promise<{
+        type: "email" | "meeting" | "call" | "task" | "follow_up" | "note";
+        description: string | null;
+        id: string;
+        status: "cancelled" | "done" | "planned";
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string | null;
+        subject: string;
+        dueAt: Date | null;
+        completedAt: Date | null;
+        location: string | null;
+    } | undefined>;
+    updateActivity(db: PostgresJsDatabase, id: string, data: UpdateActivityInput): Promise<{
+        id: string;
+        subject: string;
+        type: "email" | "meeting" | "call" | "task" | "follow_up" | "note";
+        ownerId: string | null;
+        status: "cancelled" | "done" | "planned";
+        dueAt: Date | null;
+        completedAt: Date | null;
+        location: string | null;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteActivity(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listActivityLinks(db: PostgresJsDatabase, activityId: string): Omit<import("drizzle-orm/pg-core").PgSelectBase<"activity_links", {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        activityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_type";
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "organization" | "person" | "quote" | "activity";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["organization", "person", "quote", "activity"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "primary" | "related";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["primary", "related"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "activity_links";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }, "single", Record<"activity_links", "not-null">, false, "where" | "orderBy", {
+        id: string;
+        activityId: string;
+        entityType: "organization" | "person" | "quote" | "activity";
+        entityId: string;
+        role: "primary" | "related";
+        createdAt: Date;
+    }[], {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        activityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_type";
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "organization" | "person" | "quote" | "activity";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["organization", "person", "quote", "activity"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "activity_links";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "primary" | "related";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["primary", "related"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "activity_links";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }>, "where" | "orderBy">;
+    createActivityLink(db: PostgresJsDatabase, activityId: string, data: CreateActivityLinkInput): Promise<{
+        id: string;
+        createdAt: Date;
+        entityType: "organization" | "person" | "quote" | "activity";
+        entityId: string;
+        role: "primary" | "related";
+        activityId: string;
+    } | undefined>;
+    deleteActivityLink(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listActivityParticipants(db: PostgresJsDatabase, activityId: string): Omit<import("drizzle-orm/pg-core").PgSelectBase<"activity_participants", {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_participants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        activityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_participants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        personId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_participants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isPrimary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_primary";
+            tableName: "activity_participants";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "activity_participants";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }, "single", Record<"activity_participants", "not-null">, false, "where" | "orderBy", {
+        id: string;
+        activityId: string;
+        personId: string;
+        isPrimary: boolean;
+        createdAt: Date;
+    }[], {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_participants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        activityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_participants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        personId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "activity_participants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isPrimary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_primary";
+            tableName: "activity_participants";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "activity_participants";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }>, "where" | "orderBy">;
+    createActivityParticipant(db: PostgresJsDatabase, activityId: string, data: CreateActivityParticipantInput): Promise<{
+        id: string;
+        createdAt: Date;
+        isPrimary: boolean;
+        personId: string;
+        activityId: string;
+    } | undefined>;
+    deleteActivityParticipant(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=activities.d.ts.map

package/dist/service/activities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../src/service/activities.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,uBAAuB,EACvB,wBAAwB,EACxB,+BAA+B,EAC/B,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,kBAAkB,CAAA;AAGzB,KAAK,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAChE,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAC/D,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAC/D,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAErF,eAAO,MAAM,iBAAiB;uBACH,kBAAkB,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;wBA6C3C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;uBAK/B,kBAAkB,QAAQ,mBAAmB;;;;;;;;;;;;;uBAY7C,kBAAkB,MAAM,MAAM,QAAQ,mBAAmB;;;;;;;;;;;;;uBAgBzD,kBAAkB,MAAM,MAAM;;;0BAQjC,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAStD,kBAAkB,cACV,MAAM,QACZ,uBAAuB;;;;;;;;2BASF,kBAAkB,MAAM,MAAM;;;iCAQ9B,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAS7D,kBAAkB,cACV,MAAM,QACZ,8BAA8B;;;;;;;kCASF,kBAAkB,MAAM,MAAM;;;CAOnE,CAAA"}

package/dist/service/activities.js

@@ -0,0 +1,114 @@
+import { and, desc, eq, ilike, inArray, or, sql } from "drizzle-orm";
+import { activities, activityLinks, activityParticipants } from "../schema.js";
+import { paginate, toDateOrNull } from "./helpers.js";
+export const activitiesService = {
+    async listActivities(db, query) {
+        const conditions = [];
+        if (query.ownerId)
+            conditions.push(eq(activities.ownerId, query.ownerId));
+        if (query.status)
+            conditions.push(eq(activities.status, query.status));
+        if (query.type)
+            conditions.push(eq(activities.type, query.type));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(activities.subject, term), ilike(activities.description, term)));
+        }
+        if (query.entityType && query.entityId) {
+            const linkRows = await db
+                .select({ activityId: activityLinks.activityId })
+                .from(activityLinks)
+                .where(and(eq(activityLinks.entityType, query.entityType), eq(activityLinks.entityId, query.entityId)));
+            const activityIds = linkRows.map((row) => row.activityId);
+            if (activityIds.length === 0) {
+                return { data: [], total: 0, limit: query.limit, offset: query.offset };
+            }
+            conditions.push(inArray(activities.id, activityIds));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(activities)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(activities.updatedAt)), db.select({ count: sql `count(*)::int` }).from(activities).where(where), query.limit, query.offset);
+    },
+    async getActivityById(db, id) {
+        const [row] = await db.select().from(activities).where(eq(activities.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createActivity(db, data) {
+        const [row] = await db
+            .insert(activities)
+            .values({
+            ...data,
+            dueAt: toDateOrNull(data.dueAt),
+            completedAt: toDateOrNull(data.completedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateActivity(db, id, data) {
+        const patch = {
+            ...data,
+            dueAt: data.dueAt === undefined ? undefined : toDateOrNull(data.dueAt),
+            completedAt: data.completedAt === undefined ? undefined : toDateOrNull(data.completedAt),
+            updatedAt: new Date(),
+        };
+        if (data.status === "done" && !data.completedAt) {
+            patch.completedAt = new Date();
+        }
+        const [row] = await db.update(activities).set(patch).where(eq(activities.id, id)).returning();
+        return row ?? null;
+    },
+    async deleteActivity(db, id) {
+        const [row] = await db
+            .delete(activities)
+            .where(eq(activities.id, id))
+            .returning({ id: activities.id });
+        return row ?? null;
+    },
+    listActivityLinks(db, activityId) {
+        return db
+            .select()
+            .from(activityLinks)
+            .where(eq(activityLinks.activityId, activityId))
+            .orderBy(desc(activityLinks.role), activityLinks.createdAt);
+    },
+    async createActivityLink(db, activityId, data) {
+        const [row] = await db
+            .insert(activityLinks)
+            .values({ ...data, activityId })
+            .returning();
+        return row;
+    },
+    async deleteActivityLink(db, id) {
+        const [row] = await db
+            .delete(activityLinks)
+            .where(eq(activityLinks.id, id))
+            .returning({ id: activityLinks.id });
+        return row ?? null;
+    },
+    listActivityParticipants(db, activityId) {
+        return db
+            .select()
+            .from(activityParticipants)
+            .where(eq(activityParticipants.activityId, activityId))
+            .orderBy(desc(activityParticipants.isPrimary), activityParticipants.createdAt);
+    },
+    async createActivityParticipant(db, activityId, data) {
+        const [row] = await db
+            .insert(activityParticipants)
+            .values({ ...data, activityId })
+            .returning();
+        return row;
+    },
+    async deleteActivityParticipant(db, id) {
+        const [row] = await db
+            .delete(activityParticipants)
+            .where(eq(activityParticipants.id, id))
+            .returning({ id: activityParticipants.id });
+        return row ?? null;
+    },
+};