@reventlessdev/reventless-core 3.0.0-alpha.239 → 3.0.0-alpha.240

package/tests/admin/Platform_Admin_StructureTest.res.mjs

@@ -1,9 +1,22 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+import * as PluginBaseFragment$ReventlessCore from "../../src/plugin/api/PluginBaseFragment.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "../../src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
 import * as Platform_Admin_Structure$ReventlessCore from "../../src/admin/Platform_Admin_Structure.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "../../src/admin/Platform_ComponentDefinitionsApi.res.mjs";
 
+function commandNamed(name) {
+  return Stdlib_Option.getOrThrow(Platform_Admin_Structure$ReventlessCore.pluginCommands.find(c => c.name === name), `Platform_Admin_Structure publishes no "` + name + `" command`);
+}
+
+function activate() {
+  return commandNamed("Activate");
+}
+
 globalThis.describe("the Plugins read model declares its lifecycle", () => {
   globalThis.test("names the field commands branch on", () => {
     globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.lifecycleField).toEqual("status");
@@ -21,4 +34,210 @@ globalThis.describe("the Plugins read model declares its lifecycle", () => {
   });
 });
 
+globalThis.describe("the admin structure's declared transitions are checked", () => {
+  let states = Plugin_Structure$ReventlessCore.lifecycleStatesFromStateSchema(PluginsReadModelSpec$ReventlessCore.name, PluginsReadModelSpec$ReventlessCore.stateSchema);
+  let statesByView = () => {
+    let d = {};
+    Stdlib_Option.forEach(states, s => {
+      d[PluginsReadModelSpec$ReventlessCore.name] = s;
+    });
+    return d;
+  };
+  let raises = writables => {
+    try {
+      Plugin_Structure$ReventlessCore.checkDeclaredTransitions("Platform", writables, statesByView());
+      return false;
+    } catch (exn) {
+      return true;
+    }
+  };
+  globalThis.test("the linked view yields its lifecycle states", () => {
+    globalThis.expect(states).toEqual([
+      "Connected",
+      "Disconnected",
+      "Inactive",
+      "Retired"
+    ]);
+  });
+  globalThis.test("every state the Plugin commands name is one the view declares", () => {
+    globalThis.expect(raises([Platform_Admin_Structure$ReventlessCore.pluginAggregate])).toEqual(false);
+  });
+  globalThis.test("and a state the view does not declare is caught", () => {
+    let init = commandNamed("Activate");
+    let bogus_name = Platform_Admin_Structure$ReventlessCore.pluginAggregate.name;
+    let bogus_commands = [{
+        name: init.name,
+        schema: init.schema,
+        level: init.level,
+        aggregateIdField: init.aggregateIdField,
+        mutationField: init.mutationField,
+        references: init.references,
+        allowedStates: init.allowedStates,
+        targetState: "Conected",
+        apiExposed: init.apiExposed,
+        requiredAccess: init.requiredAccess,
+        ownerField: init.ownerField
+      }];
+    let bogus_producedEventTypes = Platform_Admin_Structure$ReventlessCore.pluginAggregate.producedEventTypes;
+    let bogus_consumedEventTypes = Platform_Admin_Structure$ReventlessCore.pluginAggregate.consumedEventTypes;
+    let bogus_linkedViews = Platform_Admin_Structure$ReventlessCore.pluginAggregate.linkedViews;
+    let bogus_consistencyRead = Platform_Admin_Structure$ReventlessCore.pluginAggregate.consistencyRead;
+    let bogus_events = Platform_Admin_Structure$ReventlessCore.pluginAggregate.events;
+    let bogus_errors = Platform_Admin_Structure$ReventlessCore.pluginAggregate.errors;
+    let bogus_chapter = Platform_Admin_Structure$ReventlessCore.pluginAggregate.chapter;
+    let bogus = {
+      name: bogus_name,
+      commands: bogus_commands,
+      producedEventTypes: bogus_producedEventTypes,
+      consumedEventTypes: bogus_consumedEventTypes,
+      linkedViews: bogus_linkedViews,
+      consistencyRead: bogus_consistencyRead,
+      events: bogus_events,
+      errors: bogus_errors,
+      chapter: bogus_chapter
+    };
+    globalThis.expect(raises([bogus])).toEqual(true);
+  });
+});
+
+globalThis.describe("the Plugin command defs carry every argument the SDL requires", () => {
+  globalThis.test("the version argument is published", () => {
+    globalThis.expect(commandNamed("Activate").schema.includes(`"_0"`)).toEqual(true);
+  });
+  globalThis.test("and so is the aggregate id", () => {
+    globalThis.expect(commandNamed("Activate").aggregateIdField).toEqual(undefined);
+  });
+  globalThis.test("the exposed commands name the field PluginBaseFragment generates", () => {
+    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginCommands.filter(c => Primitive_object.notequal(c.apiExposed, false)).map(c => c.mutationField)).toEqual([
+      "Platform_Plugin_Activate",
+      "Platform_Plugin_Deactivate",
+      "Platform_Plugin_Retire"
+    ]);
+  });
+  globalThis.test("the internal commands are published as uncallable", () => {
+    let internal = Platform_Admin_Structure$ReventlessCore.pluginCommands.filter(c => Primitive_object.equal(c.apiExposed, false));
+    globalThis.expect(internal.map(c => c.name)).toEqual([
+      "Connect",
+      "ReportIncompatibility",
+      "Heartbeat",
+      "Redetect",
+      "Disconnect"
+    ]);
+    globalThis.expect(internal.every(c => c.mutationField === "")).toEqual(true);
+  });
+});
+
+globalThis.describe("the internal commands declare the edges they move rows along", () => {
+  let states = Plugin_Structure$ReventlessCore.lifecycleStatesFromStateSchema(PluginsReadModelSpec$ReventlessCore.name, PluginsReadModelSpec$ReventlessCore.stateSchema);
+  let statesByView = () => {
+    let d = {};
+    Stdlib_Option.forEach(states, s => {
+      d[PluginsReadModelSpec$ReventlessCore.name] = s;
+    });
+    return d;
+  };
+  globalThis.test("the only edge into Disconnected is declared", () => {
+    globalThis.expect([
+      commandNamed("Disconnect").allowedStates,
+      commandNamed("Disconnect").targetState
+    ]).toEqual([
+      ["Connected"],
+      "Disconnected"
+    ]);
+  });
+  globalThis.test("the handshake declares a target and no from-set", () => {
+    globalThis.expect([
+      commandNamed("Connect").allowedStates,
+      commandNamed("Connect").targetState
+    ]).toEqual([
+      undefined,
+      "Connected"
+    ]);
+  });
+  globalThis.test("and no state is left unreachable", () => {
+    globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleTopologyFindings([Platform_Admin_Structure$ReventlessCore.pluginAggregate], statesByView())).toEqual([]);
+  });
+});
+
+globalThis.describe("the Plugins view publishes the rule the server enforces", () => {
+  globalThis.test("the spec declares the group", () => {
+    globalThis.expect(PluginsReadModelSpec$ReventlessCore.authorization).toEqual({
+      TAG: "AllowGroups",
+      _0: ["Admin"]
+    });
+  });
+  globalThis.test("and the published access keys are derived from it", () => {
+    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.requiredAccess).toEqual(["Admin"]);
+  });
+  globalThis.test("the query entry carries the spec's rule and no hand-written pair", () => {
+    let entry = PluginBaseFragment$ReventlessCore.queryEntries[0];
+    globalThis.expect([
+      entry.permission,
+      entry.authorization
+    ]).toEqual([
+      PluginsReadModelSpec$ReventlessCore.authorization,
+      undefined
+    ]);
+  });
+});
+
+globalThis.describe("the Plugins queryableDef is what the generic helpers produce", () => {
+  globalThis.test("the field names are the generic ones", () => {
+    globalThis.expect([
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.queryField,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.singleQueryField
+    ]).toEqual([
+      "Platform_Plugins",
+      "Platform_Plugin"
+    ]);
+  });
+  globalThis.test("the label ladder reaches the same field, by convention", () => {
+    globalThis.expect([
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.labelField,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.labelFieldSource,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.searchableFields
+    ]).toEqual([
+      "name",
+      "convention",
+      ["name"]
+    ]);
+  });
+  globalThis.test("the key ladder finds no id field, as the hand-written def claimed", () => {
+    globalThis.expect([
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.idField,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.idFieldSource
+    ]).toEqual([
+      undefined,
+      undefined
+    ]);
+  });
+  globalThis.test("the blob fields are published, and marked hidden", () => {
+    let props = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Platform_Admin_Structure$ReventlessCore.pluginReadModel.schema)), o => o["properties"]), Stdlib_JSON.Decode.object), {});
+    let isHidden = key => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(props[key], Stdlib_JSON.Decode.object), o => o["x-reventless-hidden"]), Stdlib_JSON.Decode.bool);
+    globalThis.expect([
+      isHidden("apiSchemaFragment"),
+      isHidden("structure")
+    ]).toEqual([
+      true,
+      true
+    ]);
+  });
+  globalThis.test("while the internal fields are not published at all", () => {
+    let props = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Platform_Admin_Structure$ReventlessCore.pluginReadModel.schema)), o => o["properties"]), Stdlib_JSON.Decode.object), [], prim => Object.keys(prim));
+    globalThis.expect([
+      props.includes("eventCollector"),
+      props.includes("extensionNames"),
+      props.includes("statusChange")
+    ]).toEqual([
+      false,
+      false,
+      true
+    ]);
+  });
+});
+
+export {
+  commandNamed,
+  activate,
+}
 /*  Not a pure module */

