@voyantjs/legal 0.2.0 → 0.3.1

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

@@ -0,0 +1,434 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type ContractTemplateListQuery, type CreateContractTemplateInput, type CreateContractTemplateVersionInput, type RenderTemplateInput, type UpdateContractTemplateInput } from "./service-shared.js";
+export declare const contractTemplatesService: {
+    listTemplates(db: PostgresJsDatabase, query: ContractTemplateListQuery): Promise<{
+        data: {
+            id: string;
+            name: string;
+            slug: string;
+            scope: "customer" | "partner" | "supplier" | "other" | "channel";
+            language: string;
+            description: string | null;
+            bodyFormat: "markdown" | "html" | "lexical_json";
+            body: string;
+            variableSchema: unknown;
+            currentVersionId: string | null;
+            active: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getTemplateById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        language: string;
+        description: string | null;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        currentVersionId: string | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    getDefaultTemplate(db: PostgresJsDatabase, query: {
+        scope: "customer" | "supplier" | "partner" | "channel" | "other";
+        language?: string;
+        fallbackLanguages?: string[];
+    }): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        language: string;
+        description: string | null;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        currentVersionId: string | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createTemplate(db: PostgresJsDatabase, data: CreateContractTemplateInput): Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        description: string | null;
+        slug: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        language: string;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        currentVersionId: string | null;
+    } | null>;
+    updateTemplate(db: PostgresJsDatabase, id: string, data: UpdateContractTemplateInput): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        scope: "customer" | "partner" | "supplier" | "other" | "channel";
+        language: string;
+        description: string | null;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        currentVersionId: string | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteTemplate(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listTemplateVersions(db: PostgresJsDatabase, templateId: string): Omit<import("drizzle-orm/pg-core").PgSelectBase<"contract_template_versions", {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "contract_template_versions";
+            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;
+        }, {}, {}>;
+        templateId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "contract_template_versions";
+            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;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "contract_template_versions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bodyFormat: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body_format";
+            tableName: "contract_template_versions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "markdown" | "html" | "lexical_json";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["markdown", "html", "lexical_json"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        body: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body";
+            tableName: "contract_template_versions";
+            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;
+        }, {}, {}>;
+        variableSchema: import("drizzle-orm/pg-core").PgColumn<{
+            name: "variable_schema";
+            tableName: "contract_template_versions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        changelog: import("drizzle-orm/pg-core").PgColumn<{
+            name: "changelog";
+            tableName: "contract_template_versions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "contract_template_versions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "contract_template_versions";
+            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<"contract_template_versions", "not-null">, false, "where" | "orderBy", {
+        id: string;
+        templateId: string;
+        version: number;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        changelog: string | null;
+        createdBy: string | null;
+        createdAt: Date;
+    }[], {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "contract_template_versions";
+            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;
+        }, {}, {}>;
+        templateId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "contract_template_versions";
+            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;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "contract_template_versions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bodyFormat: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body_format";
+            tableName: "contract_template_versions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "markdown" | "html" | "lexical_json";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["markdown", "html", "lexical_json"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        body: import("drizzle-orm/pg-core").PgColumn<{
+            name: "body";
+            tableName: "contract_template_versions";
+            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;
+        }, {}, {}>;
+        variableSchema: import("drizzle-orm/pg-core").PgColumn<{
+            name: "variable_schema";
+            tableName: "contract_template_versions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        changelog: import("drizzle-orm/pg-core").PgColumn<{
+            name: "changelog";
+            tableName: "contract_template_versions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "contract_template_versions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "contract_template_versions";
+            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">;
+    getTemplateVersionById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        templateId: string;
+        version: number;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        changelog: string | null;
+        createdBy: string | null;
+        createdAt: Date;
+    } | null>;
+    createTemplateVersion(db: PostgresJsDatabase, templateId: string, data: CreateContractTemplateVersionInput): Promise<{
+        id: string;
+        createdAt: Date;
+        bodyFormat: "markdown" | "html" | "lexical_json";
+        body: string;
+        variableSchema: unknown;
+        templateId: string;
+        version: number;
+        changelog: string | null;
+        createdBy: string | null;
+    } | null>;
+    renderPreview(input: RenderTemplateInput): string;
+};
+//# sourceMappingURL=service-templates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-templates.d.ts","sourceRoot":"","sources":["../../src/contracts/service-templates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,kCAAkC,EAEvC,KAAK,mBAAmB,EAExB,KAAK,2BAA2B,EACjC,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,wBAAwB;sBACX,kBAAkB,SAAS,yBAAyB;;;;;;;;;;;;;;;;;;;;wBA6BlD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;2BASlD,kBAAkB,SACf;QACL,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;QAChE,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;KAC7B;;;;;;;;;;;;;;;uBAgCsB,kBAAkB,QAAQ,2BAA2B;;;;;;;;;;;;;;;uBAIrD,kBAAkB,MAAM,MAAM,QAAQ,2BAA2B;;;;;;;;;;;;;;;uBAQjE,kBAAkB,MAAM,MAAM;;;6BAO9B,kBAAkB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAO9B,kBAAkB,MAAM,MAAM;;;;;;;;;;;8BASzD,kBAAkB,cACV,MAAM,QACZ,kCAAkC;;;;;;;;;;;yBAmCrB,mBAAmB,GAAG,MAAM;CAKlD,CAAA"}

package/dist/contracts/service-templates.js

@@ -0,0 +1,132 @@
+import { and, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { contractTemplates, contractTemplateVersions } from "./schema.js";
+import { paginate, renderTemplate, } from "./service-shared.js";
+export const contractTemplatesService = {
+    async listTemplates(db, query) {
+        const conditions = [];
+        if (query.scope)
+            conditions.push(eq(contractTemplates.scope, query.scope));
+        if (query.language)
+            conditions.push(eq(contractTemplates.language, query.language));
+        if (query.active !== undefined)
+            conditions.push(eq(contractTemplates.active, query.active));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(contractTemplates.name, term), ilike(contractTemplates.slug, term), ilike(contractTemplates.description, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(contractTemplates)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(contractTemplates.updatedAt)), db.select({ total: sql `count(*)::int` }).from(contractTemplates).where(where), query.limit, query.offset);
+    },
+    async getTemplateById(db, id) {
+        const [row] = await db
+            .select()
+            .from(contractTemplates)
+            .where(eq(contractTemplates.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async getDefaultTemplate(db, query) {
+        const rows = await db
+            .select()
+            .from(contractTemplates)
+            .where(and(eq(contractTemplates.scope, query.scope), eq(contractTemplates.active, true)))
+            .orderBy(desc(contractTemplates.updatedAt));
+        if (rows.length === 0) {
+            return null;
+        }
+        const preferredLanguages = [
+            query.language?.trim().toLowerCase(),
+            ...(query.fallbackLanguages ?? []).map((value) => value.trim().toLowerCase()),
+        ].filter((value, index, values) => Boolean(value) && values.indexOf(value) === index);
+        if (preferredLanguages.length === 0) {
+            return rows[0] ?? null;
+        }
+        for (const language of preferredLanguages) {
+            const match = rows.find((row) => row.language.trim().toLowerCase() === language);
+            if (match) {
+                return match;
+            }
+        }
+        return rows[0] ?? null;
+    },
+    async createTemplate(db, data) {
+        const [row] = await db.insert(contractTemplates).values(data).returning();
+        return row ?? null;
+    },
+    async updateTemplate(db, id, data) {
+        const [row] = await db
+            .update(contractTemplates)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(contractTemplates.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteTemplate(db, id) {
+        const [row] = await db
+            .delete(contractTemplates)
+            .where(eq(contractTemplates.id, id))
+            .returning({ id: contractTemplates.id });
+        return row ?? null;
+    },
+    listTemplateVersions(db, templateId) {
+        return db
+            .select()
+            .from(contractTemplateVersions)
+            .where(eq(contractTemplateVersions.templateId, templateId))
+            .orderBy(desc(contractTemplateVersions.version));
+    },
+    async getTemplateVersionById(db, id) {
+        const [row] = await db
+            .select()
+            .from(contractTemplateVersions)
+            .where(eq(contractTemplateVersions.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createTemplateVersion(db, templateId, data) {
+        return db.transaction(async (tx) => {
+            const [template] = await tx
+                .select({ id: contractTemplates.id })
+                .from(contractTemplates)
+                .where(eq(contractTemplates.id, templateId))
+                .limit(1);
+            if (!template)
+                return null;
+            const [maxRow] = await tx
+                .select({ max: sql `coalesce(max(${contractTemplateVersions.version}), 0)::int` })
+                .from(contractTemplateVersions)
+                .where(eq(contractTemplateVersions.templateId, templateId));
+            const nextVersion = (maxRow?.max ?? 0) + 1;
+            const [version] = await tx
+                .insert(contractTemplateVersions)
+                .values({
+                templateId,
+                version: nextVersion,
+                bodyFormat: data.bodyFormat,
+                body: data.body,
+                variableSchema: data.variableSchema ?? null,
+                changelog: data.changelog ?? null,
+                createdBy: data.createdBy ?? null,
+            })
+                .returning();
+            if (version) {
+                await tx
+                    .update(contractTemplates)
+                    .set({ currentVersionId: version.id, updatedAt: new Date() })
+                    .where(eq(contractTemplates.id, templateId));
+            }
+            return version ?? null;
+        });
+    },
+    renderPreview(input) {
+        const body = input.body ?? "";
+        const format = input.bodyFormat ?? "markdown";
+        return renderTemplate(body, format, input.variables);
+    },
+};