@cullet/erp-core 1.0.2 → 1.0.4

package/src/core/policies/engines/v1/condition-schema.ts

@@ -7,44 +7,44 @@ import type { ConditionLeafNode, ConditionNode } from "./condition-types";
 // condition nodes without either engine depending on the other.
 
 const conditionOpSchema = z.enum([
-  "eq",
-  "neq",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "in",
-  "notIn",
-  "isNull",
-  "isNotNull",
+    "eq",
+    "neq",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "in",
+    "notIn",
+    "isNull",
+    "isNotNull",
 ]);
 
 export const conditionLeafNodeSchema: z.ZodType<ConditionLeafNode> = z
-  .object({
-    field: z.string().min(1),
-    op: conditionOpSchema,
-    value: z.unknown(),
-    allowNull: z.literal(true).optional(),
-  })
-  .strict() as z.ZodType<ConditionLeafNode>;
+    .object({
+        field: z.string().min(1),
+        op: conditionOpSchema,
+        value: z.unknown(),
+        allowNull: z.literal(true).optional(),
+    })
+    .strict() as z.ZodType<ConditionLeafNode>;
 
 export const conditionNodeSchema: z.ZodType<ConditionNode> = z.lazy(() =>
-  z.union([
-    conditionLeafNodeSchema,
-    z
-      .object({
-        and: z.array(conditionNodeSchema).min(1),
-      })
-      .strict(),
-    z
-      .object({
-        or: z.array(conditionNodeSchema).min(1),
-      })
-      .strict(),
-    z
-      .object({
-        not: conditionNodeSchema,
-      })
-      .strict(),
-  ]),
+    z.union([
+        conditionLeafNodeSchema,
+        z
+            .object({
+                and: z.array(conditionNodeSchema).min(1),
+            })
+            .strict(),
+        z
+            .object({
+                or: z.array(conditionNodeSchema).min(1),
+            })
+            .strict(),
+        z
+            .object({
+                not: conditionNodeSchema,
+            })
+            .strict(),
+    ]),
 );

package/src/core/policies/engines/v1/condition-types.ts

@@ -4,38 +4,38 @@
 // structurally dependent on gate/v1.
 
 export type ConditionOp =
-  | "eq"
-  | "neq"
-  | "gt"
-  | "gte"
-  | "lt"
-  | "lte"
-  | "in"
-  | "notIn"
-  | "isNull"
-  | "isNotNull";
+    | "eq"
+    | "neq"
+    | "gt"
+    | "gte"
+    | "lt"
+    | "lte"
+    | "in"
+    | "notIn"
+    | "isNull"
+    | "isNotNull";
 
 export interface ConditionLeafNode {
-  readonly field: string;
-  readonly op: ConditionOp;
-  readonly value: unknown;
-  readonly allowNull?: true;
+    readonly field: string;
+    readonly op: ConditionOp;
+    readonly value: unknown;
+    readonly allowNull?: true;
 }
 
 export interface ConditionAndNode {
-  readonly and: readonly ConditionNode[];
+    readonly and: readonly ConditionNode[];
 }
 
 export interface ConditionOrNode {
-  readonly or: readonly ConditionNode[];
+    readonly or: readonly ConditionNode[];
 }
 
 export interface ConditionNotNode {
-  readonly not: ConditionNode;
+    readonly not: ConditionNode;
 }
 
 export type ConditionNode =
-  | ConditionLeafNode
-  | ConditionAndNode
-  | ConditionOrNode
-  | ConditionNotNode;
+    | ConditionLeafNode
+    | ConditionAndNode
+    | ConditionOrNode
+    | ConditionNotNode;

package/src/core/policies/engines/v1/gate/gate-engine-v1.ts

