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

package/tests/api/GraphQL_FragmentGeneratorTest.res.mjs

@@ -322,6 +322,111 @@ globalThis.describe("GraphQL_FragmentGenerator.mutationArgTypes", () => {
   });
 });
 
+let stateSchema = S.schema(s => ({
+  id: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let RefDoorRow = {
+  stateSchema: stateSchema
+};
+
+function queryFor(fragment, needle) {
+  return GraphQL_Stitcher$ReventlessCore.decode(fragment).queries.find(q => q.includes(needle));
+}
+
+function refDoorFragment(subIdField) {
+  return GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+      singleFieldName: "Catalog_Product",
+      listFieldName: "Catalog_Products",
+      returnTypeName: "Catalog_Product",
+      stateSchema: stateSchema,
+      authorization: undefined,
+      connectionSpec: true,
+      subIdField: subIdField
+    }]);
+}
+
+globalThis.describe("the reference door and the archive argument", () => {
+  globalThis.test("projects a reference to id, label and the state that retired it", () => {
+    let sdl = GraphQL_FragmentGenerator$ReventlessCore.deriveRefTypeSdl("Catalog_Product");
+    globalThis.expect([
+      sdl.includes("type Catalog_ProductRef"),
+      sdl.includes("label: String!"),
+      sdl.includes("retiredState: String"),
+      sdl.includes("price")
+    ]).toEqual([
+      true,
+      true,
+      true,
+      false
+    ]);
+  });
+  globalThis.test("names the door after the list field it resolves against", () => {
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.deriveRefsQueryField("Catalog_Products", "Catalog_Product")).toEqual("  Catalog_ProductsRefs(ids: [ID!]!): [Catalog_ProductRef!]!");
+  });
+  globalThis.test("emits the door from generate, not only from the helper", () => {
+    globalThis.expect([
+      Stdlib_Option.isSome(queryFor(refDoorFragment(undefined), "Catalog_ProductsRefs(ids: [ID!]!)")),
+      Stdlib_Option.isSome(typeDefFor(refDoorFragment(undefined), "type Catalog_ProductRef"))
+    ]).toEqual([
+      true,
+      true
+    ]);
+  });
+  globalThis.test("withholds the door from a composite-key view", () => {
+    globalThis.expect([
+      Stdlib_Option.isSome(queryFor(refDoorFragment("lineNo"), "Catalog_ProductsRefs")),
+      Stdlib_Option.isSome(typeDefFor(refDoorFragment("lineNo"), "type Catalog_ProductRef"))
+    ]).toEqual([
+      false,
+      false
+    ]);
+  });
+  globalThis.test("lets the single-entity and by-ids doors be asked for the archive", () => {
+    globalThis.expect([
+      GraphQL_FragmentGenerator$ReventlessCore.deriveObjectQueryField("Catalog_Product", "Catalog_Product", undefined, undefined).includes("includeRetired: Boolean"),
+      GraphQL_FragmentGenerator$ReventlessCore.deriveByIdsQueryField("Catalog_Products", "Catalog_Product").includes("includeRetired: Boolean")
+    ]).toEqual([
+      true,
+      true
+    ]);
+  });
+  globalThis.test("keeps the sub-id argument when the view has one", () => {
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.deriveObjectQueryField("Ordering_OrderLine", "Ordering_OrderLine", undefined, "lineNo")).toEqual("  Ordering_OrderLine(id: ID!, lineNo: String!, includeRetired: Boolean): Ordering_OrderLine");
+  });
+});
+
+globalThis.describe("the by-index door", () => {
+  let index = (index$1, idField, subIdField) => ({
+    index: index$1,
+    type_: "S",
+    idField: idField,
+    subIdField: subIdField,
+    projectionType: "ALL"
+  });
+  globalThis.test("takes the index value it filters on, and can be asked for the archive", () => {
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.deriveIndexQueryField("Catalog_Product", index("categoryId", undefined, undefined), "Catalog_ProductConnection")).toEqual("  Catalog_ProductByCategoryId(categoryId: String!, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): Catalog_ProductConnection!");
+  });
+  globalThis.test("names the field after the index and keys it on the column", () => {
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.deriveIndexQueryField("Ordering_Order", index("byOwner", "ownerId", undefined), "Ordering_OrderConnection")).toEqual("  Ordering_OrderByOwner(ownerId: String!, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): Ordering_OrderConnection!");
+  });
+  globalThis.test("offers the sort key the sort template has always read", () => {
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.deriveIndexQueryField("Ordering_Order", index("byCustomer", "customerId", "placedAt"), "Ordering_OrderConnection")).toEqual("  Ordering_OrderByCustomer(customerId: String!, placedAt: String, first: Int, after: String, last: Int, before: String, includeRetired: Boolean): Ordering_OrderConnection!");
+  });
+  globalThis.test("drops a leading `by` exactly once", () => {
+    globalThis.expect([
+      GraphQL_FragmentGenerator$ReventlessCore.indexQueryFieldName("X", "byOwner"),
+      GraphQL_FragmentGenerator$ReventlessCore.indexQueryFieldName("X", "ownerId"),
+      GraphQL_FragmentGenerator$ReventlessCore.indexQueryFieldName("X", "by")
+    ]).toEqual([
+      "XByOwner",
+      "XByOwnerId",
+      "XByBy"
+    ]);
+  });
+});
+
 export {
   OrderSliceCmd,
   mutationFor,
@@ -330,5 +435,8 @@ export {
   AddProductCmd,
   ChangePriceCmd,
   PlaceOrder,
+  RefDoorRow,
+  queryFor,
+  refDoorFragment,
 }
 /* commandSchema Not a pure module */

package/tests/api/SuryToJsonSchemaTest.res

@@ -431,7 +431,7 @@ describe("SuryToJsonSchema:", () => {
       let schema' =
         schema->withSpec({
           ...emptySpec,
-          retired: Some({field: "archived", label: "Archived", showWhenFalse: true, values: None}),
+          retired: Some({field: "archived", label: "Archived", showWhenFalse: true, values: None, namedWhenRetired: false}),
         })
       let json = SuryToJsonSchema.deriveObjectSchema(schema')
       let retiredObj =
@@ -464,6 +464,7 @@ describe("SuryToJsonSchema:", () => {
           label: "",
           showWhenFalse: false,
           values: Some(values),
+          namedWhenRetired: false,
         }),
       })
       ->SuryToJsonSchema.deriveObjectSchema
@@ -522,7 +523,7 @@ describe("SuryToJsonSchema:", () => {
       let schema' =
         schema->withSpec({
           ...emptySpec,
-          retired: Some({field: "archived", label: "", showWhenFalse: false, values: None}),
+          retired: Some({field: "archived", label: "", showWhenFalse: false, values: None, namedWhenRetired: false}),
         })
       let json = SuryToJsonSchema.deriveObjectSchema(schema')
       let retiredObj = json->retiredOn("archived")
@@ -532,12 +533,38 @@ describe("SuryToJsonSchema:", () => {
       ))->toEqual((None, None))
     })
 
+    // The opt-in that lets a reference name a withheld row. Travels only when
+    // true, on the omit-the-default rule the keys around it follow: false is what
+    // every record said before it existed, and writing it would put a key on
+    // every retirement to report that nothing changed.
+    testSync("carries namedWhenRetired only when the record opted in", () => {
+      let build = (~named: bool) => {
+        let schema = S.schema(s => {"archived": s.matches(S.bool)})->S.castToUnknown
+        schema
+        ->withSpec({
+          ...emptySpec,
+          retired: Some({
+            field: "archived",
+            label: "",
+            showWhenFalse: false,
+            values: None,
+            namedWhenRetired: named,
+          }),
+        })
+        ->SuryToJsonSchema.deriveObjectSchema
+        ->retiredOn("archived")
+        ->Option.flatMap(r => getProperty(r, "namedWhenRetired"))
+        ->Option.flatMap(JSON.Decode.bool)
+      }
+      expect((build(~named=true), build(~named=false)))->toEqual((Some(true), None))
+    })
+
     testSync("omits the retired label when empty but always states showWhenFalse", () => {
       let schema = S.schema(s => {"deactivated": s.matches(S.bool)})->S.castToUnknown
       let schema' =
         schema->withSpec({
           ...emptySpec,
-          retired: Some({field: "deactivated", label: "", showWhenFalse: false, values: None}),
+          retired: Some({field: "deactivated", label: "", showWhenFalse: false, values: None, namedWhenRetired: false}),
         })
       let json = SuryToJsonSchema.deriveObjectSchema(schema')
       let retiredObj =

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -737,7 +737,8 @@ globalThis.describe("SuryToJsonSchema:", () => {
           field: "archived",
           label: "Archived",
           showWhenFalse: true,
-          values: undefined
+          values: undefined,
+          namedWhenRetired: false
         }
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -783,7 +784,8 @@ globalThis.describe("SuryToJsonSchema:", () => {
           field: "accountStatus",
           label: "",
           showWhenFalse: false,
-          values: values
+          values: values,
+          namedWhenRetired: false
         }
       }));
     };
@@ -837,7 +839,8 @@ globalThis.describe("SuryToJsonSchema:", () => {
           field: "archived",
           label: "",
           showWhenFalse: false,
-          values: undefined
+          values: undefined,
+          namedWhenRetired: false
         }
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);
@@ -850,6 +853,47 @@ globalThis.describe("SuryToJsonSchema:", () => {
         undefined
       ]);
     });
+    globalThis.test("carries namedWhenRetired only when the record opted in", () => {
+      let build = named => {
+        let schema = S.schema(s => ({
+          archived: s.m(S.bool)
+        }));
+        return Stdlib_Option.flatMap(Stdlib_Option.flatMap(retiredOn(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(withSpec(schema, {
+          ids: emptySpec_ids,
+          compositeIds: emptySpec_compositeIds,
+          subIds: emptySpec_subIds,
+          compositeSubIds: emptySpec_compositeSubIds,
+          indexes: emptySpec_indexes,
+          hidden: emptySpec_hidden,
+          summary: emptySpec_summary,
+          drillTargets: emptySpec_drillTargets,
+          drillTargetKeys: emptySpec_drillTargetKeys,
+          collapsed: emptySpec_collapsed,
+          scan: emptySpec_scan,
+          scanSort: emptySpec_scanSort,
+          semantic: emptySpec_semantic,
+          metric: emptySpec_metric,
+          lifecycle: undefined,
+          groupBy: undefined,
+          visibility: undefined,
+          live: undefined,
+          retired: {
+            field: "archived",
+            label: "",
+            showWhenFalse: false,
+            values: undefined,
+            namedWhenRetired: named
+          }
+        })), "archived"), r => getProperty(r, "namedWhenRetired")), Stdlib_JSON.Decode.bool);
+      };
+      globalThis.expect([
+        build(true),
+        build(false)
+      ]).toEqual([
+        true,
+        undefined
+      ]);
+    });
     globalThis.test("omits the retired label when empty but always states showWhenFalse", () => {
       let schema = S.schema(s => ({
         deactivated: s.m(S.bool)
@@ -877,7 +921,8 @@ globalThis.describe("SuryToJsonSchema:", () => {
           field: "deactivated",
           label: "",
           showWhenFalse: false,
-          values: undefined
+          values: undefined,
+          namedWhenRetired: false
         }
       });
       let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema$p);

package/tests/plugin/PluginStructureTest.res

@@ -938,7 +938,7 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
           groupBy: None,
           visibility: None,
           live: None,
-          retired: Some({field, label: "", showWhenFalse: false, values: None}),
+          retired: Some({field, label: "", showWhenFalse: false, values: None, namedWhenRetired: false}),
         },
       )
 
@@ -973,6 +973,7 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
               label: "",
               showWhenFalse: false,
               values: Some(["Deactivated", "Closed"]),
+              namedWhenRetired: false,
             }),
           },
         )
