@voyantjs/legal 0.2.0 → 0.3.1

package/dist/contracts/service-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-contracts.d.ts","sourceRoot":"","sources":["../../src/contracts/service-contracts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAQjE,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,6BAA6B,EAClC,KAAK,mBAAmB,EACxB,KAAK,4BAA4B,EAIjC,KAAK,6BAA6B,EAClC,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,sBAAsB;sBACT,kBAAkB,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2B1C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAI/B,kBAAkB,QAAQ,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAO7C,kBAAkB,MAAM,MAAM,QAAQ,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAYzD,kBAAkB,MAAM,MAAM;;;;;;;sBAW/B,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2CvC,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgBtC,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAe1C,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAQnD,kBAAkB,cACV,MAAM,QACZ,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuBV,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAe5C,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAQpD,kBAAkB,cACV,MAAM,QACZ,6BAA6B;;;;;;;;;;;;yBAe/B,kBAAkB,gBACR,MAAM,QACd,6BAA6B;;;;;;;;;;;;yBASV,kBAAkB,gBAAgB,MAAM;;;CAOpE,CAAA"}

package/dist/contracts/service-contracts.js

@@ -0,0 +1,233 @@
+import { and, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { contractAttachments, contractSignatures, contracts, contractTemplateVersions, } from "./schema.js";
+import { allocateContractNumber, paginate, renderTemplate, toTimestamp, } from "./service-shared.js";
+export const contractRecordsService = {
+    async listContracts(db, query) {
+        const conditions = [];
+        if (query.scope)
+            conditions.push(eq(contracts.scope, query.scope));
+        if (query.status)
+            conditions.push(eq(contracts.status, query.status));
+        if (query.personId)
+            conditions.push(eq(contracts.personId, query.personId));
+        if (query.organizationId)
+            conditions.push(eq(contracts.organizationId, query.organizationId));
+        if (query.supplierId)
+            conditions.push(eq(contracts.supplierId, query.supplierId));
+        if (query.bookingId)
+            conditions.push(eq(contracts.bookingId, query.bookingId));
+        if (query.orderId)
+            conditions.push(eq(contracts.orderId, query.orderId));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(contracts.title, term), ilike(contracts.contractNumber, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(contracts)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(contracts.createdAt)), db.select({ total: sql `count(*)::int` }).from(contracts).where(where), query.limit, query.offset);
+    },
+    async getContractById(db, id) {
+        const [row] = await db.select().from(contracts).where(eq(contracts.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createContract(db, data) {
+        const [row] = await db
+            .insert(contracts)
+            .values({ ...data, expiresAt: toTimestamp(data.expiresAt) })
+            .returning();
+        return row ?? null;
+    },
+    async updateContract(db, id, data) {
+        const [row] = await db
+            .update(contracts)
+            .set({
+            ...data,
+            expiresAt: data.expiresAt === undefined ? undefined : toTimestamp(data.expiresAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(contracts.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteContract(db, id) {
+        const [existing] = await db
+            .select({ id: contracts.id, status: contracts.status })
+            .from(contracts)
+            .where(eq(contracts.id, id))
+            .limit(1);
+        if (!existing)
+            return { status: "not_found" };
+        if (existing.status !== "draft")
+            return { status: "not_draft" };
+        await db.delete(contracts).where(eq(contracts.id, id));
+        return { status: "deleted" };
+    },
+    async issueContract(db, contractId) {
+        return db.transaction(async (tx) => {
+            const [contract] = await tx
+                .select()
+                .from(contracts)
+                .where(eq(contracts.id, contractId))
+                .limit(1);
+            if (!contract)
+                return { status: "not_found" };
+            if (contract.status !== "draft")
+                return { status: "not_draft" };
+            let renderedBody = contract.renderedBody;
+            let renderedBodyFormat = contract.renderedBodyFormat;
+            if (contract.templateVersionId) {
+                const [version] = await tx
+                    .select()
+                    .from(contractTemplateVersions)
+                    .where(eq(contractTemplateVersions.id, contract.templateVersionId))
+                    .limit(1);
+                if (version) {
+                    const vars = contract.variables ?? {};
+                    renderedBody = renderTemplate(version.body, version.bodyFormat, vars);
+                    renderedBodyFormat = version.bodyFormat;
+                }
+            }
+            let contractNumber = contract.contractNumber;
+            if (!contractNumber && contract.seriesId) {
+                const allocated = await allocateContractNumber(tx, contract.seriesId);
+                if (allocated)
+                    contractNumber = allocated.number;
+            }
+            const [updated] = await tx
+                .update(contracts)
+                .set({
+                status: "issued",
+                issuedAt: new Date(),
+                renderedBody,
+                renderedBodyFormat,
+                contractNumber,
+                updatedAt: new Date(),
+            })
+                .where(eq(contracts.id, contractId))
+                .returning();
+            return { status: "issued", contract: updated ?? null };
+        });
+    },
+    async sendContract(db, contractId) {
+        const [contract] = await db
+            .select({ id: contracts.id, status: contracts.status })
+            .from(contracts)
+            .where(eq(contracts.id, contractId))
+            .limit(1);
+        if (!contract)
+            return { status: "not_found" };
+        if (contract.status !== "issued" && contract.status !== "sent")
+            return { status: "not_issued" };
+        const [updated] = await db
+            .update(contracts)
+            .set({ status: "sent", sentAt: new Date(), updatedAt: new Date() })
+            .where(eq(contracts.id, contractId))
+            .returning();
+        return { status: "sent", contract: updated ?? null };
+    },
+    async voidContract(db, contractId) {
+        const [contract] = await db
+            .select({ id: contracts.id, status: contracts.status })
+            .from(contracts)
+            .where(eq(contracts.id, contractId))
+            .limit(1);
+        if (!contract)
+            return { status: "not_found" };
+        if (contract.status === "void")
+            return { status: "already_void" };
+        const [updated] = await db
+            .update(contracts)
+            .set({ status: "void", voidedAt: new Date(), updatedAt: new Date() })
+            .where(eq(contracts.id, contractId))
+            .returning();
+        return { status: "voided", contract: updated ?? null };
+    },
+    listSignatures(db, contractId) {
+        return db
+            .select()
+            .from(contractSignatures)
+            .where(eq(contractSignatures.contractId, contractId))
+            .orderBy(desc(contractSignatures.signedAt));
+    },
+    async signContract(db, contractId, data) {
+        return db.transaction(async (tx) => {
+            const [contract] = await tx
+                .select()
+                .from(contracts)
+                .where(eq(contracts.id, contractId))
+                .limit(1);
+            if (!contract)
+                return { status: "not_found" };
+            if (contract.status !== "issued" && contract.status !== "sent")
+                return { status: "not_signable" };
+            const [signature] = await tx
+                .insert(contractSignatures)
+                .values({ ...data, contractId })
+                .returning();
+            const [updated] = await tx
+                .update(contracts)
+                .set({ status: "signed", updatedAt: new Date() })
+                .where(eq(contracts.id, contractId))
+                .returning();
+            return { status: "signed", contract: updated ?? null, signature: signature ?? null };
+        });
+    },
+    async executeContract(db, contractId) {
+        const [contract] = await db
+            .select({ id: contracts.id, status: contracts.status })
+            .from(contracts)
+            .where(eq(contracts.id, contractId))
+            .limit(1);
+        if (!contract)
+            return { status: "not_found" };
+        if (contract.status !== "signed")
+            return { status: "not_signed" };
+        const [updated] = await db
+            .update(contracts)
+            .set({ status: "executed", executedAt: new Date(), updatedAt: new Date() })
+            .where(eq(contracts.id, contractId))
+            .returning();
+        return { status: "executed", contract: updated ?? null };
+    },
+    listAttachments(db, contractId) {
+        return db
+            .select()
+            .from(contractAttachments)
+            .where(eq(contractAttachments.contractId, contractId))
+            .orderBy(desc(contractAttachments.createdAt));
+    },
+    async createAttachment(db, contractId, data) {
+        const [contract] = await db
+            .select({ id: contracts.id })
+            .from(contracts)
+            .where(eq(contracts.id, contractId))
+            .limit(1);
+        if (!contract)
+            return null;
+        const [row] = await db
+            .insert(contractAttachments)
+            .values({ ...data, contractId })
+            .returning();
+        return row ?? null;
+    },
+    async updateAttachment(db, attachmentId, data) {
+        const [row] = await db
+            .update(contractAttachments)
+            .set(data)
+            .where(eq(contractAttachments.id, attachmentId))
+            .returning();
+        return row ?? null;
+    },
+    async deleteAttachment(db, attachmentId) {
+        const [row] = await db
+            .delete(contractAttachments)
+            .where(eq(contractAttachments.id, attachmentId))
+            .returning({ id: contractAttachments.id });
+        return row ?? null;
+    },
+};

package/dist/contracts/service-series.d.ts

@@ -0,0 +1,68 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { CreateContractNumberSeriesInput, UpdateContractNumberSeriesInput } from "./service-shared.js";
+export declare const contractSeriesService: {
+    listSeries(db: PostgresJsDatabase): Promise<{
+        id: string;
+        code: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        currentSequence: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        resetAt: Date | null;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    getSeriesById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        code: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        currentSequence: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        resetAt: Date | null;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createSeries(db: PostgresJsDatabase, data: CreateContractNumberSeriesInput): Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        code: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        prefix: string;
+        separator: string;
+        padLength: number;
+        currentSequence: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        resetAt: Date | null;
+    } | null>;
+    updateSeries(db: PostgresJsDatabase, id: string, data: UpdateContractNumberSeriesInput): Promise<{
+        id: string;
+        code: string;
+        name: string;
+        prefix: string;
+        separator: string;
+        padLength: number;
+        currentSequence: number;
+        resetStrategy: "never" | "annual" | "monthly";
+        resetAt: Date | null;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteSeries(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=service-series.d.ts.map

package/dist/contracts/service-series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-series.d.ts","sourceRoot":"","sources":["../../src/contracts/service-series.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,+BAA+B,EAChC,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,qBAAqB;mBACX,kBAAkB;;;;;;;;;;;;;;;sBAGf,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;qBAQ/B,kBAAkB,QAAQ,+BAA+B;;;;;;;;;;;;;;;qBAIzD,kBAAkB,MAAM,MAAM,QAAQ,+BAA+B;;;;;;;;;;;;;;;qBAQrE,kBAAkB,MAAM,MAAM;;;CAOtD,CAAA"}

package/dist/contracts/service-series.js

@@ -0,0 +1,34 @@
+import { desc, eq } from "drizzle-orm";
+import { contractNumberSeries } from "./schema.js";
+export const contractSeriesService = {
+    async listSeries(db) {
+        return db.select().from(contractNumberSeries).orderBy(desc(contractNumberSeries.updatedAt));
+    },
+    async getSeriesById(db, id) {
+        const [row] = await db
+            .select()
+            .from(contractNumberSeries)
+            .where(eq(contractNumberSeries.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createSeries(db, data) {
+        const [row] = await db.insert(contractNumberSeries).values(data).returning();
+        return row ?? null;
+    },
+    async updateSeries(db, id, data) {
+        const [row] = await db
+            .update(contractNumberSeries)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(contractNumberSeries.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteSeries(db, id) {
+        const [row] = await db
+            .delete(contractNumberSeries)
+            .where(eq(contractNumberSeries.id, id))
+            .returning({ id: contractNumberSeries.id });
+        return row ?? null;
+    },
+};

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

@@ -0,0 +1,32 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { contractListQuerySchema, contractTemplateListQuerySchema, insertContractAttachmentSchema, insertContractNumberSeriesSchema, insertContractSchema, insertContractSignatureSchema, insertContractTemplateSchema, insertContractTemplateVersionSchema, renderTemplateInputSchema, updateContractAttachmentSchema, updateContractNumberSeriesSchema, updateContractSchema, updateContractTemplateSchema } from "./validation.js";
+export type ContractListQuery = z.infer<typeof contractListQuerySchema>;
+export type ContractTemplateListQuery = z.infer<typeof contractTemplateListQuerySchema>;
+export type CreateContractTemplateInput = z.infer<typeof insertContractTemplateSchema>;
+export type UpdateContractTemplateInput = z.infer<typeof updateContractTemplateSchema>;
+export type CreateContractTemplateVersionInput = z.infer<typeof insertContractTemplateVersionSchema>;
+export type CreateContractNumberSeriesInput = z.infer<typeof insertContractNumberSeriesSchema>;
+export type UpdateContractNumberSeriesInput = z.infer<typeof updateContractNumberSeriesSchema>;
+export type CreateContractInput = z.infer<typeof insertContractSchema>;
+export type UpdateContractInput = z.infer<typeof updateContractSchema>;
+export type CreateContractSignatureInput = z.infer<typeof insertContractSignatureSchema>;
+export type CreateContractAttachmentInput = z.infer<typeof insertContractAttachmentSchema>;
+export type UpdateContractAttachmentInput = z.infer<typeof updateContractAttachmentSchema>;
+export type RenderTemplateInput = z.infer<typeof renderTemplateInputSchema>;
+export declare function toTimestamp(value?: string | null): Date | null;
+export declare function renderTemplate(body: string, bodyFormat: "markdown" | "html" | "lexical_json", variables: Record<string, unknown>): string;
+export declare function validateTemplateVariables(variableSchema: unknown, values: Record<string, unknown>): string[];
+export declare function allocateContractNumber(db: PostgresJsDatabase, seriesId: string): Promise<{
+    number: string;
+    sequence: number;
+} | null>;
+export declare function paginate<T extends object>(rowsQuery: Promise<T[]>, countQuery: Promise<Array<{
+    total: number;
+}>>, limit: number, offset: number): Promise<{
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+//# sourceMappingURL=service-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-shared.d.ts","sourceRoot":"","sources":["../../src/contracts/service-shared.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,+BAA+B,EAC/B,8BAA8B,EAC9B,gCAAgC,EAChC,oBAAoB,EACpB,6BAA6B,EAC7B,4BAA4B,EAC5B,mCAAmC,EACnC,yBAAyB,EACzB,8BAA8B,EAC9B,gCAAgC,EAChC,oBAAoB,EACpB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAA;AAExB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACtF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACtF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAC9F,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAC9F,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtE,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACxF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC1F,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC1F,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAE9D;AA8DD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,UAAU,GAAG,MAAM,GAAG,cAAc,EAChD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,MAAM,CAkBR;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,OAAO,EACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,EAAE,CAYV;AAkBD,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAmCtD;AAED,wBAAsB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAC7C,SAAS,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,EACvB,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,EAC7C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM;;;;;GAIf"}

package/dist/contracts/service-shared.js

@@ -0,0 +1,142 @@
+import { sql } from "drizzle-orm";
+import { contractNumberSeries } from "./schema.js";
+export function toTimestamp(value) {
+    return value ? new Date(value) : null;
+}
+function resolvePath(obj, path) {
+    if (obj === null || obj === undefined)
+        return undefined;
+    const segments = [];
+    const parts = path.split(".");
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const indexMatches = [...part.matchAll(/([^[\]]+)|\[(\d+)\]/g)];
+        for (const match of indexMatches) {
+            if (match[1] !== undefined)
+                segments.push(match[1]);
+            else if (match[2] !== undefined)
+                segments.push(Number.parseInt(match[2], 10));
+        }
+    }
+    let current = obj;
+    for (const seg of segments) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof seg === "number") {
+            if (!Array.isArray(current))
+                return undefined;
+            current = current[seg];
+        }
+        else {
+            if (typeof current !== "object")
+                return undefined;
+            current = current[seg];
+        }
+    }
+    return current;
+}
+function stringifyValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return JSON.stringify(value);
+}
+const MUSTACHE_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
+function renderMustache(body, variables) {
+    return body.replace(MUSTACHE_RE, (_, path) => {
+        const resolved = resolvePath(variables, path.trim());
+        return stringifyValue(resolved);
+    });
+}
+function walkLexical(node, variables) {
+    const next = { ...node };
+    if (typeof next.text === "string") {
+        next.text = renderMustache(next.text, variables);
+    }
+    if (Array.isArray(next.children)) {
+        next.children = next.children.map((child) => walkLexical(child, variables));
+    }
+    return next;
+}
+export function renderTemplate(body, bodyFormat, variables) {
+    if (bodyFormat === "lexical_json") {
+        try {
+            const parsed = JSON.parse(body);
+            if (parsed && typeof parsed === "object") {
+                const obj = parsed;
+                if (obj.root && typeof obj.root === "object") {
+                    const result = { ...obj, root: walkLexical(obj.root, variables) };
+                    return JSON.stringify(result);
+                }
+                return JSON.stringify(walkLexical(obj, variables));
+            }
+            return body;
+        }
+        catch {
+            return renderMustache(body, variables);
+        }
+    }
+    return renderMustache(body, variables);
+}
+export function validateTemplateVariables(variableSchema, values) {
+    const issues = [];
+    if (!variableSchema || typeof variableSchema !== "object")
+        return issues;
+    const schema = variableSchema;
+    const requiredList = Array.isArray(schema.required) ? schema.required : [];
+    for (const key of requiredList) {
+        const resolved = resolvePath(values, key);
+        if (resolved === undefined || resolved === null || resolved === "") {
+            issues.push(`missing required variable: ${key}`);
+        }
+    }
+    return issues;
+}
+function currentPeriodBoundary(strategy, now) {
+    if (strategy === "never")
+        return null;
+    if (strategy === "annual")
+        return new Date(Date.UTC(now.getUTCFullYear(), 0, 1));
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}
+function formatNumber(prefix, separator, sequence, padLength) {
+    const padded = String(sequence).padStart(padLength, "0");
+    return `${prefix}${separator}${padded}`;
+}
+export async function allocateContractNumber(db, seriesId) {
+    return db.transaction(async (tx) => {
+        const rows = await tx.execute(sql `SELECT * FROM ${contractNumberSeries}
+          WHERE ${contractNumberSeries.id} = ${seriesId}
+          FOR UPDATE`);
+        const row = rows[0];
+        if (!row)
+            return null;
+        const strategy = row.reset_strategy;
+        const prefix = row.prefix ?? "";
+        const separator = row.separator ?? "";
+        const padLength = row.pad_length ?? 4;
+        const currentSequence = row.current_sequence ?? 0;
+        const resetAt = row.reset_at ? new Date(row.reset_at) : null;
+        const now = new Date();
+        const boundary = currentPeriodBoundary(strategy, now);
+        const shouldReset = boundary !== null && (resetAt === null || resetAt.getTime() < boundary.getTime());
+        const nextSequence = shouldReset ? 1 : currentSequence + 1;
+        const nextResetAt = strategy === "never" ? resetAt : boundary;
+        await tx
+            .update(contractNumberSeries)
+            .set({ currentSequence: nextSequence, resetAt: nextResetAt, updatedAt: new Date() })
+            .where(sql `${contractNumberSeries.id} = ${seriesId}`);
+        return {
+            number: formatNumber(prefix, separator, nextSequence, padLength),
+            sequence: nextSequence,
+        };
+    });
+}
+export async function paginate(rowsQuery, countQuery, limit, offset) {
+    const [data, countResult] = await Promise.all([rowsQuery, countQuery]);
+    return { data, total: countResult[0]?.total ?? 0, limit, offset };
+}