@reventlessdev/reventless-spec 3.0.0-alpha.61

package/src/components/Counter.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/DcbDecode.res

@@ -0,0 +1,128 @@
+// Decodes raw stored events against a consumed event schema.
+// Supports the full spectrum of consumed events:
+//   - Payload-less variants (match by TAG only, bypass sury)
+//   - Partial projections (sury parse with field subset)
+//   - Full shape (sury parse as-is)
+
+// Build a lookup of TAG name -> variant kind (payloadLess or withFields)
+// from a consumed event schema. Cached per schema for performance.
+
+type variantKind =
+  | PayloadLess
+  | WithFields
+
+let buildVariantLookup = (schema: S.t<unknown>): dict<variantKind> => {
+  let lookup = Dict.make()
+  switch schema {
+  | Union({anyOf}) =>
+    anyOf->Array.forEach(variantSchema =>
+      switch variantSchema {
+      | Object({items, properties}) =>
+        let tagName =
+          items
+          ->Array.find(item => item.location == "TAG")
+          ->Option.flatMap(item =>
+            switch item.schema {
+            | String({const}) => Some(const)
+            | _ => None
+            }
+          )
+        switch tagName {
+        | Some(name) =>
+          let kind = if properties->Dict.keysToArray->Array.length == 0 {
+            PayloadLess
+          } else {
+            WithFields
+          }
+          lookup->Dict.set(name, kind)
+        | None => ()
+        }
+      | String({const: ?Some(name)}) =>
+        // sury represents payload-less variants in some cases as bare String({const})
+        lookup->Dict.set(name, PayloadLess)
+      | _ => ()
+      }
+    )
+  | Object({items}) =>
+    // Single-variant schema with fields
+    let tagName =
+      items
+      ->Array.find(item => item.location == "TAG")
+      ->Option.flatMap(item =>
+        switch item.schema {
+        | String({const}) => Some(const)
+        | _ => None
+        }
+      )
+    switch tagName {
+    | Some(name) => lookup->Dict.set(name, WithFields)
+    | None => ()
+    }
+  | String({const: ?Some(name)}) =>
+    // Single payload-less variant — sury compiles `type t = Foo` to String({const: "Foo"})
+    lookup->Dict.set(name, PayloadLess)
+  | _ => ()
+  }
+  lookup
+}
+
+type decoder<'event> = {
+  lookup: dict<variantKind>,
+  schema: S.t<'event>,
+  constructors: dict<'event>,
+}
+
+external unsafeCast: 'a => 'b = "%identity"
+
+// Build a map of TAG name -> constructed payload-less variant value
+// by encoding each payload-less variant through sury and storing the result.
+// This is done once per schema, not per event.
+let buildPayloadLessConstructors = (schema: S.t<'event>, lookup: dict<variantKind>): dict<'event> => {
+  let constructors = Dict.make()
+  // For payload-less variants, we need to figure out what ReScript value
+  // corresponds to each TAG name. sury's schema for a union with payload-less
+  // variants encodes them as bare strings. So `| ItemCreated` serializes to
+  // JSON string "ItemCreated". We can use S.parseJsonOrThrow with the string.
+  lookup->Dict.toArray->Array.forEach(((tagName, kind)) =>
+    switch kind {
+    | PayloadLess =>
+      try {
+        let value = JSON.String(tagName)->S.parseJsonOrThrow(schema)
+        constructors->Dict.set(tagName, value)
+      } catch {
+      | _ => ()
+      }
+    | WithFields => ()
+    }
+  )
+  constructors
+}
+
+type makeDecoderResult<'event> = {
+  decode: (~eventType: string, ~data: dict<JSON.t>) => option<'event>,
+  eventTypes: array<string>,
+}
+
+let makeDecoder = (schema: S.t<'event>): makeDecoderResult<'event> => {
+  let unknownSchema: S.t<unknown> = unsafeCast(schema)
+  let lookup = buildVariantLookup(unknownSchema)
+  let constructors = buildPayloadLessConstructors(schema, lookup)
+  let eventTypes = lookup->Dict.keysToArray
+
+  let decode = (~eventType: string, ~data: dict<JSON.t>): option<'event> =>
+    switch lookup->Dict.get(eventType) {
+    | None => None
+    | Some(PayloadLess) => constructors->Dict.get(eventType)
+    | Some(WithFields) =>
+      // Reconstruct the JSON with TAG for sury parsing
+      let jsonDict = data->Dict.copy
+      jsonDict->Dict.set("TAG", JSON.String(eventType))
+      try {
+        Some(JSON.Object(jsonDict)->S.parseJsonOrThrow(schema))
+      } catch {
+      | _ => None
+      }
+    }
+
+  {decode, eventTypes}
+}

package/src/components/DcbDecode.res.mjs

@@ -0,0 +1,117 @@
+// 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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function buildVariantLookup(schema) {
+  let lookup = {};
+  switch (schema.type) {
+    case "string" :
+      let name = schema.const;
+      if (name !== undefined) {
+        lookup[name] = "PayloadLess";
+      }
+      break;
+    case "object" :
+      let tagName = Stdlib_Option.flatMap(schema.items.find(item => item.location === "TAG"), item => {
+        let match = item.schema;
+        if (match.type !== "string") {
+          return;
+        }
+        let $$const = match.const;
+        if ($$const !== undefined) {
+          return $$const;
+        }
+      });
+      if (tagName !== undefined) {
+        lookup[tagName] = "WithFields";
+      }
+      break;
+    case "union" :
+      schema.anyOf.forEach(variantSchema => {
+        switch (variantSchema.type) {
+          case "string" :
+            let name = variantSchema.const;
+            if (name !== undefined) {
+              lookup[name] = "PayloadLess";
+              return;
+            } else {
+              return;
+            }
+          case "object" :
+            let tagName = Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+              let match = item.schema;
+              if (match.type !== "string") {
+                return;
+              }
+              let $$const = match.const;
+              if ($$const !== undefined) {
+                return $$const;
+              }
+            });
+            if (tagName === undefined) {
+              return;
+            }
+            let kind = Object.keys(variantSchema.properties).length === 0 ? "PayloadLess" : "WithFields";
+            lookup[tagName] = kind;
+            return;
+          default:
+            return;
+        }
+      });
+      break;
+  }
+  return lookup;
+}
+
+function buildPayloadLessConstructors(schema, lookup) {
+  let constructors = {};
+  Object.entries(lookup).forEach(param => {
+    let tagName = param[0];
+    if (param[1] !== "PayloadLess") {
+      return;
+    }
+    try {
+      let value = S.parseJsonOrThrow(tagName, schema);
+      constructors[tagName] = value;
+      return;
+    } catch (exn) {
+      return;
+    }
+  });
+  return constructors;
+}
+
+function makeDecoder(schema) {
+  let lookup = buildVariantLookup(schema);
+  let constructors = buildPayloadLessConstructors(schema, lookup);
+  let eventTypes = Object.keys(lookup);
+  let decode = (eventType, data) => {
+    let match = lookup[eventType];
+    if (match === undefined) {
+      return;
+    }
+    if (match === "PayloadLess") {
+      return constructors[eventType];
+    }
+    let jsonDict = Object.assign({}, data);
+    jsonDict["TAG"] = eventType;
+    try {
+      return Primitive_option.some(S.parseJsonOrThrow(jsonDict, schema));
+    } catch (exn) {
+      return;
+    }
+  };
+  return {
+    decode: decode,
+    eventTypes: eventTypes
+  };
+}
+
+export {
+  buildVariantLookup,
+  buildPayloadLessConstructors,
+  makeDecoder,
+}
+/* S Not a pure module */