@voyantjs/legal 0.3.0 → 0.4.0

package/dist/contracts/service-documents.js

@@ -0,0 +1,244 @@
+import { renderPdfDocument } from "@voyantjs/utils/pdf-renderer";
+import { desc, eq } from "drizzle-orm";
+import { contractAttachments, contracts, contractTemplateVersions } from "./schema.js";
+import { contractRecordsService } from "./service-contracts.js";
+import { renderTemplate } from "./service-shared.js";
+function normalizeAttachmentInput(input, fallbackKind) {
+    return {
+        kind: input.kind ?? fallbackKind,
+        name: input.name,
+        mimeType: input.mimeType ?? null,
+        fileSize: input.fileSize ?? null,
+        storageKey: input.storageKey ?? null,
+        checksum: input.checksum ?? null,
+        metadata: input.metadata ?? null,
+    };
+}
+function defaultContractDocumentExtension(format) {
+    switch (format) {
+        case "html":
+            return "html";
+        case "lexical_json":
+            return "json";
+        default:
+            return "md";
+    }
+}
+function defaultContractDocumentMimeType(format) {
+    switch (format) {
+        case "html":
+            return "text/html; charset=utf-8";
+        case "lexical_json":
+            return "application/json; charset=utf-8";
+        default:
+            return "text/markdown; charset=utf-8";
+    }
+}
+function encodeStringBody(value) {
+    return new TextEncoder().encode(value);
+}
+function getBodySize(body) {
+    if (body instanceof Uint8Array)
+        return body.byteLength;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength;
+    return body.size;
+}
+function toUploadMetadata(metadata) {
+    const entries = Object.entries(metadata ?? {}).filter(([, value]) => ["string", "number", "boolean"].includes(typeof value));
+    return entries.length > 0
+        ? Object.fromEntries(entries.map(([key, value]) => [key, String(value)]))
+        : undefined;
+}
+export function defaultStorageBackedContractDocumentSerializer(context) {
+    const extension = defaultContractDocumentExtension(context.renderedBodyFormat);
+    return {
+        body: encodeStringBody(context.renderedBody),
+        name: `contract-${context.contract.id}.${extension}`,
+        mimeType: defaultContractDocumentMimeType(context.renderedBodyFormat),
+        metadata: {
+            renderedBodyFormat: context.renderedBodyFormat,
+        },
+    };
+}
+export async function defaultPdfContractDocumentSerializer(context) {
+    const body = await renderPdfDocument({
+        title: `Contract ${context.contract.id}`,
+        content: context.renderedBody,
+        format: context.renderedBodyFormat === "lexical_json"
+            ? "lexical_json"
+            : context.renderedBodyFormat === "html"
+                ? "html"
+                : "markdown",
+        metadataLines: [`Contract ID: ${context.contract.id}`, `Status: ${context.contract.status}`],
+    });
+    return {
+        body,
+        name: `contract-${context.contract.id}.pdf`,
+        mimeType: "application/pdf",
+        metadata: {
+            renderedBodyFormat: context.renderedBodyFormat,
+            renderer: "voyant-basic-pdf",
+        },
+    };
+}
+export function createStorageBackedContractDocumentGenerator(options) {
+    const serializer = options.serializer ?? defaultStorageBackedContractDocumentSerializer;
+    return async (context) => {
+        const upload = await serializer(context);
+        const keyPrefix = typeof options.keyPrefix === "function"
+            ? await options.keyPrefix(context)
+            : (options.keyPrefix ?? `contracts/${context.contract.id}`);
+        const normalizedName = upload.name?.trim() ||
+            `contract-${context.contract.id}.${defaultContractDocumentExtension(context.renderedBodyFormat)}`;
+        const normalizedKey = upload.key?.trim() || `${keyPrefix.replace(/\/$/, "")}/${normalizedName}`;
+        const uploaded = await options.storage.upload(upload.body, {
+            key: normalizedKey,
+            contentType: upload.mimeType ?? defaultContractDocumentMimeType(context.renderedBodyFormat),
+            metadata: toUploadMetadata(upload.metadata),
+        });
+        const downloadUrl = uploaded.url ||
+            (options.signedUrlExpiresIn
+                ? await options.storage.signedUrl(uploaded.key, options.signedUrlExpiresIn)
+                : "");
+        return {
+            kind: upload.kind ?? "document",
+            name: normalizedName,
+            mimeType: upload.mimeType ?? defaultContractDocumentMimeType(context.renderedBodyFormat),
+            fileSize: getBodySize(upload.body),
+            storageKey: uploaded.key,
+            metadata: {
+                ...(upload.metadata ?? {}),
+                storageProvider: options.storage.name,
+                ...(uploaded.url ? { url: uploaded.url } : {}),
+                ...(downloadUrl ? { downloadUrl } : {}),
+            },
+        };
+    };
+}
+export function createPdfContractDocumentGenerator(options) {
+    return createStorageBackedContractDocumentGenerator({
+        ...options,
+        serializer: defaultPdfContractDocumentSerializer,
+    });
+}
+async function loadTemplateVersion(db, templateVersionId) {
+    if (!templateVersionId) {
+        return null;
+    }
+    const [version] = await db
+        .select()
+        .from(contractTemplateVersions)
+        .where(eq(contractTemplateVersions.id, templateVersionId))
+        .limit(1);
+    return version ?? null;
+}
+async function ensureRenderedContract(db, contractId, issueIfDraft) {
+    let contract = await contractRecordsService.getContractById(db, contractId);
+    if (!contract) {
+        return { status: "not_found" };
+    }
+    if (contract.status === "draft" && issueIfDraft) {
+        const issued = await contractRecordsService.issueContract(db, contractId);
+        if (issued.status !== "issued" || !issued.contract) {
+            if (issued.status === "not_found") {
+                return { status: "not_found" };
+            }
+            return { status: "not_draft", contract: null };
+        }
+        contract = issued.contract;
+    }
+    const templateVersion = await loadTemplateVersion(db, contract.templateVersionId ?? null);
+    let renderedBody = contract.renderedBody;
+    let renderedBodyFormat = contract.renderedBodyFormat;
+    if ((!renderedBody || !renderedBodyFormat) && templateVersion) {
+        const variables = contract.variables ?? {};
+        renderedBody = renderTemplate(templateVersion.body, templateVersion.bodyFormat, variables);
+        renderedBodyFormat = templateVersion.bodyFormat;
+        const [updated] = await db
+            .update(contracts)
+            .set({
+            renderedBody,
+            renderedBodyFormat,
+            updatedAt: new Date(),
+        })
+            .where(eq(contracts.id, contractId))
+            .returning();
+        contract = updated ?? contract;
+    }
+    if (!renderedBody || !renderedBodyFormat) {
+        return { status: "render_unavailable", contract, templateVersion };
+    }
+    return {
+        status: "ready",
+        contract,
+        templateVersion,
+        renderedBody,
+        renderedBodyFormat,
+    };
+}
+export const contractDocumentsService = {
+    async generateContractDocument(db, contractId, input, runtime) {
+        const prepared = await ensureRenderedContract(db, contractId, input.issueIfDraft);
+        if (prepared.status === "not_found") {
+            return { status: "not_found" };
+        }
+        if (prepared.status === "not_draft") {
+            return { status: "not_draft" };
+        }
+        if (prepared.status === "render_unavailable") {
+            return { status: "render_unavailable" };
+        }
+        let artifact;
+        try {
+            artifact = await runtime.generator({
+                db,
+                contract: prepared.contract,
+                templateVersion: prepared.templateVersion,
+                renderedBody: prepared.renderedBody,
+                renderedBodyFormat: prepared.renderedBodyFormat,
+                variables: prepared.contract.variables ?? {},
+                bindings: runtime.bindings ?? {},
+            });
+        }
+        catch {
+            return { status: "generator_failed" };
+        }
+        if (input.replaceExisting) {
+            const existing = await db
+                .select({ id: contractAttachments.id })
+                .from(contractAttachments)
+                .where(eq(contractAttachments.contractId, contractId))
+                .orderBy(desc(contractAttachments.createdAt));
+            for (const attachment of existing) {
+                const row = await db
+                    .select({ id: contractAttachments.id, kind: contractAttachments.kind })
+                    .from(contractAttachments)
+                    .where(eq(contractAttachments.id, attachment.id))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null);
+                if (row?.kind === (artifact.kind ?? input.kind)) {
+                    await contractRecordsService.deleteAttachment(db, attachment.id);
+                }
+            }
+        }
+        const attachment = await contractRecordsService.createAttachment(db, contractId, normalizeAttachmentInput(artifact, input.kind));
+        if (!attachment) {
+            return { status: "not_found" };
+        }
+        return {
+            status: "generated",
+            contractId: prepared.contract.id,
+            contractStatus: prepared.contract.status,
+            renderedBodyFormat: prepared.renderedBodyFormat,
+            renderedBody: prepared.renderedBody,
+            attachment,
+        };
+    },
+    async regenerateContractDocument(db, contractId, input, runtime) {
+        return this.generateContractDocument(db, contractId, {
+            ...input,
+            issueIfDraft: input.issueIfDraft,
+        }, runtime);
+    },
+};

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

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

