@reventlessdev/reventless-core 3.0.0-alpha.179 → 3.0.0-alpha.181

package/tests/api/ApiNoApiTest.res.mjs

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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);
+  });
+  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);
+    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);
+  });
+  globalThis.test("getExcludedVariants returns Some with DeleteItem when set", () => {
+    let excluded = new Set([
+      "DeleteItem",
+      "UpdateItem"
+    ]);
+    let schema$p = S.Metadata.set(S.string, 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 fieldNames = [
+      "CreateItem",
+      "DeleteItem",
+      "UpdateItem"
+    ];
+    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, S.string);
+    globalThis.expect(filtered).toEqual([
+      "CreateItem",
+      "DeleteItem",
+      "UpdateItem"
+    ]);
+  });
+  globalThis.test("filterNoApiVariants filters out excluded variants", () => {
+    let excluded = new Set(["DeleteItem"]);
+    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let fieldNames = [
+      "CreateItem",
+      "DeleteItem",
+      "UpdateItem"
+    ];
+    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, schema$p);
+    globalThis.expect(filtered).toEqual([
+      "CreateItem",
+      "UpdateItem"
+    ]);
+  });
+  globalThis.test("filterNoApiVariants filters out multiple excluded variants", () => {
+    let excluded = new Set([
+      "DeleteItem",
+      "UpdateItem"
+    ]);
+    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let fieldNames = [
+      "CreateItem",
+      "DeleteItem",
+      "UpdateItem",
+      "GetItem"
+    ];
+    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, schema$p);
+    globalThis.expect(filtered).toEqual([
+      "CreateItem",
+      "GetItem"
+    ]);
+  });
+  globalThis.test("filterNoApiVariants returns empty array when all variants are excluded", () => {
+    let excluded = new Set([
+      "CreateItem",
+      "DeleteItem",
+      "UpdateItem"
+    ]);
+    let schema$p = S.Metadata.set(S.string, Api$ReventlessInfra.noApiVariantsId, excluded);
+    let fieldNames = [
+      "CreateItem",
+      "DeleteItem",
+      "UpdateItem"
+    ];
+    let filtered = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(fieldNames, schema$p);
+    globalThis.expect(filtered).toEqual([]);
+  });
+});
+
+/*  Not a pure module */

package/tests/api/GraphQL_StitcherTest.res.mjs

