@hyperscale0/udl 1.0.251 → 1.0.258

package/src/index.ts

@@ -1,10 +1,12 @@
 export * from "./schema.js";
+export { sarCurrency, sarMinorUnitExponent, currencySchema } from "./money.js";
 export { serializeUdl, canonicalDigest } from "./canonical.js";
 export {
   validateUdl,
   RESERVED_OBJECT_NAMES,
   assertValidUdl,
   resolveField,
+  sameAccount,
   resolveSubjectRequirement,
   UdlError,
   type UdlValidationResult,

package/src/money.ts

@@ -0,0 +1,5 @@
+import * as z from "zod";
+
+export const sarCurrency = "SAR";
+export const sarMinorUnitExponent = 2;
+export const currencySchema = z.literal(sarCurrency);

package/src/reporting.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+import { currencySchema } from "./money.js";
 
 const name = z
   .string()
@@ -12,7 +13,7 @@ const integer = z.number().int().safe();
 export const reportTypeSchema = z.discriminatedUnion("kind", [
   z.strictObject({
     kind: z.literal("money"),
-    currency: z.string().regex(/^[A-Z]{3}$/),
+    currency: currencySchema,
   }),
   z.strictObject({ kind: z.enum(["text", "integer", "boolean", "date"]) }),
 ]);
@@ -94,7 +95,7 @@ export const reportDefinitionSchema = z.strictObject({
   scope: z.strictObject({
     kind: z.enum(["product", "company"]),
     classification: z.enum(["internal", "personal", "restricted"]),
-    currency: z.string().regex(/^[A-Z]{3}$/),
+    currency: currencySchema,
   }),
   datasets: z
     .array(

package/src/schema.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+import { currencySchema } from "./money.js";
 import { reportDefinitionSchema } from "./reporting.js";
 import { writeJson } from "./json.js";
 
@@ -553,7 +554,7 @@ export const udlDocumentSchema = z.strictObject({
   version: integer.positive(),
   product: name,
   title: text,
-  currency: z.literal("SAR"),
+  currency: currencySchema,
   parties: z.record(name, udlPartySchema),
   objects: z.array(udlObjectKindSchema).max(256),
   instruments: z.array(udlInstrumentSchema).max(256),

package/src/validation.ts

@@ -234,6 +234,47 @@ export function resolveField(
   return resolvePath(document, instrument, path, input, new Map(), action);
 }
 
+/** The account identity used by the distinct-account transfer rule. */
+export function sameAccount(
+  document: UdlDocument,
+  instrument: UdlInstrument,
+  fromPath: string,
+  toPath: string,
+  input: readonly UdlField[] = [],
+  action?: UdlAction,
+): boolean {
+  const from = resolveField(document, instrument, fromPath, input, action);
+  const to = resolveField(document, instrument, toPath, input, action);
+  const accountOwner = (
+    field: Extract<UdlField, { type: "account" }>,
+    path: string,
+  ): string => {
+    if (typeof field.owner === "string") return `party:${field.owner}`;
+    const binding = field.owner.adapter;
+    const provider =
+      path === `self.${field.name}`
+        ? Object.values(instrument.actions)
+            .flatMap((action) => action.subject?.adapters ?? [])
+            .find((entry) => entry.binding === binding && entry.snapshot)
+            ?.snapshot?.provider
+        : undefined;
+    return provider ? `provider:${provider}` : `binding:${binding}`;
+  };
+  return (
+    fromPath === toPath ||
+    !!(
+      from?.type === "account" &&
+      to?.type === "account" &&
+      (from.owner !== "self" ||
+        (fromPath === `self.${from.name}` && toPath === `self.${to.name}`)) &&
+      accountOwner(from, fromPath) === accountOwner(to, toPath) &&
+      from.book === to.book &&
+      (from.key ?? (from.owner === "self" ? from.name : "balance")) ===
+        (to.key ?? (to.owner === "self" ? to.name : "balance"))
+    )
+  );
+}
+
 /** A subject expression names a requirement; objectField names its stored metadata. */
 export function resolveSubjectRequirement(
   instrument: UdlInstrument,
@@ -1101,7 +1142,13 @@ export function validateUdl(value: unknown): UdlValidationResult {
         dependencies.set(
           c.target,
           operands.flatMap((v) =>
-            "field" in v && v.field.startsWith("self.")
+            "field" in v &&
+            v.field.startsWith("self.") &&
+            !(
+              act &&
+              v.field === `self.${c.target}` &&
+              !inst.calculate.some((node) => node.target === c.target)
+            )
               ? [v.field.slice(5)]
               : [],
           ),
@@ -1526,33 +1573,16 @@ export function validateUdl(value: unknown): UdlValidationResult {
             from.book !== to.book
           )
             add(where, "moves cannot cross account books", "UDL4001");
-          const accountOwner = (
-            field: Extract<UdlField, { type: "account" }>,
-            path: string,
-          ): string => {
-            if (typeof field.owner === "string") return `party:${field.owner}`;
-            const binding = field.owner.adapter;
-            const provider =
-              path === `self.${field.name}`
-                ? Object.values(inst.actions)
-                    .flatMap((action) => action.subject?.adapters ?? [])
-                    .find(
-                      (entry) => entry.binding === binding && entry.snapshot,
-                    )?.snapshot?.provider
-                : undefined;
-            return provider ? `provider:${provider}` : `binding:${binding}`;
-          };
-          const sameBoundAccount =
-            from?.type === "account" &&
-            to?.type === "account" &&
-            (from.owner !== "self" ||
-              (move.from === `self.${from.name}` &&
-                move.to === `self.${to.name}`)) &&
-            accountOwner(from, move.from) === accountOwner(to, move.to) &&
-            from.book === to.book &&
-            (from.key ?? (from.owner === "self" ? from.name : "balance")) ===
-              (to.key ?? (to.owner === "self" ? to.name : "balance"));
-          if (move.from === move.to || sameBoundAccount)
+          if (
+            sameAccount(
+              document,
+              inst,
+              move.from,
+              move.to,
+              action.input,
+              action,
+            )
+          )
             add(where, "a transfer needs distinct accounts", "UDL4001");
         } else expect(move.transfer, "text", where, action.input, action);
       }