@@ -1,3 +1,4 @@
+import { renderStructuredTemplate } from "@voyantjs/utils/template-renderer";
 import { sql } from "drizzle-orm";
 import { contractNumberSeries } from "./schema.js";
 export function toTimestamp(value) {
@@ -36,51 +37,8 @@ function resolvePath(obj, path) {
     }
     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);
+    return renderStructuredTemplate(body, bodyFormat, variables);
 }
 export function validateTemplateVariables(variableSchema, values) {
     const issues = [];

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

@@ -36,6 +36,25 @@ export declare const contractTemplatesService: {
         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;

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

@@ -1 +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;;;;;;;;;;;;;;;uBAQ/B,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"}
+{"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

@@ -31,6 +31,30 @@ export const contractTemplatesService = {
             .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;

package/dist/contracts/service.d.ts

@@ -1,6 +1,16 @@
 import { allocateContractNumber, renderTemplate, validateTemplateVariables } from "./service-shared.js";
 export { allocateContractNumber, renderTemplate, validateTemplateVariables };
 export declare const contractsService: {
+    generateContractDocument(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, contractId: string, input: import("./validation.js").GenerateContractDocumentInput, runtime: import("./service-documents.js").ContractDocumentRuntimeOptions): Promise<{
+        status: "not_found" | "not_draft" | "render_unavailable" | "generator_failed";
+    } | ({
+        status: "generated";
+    } & import("./service-documents.js").GeneratedContractDocumentRecord)>;
+    regenerateContractDocument(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, contractId: string, input: import("./validation.js").GenerateContractDocumentInput, runtime: import("./service-documents.js").ContractDocumentRuntimeOptions): Promise<{
+        status: "not_found" | "not_draft" | "render_unavailable" | "generator_failed";
+    } | ({
+        status: "generated";
+    } & import("./service-documents.js").GeneratedContractDocumentRecord)>;
     listContracts(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./service-shared.js").ContractListQuery): Promise<{
         data: {
             id: string;
@@ -1328,6 +1338,25 @@ export declare const contractsService: {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
+    getDefaultTemplate(db: import("drizzle-orm/postgres-js").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: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./service-shared.js").CreateContractTemplateInput): Promise<{
         id: string;
         name: string;

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

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/contracts/service.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,yBAAyB,EAAE,CAAA;AAE5E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI5B,CAAA"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/contracts/service.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,yBAAyB,EAAE,CAAA;AAE5E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAMwxC,CAAC;yBAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADt1C,CAAA"}

package/dist/contracts/service.js

@@ -1,4 +1,5 @@
 import { contractRecordsService } from "./service-contracts.js";
+import { contractDocumentsService } from "./service-documents.js";
 import { contractSeriesService } from "./service-series.js";
 import { allocateContractNumber, renderTemplate, validateTemplateVariables, } from "./service-shared.js";
 import { contractTemplatesService } from "./service-templates.js";
@@ -7,4 +8,5 @@ export const contractsService = {
     ...contractTemplatesService,
     ...contractSeriesService,
     ...contractRecordsService,
+    ...contractDocumentsService,
 };

package/dist/contracts/validation.d.ts

@@ -87,6 +87,17 @@ export declare const contractTemplateListQuerySchema: z.ZodObject<{
     active: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
     search: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const contractTemplateDefaultQuerySchema: z.ZodObject<{
+    scope: z.ZodDefault<z.ZodEnum<{
+        customer: "customer";
+        partner: "partner";
+        supplier: "supplier";
+        other: "other";
+        channel: "channel";
+    }>>;
+    language: z.ZodOptional<z.ZodString>;
+    fallbackLanguages: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[], string | undefined>>;
+}, z.core.$strip>;
 export declare const insertContractTemplateVersionSchema: z.ZodObject<{
     bodyFormat: z.ZodDefault<z.ZodEnum<{
         markdown: "markdown";
@@ -235,6 +246,56 @@ export declare const renderTemplateInputSchema: z.ZodObject<{
     }>>;
     body: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const publicRenderTemplatePreviewInputSchema: z.ZodObject<{
+    variables: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const generateContractDocumentInputSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodString>;
+    replaceExisting: z.ZodDefault<z.ZodBoolean>;
+    issueIfDraft: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const generatedContractDocumentAttachmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    contractId: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodNullable<z.ZodString>;
+    fileSize: z.ZodNullable<z.ZodNumber>;
+    storageKey: z.ZodNullable<z.ZodString>;
+    checksum: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const generatedContractDocumentResultSchema: z.ZodObject<{
+    contractId: z.ZodString;
+    contractStatus: z.ZodEnum<{
+        draft: "draft";
+        sent: "sent";
+        expired: "expired";
+        issued: "issued";
+        signed: "signed";
+        executed: "executed";
+        void: "void";
+    }>;
+    renderedBodyFormat: z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+        lexical_json: "lexical_json";
+    }>;
+    renderedBody: z.ZodString;
+    attachment: z.ZodObject<{
+        id: z.ZodString;
+        contractId: z.ZodString;
+        kind: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodNullable<z.ZodString>;
+        fileSize: z.ZodNullable<z.ZodNumber>;
+        storageKey: z.ZodNullable<z.ZodString>;
+        checksum: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const insertContractSignatureSchema: z.ZodObject<{
     signerName: z.ZodString;
     signerEmail: z.ZodNullable<z.ZodOptional<z.ZodString>>;
@@ -271,4 +332,5 @@ export declare const updateContractAttachmentSchema: z.ZodObject<{
     checksum: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
     metadata: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
 }, z.core.$strip>;
+export type GenerateContractDocumentInput = z.infer<typeof generateContractDocumentInputSchema>;
 //# sourceMappingURL=validation.d.ts.map

package/dist/contracts/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/contracts/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mBAAmB;;;;;;EAAkE,CAAA;AAElG,eAAO,MAAM,oBAAoB;;;;;;;;EAQ/B,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;EAAwD,CAAA;AAElG,eAAO,MAAM,iCAAiC;;;;EAAyC,CAAA;AAEvF,eAAO,MAAM,wBAAwB;;;;EAA+C,CAAA;AAyBpF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAA;AACtE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;iBAAuC,CAAA;AAEhF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;iBAK1C,CAAA;AAIF,eAAO,MAAM,mCAAmC;;;;;;;;;;iBAM9C,CAAA;AAeF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;iBAAiC,CAAA;AAC9E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;iBAA2C,CAAA;AAsBxF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqB,CAAA;AACtD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+B,CAAA;AAEhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;iBAIpC,CAAA;AAkBF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;iBAA8B,CAAA;AAcxE,eAAO,MAAM,8BAA8B;;;;;;;;iBAA+B,CAAA;AAC1E,eAAO,MAAM,8BAA8B;;;;;;;;iBAAyC,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/contracts/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mBAAmB;;;;;;EAAkE,CAAA;AAElG,eAAO,MAAM,oBAAoB;;;;;;;;EAQ/B,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;EAAwD,CAAA;AAElG,eAAO,MAAM,iCAAiC;;;;EAAyC,CAAA;AAEvF,eAAO,MAAM,wBAAwB;;;;EAA+C,CAAA;AAyBpF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAA;AACtE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;iBAAuC,CAAA;AAEhF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;iBAK1C,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;iBAc7C,CAAA;AAIF,eAAO,MAAM,mCAAmC;;;;;;;;;;iBAM9C,CAAA;AAeF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;iBAAiC,CAAA;AAC9E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;iBAA2C,CAAA;AAsBxF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqB,CAAA;AACtD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+B,CAAA;AAEhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;iBAIpC,CAAA;AAEF,eAAO,MAAM,sCAAsC;;iBAEjD,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;iBAI9C,CAAA;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;iBAWpD,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMhD,CAAA;AAkBF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;iBAA8B,CAAA;AAcxE,eAAO,MAAM,8BAA8B;;;;;;;;iBAA+B,CAAA;AAC1E,eAAO,MAAM,8BAA8B;;;;;;;;iBAAyC,CAAA;AAEpF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA"}

package/dist/contracts/validation.js

@@ -40,6 +40,19 @@ export const contractTemplateListQuerySchema = paginationSchema.extend({
     active: z.coerce.boolean().optional(),
     search: z.string().optional(),
 });
+export const contractTemplateDefaultQuerySchema = z.object({
+    scope: contractScopeSchema.default("customer"),
+    language: z.string().min(2).max(10).optional(),
+    fallbackLanguages: z
+        .string()
+        .optional()
+        .transform((value) => value
+        ? value
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean)
+        : []),
+});
 // ---------- contract template versions ----------
 export const insertContractTemplateVersionSchema = z.object({
     bodyFormat: contractBodyFormatSchema.default("markdown"),
@@ -96,6 +109,33 @@ export const renderTemplateInputSchema = z.object({
     bodyFormat: contractBodyFormatSchema.optional(),
     body: z.string().optional(),
 });
+export const publicRenderTemplatePreviewInputSchema = z.object({
+    variables: z.record(z.string(), z.unknown()),
+});
+export const generateContractDocumentInputSchema = z.object({
+    kind: z.string().min(1).max(50).default("document"),
+    replaceExisting: z.boolean().default(true),
+    issueIfDraft: z.boolean().default(true),
+});
+export const generatedContractDocumentAttachmentSchema = z.object({
+    id: z.string(),
+    contractId: z.string(),
+    kind: z.string(),
+    name: z.string(),
+    mimeType: z.string().nullable(),
+    fileSize: z.number().int().nullable(),
+    storageKey: z.string().nullable(),
+    checksum: z.string().nullable(),
+    metadata: z.record(z.string(), z.unknown()).nullable(),
+    createdAt: z.string(),
+});
+export const generatedContractDocumentResultSchema = z.object({
+    contractId: z.string(),
+    contractStatus: contractStatusSchema,
+    renderedBodyFormat: contractBodyFormatSchema,
+    renderedBody: z.string(),
+    attachment: generatedContractDocumentAttachmentSchema,
+});
 // ---------- contract signatures ----------
 const contractSignatureCoreSchema = z.object({
     signerName: z.string().min(1).max(255),

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { Module } from "@voyantjs/core";
 import type { HonoModule } from "@voyantjs/hono/module";
+import { type ContractsRouteOptions } from "./contracts/routes.js";
 export declare const legalLinkable: {
     policy: import("@voyantjs/core").LinkableDefinition;
     policyVersion: import("@voyantjs/core").LinkableDefinition;
@@ -8,7 +9,9 @@ export declare const legalLinkable: {
     contractTemplate: import("@voyantjs/core").LinkableDefinition;
 };
 export declare const legalModule: Module;
+export declare function createLegalHonoModule(options?: ContractsRouteOptions): HonoModule;
 export declare const legalHonoModule: HonoModule;
 export * from "./contracts/index.js";
+export type { ContractsRouteOptions } from "./contracts/routes.js";
 export * from "./policies/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAOvD,eAAO,MAAM,aAAa;;;;;;CAGzB,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAGzB,CAAA;AAUD,eAAO,MAAM,eAAe,EAAE,UAI7B,CAAA;AAED,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGvD,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,uBAAuB,CAAA;AAI9B,eAAO,MAAM,aAAa;;;;;;CAGzB,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAGzB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU,CAcrF;AAED,eAAO,MAAM,eAAe,EAAE,UAAoC,CAAA;AAElE,cAAc,sBAAsB,CAAA;AACpC,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAClE,cAAc,qBAAqB,CAAA"}

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Hono } from "hono";
 import { contractsLinkable } from "./contracts/index.js";
-import { contractsAdminRoutes, contractsPublicRoutes } from "./contracts/routes.js";
+import { createContractsAdminRoutes, createContractsPublicRoutes, } from "./contracts/routes.js";
 import { policiesLinkable } from "./policies/index.js";
 import { policiesAdminRoutes, policiesPublicRoutes } from "./policies/routes.js";
 export const legalLinkable = {
@@ -11,16 +11,19 @@ export const legalModule = {
     name: "legal",
     linkable: legalLinkable,
 };
-const legalAdminRoutes = new Hono()
-    .route("/contracts", contractsAdminRoutes)
-    .route("/policies", policiesAdminRoutes);
-const legalPublicRoutes = new Hono()
-    .route("/contracts", contractsPublicRoutes)
-    .route("/policies", policiesPublicRoutes);
-export const legalHonoModule = {
-    module: legalModule,
-    adminRoutes: legalAdminRoutes,
-    publicRoutes: legalPublicRoutes,
-};
+export function createLegalHonoModule(options = {}) {
+    const legalAdminRoutes = new Hono()
+        .route("/contracts", createContractsAdminRoutes(options))
+        .route("/policies", policiesAdminRoutes);
+    const legalPublicRoutes = new Hono()
+        .route("/contracts", createContractsPublicRoutes())
+        .route("/policies", policiesPublicRoutes);
+    return {
+        module: legalModule,
+        adminRoutes: legalAdminRoutes,
+        publicRoutes: legalPublicRoutes,
+    };
+}
+export const legalHonoModule = createLegalHonoModule();
 export * from "./contracts/index.js";
 export * from "./policies/index.js";