@@ -0,0 +1,112 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as Platform_AdminApi$ReventlessCore from "../../src/admin/Platform_AdminApi.res.mjs";
+
+globalThis.describe("GraphQL_Stitcher.subscriptionSources", () => {
+  globalThis.test("encode/decode round-trips the subscription→mutation source mapping", () => {
+    let fragment = GraphQL_Stitcher$ReventlessCore.encode({
+      types: [],
+      mutations: [`  Catalog_AddProduct(input: AddInput): CommandResult`],
+      queries: [],
+      subscriptions: [`  onCatalog_AddProduct(id: ID): CommandResult`],
+      subscriptionSources: [{
+          field: "onCatalog_AddProduct",
+          mutations: ["Catalog_AddProduct"]
+        }]
+    });
+    let parts = GraphQL_Stitcher$ReventlessCore.decode(fragment);
+    globalThis.expect(parts.subscriptionSources).toEqual([{
+        field: "onCatalog_AddProduct",
+        mutations: ["Catalog_AddProduct"]
+      }]);
+  });
+  globalThis.test("decode tolerates fragments encoded before the field existed", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.decode({
+      encoded: `{"types":[],"mutations":[],"queries":[],"subscriptions":["  onX(id: ID): CommandResult"]}`,
+      protocol: "graphql"
+    }).subscriptionSources).toEqual([]);
+  });
+  globalThis.test("collectSubscriptionSources unions across fragments, first wins per field", () => {
+    let base = GraphQL_Stitcher$ReventlessCore.encode({
+      types: [],
+      mutations: [],
+      queries: [],
+      subscriptions: [`  onUIFragmentChange: UIFragmentChangeEvent`],
+      subscriptionSources: [{
+          field: "onUIFragmentChange",
+          mutations: ["Platform_UIFragmentRegistered"]
+        }]
+    });
+    let pluginA = GraphQL_Stitcher$ReventlessCore.encode({
+      types: [],
+      mutations: [],
+      queries: [],
+      subscriptions: [`  onA(id: ID): CommandResult`],
+      subscriptionSources: [
+        {
+          field: "onA",
+          mutations: ["A"]
+        },
+        {
+          field: "onUIFragmentChange",
+          mutations: ["Rogue_Mutation"]
+        }
+      ]
+    });
+    let collected = GraphQL_Stitcher$ReventlessCore.collectSubscriptionSources(base, [pluginA]);
+    globalThis.expect(collected).toEqual([
+      {
+        field: "onUIFragmentChange",
+        mutations: ["Platform_UIFragmentRegistered"]
+      },
+      {
+        field: "onA",
+        mutations: ["A"]
+      }
+    ]);
+  });
+  globalThis.test("core-emitted admin base fragment carries no provider directives", () => {
+    let base = Platform_AdminApi$ReventlessCore.baseFragment(true);
+    globalThis.expect(base.encoded.includes("@aws_subscribe")).toBe(false);
+    globalThis.expect(base.encoded.includes("@aws_auth")).toBe(false);
+    let parts = GraphQL_Stitcher$ReventlessCore.decode(base);
+    let fields = parts.subscriptionSources.map(s => s.field);
+    globalThis.expect(fields.includes("onUIFragmentChange")).toBe(true);
+    globalThis.expect(fields.includes("onPluginStatusChange")).toBe(true);
+  });
+});
+
+globalThis.describe("GraphQL_Stitcher.stitchStandalone", () => {
+  let pluginFragment = GraphQL_Stitcher$ReventlessCore.encode({
+    types: [
+      `type Product implements Node {\n  id: ID!\n  name: String\n}`,
+      `union CommandResult = CommandAccepted | CommandRejected | CommandPending`
+    ],
+    mutations: [`  Catalog_AddProduct(input: AddInput): CommandResult`],
+    queries: [`  Catalog_products: [Product]`],
+    subscriptions: [`  onCatalog_AddProduct(id: ID): CommandResult`],
+    subscriptionSources: [{
+        field: "onCatalog_AddProduct",
+        mutations: ["Catalog_AddProduct"]
+      }]
+  });
+  globalThis.test("renders a self-contained subgraph document with relay base types", () => {
+    let sdl = GraphQL_Stitcher$ReventlessCore.stitchStandalone(pluginFragment);
+    globalThis.expect(sdl).toContain("interface Node {");
+    globalThis.expect(sdl).toContain("type PageInfo {");
+    globalThis.expect(sdl).toContain("type Product implements Node {");
+    globalThis.expect(sdl).toContain("Catalog_AddProduct(input: AddInput): CommandResult");
+    globalThis.expect(sdl).toContain("onCatalog_AddProduct(id: ID): CommandResult");
+  });
+  globalThis.test("omits the global node query (the canonical base document owns it)", () => {
+    let sdl = GraphQL_Stitcher$ReventlessCore.stitchStandalone(pluginFragment);
+    globalThis.expect(sdl.includes("node(id: ID!): Node")).toBe(false);
+  });
+  globalThis.test("stitch keeps injecting the global node query (whole-schema path unchanged)", () => {
+    let sdl = GraphQL_Stitcher$ReventlessCore.stitch(pluginFragment, []);
+    globalThis.expect(sdl).toContain("node(id: ID!): Node");
+  });
+});
+
+/*  Not a pure module */

package/tests/api/SimpleTest.res.mjs

@@ -0,0 +1,10 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+globalThis.describe("Basic test", () => {
+  globalThis.test("1 + 1 = 2", () => {
+    globalThis.expect(2).toBe(2);
+  });
+});
+
+/*  Not a pure module */