@@ -1017,6 +1018,108 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     })
   })
 
+  // A misspelled retirement state used to be fatal or merely logged depending on
+  // where the enum happened to be declared — the PPX refuses it when the enum is
+  // in the same file, and this pass, which sees the resolved schema, only warned.
+  // File layout is not a defensible arbiter of whether a data-exposure bug stops
+  // a build, so this rung was raised to match the other.
+  describe("@retired state names are checked against the field's own enum", () => {
+    let withRetiredStates = (schema, ~field, ~lifecycle, ~values) =>
+      schema->S.castToUnknown->S.Metadata.set(
+        ~id=Reventless.StateAnnotations.stateAnnotationsId,
+        {
+          ids: [],
+          compositeIds: [],
+          subIds: [],
+          compositeSubIds: [],
+          indexes: [],
+          hidden: [],
+          summary: [],
+          drillTargets: [],
+          drillTargetKeys: [],
+          collapsed: [],
+          scan: [],
+          scanSort: [],
+          semantic: [],
+          metric: [],
+          lifecycle,
+          groupBy: None,
+          visibility: None,
+          live: None,
+          retired: Some({field, label: "", showWhenFalse: false, values, namedWhenRetired: false}),
+        },
+      )
+
+    let shelf = values =>
+      S.schema(s =>
+        {
+          "shelf": s.matches(S.union([S.literal("Listed"), S.literal("Archived")])),
+        }
+      )->withRetiredStates(~field="shelf", ~lifecycle=Some("shelf"), ~values=Some(values))
+
+    let check = schema => Plugin_Structure.checkRetiredValue(~entityName="Products", schema)
+
+    testSync("a declared state passes", () => {
+      expect(check(shelf(["Archived"])))->toEqual(Plugin_Structure.Checked([]))
+    })
+
+    // Reported per state rather than as a set: one wrong entry among several
+    // still narrows something, so the symptom is a subset of rows leaking.
+    testSync("each undeclared state is reported on its own", () => {
+      switch check(shelf(["Archived", "Discontinud", "Withdrawn"])) {
+      | Checked(failures) =>
+        expect(failures->Array.length)->toBe(2)
+        expect(failures->Array.some(f => f->String.includes("Discontinud")))->toBe(true)
+        expect(failures->Array.some(f => f->String.includes("Withdrawn")))->toBe(true)
+        // Naming what the field does declare is what turns the failure into a fix.
+        expect(failures->Array.every(f => f->String.includes("Listed, Archived")))->toBe(true)
+      | other => expect(other)->toEqual(Plugin_Structure.Checked([]))
+      }
+    })
+
+    // The condition that came with promoting this: a fatal rule that is silent
+    // when it cannot run looks exactly like one that passed.
+    testSync("a field with no cases to compare against says so instead of passing", () => {
+      let schema =
+        S.schema(s => {"shelf": s.matches(S.string)})->withRetiredStates(
+          ~field="shelf",
+          ~lifecycle=Some("shelf"),
+          ~values=Some(["Archived"]),
+        )
+      switch check(schema) {
+      | Unchecked(why) => expect(why->String.includes("no cases"))->toBe(true)
+      | other => expect(other)->toEqual(Plugin_Structure.Unchecked(""))
+      }
+    })
+
+    // The boolean form names no state, so there is nothing to compare — which is
+    // not the same as having failed to compare it.
+    testSync("the boolean form is not a skip", () => {
+      let schema =
+        S.schema(s => {"archived": s.matches(S.bool)})->withRetiredStates(
+          ~field="archived",
+          ~lifecycle=None,
+          ~values=None,
+        )
+      expect(Plugin_Structure.checkRetiredValue(~entityName="Products", schema))->toEqual(
+        Plugin_Structure.NotDeclared,
+      )
+    })
+
+    // The second rule stays a warning: retirement still works, and which field
+    // carries it is a modelling judgement rather than a name that is wrong.
+    testSync("a state on a non-lifecycle field is not a failure", () => {
+      let schema =
+        S.schema(s =>
+          {
+            "shelf": s.matches(S.union([S.literal("Listed"), S.literal("Archived")])),
+            "lifecycle": s.matches(S.union([S.literal("Draft"), S.literal("Live")])),
+          }
+        )->withRetiredStates(~field="shelf", ~lifecycle=Some("lifecycle"), ~values=Some(["Archived"]))
+      expect(check(schema))->toEqual(Plugin_Structure.Checked([]))
+    })
+  })
+
   // Shared by the read-side and write-side schema cases below, which ask the
   // same question of the same emitter.
   let getProperty = (json: JSON.t, key: string): option<JSON.t> =>

