@reventlessdev/reventless-spec 3.0.0-alpha.130 → 3.0.0-alpha.132

package/src/semantic/Semantic.res.mjs

@@ -6,6 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 let Id = {
   dateTime: "dateTime",
+  date: "date",
   reference: "reference",
   storageRef: "storageRef",
   offload: "offload",
@@ -25,6 +26,7 @@ let Id = {
   money: "money",
   dateRange: "dateRange",
   geoPoint: "geoPoint",
+  lifecycleTrail: "lifecycleTrail",
   geolocation: "geolocation"
 };
 

package/src/types/Lifecycle.res

@@ -0,0 +1,106 @@
+/**
+Where a record's lifecycle lives, and the trail of states it has been through.
+
+`fieldName` is the single rule for which field holds a lifecycle — every
+consumer resolves it here rather than restating it. `Trail` is the one field a
+view declares to have each state it reaches recorded with the instant it was
+reached; the projection machinery fills it, not the domain.
+*/
+
+// A wire enum: a union whose non-null members are all string constants. A
+// tagged union's members are objects, so the same test excludes it.
+let isEnumSchema = (schema: S.t<unknown>): bool =>
+  switch schema {
+  | AnyOf({anyOf}) =>
+    let members = anyOf->Array.filter(v =>
+      switch v {
+      | Null(_) | Undefined(_) => false
+      | _ => true
+      }
+    )
+    members->Array.length > 0 &&
+      members->Array.every(v =>
+        switch v {
+        | String({const: ?Some(_)}) => true
+        | _ => false
+        }
+      )
+  | _ => false
+  }
+
+// A semantic or a DCB tag makes the field an instant, an id or a reference
+// before it is ever an enum — the order `SchemaType.fromSury` resolves in.
+let isLifecycleShape = (schema: S.t<unknown>): bool =>
+  Semantic.get(schema)->Option.isNone && !DcbTag.isTagged(schema) && isEnumSchema(schema)
+
+/**
+The field holding a record's lifecycle: `@lifecycle`, else an enum field
+literally named `lifecycle`. Not keyed on `status`, a name that would guess.
+*/
+let fieldName = (stateSchema: S.t<unknown>): option<string> =>
+  switch StateAnnotations.getSpec(stateSchema) {
+  | Some({lifecycle: Some(_) as annotated}) => annotated
+  | _ =>
+    switch stateSchema {
+    | Object({properties}) =>
+      properties
+      ->Dict.get("lifecycle")
+      ->Option.flatMap(schema => isLifecycleShape(schema) ? Some("lifecycle") : None)
+    | _ => None
+    }
+  }
+
+/**
+The ordered record of the states a row has been through.
+
+Ordered rather than keyed by state because a lifecycle revisits states — a
+reopened order is `Placed` twice, and a map has to choose which visit to keep.
+A state the row never reached has no entry; there is no value to invent for it.
+*/
+module Trail = {
+  /** One state the row entered, and the instant it did. */
+  @schema
+  type entry<'state> = {
+    state: 'state,
+    at: DateTime.t,
+    /** First entry after a span the cap dropped. Absent while trails are kept
+        whole; declared now so capping later is not a contract change. */
+    afterGap?: bool,
+  }
+
+  type t<'state> = array<entry<'state>>
+
+  /** The schema for a trail field. Resolved by sury-ppx from the declared type
+      `Reventless.Lifecycle.Trail.t<lifecycle>`, so a view writes no annotation.
+
+      Marked with the shared semantic rather than a metadata id of its own: that
+      marker is the one the JSON Schema walk emits, so a private id would leave
+      the trail indistinguishable on the wire from any other array of objects —
+      and a consumer reduced to matching a field called `trail` by name. */
+  let schema = (stateSchema: S.t<'state>): S.t<t<'state>> =>
+    S.array(entrySchema(stateSchema))->Semantic.mark(~id=Semantic.Id.lifecycleTrail)
+
+  let isTrail = (schema: S.t<unknown>): bool =>
+    Semantic.has(schema, ~id=Semantic.Id.lifecycleTrail)
+
+  /** The trail field declared on a state record, if it declares one. */
+  let fieldName = (stateSchema: S.t<unknown>): option<string> =>
+    switch stateSchema {
+    | Object({properties}) =>
+      properties
+      ->Dict.toArray
+      ->Array.find(((_, schema)) => isTrail(schema))
+      ->Option.map(((name, _)) => name)
+    | _ => None
+    }
+
+  /** Append `{state, at}` to the trail a state's JSON holds at `field`. */
+  let record = (stateDict: dict<JSON.t>, ~field: string, ~state: JSON.t, ~at: string): unit => {
+    let entries = switch stateDict->Dict.get(field) {
+    | Some(Array(existing)) => existing
+    | _ => []
+    }
+    let entry = Dict.fromArray([("state", state), ("at", JSON.Encode.string(at))])
+    stateDict->Dict.set(field, entries->Array.concat([entry->JSON.Encode.object])->JSON.Encode.array)
+  }
+}

package/src/types/Lifecycle.res.mjs

@@ -0,0 +1,115 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DcbTag$Reventless from "../components/DcbTag.res.mjs";
+import * as DateTime$Reventless from "../semantic/DateTime.res.mjs";
+import * as Semantic$Reventless from "../semantic/Semantic.res.mjs";
+import * as StateAnnotations$Reventless from "../components/StateAnnotations.res.mjs";
+
+function isEnumSchema(schema) {
+  if (schema.type !== "anyOf") {
+    return false;
+  }
+  let members = schema.anyOf.filter(v => {
+    switch (v.type) {
+      case "null" :
+      case "undefined" :
+        return false;
+      default:
+        return true;
+    }
+  });
+  if (members.length !== 0) {
+    return members.every(v => {
+      if (v.type === "string") {
+        return v.const !== undefined;
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
+function isLifecycleShape(schema) {
+  if (Stdlib_Option.isNone(Semantic$Reventless.get(schema)) && !DcbTag$Reventless.isTagged(schema)) {
+    return isEnumSchema(schema);
+  } else {
+    return false;
+  }
+}
+
+function fieldName(stateSchema) {
+  let match = StateAnnotations$Reventless.getSpec(stateSchema);
+  if (match !== undefined) {
+    let annotated = match.lifecycle;
+    if (annotated !== undefined) {
+      return annotated;
+    }
+  }
+  if (stateSchema.type === "object") {
+    return Stdlib_Option.flatMap(stateSchema.properties["lifecycle"], schema => {
+      if (isLifecycleShape(schema)) {
+        return "lifecycle";
+      }
+    });
+  }
+}
+
+function entrySchema(_stateSchema) {
+  return Sury.$schema(s => ({
+    state: s.m(_stateSchema),
+    at: s.m(DateTime$Reventless.schema),
+    afterGap: s.m(Sury.$option(Sury.bool))
+  }));
+}
+
+function schema(stateSchema) {
+  return Semantic$Reventless.mark(Sury.array(entrySchema(stateSchema)), Semantic$Reventless.Id.lifecycleTrail, undefined);
+}
+
+function isTrail(schema) {
+  return Semantic$Reventless.has(schema, Semantic$Reventless.Id.lifecycleTrail);
+}
+
+function fieldName$1(stateSchema) {
+  if (stateSchema.type === "object") {
+    return Stdlib_Option.map(Object.entries(stateSchema.properties).find(param => Semantic$Reventless.has(param[1], Semantic$Reventless.Id.lifecycleTrail)), param => param[0]);
+  }
+}
+
+function record(stateDict, field, state, at) {
+  let match = stateDict[field];
+  let entries = match !== undefined ? (
+      Array.isArray(match) ? match : []
+    ) : [];
+  let entry = Object.fromEntries([
+    [
+      "state",
+      state
+    ],
+    [
+      "at",
+      at
+    ]
+  ]);
+  stateDict[field] = entries.concat([entry]);
+}
+
+let Trail = {
+  entrySchema: entrySchema,
+  schema: schema,
+  isTrail: isTrail,
+  fieldName: fieldName$1,
+  record: record
+};
+
+export {
+  isEnumSchema,
+  isLifecycleShape,
+  fieldName,
+  Trail,
+}
+/* sury Not a pure module */

package/src/types/DateTime.res

@@ -1,29 +0,0 @@
-/**
-Marks a `string` state field as an ISO-8601 date-time.
-
-Sury has no string-typed datetime format (`S.datetime` transforms to `Js.Date.t`,
-changing the field's runtime type), so this mirrors the `DcbTag.string`
-precedent: a `S.t<string>` carrying sury metadata that downstream schema walkers
-detect. `SchemaType`/`SuryToJsonSchema` surface it as `format: "date-time"` on
-the field's JSON Schema, which the AutoUI date heuristics key off (CalendarView,
-TimelineView, date-axis charts).
-
-Use on a producer/storage timestamp a projection writes into its state — most
-commonly a `meta.time`-derived field such as `placedAt` / `shippedAt`:
-
-@example
-```rescript
-@schema
-type state = {
-  orderId: string,
-  placedAt: @s.matches(Reventless.DateTime.string) string,
-}
-```
-*/
-
-/** A sury string schema annotated as an ISO-8601 date-time field.
-    Use with `@s.matches(Reventless.DateTime.string)`. */
-let string: S.t<string> = S.string->Semantic.mark(~id=Semantic.Id.dateTime)
-
-/** Whether a field schema carries the date-time marker. */
-let isDateTime = (fieldSchema: S.t<unknown>) => fieldSchema->Semantic.has(~id=Semantic.Id.dateTime)

package/src/types/DateTime.res.mjs

@@ -1,16 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Sury from "sury";
-import * as Semantic$Reventless from "../semantic/Semantic.res.mjs";
-
-let string = Semantic$Reventless.mark(Sury.string, Semantic$Reventless.Id.dateTime, undefined);
-
-function isDateTime(fieldSchema) {
-  return Semantic$Reventless.has(fieldSchema, Semantic$Reventless.Id.dateTime);
-}
-
-export {
-  string,
-  isDateTime,
-}
-/* string Not a pure module */