package/tests/api/SuryToJsonSchemaTest.res

@@ -29,6 +29,8 @@ let emptySpec: Reventless.StateAnnotations.stateAnnotationSpec = {
   collapsed: [],
   scan: [],
   scanSort: [],
+  semantic: [],
+  metric: [],
   status: None,
   groupBy: None,
   visibility: None,
@@ -49,6 +51,25 @@ describe("SuryToJsonSchema:", () => {
         idSchema->Option.flatMap(s => getProperty(s, "x-reventless-id")),
       )->toBe(None)
     })
+
+    testSync("emits format:\"date-time\" for a DateTime-marked string field", () => {
+      let schema = S.schema(s =>
+        {
+          "placedAt": s.matches(Reventless.DateTime.string),
+          "name": s.matches(S.string),
+        }
+      )->S.castToUnknown
+      let json = SuryToJsonSchema.deriveObjectSchema(schema)
+      expect(
+        getPropertyOf(json, "placedAt")
+        ->Option.flatMap(s => getProperty(s, "format"))
+        ->Option.flatMap(JSON.Decode.string),
+      )->toBe(Some("date-time"))
+      // A plain string field stays plain — the marker is opt-in.
+      expect(
+        getPropertyOf(json, "name")->Option.flatMap(s => getProperty(s, "format")),
+      )->toBe(None)
+    })
   })
 
   describe("deriveObjectSchema with stateAnnotations metadata:", () => {
@@ -306,6 +327,53 @@ describe("SuryToJsonSchema:", () => {
       ))->toEqual((Some(true), None))
     })
 
+    testSync("emits x-reventless-semantic on the field listed in semantic", () => {
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "total": s.matches(S.float),
+        }
+      )->S.castToUnknown
+      let schema' = schema->withSpec({...emptySpec, semantic: [("total", "currency")]})
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let totalSchema = getPropertyOf(json, "total")
+      let idSchema = getPropertyOf(json, "id")
+      expect((
+        totalSchema
+        ->Option.flatMap(s => getProperty(s, "x-reventless-semantic"))
+        ->Option.flatMap(JSON.Decode.string),
+        idSchema->Option.flatMap(s => getProperty(s, "x-reventless-semantic")),
+      ))->toEqual((Some("currency"), None))
+    })
+
+    testSync("emits x-reventless-metric {aggregate,label} on the field listed in metric", () => {
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "total": s.matches(S.float),
+        }
+      )->S.castToUnknown
+      let schema' =
+        schema->withSpec({...emptySpec, metric: [("total", {aggregate: "sum", label: "Revenue"})]})
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let metricObj = getPropertyOf(json, "total")->Option.flatMap(s => getProperty(s, "x-reventless-metric"))
+      expect((
+        metricObj->Option.flatMap(m => getProperty(m, "aggregate"))->Option.flatMap(JSON.Decode.string),
+        metricObj->Option.flatMap(m => getProperty(m, "label"))->Option.flatMap(JSON.Decode.string),
+      ))->toEqual((Some("sum"), Some("Revenue")))
+    })
+
+    testSync("omits the metric label when empty (UI derives one from the field name)", () => {
+      let schema = S.schema(s => {"total": s.matches(S.float)})->S.castToUnknown
+      let schema' = schema->withSpec({...emptySpec, metric: [("total", {aggregate: "sum", label: ""})]})
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let metricObj = getPropertyOf(json, "total")->Option.flatMap(s => getProperty(s, "x-reventless-metric"))
+      expect((
+        metricObj->Option.flatMap(m => getProperty(m, "aggregate"))->Option.flatMap(JSON.Decode.string),
+        metricObj->Option.flatMap(m => getProperty(m, "label")),
+      ))->toEqual((Some("sum"), None))
+    })
+
     testSync("emits x-reventless-group-by on the field named by groupBy", () => {
       let schema = S.schema(s =>
         {