package/tests/plugin/PluginStructureTest.res.mjs

@@ -1053,7 +1053,8 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         field: field,
         label: "",
         showWhenFalse: false,
-        values: undefined
+        values: undefined,
+        namedWhenRetired: false
       }
     });
     globalThis.test("publishes the retirement state beside the field", () => {
@@ -1083,7 +1084,8 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
           values: [
             "Deactivated",
             "Closed"
-          ]
+          ],
+          namedWhenRetired: false
         }
       });
       let schema = withState(S.schema(s => ({
@@ -1126,6 +1128,116 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.expect(Plugin_Structure$ReventlessCore.retiredFieldFromStateSchema(schema)).toEqual(undefined);
     });
   });
+  globalThis.describe("@retired state names are checked against the field's own enum", () => {
+    let withRetiredStates = (schema, field, lifecycle, values) => S.Metadata.set(schema, StateAnnotations$Reventless.stateAnnotationsId, {
+      ids: [],
+      compositeIds: [],
+      subIds: [],
+      compositeSubIds: [],
+      indexes: [],
+      hidden: [],
+      summary: [],
+      drillTargets: [],
+      drillTargetKeys: [],
+      collapsed: [],
+      scan: [],
+      scanSort: [],
+      semantic: [],
+      metric: [],
+      lifecycle: lifecycle,
+      groupBy: undefined,
+      visibility: undefined,
+      live: undefined,
+      retired: {
+        field: field,
+        label: "",
+        showWhenFalse: false,
+        values: values,
+        namedWhenRetired: false
+      }
+    });
+    let shelf = values => withRetiredStates(S.schema(s => ({
+      shelf: s.m(S.union([
+        S.literal("Listed"),
+        S.literal("Archived")
+      ]))
+    })), "shelf", "shelf", values);
+    globalThis.test("a declared state passes", () => {
+      globalThis.expect(Plugin_Structure$ReventlessCore.checkRetiredValue("Products", shelf(["Archived"]))).toEqual({
+        TAG: "Checked",
+        _0: []
+      });
+    });
+    globalThis.test("each undeclared state is reported on its own", () => {
+      let failures = Plugin_Structure$ReventlessCore.checkRetiredValue("Products", shelf([
+        "Archived",
+        "Discontinud",
+        "Withdrawn"
+      ]));
+      if (typeof failures !== "object") {
+        globalThis.expect(failures).toEqual({
+          TAG: "Checked",
+          _0: []
+        });
+        return;
+      }
+      if (failures.TAG === "Unchecked") {
+        globalThis.expect(failures).toEqual({
+          TAG: "Checked",
+          _0: []
+        });
+        return;
+      }
+      let failures$1 = failures._0;
+      globalThis.expect(failures$1.length).toBe(2);
+      globalThis.expect(failures$1.some(f => f.includes("Discontinud"))).toBe(true);
+      globalThis.expect(failures$1.some(f => f.includes("Withdrawn"))).toBe(true);
+      globalThis.expect(failures$1.every(f => f.includes("Listed, Archived"))).toBe(true);
+    });
+    globalThis.test("a field with no cases to compare against says so instead of passing", () => {
+      let schema = withRetiredStates(S.schema(s => ({
+        shelf: s.m(S.string)
+      })), "shelf", "shelf", ["Archived"]);
+      let why = Plugin_Structure$ReventlessCore.checkRetiredValue("Products", schema);
+      if (typeof why !== "object") {
+        globalThis.expect(why).toEqual({
+          TAG: "Unchecked",
+          _0: ""
+        });
+        return;
+      }
+      if (why.TAG === "Unchecked") {
+        globalThis.expect(why._0.includes("no cases")).toBe(true);
+        return;
+      }
+      globalThis.expect(why).toEqual({
+        TAG: "Unchecked",
+        _0: ""
+      });
+    });
+    globalThis.test("the boolean form is not a skip", () => {
+      let schema = withRetiredStates(S.schema(s => ({
+        archived: s.m(S.bool)
+      })), "archived", undefined, undefined);
+      globalThis.expect(Plugin_Structure$ReventlessCore.checkRetiredValue("Products", schema)).toEqual("NotDeclared");
+    });
+    globalThis.test("a state on a non-lifecycle field is not a failure", () => {
+      let schema = withRetiredStates(S.schema(s => ({
+        shelf: s.m(S.union([
+          S.literal("Listed"),
+          S.literal("Archived")
+        ])),
+        lifecycle: s.m(S.union([
+          S.literal("Draft"),
+          S.literal("Live")
+        ]))
+      })), "shelf", "lifecycle", ["Archived"]);
+      globalThis.expect(Plugin_Structure$ReventlessCore.checkRetiredValue("Products", schema)).toEqual({
+        TAG: "Checked",
+        _0: []
+      });
+    });
+  });
   let getProperty = (json, key) => {
     let obj = Stdlib_JSON.Decode.object(json);
     if (obj !== undefined) {