@voyantjs/legal 0.2.0 → 0.3.0

package/dist/policies/service-core.d.ts.map

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

package/dist/policies/service-core.js

@@ -0,0 +1,357 @@
+import { and, desc, eq, gte, ilike, lte, or, sql } from "drizzle-orm";
+import { policies, policyAcceptances, policyAssignments, policyRules, policyVersions, } from "./schema.js";
+import { evaluateCancellationPolicy, paginate, toDateString, } from "./service-shared.js";
+export const policiesCoreService = {
+    async listPolicies(db, query) {
+        const conditions = [];
+        if (query.kind)
+            conditions.push(eq(policies.kind, query.kind));
+        if (query.language)
+            conditions.push(eq(policies.language, query.language));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(policies.name, term), ilike(policies.slug, term), ilike(policies.description, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(policies)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(policies.updatedAt)), db.select({ total: sql `count(*)::int` }).from(policies).where(where), query.limit, query.offset);
+    },
+    async getPolicyById(db, id) {
+        const [row] = await db.select().from(policies).where(eq(policies.id, id)).limit(1);
+        return row ?? null;
+    },
+    async getPolicyBySlug(db, slug) {
+        const [row] = await db.select().from(policies).where(eq(policies.slug, slug)).limit(1);
+        return row ?? null;
+    },
+    async createPolicy(db, data) {
+        const [row] = await db.insert(policies).values(data).returning();
+        return row ?? null;
+    },
+    async updatePolicy(db, id, data) {
+        const [row] = await db
+            .update(policies)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(policies.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deletePolicy(db, id) {
+        const [row] = await db
+            .delete(policies)
+            .where(eq(policies.id, id))
+            .returning({ id: policies.id });
+        return row ?? null;
+    },
+    listPolicyVersions(db, policyId) {
+        return db
+            .select()
+            .from(policyVersions)
+            .where(eq(policyVersions.policyId, policyId))
+            .orderBy(desc(policyVersions.version));
+    },
+    async getPolicyVersionById(db, id) {
+        const [row] = await db.select().from(policyVersions).where(eq(policyVersions.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createPolicyVersion(db, policyId, data) {
+        return db.transaction(async (tx) => {
+            const [policy] = await tx
+                .select({ id: policies.id })
+                .from(policies)
+                .where(eq(policies.id, policyId))
+                .limit(1);
+            if (!policy)
+                return null;
+            const [maxRow] = await tx
+                .select({ max: sql `coalesce(max(${policyVersions.version}), 0)::int` })
+                .from(policyVersions)
+                .where(eq(policyVersions.policyId, policyId));
+            const nextVersion = (maxRow?.max ?? 0) + 1;
+            const [row] = await tx
+                .insert(policyVersions)
+                .values({
+                policyId,
+                version: nextVersion,
+                status: "draft",
+                title: data.title,
+                bodyFormat: data.bodyFormat,
+                body: data.body ?? null,
+                publishedBy: data.publishedBy ?? null,
+                metadata: data.metadata ?? null,
+            })
+                .returning();
+            return row ?? null;
+        });
+    },
+    async updatePolicyVersion(db, versionId, data) {
+        const [row] = await db
+            .update(policyVersions)
+            .set({ ...data, updatedAt: new Date() })
+            .where(and(eq(policyVersions.id, versionId), eq(policyVersions.status, "draft")))
+            .returning();
+        return row ?? null;
+    },
+    async publishPolicyVersion(db, versionId) {
+        return db.transaction(async (tx) => {
+            const [version] = await tx
+                .select()
+                .from(policyVersions)
+                .where(eq(policyVersions.id, versionId))
+                .limit(1);
+            if (!version)
+                return { status: "not_found" };
+            if (version.status !== "draft")
+                return { status: "not_draft" };
+            const now = new Date();
+            await tx
+                .update(policyVersions)
+                .set({ status: "retired", retiredAt: now, updatedAt: now })
+                .where(and(eq(policyVersions.policyId, version.policyId), eq(policyVersions.status, "published")));
+            const [published] = await tx
+                .update(policyVersions)
+                .set({ status: "published", publishedAt: now, updatedAt: now })
+                .where(eq(policyVersions.id, versionId))
+                .returning();
+            await tx
+                .update(policies)
+                .set({ currentVersionId: versionId, updatedAt: now })
+                .where(eq(policies.id, version.policyId));
+            return { status: "published", version: published ?? null };
+        });
+    },
+    async retirePolicyVersion(db, versionId) {
+        const [row] = await db
+            .update(policyVersions)
+            .set({ status: "retired", retiredAt: new Date(), updatedAt: new Date() })
+            .where(eq(policyVersions.id, versionId))
+            .returning();
+        return row ?? null;
+    },
+    listPolicyRules(db, versionId) {
+        return db
+            .select()
+            .from(policyRules)
+            .where(eq(policyRules.policyVersionId, versionId))
+            .orderBy(policyRules.sortOrder, policyRules.createdAt);
+    },
+    async createPolicyRule(db, versionId, data) {
+        const [version] = await db
+            .select({ id: policyVersions.id })
+            .from(policyVersions)
+            .where(eq(policyVersions.id, versionId))
+            .limit(1);
+        if (!version)
+            return null;
+        const [row] = await db
+            .insert(policyRules)
+            .values({
+            policyVersionId: versionId,
+            ruleType: data.ruleType,
+            label: data.label ?? null,
+            daysBeforeDeparture: data.daysBeforeDeparture ?? null,
+            refundPercent: data.refundPercent ?? null,
+            refundType: data.refundType ?? null,
+            flatAmountCents: data.flatAmountCents ?? null,
+            currency: data.currency ?? null,
+            validFrom: toDateString(data.validFrom),
+            validTo: toDateString(data.validTo),
+            conditions: data.conditions ?? null,
+            sortOrder: data.sortOrder,
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updatePolicyRule(db, ruleId, data) {
+        const [row] = await db
+            .update(policyRules)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(policyRules.id, ruleId))
+            .returning();
+        return row ?? null;
+    },
+    async deletePolicyRule(db, ruleId) {
+        const [row] = await db
+            .delete(policyRules)
+            .where(eq(policyRules.id, ruleId))
+            .returning({ id: policyRules.id });
+        return row ?? null;
+    },
+    async listPolicyAssignments(db, query) {
+        const conditions = [];
+        if (query.policyId)
+            conditions.push(eq(policyAssignments.policyId, query.policyId));
+        if (query.scope)
+            conditions.push(eq(policyAssignments.scope, query.scope));
+        if (query.productId)
+            conditions.push(eq(policyAssignments.productId, query.productId));
+        if (query.channelId)
+            conditions.push(eq(policyAssignments.channelId, query.channelId));
+        if (query.supplierId)
+            conditions.push(eq(policyAssignments.supplierId, query.supplierId));
+        if (query.marketId)
+            conditions.push(eq(policyAssignments.marketId, query.marketId));
+        if (query.organizationId)
+            conditions.push(eq(policyAssignments.organizationId, query.organizationId));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(policyAssignments)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(policyAssignments.priority), desc(policyAssignments.createdAt)), db.select({ total: sql `count(*)::int` }).from(policyAssignments).where(where), query.limit, query.offset);
+    },
+    async createPolicyAssignment(db, data) {
+        const [row] = await db
+            .insert(policyAssignments)
+            .values({
+            policyId: data.policyId,
+            scope: data.scope,
+            productId: data.productId ?? null,
+            channelId: data.channelId ?? null,
+            supplierId: data.supplierId ?? null,
+            marketId: data.marketId ?? null,
+            organizationId: data.organizationId ?? null,
+            validFrom: toDateString(data.validFrom),
+            validTo: toDateString(data.validTo),
+            priority: data.priority,
+            metadata: data.metadata ?? null,
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updatePolicyAssignment(db, id, data) {
+        const [row] = await db
+            .update(policyAssignments)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(policyAssignments.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deletePolicyAssignment(db, id) {
+        const [row] = await db
+            .delete(policyAssignments)
+            .where(eq(policyAssignments.id, id))
+            .returning({ id: policyAssignments.id });
+        return row ?? null;
+    },
+    async resolvePolicy(db, input) {
+        const conditions = [];
+        const atDate = input.at ?? new Date().toISOString().slice(0, 10);
+        const scopeConditions = [];
+        if (input.productId)
+            scopeConditions.push(or(eq(policyAssignments.productId, input.productId), sql `${policyAssignments.productId} IS NULL`));
+        if (input.channelId)
+            scopeConditions.push(or(eq(policyAssignments.channelId, input.channelId), sql `${policyAssignments.channelId} IS NULL`));
+        if (input.supplierId)
+            scopeConditions.push(or(eq(policyAssignments.supplierId, input.supplierId), sql `${policyAssignments.supplierId} IS NULL`));
+        if (input.marketId)
+            scopeConditions.push(or(eq(policyAssignments.marketId, input.marketId), sql `${policyAssignments.marketId} IS NULL`));
+        if (input.organizationId)
+            scopeConditions.push(or(eq(policyAssignments.organizationId, input.organizationId), sql `${policyAssignments.organizationId} IS NULL`));
+        const validity = and(or(sql `${policyAssignments.validFrom} IS NULL`, lte(policyAssignments.validFrom, atDate)), or(sql `${policyAssignments.validTo} IS NULL`, gte(policyAssignments.validTo, atDate)));
+        const candidates = await db
+            .select({ assignment: policyAssignments, policy: policies })
+            .from(policyAssignments)
+            .innerJoin(policies, eq(policyAssignments.policyId, policies.id))
+            .where(and(eq(policies.kind, input.kind), validity, ...conditions, ...(scopeConditions.length ? [and(...scopeConditions)] : [])))
+            .orderBy(desc(policyAssignments.priority), desc(policyAssignments.createdAt));
+        if (candidates.length === 0)
+            return null;
+        const scored = candidates.map((c) => {
+            const a = c.assignment;
+            const specificity = (a.productId ? 1 : 0) +
+                (a.channelId ? 1 : 0) +
+                (a.supplierId ? 1 : 0) +
+                (a.marketId ? 1 : 0) +
+                (a.organizationId ? 1 : 0);
+            return { ...c, specificity };
+        });
+        scored.sort((a, b) => {
+            if (b.assignment.priority !== a.assignment.priority)
+                return b.assignment.priority - a.assignment.priority;
+            if (b.specificity !== a.specificity)
+                return b.specificity - a.specificity;
+            return b.assignment.createdAt.getTime() - a.assignment.createdAt.getTime();
+        });
+        const winner = scored[0];
+        if (!winner)
+            return null;
+        if (!winner.policy.currentVersionId)
+            return { policy: winner.policy, assignment: winner.assignment, version: null, rules: [] };
+        const [version] = await db
+            .select()
+            .from(policyVersions)
+            .where(eq(policyVersions.id, winner.policy.currentVersionId))
+            .limit(1);
+        const rules = version
+            ? await db
+                .select()
+                .from(policyRules)
+                .where(eq(policyRules.policyVersionId, version.id))
+                .orderBy(policyRules.sortOrder)
+            : [];
+        return { policy: winner.policy, assignment: winner.assignment, version: version ?? null, rules };
+    },
+    async evaluateCancellation(db, policyId, input) {
+        const [policy] = await db.select().from(policies).where(eq(policies.id, policyId)).limit(1);
+        if (!policy?.currentVersionId)
+            return null;
+        const rules = await db
+            .select()
+            .from(policyRules)
+            .where(eq(policyRules.policyVersionId, policy.currentVersionId));
+        const mapped = rules.map((r) => ({
+            id: r.id,
+            daysBeforeDeparture: r.daysBeforeDeparture,
+            refundPercent: r.refundPercent,
+            refundType: r.refundType,
+            flatAmountCents: r.flatAmountCents,
+            label: r.label,
+        }));
+        return evaluateCancellationPolicy(mapped, input);
+    },
+    async listPolicyAcceptances(db, query) {
+        const conditions = [];
+        if (query.policyVersionId)
+            conditions.push(eq(policyAcceptances.policyVersionId, query.policyVersionId));
+        if (query.personId)
+            conditions.push(eq(policyAcceptances.personId, query.personId));
+        if (query.bookingId)
+            conditions.push(eq(policyAcceptances.bookingId, query.bookingId));
+        if (query.orderId)
+            conditions.push(eq(policyAcceptances.orderId, query.orderId));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(policyAcceptances)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(policyAcceptances.acceptedAt)), db.select({ total: sql `count(*)::int` }).from(policyAcceptances).where(where), query.limit, query.offset);
+    },
+    async recordPolicyAcceptance(db, data) {
+        const [row] = await db
+            .insert(policyAcceptances)
+            .values({
+            policyVersionId: data.policyVersionId,
+            personId: data.personId ?? null,
+            bookingId: data.bookingId ?? null,
+            orderId: data.orderId ?? null,
+            offerId: data.offerId ?? null,
+            acceptedBy: data.acceptedBy ?? null,
+            method: data.method,
+            ipAddress: data.ipAddress ?? null,
+            userAgent: data.userAgent ?? null,
+            metadata: data.metadata ?? null,
+        })
+            .returning();
+        return row ?? null;
+    },
+};

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

@@ -0,0 +1,43 @@
+import { inArray } from "drizzle-orm";
+import type { z } from "zod";
+import type { evaluateCancellationInputSchema, insertPolicyAcceptanceSchema, insertPolicyAssignmentSchema, insertPolicyRuleSchema, insertPolicySchema, insertPolicyVersionSchema, policyAcceptanceListQuerySchema, policyAssignmentListQuerySchema, policyListQuerySchema, resolvePolicyInputSchema, updatePolicyAssignmentSchema, updatePolicyRuleSchema, updatePolicySchema, updatePolicyVersionSchema } from "./validation.js";
+export type PolicyListQuery = z.infer<typeof policyListQuerySchema>;
+export type CreatePolicyInput = z.infer<typeof insertPolicySchema>;
+export type UpdatePolicyInput = z.infer<typeof updatePolicySchema>;
+export type CreatePolicyVersionInput = z.infer<typeof insertPolicyVersionSchema>;
+export type UpdatePolicyVersionInput = z.infer<typeof updatePolicyVersionSchema>;
+export type CreatePolicyRuleInput = z.infer<typeof insertPolicyRuleSchema>;
+export type UpdatePolicyRuleInput = z.infer<typeof updatePolicyRuleSchema>;
+export type CreatePolicyAssignmentInput = z.infer<typeof insertPolicyAssignmentSchema>;
+export type UpdatePolicyAssignmentInput = z.infer<typeof updatePolicyAssignmentSchema>;
+export type PolicyAssignmentListQuery = z.infer<typeof policyAssignmentListQuerySchema>;
+export type CreatePolicyAcceptanceInput = z.infer<typeof insertPolicyAcceptanceSchema>;
+export type PolicyAcceptanceListQuery = z.infer<typeof policyAcceptanceListQuerySchema>;
+export type EvaluateCancellationInput = z.infer<typeof evaluateCancellationInputSchema>;
+export type ResolvePolicyInput = z.infer<typeof resolvePolicyInputSchema>;
+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;
+}>;
+export declare function toDateString(value?: string | null): string | null;
+export type CancellationRule = {
+    id?: string;
+    daysBeforeDeparture: number | null;
+    refundPercent: number | null;
+    refundType: "cash" | "credit" | "cash_or_credit" | "none" | null;
+    flatAmountCents: number | null;
+    label: string | null;
+};
+export type CancellationResult = {
+    refundPercent: number;
+    refundCents: number;
+    refundType: "cash" | "credit" | "cash_or_credit" | "none";
+    appliedRule: CancellationRule | null;
+};
+export declare function evaluateCancellationPolicy(rules: CancellationRule[], input: EvaluateCancellationInput): CancellationResult;
+export declare const _unused: typeof inArray;
+//# sourceMappingURL=service-shared.d.ts.map

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

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

package/dist/policies/service-shared.js

@@ -0,0 +1,30 @@
+import { inArray } from "drizzle-orm";
+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 };
+}
+export function toDateString(value) {
+    return value ?? null;
+}
+export function evaluateCancellationPolicy(rules, input) {
+    if (rules.length === 0) {
+        return { refundPercent: 0, refundCents: 0, refundType: "none", appliedRule: null };
+    }
+    const sorted = [...rules].sort((a, b) => {
+        const ad = a.daysBeforeDeparture ?? Number.NEGATIVE_INFINITY;
+        const bd = b.daysBeforeDeparture ?? Number.NEGATIVE_INFINITY;
+        return bd - ad;
+    });
+    const applied = sorted.find((rule) => rule.daysBeforeDeparture !== null && input.daysBeforeDeparture >= rule.daysBeforeDeparture) ??
+        sorted[sorted.length - 1] ??
+        null;
+    if (!applied) {
+        return { refundPercent: 0, refundCents: 0, refundType: "none", appliedRule: null };
+    }
+    const refundPercent = applied.refundPercent ?? 0;
+    const refundType = applied.refundType ?? "none";
+    const percentageRefundCents = Math.floor((input.totalCents * refundPercent) / 10000);
+    const refundCents = applied.flatAmountCents ?? percentageRefundCents;
+    return { refundPercent, refundCents, refundType, appliedRule: applied };
+}
+export const _unused = inArray;