@reventlessdev/reventless-core 3.0.0-alpha.237 → 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/commandgenerator/OwnerStampingTest.res

@@ -185,3 +185,60 @@ describe("@owner stamping on the command path:", () => {
     })
   })
 })
+
+// The schema is not only a validator, and the case below is the one that proves
+// it. Two AppSync-side call sites passed `S.json` in place of the command schema
+// — a defensible substitution while its only job was validation, since AppSync
+// has already checked the input against the SDL, and per-slice decoding happens
+// downstream anyway. Owner stamping then gave the same argument a second job:
+// it is where the `@owner` fields are read from. Handed a permissive schema the
+// lookup answers "no owner fields" for every command there is, and the write
+// keeps whatever owner the client sent — no error, no warning, a wrong row.
+//
+// Nothing about a single call site was wrong, which is why per-path tests could
+// not catch it. What was missing is a check on the RELATIONSHIP: a generator
+// built for a command whose spec marks an owner must be able to find it.
+describe("the schema a generator is built with must answer for its commands:", () => {
+  let permissive = CommandGenerator_Callback.makeGenerateCommand(
+    ~publishJsons=async cmds => published := published.contents->Array.concat(cmds),
+    ~serviceName="Ordering",
+    ~commandSchema=S.json->S.castToUnknown,
+    ~componentKind=CommandGenerator_Callback.StateChangeSlice,
+    ~stripIdFromParams=false,
+  )
+
+  testPromise("a permissive schema silently stamps nothing — the defect, pinned", async () => {
+    let _ =
+      await permissive(
+        placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
+      )->Effect.runPromise
+    // Not the behaviour we want anywhere — recorded so that a change making the
+    // permissive path stamp correctly is a deliberate one, and so the contrast
+    // with the case below cannot be read as incidental.
+    expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-B")))
+  })
+
+  testPromise("the real schema stamps, from the same payload and caller", async () => {
+    let _ =
+      await generate(
+        placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
+      )->Effect.runPromise
+    expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-A")))
+  })
+
+  // The check a call site can run against itself, and the one the DCB routing
+  // maps now satisfy by construction: every command a spec exposes resolves to
+  // its own owner fields through the schema that command will be dispatched
+  // with. Reading `[]` here is exactly the state that stamps nothing.
+  testPromise("every command of a spec resolves its owner fields through that spec's schema", async () => {
+    let schema = commandSchema->S.castToUnknown
+    expect(Reventless.Owner.variantFieldNames(schema, ~variant="PlaceOrder"))->toEqual([
+      "customerId",
+    ])
+    expect(Reventless.Owner.variantFieldNames(schema, ~variant="ImportProducts"))->toEqual([])
+    // The substitution, asked the same question.
+    expect(
+      Reventless.Owner.variantFieldNames(S.json->S.castToUnknown, ~variant="PlaceOrder"),
+    )->toEqual([])
+  })
+})

package/tests/commandgenerator/OwnerStampingTest.res.mjs

@@ -192,6 +192,25 @@ globalThis.describe("@owner stamping on the command path:", () => {
   });
 });
 
+globalThis.describe("the schema a generator is built with must answer for its commands:", () => {
+  let permissive = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(async cmds => {
+    published.contents = published.contents.concat(cmds);
+  }, undefined, "Ordering", S.json, "StateChangeSlice", false);
+  globalThis.test("a permissive schema silently stamps nothing — the defect, pinned", async () => {
+    await Effect.runPromise(permissive(placeOrder("cust-B", cognito("cust-A", ["User"]))));
+    globalThis.expect(fieldOf(published.contents[published.contents.length - 1 | 0], "customerId")).toEqual("cust-B");
+  });
+  globalThis.test("the real schema stamps, from the same payload and caller", async () => {
+    await Effect.runPromise(generate(placeOrder("cust-B", cognito("cust-A", ["User"]))));
+    globalThis.expect(fieldOf(published.contents[published.contents.length - 1 | 0], "customerId")).toEqual("cust-A");
+  });
+  globalThis.test("every command of a spec resolves its owner fields through that spec's schema", async () => {
+    globalThis.expect(Owner$Reventless.variantFieldNames(commandSchema, "PlaceOrder")).toEqual(["customerId"]);
+    globalThis.expect(Owner$Reventless.variantFieldNames(commandSchema, "ImportProducts")).toEqual([]);
+    globalThis.expect(Owner$Reventless.variantFieldNames(S.json, "PlaceOrder")).toEqual([]);
+  });
+});
+
 export {
   commandSchema,
   published,

package/tests/message/MessageTest.res

@@ -96,7 +96,7 @@ describe("Message should", () => {
   // Schema-migration-on-read: a VersionConnected event persisted before `kind` (and
   // before later pluginStructure fields like `events`/`chapter`) existed must still
   // decode — otherwise the one stale event bricks the whole lifecycle aggregate. See
-  // docs/plans/platform-infrastructure-in-plugin-list.md (durable fix option 2).
+  // docs/plans/done/platform-infrastructure-in-plugin-list.md (durable fix option 2).
   testSync("tolerantly decode a VersionConnected persisted before kind/structure fields existed", () => {
     open PluginSpec
     let def: Reventless.Plugin.pluginDefinition = {

package/tests/plugin/HeartbeatDisconnectGraceTest.res

@@ -7,7 +7,7 @@
 // (which drives CreateDisconnectSchedule). A deployed plugin once ran with schedule
 // rate(60min) but a Heartbeat(10) command (grace ~12min), so it reconnected for
 // ~12min after each hourly beat then sat Disconnected for the rest of the hour —
-// it flapped. See docs/plans/plugin-heartbeat-disconnect-margin-hardening.md.
+// it flapped. See docs/plans/done/plugin-heartbeat-disconnect-margin-hardening.md.
 //
 // These tests pin the two guarantees that the fix provides at this layer:
 //   1. the disconnect grace scales with the interval (large cadences keep headroom);