@@ -3,155 +3,159 @@ import { Outcome } from "../../../../result/outcome";
 import { Result } from "../../../../result/result";
 
 import {
-  ConditionEvaluatorV1,
-  type TracedConditionEvaluation,
+    ConditionEvaluatorV1,
+    type TracedConditionEvaluation,
 } from "../condition-evaluator";
 import type { ConditionLeafNode, ConditionNode } from "../condition-types";
 import type { GatePayload } from "../../gate-payload";
 import type {
-  GateOutcome,
-  GateStatus,
-  GateTraceLeafSnapshot,
-  GateTraceNodeSnapshot,
-  PolicyContext,
-  PolicyViolation,
-  VersionedGateEngine,
+    GateOutcome,
+    GateStatus,
+    GateTraceLeafSnapshot,
+    GateTraceNodeSnapshot,
+    PolicyContext,
+    PolicyViolation,
+    VersionedGateEngine,
 } from "../../gate-types";
 
 // ─── Gate engine v1 ─────────────────────────────────────────────────────────
 
 export class GateEngineV1 implements VersionedGateEngine {
-  public readonly version = 1;
-  private readonly coreConfig: CoreConfig;
-
-  constructor(params: { readonly coreConfig?: CoreConfig } = {}) {
-    this.coreConfig = params.coreConfig ?? coreConfig;
-  }
-
-  private allow(): Result<GateOutcome, string> {
-    return Result.ok(Outcome.of("ALLOW", { violations: [] }));
-  }
-
-  private deny(violation: PolicyViolation): Result<GateOutcome, string> {
-    return Result.ok(
-      Outcome.of("DENY", {
-        violations: [violation],
-      }),
-    );
-  }
-
-  private outcomeFromStatus(
-    status: GateStatus,
-    violation: PolicyViolation,
-  ): Result<GateOutcome, string> {
-    return status === "ALLOW" ? this.allow() : this.deny(violation);
-  }
-
-  private isLeafNode(node: ConditionNode): node is ConditionLeafNode {
-    return "field" in node && "op" in node;
-  }
-
-  private toLeafSnapshot(node: ConditionLeafNode): GateTraceLeafSnapshot {
-    return {
-      kind: "LEAF",
-      field: node.field,
-      op: node.op,
-      ...(node.allowNull === true ? { allowNull: true } : {}),
-    };
-  }
-
-  private toNodeSnapshot(node: ConditionNode): GateTraceNodeSnapshot {
-    if (this.isLeafNode(node)) {
-      return this.toLeafSnapshot(node);
+    public readonly version = 1;
+    private readonly coreConfig: CoreConfig;
+
+    constructor(params: { readonly coreConfig?: CoreConfig } = {}) {
+        this.coreConfig = params.coreConfig ?? coreConfig;
+    }
+
+    private allow(): Result<GateOutcome, string> {
+        return Result.ok(Outcome.of("ALLOW", { violations: [] }));
+    }
+
+    private deny(violation: PolicyViolation): Result<GateOutcome, string> {
+        return Result.ok(
+            Outcome.of("DENY", {
+                violations: [violation],
+            }),
+        );
+    }
+
+    private outcomeFromStatus(
+        status: GateStatus,
+        violation: PolicyViolation,
+    ): Result<GateOutcome, string> {
+        return status === "ALLOW" ? this.allow() : this.deny(violation);
     }
 
-    if ("and" in node) {
-      return {
-        kind: "AND",
-        childCount: node.and.length,
-      };
+    private isLeafNode(node: ConditionNode): node is ConditionLeafNode {
+        return "field" in node && "op" in node;
     }
 
-    if ("or" in node) {
-      return {
-        kind: "OR",
-        childCount: node.or.length,
-      };
+    private toLeafSnapshot(node: ConditionLeafNode): GateTraceLeafSnapshot {
+        return {
+            kind: "LEAF",
+            field: node.field,
+            op: node.op,
+            ...(node.allowNull === true ? { allowNull: true } : {}),
+        };
     }
 
-    return {
-      kind: "NOT",
-    };
-  }
-
-  private buildDenyViolation(
-    conditionResult: TracedConditionEvaluation,
-  ): PolicyViolation {
-    return {
-      code: "DENY_CONDITION_MET",
-      message: `Gate denied at ${conditionResult.trace.conditionPath}`,
-      trace: {
-        conditionPath: conditionResult.trace.conditionPath,
-        decisiveNode: this.toNodeSnapshot(conditionResult.trace.decisiveNode),
-        lastEvaluatedLeaf: this.toLeafSnapshot(
-          conditionResult.trace.lastEvaluatedLeaf,
-        ),
-        lastEvaluatedLeafPath: conditionResult.trace.lastEvaluatedLeafPath,
-        lastEvaluatedLeafResult: conditionResult.trace.lastEvaluatedLeafResult,
-        field: conditionResult.trace.lastEvaluatedLeaf.field,
-        op: conditionResult.trace.lastEvaluatedLeaf.op,
-      },
-    };
-  }
-
-  private normalizePayload(payload: GatePayload): {
-    readonly allowIf: ConditionNode;
-    readonly defaultOutcome: "ALLOW" | "DENY";
-  } {
-    if ("condition" in payload) {
-      return {
-        allowIf: payload.condition,
-        defaultOutcome: "DENY",
-      };
+    private toNodeSnapshot(node: ConditionNode): GateTraceNodeSnapshot {
+        if (this.isLeafNode(node)) {
+            return this.toLeafSnapshot(node);
+        }
+
+        if ("and" in node) {
+            return {
+                kind: "AND",
+                childCount: node.and.length,
+            };
+        }
+
+        if ("or" in node) {
+            return {
+                kind: "OR",
+                childCount: node.or.length,
+            };
+        }
+
+        return {
+            kind: "NOT",
+        };
     }
 
-    return payload;
-  }
-
-  /**
-   * Evaluates a GATE payload against a context object.
-   * Pure function — no side effects.
-   *
-   * Receives an already-parsed `GatePayload`; the registry is responsible
-   * for parsing from raw `unknown` before calling this method.
-   * Returns Result for technical failures (condition evaluation errors).
-   * The Outcome inside carries the business decision (ALLOW/DENY).
-   */
-  evaluate(
-    payload: GatePayload,
-    context: PolicyContext,
-  ): Result<GateOutcome, string> {
-    const gatePayload = this.normalizePayload(payload);
-    const conditionEvaluator = new ConditionEvaluatorV1(
-      context,
-      this.coreConfig.getConditionEvaluationOptions(this.version),
-    );
-
-    const isAllowedResult = conditionEvaluator.evaluateWithTrace(
-      gatePayload.allowIf,
-    );
-    if (isAllowedResult.isErr()) {
-      return Result.err(isAllowedResult.errorOrNull()!);
+    private buildDenyViolation(
+        conditionResult: TracedConditionEvaluation,
+    ): PolicyViolation {
+        return {
+            code: "DENY_CONDITION_MET",
+            message: `Gate denied at ${conditionResult.trace.conditionPath}`,
+            trace: {
+                conditionPath: conditionResult.trace.conditionPath,
+                decisiveNode: this.toNodeSnapshot(
+                    conditionResult.trace.decisiveNode,
+                ),
+                lastEvaluatedLeaf: this.toLeafSnapshot(
+                    conditionResult.trace.lastEvaluatedLeaf,
+                ),
+                lastEvaluatedLeafPath:
+                    conditionResult.trace.lastEvaluatedLeafPath,
+                lastEvaluatedLeafResult:
+                    conditionResult.trace.lastEvaluatedLeafResult,
+                field: conditionResult.trace.lastEvaluatedLeaf.field,
+                op: conditionResult.trace.lastEvaluatedLeaf.op,
+            },
+        };
     }
 
-    const isAllowed = isAllowedResult.getOrNull()!;
-    if (isAllowed.matched) {
-      return this.allow();
+    private normalizePayload(payload: GatePayload): {
+        readonly allowIf: ConditionNode;
+        readonly defaultOutcome: "ALLOW" | "DENY";
+    } {
+        if ("condition" in payload) {
+            return {
+                allowIf: payload.condition,
+                defaultOutcome: "DENY",
+            };
+        }
+
+        return payload;
     }
 
-    return this.outcomeFromStatus(
-      gatePayload.defaultOutcome,
-      this.buildDenyViolation(isAllowed),
-    );
-  }
+    /**
+     * Evaluates a GATE payload against a context object.
+     * Pure function — no side effects.
+     *
+     * Receives an already-parsed `GatePayload`; the registry is responsible
+     * for parsing from raw `unknown` before calling this method.
+     * Returns Result for technical failures (condition evaluation errors).
+     * The Outcome inside carries the business decision (ALLOW/DENY).
+     */
+    evaluate(
+        payload: GatePayload,
+        context: PolicyContext,
+    ): Result<GateOutcome, string> {
+        const gatePayload = this.normalizePayload(payload);
+        const conditionEvaluator = new ConditionEvaluatorV1(
+            context,
+            this.coreConfig.getConditionEvaluationOptions(this.version),
+        );
+
+        const isAllowedResult = conditionEvaluator.evaluateWithTrace(
+            gatePayload.allowIf,
+        );
+        if (isAllowedResult.isErr()) {
+            return Result.err(isAllowedResult.errorOrNull()!);
+        }
+
+        const isAllowed = isAllowedResult.getOrNull()!;
+        if (isAllowed.matched) {
+            return this.allow();
+        }
+
+        return this.outcomeFromStatus(
+            gatePayload.defaultOutcome,
+            this.buildDenyViolation(isAllowed),
+        );
+    }
 }

package/src/core/policies/engines/v1/gate/gate-types-v1.ts

@@ -5,8 +5,8 @@
 import type { ConditionNode } from "../condition-types";
 
 export type GatePayloadV1 =
-  | { readonly condition: ConditionNode }
-  | {
-      readonly allowIf: ConditionNode;
-      readonly defaultOutcome: "ALLOW" | "DENY";
-    };
+    | { readonly condition: ConditionNode }
+    | {
+          readonly allowIf: ConditionNode;
+          readonly defaultOutcome: "ALLOW" | "DENY";
+      };

package/src/core/policies/engines/v1/gate/gate-v1-payload.schema.ts

@@ -4,43 +4,45 @@ import { Result } from "../../../../result/result";
 
 import type { GatePayloadV1 } from "./gate-types-v1";
 import {
-  conditionLeafNodeSchema,
-  conditionNodeSchema,
+    conditionLeafNodeSchema,
+    conditionNodeSchema,
 } from "../condition-schema";
 
 // Re-export so gate/v1 public API remains unchanged.
 export { conditionLeafNodeSchema, conditionNodeSchema };
 
 export class GatePayloadSchemaV1 {
-  static readonly schema = z.union([
-    z
-      .object({
-        condition: conditionNodeSchema,
-      })
-      .strict(),
-    z
-      .object({
-        allowIf: conditionNodeSchema,
-        defaultOutcome: z.enum(["ALLOW", "DENY"]),
-      })
-      .strict(),
-  ]);
-
-  static parse(payload: unknown): Result<GatePayloadV1, string> {
-    const parsed = GatePayloadSchemaV1.schema.safeParse(payload);
-    if (!parsed.success) {
-      const details = parsed.error.issues
-        .map((issue) => {
-          const path = issue.path.join(".");
-          return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
-        })
-        .join("; ");
-
-      return Result.err(`Invalid gate payload: ${details}`);
+    static readonly schema = z.union([
+        z
+            .object({
+                condition: conditionNodeSchema,
+            })
+            .strict(),
+        z
+            .object({
+                allowIf: conditionNodeSchema,
+                defaultOutcome: z.enum(["ALLOW", "DENY"]),
+            })
+            .strict(),
+    ]);
+
+    static parse(payload: unknown): Result<GatePayloadV1, string> {
+        const parsed = GatePayloadSchemaV1.schema.safeParse(payload);
+        if (!parsed.success) {
+            const details = parsed.error.issues
+                .map((issue) => {
+                    const path = issue.path.join(".");
+                    return path.length > 0
+                        ? `${path}: ${issue.message}`
+                        : issue.message;
+                })
+                .join("; ");
+
+            return Result.err(`Invalid gate payload: ${details}`);
+        }
+
+        return Result.ok(parsed.data as GatePayloadV1);
     }
-
-    return Result.ok(parsed.data as GatePayloadV1);
-  }
 }
 
 export const gatePayloadSchema = GatePayloadSchemaV1.schema;

package/src/core/policies/engines/v1/gate/index.ts

@@ -2,8 +2,8 @@ export { ConditionEvaluatorV1 } from "../condition-evaluator";
 export { GateEngineV1 } from "./gate-engine-v1";
 export type { GatePayloadV1 } from "./gate-types-v1";
 export {
-  conditionLeafNodeSchema,
-  conditionNodeSchema,
-  gatePayloadSchema,
-  GatePayloadSchemaV1,
+    conditionLeafNodeSchema,
+    conditionNodeSchema,
+    gatePayloadSchema,
+    GatePayloadSchemaV1,
 } from "./gate-v1-payload.schema";

package/src/core/policies/engines/v1/index.ts

@@ -1,13 +1,13 @@
 export { ConditionEvaluatorV1 } from "./condition-evaluator";
 export {
-  conditionLeafNodeSchema,
-  conditionNodeSchema,
+    conditionLeafNodeSchema,
+    conditionNodeSchema,
 } from "./condition-schema";
 export type {
-  ConditionAndNode,
-  ConditionLeafNode,
-  ConditionNode,
-  ConditionNotNode,
-  ConditionOp,
-  ConditionOrNode,
+    ConditionAndNode,
+    ConditionLeafNode,
+    ConditionNode,
+    ConditionNotNode,
+    ConditionOp,
+    ConditionOrNode,
 } from "./condition-types";