@reventlessdev/reventless-spec 3.0.0-alpha.135 → 3.0.0-alpha.137

package/src/lifecycle/CheckLifecycleModel.res.mjs

@@ -489,6 +489,109 @@ function deriveCommands(component, observations, labelled) {
   });
 }
 
+function shownOutcomeOf(s) {
+  let match = s.thenKind;
+  switch (match) {
+    case "error" :
+    case "event" :
+      break;
+    case "noEvent" :
+      return [
+        "noEvent",
+        []
+      ];
+    default:
+      return;
+  }
+  return [
+    s.thenKind,
+    s.thenElements.map(e => e.name)
+  ];
+}
+
+function byPluginComponentCommand(xs) {
+  return xs.toSorted((a, b) => {
+    let c = Primitive_string.compare(a.plugin, b.plugin);
+    if (c !== 0) {
+      return c;
+    }
+    let c$1 = Primitive_string.compare(a.component, b.component);
+    if (c$1 !== 0) {
+      return c$1;
+    } else {
+      return Primitive_string.compare(a.command, b.command);
+    }
+  });
+}
+
+function commandOutcomes(plugin, corpora) {
+  let entries = [];
+  corpora.forEach(c => {
+    c.scenarios.forEach(s => {
+      let match = s.whenKind;
+      let match$1 = s.whenElements[0];
+      let match$2 = shownOutcomeOf(s);
+      if (match !== "command") {
+        return;
+      }
+      if (match$1 === undefined) {
+        return;
+      }
+      if (match$2 === undefined) {
+        return;
+      }
+      let names = match$2[1];
+      let kind = match$2[0];
+      let e = entries.find(e => {
+        if (e.component === c.component) {
+          return e.command === match$1.name;
+        } else {
+          return false;
+        }
+      });
+      let entry;
+      if (e !== undefined) {
+        entry = e;
+      } else {
+        let e_component = c.component;
+        let e_command = match$1.name;
+        let e_outcomes = [];
+        let e$1 = {
+          plugin: plugin,
+          component: e_component,
+          command: e_command,
+          outcomes: e_outcomes
+        };
+        entries.push(e$1);
+        entry = e$1;
+      }
+      let o = entry.outcomes.find(o => {
+        if (o.kind === kind) {
+          return Primitive_object.equal(o.names, names);
+        } else {
+          return false;
+        }
+      });
+      if (o !== undefined) {
+        if (!o.scenarios.includes(s.title)) {
+          o.scenarios.push(s.title);
+          return;
+        } else {
+          return;
+        }
+      } else {
+        entry.outcomes.push({
+          kind: kind,
+          names: names,
+          scenarios: [s.title]
+        });
+        return;
+      }
+    });
+  });
+  return byPluginComponentCommand(entries);
+}
+
 function allUnverified(cmd, add, why) {
   let states = cmd.allowedStates;
   if (states !== undefined && states.length !== 0) {
@@ -659,7 +762,7 @@ function isWritablePath(path) {
   }
 }
 
-async function runPlugin(plugin, pluginDir, findings, opaque) {
+async function runPlugin(plugin, pluginDir, findings, opaque, outcomes) {
   let msg = await readDeclared(pluginDir);
   if (msg.TAG !== "Ok") {
     return {
@@ -669,6 +772,7 @@ async function runPlugin(plugin, pluginDir, findings, opaque) {
   }
   let declared = msg._0;
   let corpora = Stdlib_Array.filterMap(filesUnder(Nodepath.join(pluginDir, "tests"), ".gwt.json"), readCorpus);
+  outcomes.push(...commandOutcomes(plugin, corpora));
   corpora.forEach(c => {
     let unreadable = c.scenarios.filter(s => s.whenElements.length === 0);
     if (unreadable.length !== 0) {
@@ -805,7 +909,7 @@ function goldenPath(root) {
   return Nodepath.join(root.dir, "schema", "lifecycle-model.json");
 }
 
-function reportJson(findings, opaque, derived, failures) {
+function reportJson(findings, opaque, derived, outcomes, failures) {
   let findingJson = f => Object.fromEntries([
     [
       "verdict",
@@ -891,6 +995,38 @@ function reportJson(findings, opaque, derived, failures) {
       o.unreadable
     ]
   ]);
+  let shownOutcomeJson = o => Object.fromEntries([
+    [
+      "kind",
+      o.kind
+    ],
+    [
+      "names",
+      o.names.map(prim => prim)
+    ],
+    [
+      "scenarios",
+      o.scenarios.map(prim => prim)
+    ]
+  ]);
+  let commandOutcomesJson = e => Object.fromEntries([
+    [
+      "plugin",
+      e.plugin
+    ],
+    [
+      "component",
+      e.component
+    ],
+    [
+      "command",
+      e.command
+    ],
+    [
+      "outcomes",
+      e.outcomes.map(shownOutcomeJson)
+    ]
+  ]);
   return JSON.stringify(Object.fromEntries([
     [
       "version",
@@ -904,6 +1040,10 @@ function reportJson(findings, opaque, derived, failures) {
       "commands",
       derived.map(commandJson)
     ],
+    [
+      "outcomes",
+      byPluginComponentCommand(outcomes).map(commandOutcomesJson)
+    ],
     [
       "opaque",
       opaque.map(opaqueJson)
@@ -995,6 +1135,7 @@ function writeOrCompare(path, actual, label, drifted) {
 async function main() {
   let findings = [];
   let opaque = [];
+  let outcomes = [];
   let failures = [];
   let drifted = [];
   let allDerived = [];
@@ -1024,7 +1165,7 @@ async function main() {
         if (pluginDir !== undefined) {
           let plugin = Nodepath.basename(pluginDir);
           let qualified = example + `/` + plugin;
-          let commands = await runPlugin(qualified, pluginDir, findings, opaque);
+          let commands = await runPlugin(qualified, pluginDir, findings, opaque, outcomes);
           if (commands.TAG === "Ok") {
             let commands$1 = commands._0;
             commands$1.forEach(c => {
@@ -1057,7 +1198,7 @@ async function main() {
   let of_ = severity => findings.filter(f => f.severity === severity);
   let contradicted = of_("contradicted");
   if (json) {
-    console.log(reportJson(findings, opaque, allDerived, failures));
+    console.log(reportJson(findings, opaque, allDerived, outcomes, failures));
   } else {
     [
       "contradicted",
@@ -1131,6 +1272,9 @@ export {
   sameRow,
   observe,
   deriveCommands,
+  shownOutcomeOf,
+  byPluginComponentCommand,
+  commandOutcomes,
   allUnverified,
   compare,
   pluginDirsIn,

package/src/semantic/Semantic.res

@@ -113,6 +113,50 @@ module Id = {
   let geolocation = "geolocation"
 }
 
+/** One transparent-string semantic: a `semantic/` module whose `type t` is a
+    bare `string`. */
+type brandedString = {
+  moduleName: string,
+  /** The `Id` values of this module carry. Not derivable from the module name —
+      `CalendarDate` carries `date`. */
+  id: string,
+  /** Whether the module exposes the `let schema` that sury-ppx resolves `X.t`
+      to by convention. The `false`s build theirs from a function taking
+      arguments (`forStore` / `forField` / `forCollection`), so such a field
+      always carries an explicit `@s.matches` and there is no name a pass could
+      derive. Offering one as a plain type pick emits code that does not
+      compile. */
+  hasDerivableSchema: bool,
+}
+
+/** Every transparent-string semantic, so a consumer can ask what they are
+    instead of transcribing the set.
+
+    A check written against the literal `string` keyword sees only the brand and
+    refuses the field, which would make declaring a semantic cost the field
+    whatever that check gates — so a pass that must leave these alone needs the
+    set, not a guess. It cannot be guessed from the names: `Money.t` is a record,
+    `Duration.t` an int, `Percent.t` and `Bytes.t` floats, and all four are
+    deliberately absent.
+
+    Both facts here are computable from the sources, and `SemanticBrandedStringsTest`
+    recomputes them rather than trusting this list — so adding a module without
+    adding it here fails, and so does the ppx's copy drifting from either. */
+let brandedStrings: array<brandedString> = [
+  {moduleName: "DateTime", id: Id.dateTime, hasDerivableSchema: true},
+  {moduleName: "CalendarDate", id: Id.date, hasDerivableSchema: true},
+  {moduleName: "Email", id: Id.email, hasDerivableSchema: true},
+  {moduleName: "Phone", id: Id.phone, hasDerivableSchema: true},
+  {moduleName: "Url", id: Id.url, hasDerivableSchema: true},
+  {moduleName: "Color", id: Id.color, hasDerivableSchema: true},
+  {moduleName: "FileRef", id: Id.fileRef, hasDerivableSchema: true},
+  {moduleName: "ImageRef", id: Id.imageRef, hasDerivableSchema: true},
+  {moduleName: "MemberRef", id: Id.memberRef, hasDerivableSchema: false},
+  {moduleName: "StorageRef", id: Id.storageRef, hasDerivableSchema: false},
+  {moduleName: "UploadableFile", id: Id.uploadableFile, hasDerivableSchema: false},
+  {moduleName: "UploadableImage", id: Id.uploadableImage, hasDerivableSchema: false},
+]
+
 let semanticId: S.Metadata.Id.t<t> = S.Metadata.Id.make(~namespace="reventless", ~name="semantic")
 
 /** Mark a schema as carrying a semantic. */

package/src/semantic/Semantic.res.mjs

@@ -4,25 +4,49 @@ 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";
 
+let dateTime = "dateTime";
+
+let date = "date";
+
+let storageRef = "storageRef";
+
+let uploadableImage = "uploadableImage";
+
+let uploadableFile = "uploadableFile";
+
+let imageRef = "imageRef";
+
+let fileRef = "fileRef";
+
+let memberRef = "memberRef";
+
+let email = "email";
+
+let phone = "phone";
+
+let url = "url";
+
+let color = "color";
+
 let Id = {
-  dateTime: "dateTime",
-  date: "date",
+  dateTime: dateTime,
+  date: date,
   reference: "reference",
-  storageRef: "storageRef",
+  storageRef: storageRef,
   offload: "offload",
-  uploadableImage: "uploadableImage",
-  uploadableFile: "uploadableFile",
-  imageRef: "imageRef",
-  fileRef: "fileRef",
+  uploadableImage: uploadableImage,
+  uploadableFile: uploadableFile,
+  imageRef: imageRef,
+  fileRef: fileRef,
   captionedImage: "captionedImage",
-  memberRef: "memberRef",
-  email: "email",
-  phone: "phone",
-  url: "url",
+  memberRef: memberRef,
+  email: email,
+  phone: phone,
+  url: url,
   percent: "percent",
   bytes: "bytes",
   duration: "duration",
-  color: "color",
+  color: color,
   money: "money",
   dateRange: "dateRange",
   geoPoint: "geoPoint",
@@ -30,6 +54,69 @@ let Id = {
   geolocation: "geolocation"
 };
 
+let brandedStrings = [
+  {
+    moduleName: "DateTime",
+    id: dateTime,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "CalendarDate",
+    id: date,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "Email",
+    id: email,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "Phone",
+    id: phone,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "Url",
+    id: url,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "Color",
+    id: color,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "FileRef",
+    id: fileRef,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "ImageRef",
+    id: imageRef,
+    hasDerivableSchema: true
+  },
+  {
+    moduleName: "MemberRef",
+    id: memberRef,
+    hasDerivableSchema: false
+  },
+  {
+    moduleName: "StorageRef",
+    id: storageRef,
+    hasDerivableSchema: false
+  },
+  {
+    moduleName: "UploadableFile",
+    id: uploadableFile,
+    hasDerivableSchema: false
+  },
+  {
+    moduleName: "UploadableImage",
+    id: uploadableImage,
+    hasDerivableSchema: false
+  }
+];
+
 let semanticId = Sury.$Metadata_Id_make("reventless", "semantic");
 
 function mark(schema, id, payloadOpt) {
@@ -129,6 +216,7 @@ function has(fieldSchema, id) {
 
 export {
   Id,
+  brandedStrings,
   semanticId,
   mark,
   refined,

package/src/types/AccountsManifest.res

@@ -27,6 +27,11 @@ provisioned" on both platforms.
 `userId` is what the platform stamps on rows this account writes. Locally it
 defaults to the username; on AWS it is the `sub` the pool minted, so it can only
 be filled in after the account exists.
+
+`demoOwner` names the person this account plays in a demo's data, for a seed to
+find it by. It exists because the name a pool accepts is not always the demo's:
+a pool that signs in on an email address takes `shopper@example.com`, not
+`shopper`.
 */
 @schema
 type entry = {
@@ -34,6 +39,7 @@ type entry = {
   password: string,
   groups: array<string>,
   userId?: string,
+  demoOwner?: string,
 }
 
 let entriesSchema = S.array(entrySchema)

package/src/types/AccountsManifest.res.mjs

@@ -15,7 +15,8 @@ let entrySchema = Sury.$schema(s => ({
   username: s.m(Sury.string),
   password: s.m(Sury.string),
   groups: s.m(Sury.array(Sury.string)),
-  userId: s.m(Sury.$option(Sury.string))
+  userId: s.m(Sury.$option(Sury.string)),
+  demoOwner: s.m(Sury.$option(Sury.string))
 }));
 
 let entriesSchema = Sury.array(entrySchema);