package/tests/aggregate/AggregateCacheTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-S.enableJson()
 
 module AggSpec = {
   module Id = Reventless.Id.StringPure

package/tests/aggregate/AggregateCacheTest.res.mjs

@@ -1,37 +1,35 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "CacheTestAggregate";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Add",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.literal("Checkpoint"),
-  S.literal("Noop")
+  Sury.literal("Checkpoint"),
+  Sury.literal("Noop")
 ]);
 
-let eventSchema = S.union([
-  S.schema(s => ({
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Added",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "CheckpointTaken",
-    count: s.m(S.int)
+    count: s.m(Sury.int)
   }))
 ]);
 
-let errorSchema = S.literal("Never");
+let errorSchema = Sury.literal("Never");
 
 let moduleUrl = import.meta.url;
 
@@ -430,4 +428,4 @@ export {
   makeTopicItem,
   run,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/aggregate/AggregateConflictTest.res

@@ -3,7 +3,6 @@
 
 open JestGlobals
 
-S.enableJson()
 
 module AggSpec = {
   module Id = Reventless.Id.StringPure

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -1,26 +1,24 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "ConflictTestAggregate";
 
-let commandSchema = S.schema(s => ({
+let commandSchema = Sury.$schema(s => ({
   TAG: "Create",
-  name: s.m(S.string)
+  name: s.m(Sury.string)
 }));
 
-let eventSchema = S.schema(s => ({
+let eventSchema = Sury.$schema(s => ({
   TAG: "Created",
-  name: s.m(S.string)
+  name: s.m(Sury.string)
 }));
 
-let errorSchema = S.literal("AlreadyExists");
+let errorSchema = Sury.literal("AlreadyExists");
 
 let moduleUrl = import.meta.url;
 
@@ -383,4 +381,4 @@ export {
   testMeta,
   makeTopicItem,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/aggregate/AggregateFixtures.res

@@ -1,4 +1,3 @@
-S.enableJson()
 
 // ─────────────────────────────────────────────────────────────
 // Aggregate spec

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -1,39 +1,37 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stream from "effect/Stream";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "TestAggregate";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Create",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "Rename",
-    newName: s.m(S.string)
+    newName: s.m(Sury.string)
   }))
 ]);
 
-let eventSchema = S.union([
-  S.schema(s => ({
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Created",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "Renamed",
-    newName: s.m(S.string)
+    newName: s.m(Sury.string)
   }))
 ]);
 
-let errorSchema = S.union([
-  S.literal("AlreadyExists"),
-  S.literal("NotFound")
+let errorSchema = Sury.union([
+  Sury.literal("AlreadyExists"),
+  Sury.literal("NotFound")
 ]);
 
 let moduleUrl = import.meta.url;
@@ -52,11 +50,11 @@ let AggSpec = {
   commandAuthorization: commandAuthorization
 };
 
-let stateSchema = S.union([
-  S.literal("NotCreated"),
-  S.schema(s => ({
+let stateSchema = Sury.union([
+  Sury.literal("NotCreated"),
+  Sury.$schema(s => ({
     TAG: "Created",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   }))
 ]);
 
@@ -305,4 +303,4 @@ export {
   testMeta,
   makeTopicItem,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/aggregate/AggregateSnapshotTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-S.enableJson()
 
 module AggSpec = {
   module Id = Reventless.Id.StringPure
@@ -300,7 +299,7 @@ describe("Aggregate_Callback — snapshots:", () => {
     | Some(snap) =>
       expect(snap.seqNr)->toBe(20)
       // 20 items folded through the seeded state — no double-count, no gap.
-      let decoded = snap.state->S.parseJsonOrThrow(TestBehavior.stateSchema)
+      let decoded = snap.state->Reventless.Util_Sury.fromJson(TestBehavior.stateSchema)
       expect(decoded.items->Array.length)->toBe(20)
     | None => expect("expected snapshot at 20")->toBe("none")
     }

package/tests/aggregate/AggregateSnapshotTest.res.mjs

@@ -1,31 +1,30 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Effect from "effect/Effect";
 import * as Stream$1 from "effect/Stream";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "SnapshotTestAggregate";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Add",
-    item: s.m(S.string)
+    item: s.m(Sury.string)
   })),
-  S.literal("Noop")
+  Sury.literal("Noop")
 ]);
 
-let eventSchema = S.schema(s => ({
+let eventSchema = Sury.$schema(s => ({
   TAG: "Added",
-  item: s.m(S.string)
+  item: s.m(Sury.string)
 }));
 
-let errorSchema = S.literal("Never");
+let errorSchema = Sury.literal("Never");
 
 let moduleUrl = import.meta.url;
 
@@ -43,8 +42,8 @@ let AggSpec = {
   commandAuthorization: commandAuthorization
 };
 
-let stateSchema = S.schema(s => ({
-  items: s.m(S.array(S.string))
+let stateSchema = Sury.$schema(s => ({
+  items: s.m(Sury.array(Sury.string))
 }));
 
 let initialState = {
@@ -325,8 +324,8 @@ let TestHandler = Aggregate_Callback$ReventlessCore.Make({
   eventLog: eventLog
 });
 
-let stateSchema$1 = S.schema(s => ({
-  items: s.m(S.array(S.string))
+let stateSchema$1 = Sury.$schema(s => ({
+  items: s.m(Sury.array(Sury.string))
 }));
 
 let initialState$1 = {
@@ -550,7 +549,7 @@ globalThis.describe("Aggregate_Callback — snapshots:", () => {
     let snap = mock.getSnapshot("agg-1");
     if (snap !== undefined) {
       globalThis.expect(snap.seqNr).toBe(20);
-      let decoded = S.parseJsonOrThrow(snap.state, stateSchema);
+      let decoded = Util_Sury$Reventless.fromJson(snap.state, stateSchema);
       globalThis.expect(decoded.items.length).toBe(20);
     } else {
       globalThis.expect("expected snapshot at 20").toBe("none");
@@ -642,4 +641,4 @@ export {
   run,
   tick,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/api/ApiNoApiTest.res.mjs

@@ -1,37 +1,42 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../src/components/Api/ApiNoApiHelpers.res.mjs";
 
 globalThis.describe("ApiNoApiHelpers:", () => {
   globalThis.test("isNoApi returns false for schema without noApi metadata", () => {
-    globalThis.expect(ApiNoApiHelpers$ReventlessCore.isNoApi(S.string)).toBe(false);
+    let schema = Sury.string;
+    globalThis.expect(ApiNoApiHelpers$ReventlessCore.isNoApi(schema)).toBe(false);
   });
   globalThis.test("isNoApi returns true for schema with noApi metadata set to true", () => {
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiId, true);
+    let schema = Sury.string;
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiId, true);
     globalThis.expect(ApiNoApiHelpers$ReventlessCore.isNoApi(schema$p)).toBe(true);
   });
   globalThis.test("getExcludedVariants returns None for schema without noApiVariants metadata", () => {
-    globalThis.expect(ApiNoApiHelpers$ReventlessCore.getExcludedVariants(S.string)).toBe(undefined);
+    let schema = Sury.string;
+    globalThis.expect(ApiNoApiHelpers$ReventlessCore.getExcludedVariants(schema)).toBe(undefined);
   });
   globalThis.test("getExcludedVariants returns Some with DeleteItem when set", () => {
+    let schema = Sury.string;
     let excluded = new Set([
       "DeleteItem",
       "UpdateItem"
     ]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let result = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(schema$p);
     globalThis.expect(Stdlib_Option.getOr(Stdlib_Option.map(result, set => set.has("DeleteItem")), false)).toBe(true);
   });
   globalThis.test("filterNoApiVariants returns all field names when no variants are excluded", () => {
+    let schema = Sury.string;
     let fieldNames = [
       "CreateItem",
       "DeleteItem",
       "UpdateItem"
     ];
-    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, S.string);
+    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, schema);
     globalThis.expect(filtered).toEqual([
       "CreateItem",
       "DeleteItem",
@@ -39,8 +44,9 @@ globalThis.describe("ApiNoApiHelpers:", () => {
     ]);
   });
   globalThis.test("filterNoApiVariants filters out excluded variants", () => {
+    let schema = Sury.string;
     let excluded = new Set(["DeleteItem"]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let fieldNames = [
       "CreateItem",
       "DeleteItem",
@@ -53,11 +59,12 @@ globalThis.describe("ApiNoApiHelpers:", () => {
     ]);
   });
   globalThis.test("filterNoApiVariants filters out multiple excluded variants", () => {
+    let schema = Sury.string;
     let excluded = new Set([
       "DeleteItem",
       "UpdateItem"
     ]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let fieldNames = [
       "CreateItem",
       "DeleteItem",
@@ -71,12 +78,13 @@ globalThis.describe("ApiNoApiHelpers:", () => {
     ]);
   });
   globalThis.test("filterNoApiVariants returns empty array when all variants are excluded", () => {
+    let schema = Sury.string;
     let excluded = new Set([
       "CreateItem",
       "DeleteItem",
       "UpdateItem"
     ]);
-    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let schema$p = Sury.$Metadata_set(schema, Api$ReventlessInfra.noApiVariantsId, excluded);
     let fieldNames = [
       "CreateItem",
       "DeleteItem",