@hyperscale0/udl 4.2.1 → 4.4.0

package/src/schema.ts

@@ -73,7 +73,7 @@ export const udlFieldSchema = z.discriminatedUnion("type", [
   z.strictObject({
     ...fieldBase,
     type: z.literal("account"),
-    owner: name,
+    owner: z.union([name, z.strictObject({ adapter: name })]),
     key: name.optional(),
     book: z.enum(["cash", "claim"]).default("cash"),
     contra: z.literal(true).optional(),
@@ -154,10 +154,43 @@ export const udlObjectFieldSchema = z.discriminatedUnion("type", [
   boundedListField,
 ]);
 
+/** Values are constants or resolved typed paths, never executable strings. */
+export const udlValueSchema = z.union([
+  z.strictObject({ literal: scalar }),
+  z.strictObject({ field: path }),
+]);
+const value = udlValueSchema;
+
+const comparisonRequirement = z.strictObject({
+  kind: z.literal("compare"),
+  left: value,
+  operator: z.enum(["==", "!=", "<", "<=", ">", ">="]),
+  right: value,
+});
+
+// Alternatives are OR; each invocation path is a conjunction of scoped guards.
+export const udlSubjectConditionsSchema = z
+  .array(
+    z
+      .array(
+        z.strictObject({
+          instrument: instrumentId,
+          action: name,
+          guard: comparisonRequirement,
+          valueType: z.enum(["money", "date"]).optional(),
+        }),
+      )
+      .min(1)
+      .max(32),
+  )
+  .min(1)
+  .max(128);
+
 export const udlSubjectRequirementSchema = z.strictObject({
   field: udlObjectFieldSchema,
   // Present only for an authored rename.
   objectField: name.optional(),
+  when: udlSubjectConditionsSchema.optional(),
 });
 
 export const adapterSubjectSnapshotSchema = z.strictObject({
@@ -192,6 +225,7 @@ export type AttachmentPartyBinding = z.infer<
 >;
 export const udlObjectAttachmentSchema = z.strictObject({
   name,
+  parent: name.optional(),
   instrument: instrumentId,
   parties: z.record(name, attachmentPartyBindingSchema),
 });
@@ -207,12 +241,6 @@ export const udlObjectKindSchema = z.strictObject({
   columns: z.array(name).max(8),
 });
 
-/** Values are constants or resolved typed paths, never executable strings. */
-export const udlValueSchema = z.union([
-  z.strictObject({ literal: scalar }),
-  z.strictObject({ field: path }),
-]);
-const value = udlValueSchema;
 const values = z.array(value).min(1).max(256);
 
 const selection = z.strictObject({
@@ -295,13 +323,6 @@ export const udlCalculationSchema = z.discriminatedUnion("op", [
   }),
 ]);
 
-const comparisonRequirement = z.strictObject({
-  kind: z.literal("compare"),
-  left: value,
-  operator: z.enum(["==", "!=", "<", "<=", ">", ">="]),
-  right: value,
-});
-
 export const udlRequirementSchema = z.discriminatedUnion("kind", [
   z.strictObject({
     kind: z.literal("hours"),

package/src/validation.ts

@@ -153,7 +153,7 @@ function commonField(
       (field) =>
         field?.type !== "account" ||
         field.book !== first.book ||
-        field.owner !== first.owner ||
+        JSON.stringify(field.owner) !== JSON.stringify(first.owner) ||
         field.key !== first.key ||
         field.contra !== first.contra,
     )
@@ -455,8 +455,32 @@ export function validateUdl(value: unknown): UdlValidationResult {
           )
         )
           add(where, `${f.name} is a sealed instance field`);
+        if (f.type === "account" && typeof f.owner === "object") {
+          const binding = f.owner.adapter;
+          const declarations = Object.values(instrument?.actions ?? {})
+            .flatMap((action) => action.subject?.adapters ?? [])
+            .filter((entry) => entry.binding === binding);
+          if (!declarations.length)
+            add(
+              where,
+              `${f.name} needs adapter declaration ${binding}`,
+              "subject_adapter_unbound",
+            );
+          const providers = new Set(
+            declarations.flatMap((entry) =>
+              entry.snapshot ? [entry.snapshot.provider] : [],
+            ),
+          );
+          if (providers.size > 1)
+            add(
+              where,
+              `${binding} names conflicting providers`,
+              "subject_adapter_unbound",
+            );
+        }
         if (
           f.type === "account" &&
+          typeof f.owner === "string" &&
           f.owner !== "self" &&
           !moneyParty(document, instrument, f.owner)
         )
@@ -1269,14 +1293,14 @@ export function validateUdl(value: unknown): UdlValidationResult {
             from.book !== to.book
           )
             add(where, "moves cannot cross account books", "UDL4001");
-          const samePartyAccount =
+          const sameBoundAccount =
             from?.type === "account" &&
             to?.type === "account" &&
             from.owner !== "self" &&
-            from.owner === to.owner &&
+            JSON.stringify(from.owner) === JSON.stringify(to.owner) &&
             from.book === to.book &&
             (from.key ?? "balance") === (to.key ?? "balance");
-          if (move.from === move.to || samePartyAccount)
+          if (move.from === move.to || sameBoundAccount)
             add(where, "a transfer needs distinct accounts", "UDL4001");
         } else expect(move.transfer, "text", where, action.input, action);
       }