@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -0,0 +1,578 @@
+// 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 DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as GraphQL_Server$ReventlessLocal from "../../src/adapter/GraphQL_Server.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as GraphQL_SchemaInspector$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_SchemaInspector.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let testStateSchema = S.schema(s => ({
+  id: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string),
+  price: s.m(S.float),
+  active: s.m(S.bool)
+}));
+
+let svStateSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string),
+  price: s.m(S.float)
+}));
+
+let addCommandSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let unionCommandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Create",
+    itemId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Rename",
+    itemId: s.m(DcbTag$Reventless.string),
+    newName: s.m(S.string)
+  }))
+]);
+
+let plainStateSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let indexedStateSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  ownerId: s.m(S.string),
+  status: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let indexedStateSchemaWithAnnotations = S.Metadata.set(indexedStateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: ["productId"],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [[
+      "ownerId",
+      "byOwner"
+    ]],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  status: undefined,
+  visibility: undefined
+});
+
+let orderedStateSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  createdAt: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let orderedStateSchemaWithAnnotations = S.Metadata.set(orderedStateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: ["productId"],
+  compositeIds: [],
+  subIds: ["createdAt"],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  status: undefined,
+  visibility: undefined
+});
+
+let scanStateSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  status: s.m(S.string),
+  name: s.m(S.string),
+  description: s.m(S.string)
+}));
+
+let scanStateSchemaWithAnnotations = S.Metadata.set(scanStateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: ["productId"],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: ["status"],
+  scanSort: ["name"],
+  status: undefined,
+  visibility: undefined
+});
+
+globalThis.describe("GraphQL_SchemaInspector", () => {
+  globalThis.describe("inspectScalar", () => {
+    globalThis.test("plain string derives to String", async () => {
+      globalThis.expect(GraphQL_SchemaInspector$ReventlessCore.inspectScalar(S.string)).toBe("String");
+    });
+    globalThis.test("tagged string derives to ID", async () => {
+      globalThis.expect(GraphQL_SchemaInspector$ReventlessCore.inspectScalar(DcbTag$Reventless.string)).toBe("ID");
+    });
+    globalThis.test("float derives to Float", async () => {
+      globalThis.expect(GraphQL_SchemaInspector$ReventlessCore.inspectScalar(S.float)).toBe("Float");
+    });
+    globalThis.test("bool derives to Boolean", async () => {
+      globalThis.expect(GraphQL_SchemaInspector$ReventlessCore.inspectScalar(S.bool)).toBe("Boolean");
+    });
+  });
+  globalThis.describe("inspectObjectType", () => {
+    globalThis.test("derives type definition from object schema", async () => {
+      let result = GraphQL_SchemaInspector$ReventlessCore.inspectObjectType("TestState", testStateSchema);
+      globalThis.expect(Stdlib_Option.isSome(result)).toBe(true);
+      let sdl = Stdlib_Option.getOrThrow(result, undefined);
+      globalThis.expect(sdl.includes("type TestState")).toBe(true);
+      globalThis.expect(sdl.includes("id: ID!")).toBe(true);
+      globalThis.expect(sdl.includes("name: String")).toBe(true);
+      globalThis.expect(sdl.includes("price: Float")).toBe(true);
+      globalThis.expect(sdl.includes("active: Boolean")).toBe(true);
+    });
+    globalThis.test("returns None for non-object schema", async () => {
+      let result = GraphQL_SchemaInspector$ReventlessCore.inspectObjectType("Foo", S.string);
+      globalThis.expect(Stdlib_Option.isNone(result)).toBe(true);
+    });
+  });
+  globalThis.describe("inspectMutationFields", () => {
+    globalThis.test("derives fields from single-variant (DCB slice) command", async () => {
+      let fields = GraphQL_SchemaInspector$ReventlessCore.inspectMutationFields("Catalog_AddProduct", addCommandSchema);
+      globalThis.expect(fields.length).toBe(1);
+      let field = fields[0];
+      globalThis.expect(field.includes("Catalog_AddProduct")).toBe(true);
+      globalThis.expect(field.includes("productId: ID!")).toBe(true);
+      globalThis.expect(field.includes("name: String")).toBe(true);
+    });
+    globalThis.test("derives fields from union (aggregate) command", async () => {
+      let fields = GraphQL_SchemaInspector$ReventlessCore.inspectMutationFields("App_Item", unionCommandSchema);
+      globalThis.expect(fields.length).toBe(2);
+      let createField = fields[0];
+      globalThis.expect(createField.includes("App_Item_Create")).toBe(true);
+      globalThis.expect(createField.includes("itemId: ID!")).toBe(true);
+      let renameField = fields[1];
+      globalThis.expect(renameField.includes("App_Item_Rename")).toBe(true);
+      globalThis.expect(renameField.includes("newName: String")).toBe(true);
+    });
+    globalThis.test("returns empty for non-object/non-union schema", async () => {
+      let fields = GraphQL_SchemaInspector$ReventlessCore.inspectMutationFields("Foo", S.string);
+      globalThis.expect(fields.length).toBe(0);
+    });
+  });
+  globalThis.describe("inspectQueryFields", () => {
+    globalThis.test("derives type def and query fields from state schema", async () => {
+      let result = GraphQL_SchemaInspector$ReventlessCore.inspectQueryFields("Catalog_Product", "CatalogProduct", testStateSchema);
+      globalThis.expect(Stdlib_Option.isSome(result.typeDef)).toBe(true);
+      let typeDef = Stdlib_Option.getOrThrow(result.typeDef, undefined);
+      globalThis.expect(typeDef.includes("type CatalogProduct")).toBe(true);
+      globalThis.expect(result.singleQuery.includes("Catalog_Product(id: ID!)")).toBe(true);
+      globalThis.expect(result.singleQuery.includes("CatalogProduct")).toBe(true);
+      globalThis.expect(Stdlib_Option.isSome(result.listQuery)).toBe(true);
+      let listQ = Stdlib_Option.getOrThrow(result.listQuery, undefined);
+      globalThis.expect(listQ.includes("Catalog_Products")).toBe(true);
+    });
+  });
+  globalThis.describe("includeIdParam — ReadModel vs StateViewSlice", () => {
+    globalThis.test("ReadModel fragment: query has (id: ID!) and type has injected id: ID!", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "RM_Product",
+          listFieldName: "RM_Products",
+          returnTypeName: "RMProduct",
+          stateSchema: testStateSchema,
+          authorization: undefined,
+          includeIdParam: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("RM_Product(id: ID!): RMProduct")).toBe(true);
+      globalThis.expect(sdl.includes("type RMProduct")).toBe(true);
+      let typeLines = sdl.split("\n");
+      let idFieldInType = typeLines.some(line => {
+        if (line.trim() === "id: ID!") {
+          return !line.includes("(");
+        } else {
+          return false;
+        }
+      });
+      globalThis.expect(idFieldInType).toBe(true);
+    });
+    globalThis.test("StateViewSlice fragment: query has no (id: ID!) and type has no injected id", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "SV_Item",
+          listFieldName: "SV_Items",
+          returnTypeName: "SVItem",
+          stateSchema: svStateSchema,
+          authorization: undefined,
+          includeIdParam: false
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("SV_Item: SVItem")).toBe(true);
+      globalThis.expect(sdl.includes("SV_Item(id: ID!)")).toBe(false);
+      globalThis.expect(sdl.includes("type SVItem")).toBe(true);
+      globalThis.expect(sdl.includes("productId: ID!")).toBe(true);
+      let typeSection = Stdlib_Option.getOr(sdl.split("type SVItem")[1], "");
+      let typeEnd = typeSection.indexOf("}");
+      let typeEnd$1 = typeEnd >= 0 ? typeEnd : typeSection.length;
+      let typeBody = typeSection.slice(0, typeEnd$1);
+      let hasInjectedId = typeBody.split("\n").some(line => line.trim() === "id: ID!");
+      globalThis.expect(hasInjectedId).toBe(false);
+    });
+    globalThis.test("default includeIdParam (omitted) behaves like ReadModel", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Default_Thing",
+          listFieldName: "Default_Things",
+          returnTypeName: "DefaultThing",
+          stateSchema: testStateSchema,
+          authorization: undefined
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("Default_Thing(id: ID!): DefaultThing")).toBe(true);
+    });
+  });
+  globalThis.describe("Relay compliance", () => {
+    globalThis.test("entity type includes 'implements Node' when includeIdParam is true", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Relay_Product",
+          listFieldName: "Relay_Products",
+          returnTypeName: "RelayProduct",
+          stateSchema: testStateSchema,
+          authorization: undefined,
+          includeIdParam: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("type RelayProduct implements Node")).toBe(true);
+      globalThis.expect(sdl.includes("id: ID!")).toBe(true);
+    });
+    globalThis.test("non-entity type does not include 'implements Node'", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Relay_View",
+          listFieldName: "Relay_Views",
+          returnTypeName: "RelayView",
+          stateSchema: svStateSchema,
+          authorization: undefined,
+          includeIdParam: false
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("type RelayView implements Node")).toBe(false);
+      globalThis.expect(sdl.includes("type RelayView {")).toBe(true);
+    });
+    globalThis.test("connectionSpec generates Edge and Connection types instead of plural wrapper", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Relay_Product",
+          listFieldName: "Relay_Products",
+          returnTypeName: "RelayProduct",
+          stateSchema: testStateSchema,
+          authorization: undefined,
+          includeIdParam: true,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("type RelayProductEdge")).toBe(true);
+      globalThis.expect(sdl.includes("node: RelayProduct!")).toBe(true);
+      globalThis.expect(sdl.includes("cursor: String!")).toBe(true);
+      globalThis.expect(sdl.includes("type RelayProductConnection")).toBe(true);
+      globalThis.expect(sdl.includes("edges: [RelayProductEdge!]!")).toBe(true);
+      globalThis.expect(sdl.includes("pageInfo: PageInfo!")).toBe(true);
+      globalThis.expect(sdl.includes("totalCount")).toBe(false);
+      globalThis.expect(sdl.includes("Relay_Products(filter: RelayProductFilter, first: Int, after: String, last: Int, before: String): RelayProductConnection!")).toBe(true);
+      globalThis.expect(sdl.includes("input RelayProductFilter")).toBe(true);
+      globalThis.expect(sdl.includes("search: String")).toBe(true);
+      globalThis.expect(sdl.includes("searchPrefix: String")).toBe(true);
+      globalThis.expect(sdl.includes("ids: [ID!]")).toBe(true);
+      globalThis.expect(sdl.includes("items: [RelayProduct!]!")).toBe(false);
+      globalThis.expect(sdl.includes("nextToken:")).toBe(false);
+    });
+    globalThis.test("subIdField generates ItemsFilter (distinct from connection Filter)", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Items_Product",
+          listFieldName: "Items_Products",
+          returnTypeName: "ItemsProduct",
+          stateSchema: testStateSchema,
+          authorization: undefined,
+          includeIdParam: true,
+          connectionSpec: true,
+          subIdField: "sku"
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("input ItemsProductFilter")).toBe(true);
+      globalThis.expect(sdl.includes("input ItemsProductItemsFilter")).toBe(true);
+      globalThis.expect(sdl.includes("Items_ProductItems(id: ID!, filter: ItemsProductItemsFilter,")).toBe(true);
+    });
+    globalThis.test("explicit connectionSpec=false generates legacy plural wrapper (opt-out)", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Legacy_Product",
+          listFieldName: "Legacy_Products",
+          returnTypeName: "LegacyProduct",
+          stateSchema: testStateSchema,
+          authorization: undefined,
+          includeIdParam: true,
+          connectionSpec: false
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("items: [LegacyProduct!]!")).toBe(true);
+      globalThis.expect(sdl.includes("nextToken: String")).toBe(true);
+      globalThis.expect(sdl.includes("LegacyProductEdge")).toBe(false);
+      globalThis.expect(sdl.includes("LegacyProductConnection")).toBe(false);
+    });
+    globalThis.test("stitcher injects Node interface and node query", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Stitch_Product",
+          listFieldName: "Stitch_Products",
+          returnTypeName: "StitchProduct",
+          stateSchema: testStateSchema,
+          authorization: undefined,
+          includeIdParam: true
+        }]);
+      let sdl = GraphQL_Stitcher$ReventlessCore.stitch(fragment, []);
+      globalThis.expect(sdl.includes("interface Node")).toBe(true);
+      globalThis.expect(sdl.includes("node(id: ID!): Node")).toBe(true);
+      globalThis.expect(sdl.includes("type PageInfo")).toBe(true);
+      globalThis.expect(sdl.includes("hasNextPage: Boolean!")).toBe(true);
+    });
+  });
+  globalThis.describe("inspectFragment", () => {
+    globalThis.test("decodes and previews a fragment", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([{
+          fieldNames: ["Test_Add"],
+          commandSchema: addCommandSchema
+        }], [{
+          singleFieldName: "Test_State",
+          listFieldName: "Test_States",
+          returnTypeName: "TestState",
+          stateSchema: testStateSchema,
+          authorization: undefined
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      globalThis.expect(inspection.types.length).toBe(8);
+      globalThis.expect(inspection.mutations.length).toBe(1);
+      globalThis.expect(inspection.queries.length).toBe(3);
+      globalThis.expect(inspection.sdlPreview.includes("type TestState")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("type TestStateEdge")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("type TestStateConnection")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("input TestStateFilter")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("edges: [TestStateEdge!]!")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("Test_Add")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("Test_State")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("TestStateConnection!")).toBe(true);
+      globalThis.expect(inspection.sdlPreview.includes("union CommandResult")).toBe(true);
+    });
+  });
+  globalThis.describe("inspectPluginEntries", () => {
+    globalThis.test("formats mutation and query entries", async () => {
+      let summary = GraphQL_SchemaInspector$ReventlessCore.inspectPluginEntries([{
+          fieldNames: [
+            "Plugin_Add",
+            "Plugin_Remove"
+          ],
+          commandSchema: unionCommandSchema
+        }], [{
+          singleFieldName: "Plugin_Item",
+          listFieldName: "Plugin_Items",
+          returnTypeName: "PluginItem",
+          stateSchema: testStateSchema,
+          authorization: undefined
+        }]);
+      globalThis.expect(summary.includes("Mutations (2)")).toBe(true);
+      globalThis.expect(summary.includes("Plugin_Add")).toBe(true);
+      globalThis.expect(summary.includes("Plugin_Remove")).toBe(true);
+      globalThis.expect(summary.includes("Queries (1)")).toBe(true);
+      globalThis.expect(summary.includes("Plugin_Item(id) -> PluginItem")).toBe(true);
+    });
+  });
+  globalThis.describe("server capability — auto-derived Filter / OrderBy", () => {
+    globalThis.test("read model with no annotations emits the unchanged search-only Filter", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Plain_View",
+          listFieldName: "Plain_Views",
+          returnTypeName: "PlainView",
+          stateSchema: plainStateSchema,
+          authorization: undefined,
+          includeIdParam: false,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("input PlainViewFilter")).toBe(true);
+      globalThis.expect(sdl.includes("search: String")).toBe(true);
+      globalThis.expect(sdl.includes("searchPrefix: String")).toBe(true);
+      globalThis.expect(sdl.includes("ids: [ID!]")).toBe(true);
+      globalThis.expect(sdl.includes("Eq:")).toBe(false);
+      globalThis.expect(sdl.includes("PlainViewOrderBy")).toBe(false);
+      globalThis.expect(sdl.includes("PlainViewOrderField")).toBe(false);
+      globalThis.expect(sdl.includes("orderBy:")).toBe(false);
+    });
+    globalThis.test("read model with @id + @index emits Eq filters + OrderBy + orderBy arg", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Indexed_Product",
+          listFieldName: "Indexed_Products",
+          returnTypeName: "IndexedProduct",
+          stateSchema: indexedStateSchemaWithAnnotations,
+          authorization: undefined,
+          includeIdParam: true,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("input IndexedProductFilter")).toBe(true);
+      globalThis.expect(sdl.includes("productIdEq: ID")).toBe(true);
+      globalThis.expect(sdl.includes("ownerIdEq: ID")).toBe(true);
+      globalThis.expect(sdl.includes("enum IndexedProductOrderField")).toBe(true);
+      globalThis.expect(sdl.includes("input IndexedProductOrderBy")).toBe(true);
+      globalThis.expect(sdl.includes("direction: SortOrder!")).toBe(true);
+      globalThis.expect(sdl.includes("orderBy: IndexedProductOrderBy")).toBe(true);
+    });
+    globalThis.test("read model with @scan / @scanSort folds opt-in fields into Filter / OrderBy", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Scan_Item",
+          listFieldName: "Scan_Items",
+          returnTypeName: "ScanItem",
+          stateSchema: scanStateSchemaWithAnnotations,
+          authorization: undefined,
+          includeIdParam: true,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("statusEq: String")).toBe(true);
+      globalThis.expect(sdl.includes("enum ScanItemOrderField")).toBe(true);
+      globalThis.expect(sdl.includes("name")).toBe(true);
+      globalThis.expect(sdl.includes("orderBy: ScanItemOrderBy")).toBe(true);
+      globalThis.expect(sdl.includes("nameEq:")).toBe(false);
+      globalThis.expect(sdl.includes("statusFrom:")).toBe(false);
+      globalThis.expect(sdl.includes("statusTo:")).toBe(false);
+    });
+    globalThis.test("validateScanSortAlignment warns when @scanSort field is not a sort key", async () => {
+      let warnings = GraphQL_FragmentGenerator$ReventlessCore.validateScanSortAlignment(scanStateSchemaWithAnnotations, "ScanItem", []);
+      globalThis.expect(warnings.length).toBe(1);
+      let msg = warnings[0];
+      globalThis.expect(msg.includes("ScanItem")).toBe(true);
+      globalThis.expect(msg.includes("name")).toBe(true);
+      globalThis.expect(msg.includes("per-page")).toBe(true);
+    });
+    globalThis.test("validateScanSortAlignment is silent when @scanSort field aligns with a known sort key", async () => {
+      let warnings = GraphQL_FragmentGenerator$ReventlessCore.validateScanSortAlignment(scanStateSchemaWithAnnotations, "ScanItem", ["name"]);
+      globalThis.expect(warnings).toEqual([]);
+    });
+    globalThis.test("validateScanSortAlignment is a no-op when there are no @scanSort fields", async () => {
+      let warnings = GraphQL_FragmentGenerator$ReventlessCore.validateScanSortAlignment(indexedStateSchemaWithAnnotations, "IndexedProduct", []);
+      globalThis.expect(warnings).toEqual([]);
+    });
+    globalThis.test("read model with @subId emits range filters + OrderBy on the sort key", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Ordered_Item",
+          listFieldName: "Ordered_Items",
+          returnTypeName: "OrderedItem",
+          stateSchema: orderedStateSchemaWithAnnotations,
+          authorization: undefined,
+          includeIdParam: true,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("createdAtEq: String")).toBe(true);
+      globalThis.expect(sdl.includes("createdAtFrom: String")).toBe(true);
+      globalThis.expect(sdl.includes("createdAtTo: String")).toBe(true);
+      globalThis.expect(sdl.includes("enum OrderedItemOrderField")).toBe(true);
+      globalThis.expect(sdl.includes("orderBy: OrderedItemOrderBy")).toBe(true);
+    });
+  });
+  globalThis.describe("GraphQL_Server diagnostics", () => {
+    globalThis.test("diagnostics detects resolver without SDL field", async () => {
+      GraphQL_Server$ReventlessLocal.reset();
+      let resolvers = {};
+      resolvers["orphanResolver"] = async (_root, _args, _ctx) => "ok";
+      GraphQL_Server$ReventlessLocal.registerMutations([], resolvers);
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      globalThis.expect(d.resolverMutationCount).toBe(1);
+      globalThis.expect(d.sdlMutationCount).toBe(0);
+      globalThis.expect(d.mismatches.length).toBe(1);
+      globalThis.expect(d.mismatches[0].includes("resolver but no SDL field")).toBe(true);
+      return GraphQL_Server$ReventlessLocal.reset();
+    });
+    globalThis.test("diagnostics detects SDL field without resolver", async () => {
+      GraphQL_Server$ReventlessLocal.reset();
+      GraphQL_Server$ReventlessLocal.registerQueries(["  orphanField(id: ID!): String"], {});
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      globalThis.expect(d.sdlQueryCount).toBe(1);
+      globalThis.expect(d.resolverQueryCount).toBe(0);
+      globalThis.expect(d.mismatches.length).toBe(1);
+      globalThis.expect(d.mismatches[0].includes("SDL field but no resolver")).toBe(true);
+      return GraphQL_Server$ReventlessLocal.reset();
+    });
+    globalThis.test("diagnostics reports no mismatches when fields and resolvers match", async () => {
+      GraphQL_Server$ReventlessLocal.reset();
+      let resolvers = {};
+      resolvers["myQuery"] = async (_root, _args, _ctx) => "ok";
+      GraphQL_Server$ReventlessLocal.registerQueries(["  myQuery(id: ID!): String"], resolvers);
+      let d = GraphQL_Server$ReventlessLocal.diagnostics();
+      globalThis.expect(d.mismatches.length).toBe(0);
+      globalThis.expect(d.sdlQueryCount).toBe(1);
+      globalThis.expect(d.resolverQueryCount).toBe(1);
+      return GraphQL_Server$ReventlessLocal.reset();
+    });
+    globalThis.test("getFullSdl returns None before start", async () => {
+      GraphQL_Server$ReventlessLocal.reset();
+      globalThis.expect(Stdlib_Option.isNone(GraphQL_Server$ReventlessLocal.getFullSdl())).toBe(true);
+    });
+    globalThis.test("getRegisteredSdl returns Query/Mutation SDL", async () => {
+      GraphQL_Server$ReventlessLocal.reset();
+      GraphQL_Server$ReventlessLocal.registerQueries(["  hello: String"], {});
+      let sdl = GraphQL_Server$ReventlessLocal.getRegisteredSdl();
+      globalThis.expect(sdl.includes("hello: String")).toBe(true);
+      globalThis.expect(sdl.includes("type Query")).toBe(true);
+      return GraphQL_Server$ReventlessLocal.reset();
+    });
+  });
+});
+
+let stringSchema = S.string;
+
+let taggedSchema = DcbTag$Reventless.string;
+
+let numberSchema = S.float;
+
+let boolSchema = S.bool;
+
+export {
+  stringSchema,
+  taggedSchema,
+  numberSchema,
+  boolSchema,
+  testStateSchema,
+  svStateSchema,
+  addCommandSchema,
+  unionCommandSchema,
+  plainStateSchema,
+  indexedStateSchema,
+  indexedStateSchemaWithAnnotations,
+  orderedStateSchema,
+  orderedStateSchemaWithAnnotations,
+  scanStateSchema,
+  scanStateSchemaWithAnnotations,
+}
+/*  Not a pure module */