@reventlessdev/reventless-spec 3.0.0-alpha.62 → 3.0.0-alpha.64

package/src/components/DcbTag.res.mjs

@@ -130,6 +130,19 @@ function extractTagsFromProperties(properties, jsonDict) {
   });
 }
 
+function variantTagName(items) {
+  return Stdlib_Option.flatMap(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;
+    }
+  });
+}
+
 function extractTagsFromJson(schema, json) {
   switch (schema.type) {
     case "object" :
@@ -152,22 +165,12 @@ function extractTagsFromJson(schema, json) {
       return Stdlib_Array.reduce(schema.anyOf, [], (acc, variantSchema) => {
         if (acc.length !== 0) {
           return acc;
-        }
-        if (variantSchema.type !== "object") {
-          return [];
-        }
-        let variantTag = 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;
+        } else if (variantSchema.type === "object") {
+          if (Primitive_object.equal(variantTagName(variantSchema.items), jsonTag)) {
+            return extractTagsFromProperties(variantSchema.properties, jsonDict$1);
+          } else {
+            return [];
           }
-        });
-        if (Primitive_object.equal(variantTag, jsonTag)) {
-          return extractTagsFromProperties(variantSchema.properties, jsonDict$1);
         } else {
           return [];
         }
@@ -185,29 +188,11 @@ function extractTags(schema, value) {
 function extractVariantNames(schema) {
   switch (schema.type) {
     case "object" :
-      return Stdlib_Option.getOr(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];
-        }
-      }), []);
+      return Stdlib_Option.mapOr(variantTagName(schema.items), [], t => [t]);
     case "union" :
       return Stdlib_Array.filterMap(schema.anyOf, variantSchema => {
         if (variantSchema.type === "object") {
-          return 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;
-            }
-          });
+          return variantTagName(variantSchema.items);
         }
       });
     default:
@@ -225,16 +210,7 @@ function extractAllVariantNames(schema) {
         return [];
       }
     case "object" :
-      return Stdlib_Option.getOr(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];
-        }
-      }), []);
+      return Stdlib_Option.mapOr(variantTagName(schema.items), [], t => [t]);
     case "union" :
       return Stdlib_Array.filterMap(schema.anyOf, variantSchema => {
         switch (variantSchema.type) {
@@ -246,16 +222,7 @@ function extractAllVariantNames(schema) {
               return;
             }
           case "object" :
-            return 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;
-              }
-            });
+            return variantTagName(variantSchema.items);
           default:
             return;
         }
@@ -272,29 +239,11 @@ function isVariantPayloadBearing(schema, name) {
   }
   switch (schema.type) {
     case "object" :
-      return Stdlib_Option.getOr(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 === name;
-        }
-      }), false);
+      return Stdlib_Option.mapOr(variantTagName(schema.items), false, t => t === name);
     case "union" :
       return schema.anyOf.some(variantSchema => {
         if (variantSchema.type === "object") {
-          return Stdlib_Option.getOr(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 === name;
-            }
-          }), false);
+          return Stdlib_Option.mapOr(variantTagName(variantSchema.items), false, t => t === name);
         } else {
           return false;
         }
@@ -359,22 +308,12 @@ function extractTagsFromJsonExpanded(schema, json) {
       return Stdlib_Array.reduce(schema.anyOf, [], (acc, variantSchema) => {
         if (acc.length !== 0) {
           return acc;
-        }
-        if (variantSchema.type !== "object") {
-          return [];
-        }
-        let variantTag = 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;
+        } else if (variantSchema.type === "object") {
+          if (Primitive_object.equal(variantTagName(variantSchema.items), jsonTag)) {
+            return extractTagsFromPropertiesExpanded(variantSchema.properties, jsonDict$1);
+          } else {
+            return [];
           }
-        });
-        if (Primitive_object.equal(variantTag, jsonTag)) {
-          return extractTagsFromPropertiesExpanded(variantSchema.properties, jsonDict$1);
         } else {
           return [];
         }
@@ -427,16 +366,7 @@ function extractTagKeysByEventType(schema) {
       return;
     }
     let properties = variantSchema.properties;
-    Stdlib_Option.forEach(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;
-      }
-    }), eventType => {
+    Stdlib_Option.forEach(variantTagName(variantSchema.items), eventType => {
       result[eventType] = tagKeysOfProperties(properties);
     });
   };
@@ -608,16 +538,7 @@ function eventShapesOfSchema(schema) {
         }
       case "object" :
         let properties = variantSchema.properties;
-        return Stdlib_Option.map(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;
-          }
-        }), eventType => ({
+        return Stdlib_Option.map(variantTagName(variantSchema.items), eventType => ({
           eventType: eventType,
           idFields: idFieldsOfProperties(properties)
         }));
@@ -702,16 +623,7 @@ function findMultiTagVariantNames(schema) {
     }
     let tagCount = Object.entries(variantSchema.properties).filter(param => isTagged(param[1])).length;
     if (tagCount > 1) {
-      return Stdlib_Option.getOr(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;
-        }
-      }), "(unknown)");
+      return Stdlib_Option.getOr(variantTagName(variantSchema.items), "(unknown)");
     }
   };
   if (schema.type === "union") {
@@ -909,6 +821,7 @@ export {
   resolveArrayTagKey,
   jsonValueToString,
   extractTagsFromProperties,
+  variantTagName,
   extractTagsFromJson,
   extractTags,
   extractVariantNames,

package/src/components/DcbValidation.res

@@ -13,16 +13,7 @@ type variantInfo = {
 let extractVariantInfo = (variantSchema: S.t<unknown>): option<variantInfo> =>
   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
-        }
-      )
-    tagName->Option.map(tagName => {
+    DcbTag.variantTagName(items)->Option.map(tagName => {
       let taggedFields =
         properties
         ->Dict.toArray
@@ -56,7 +47,10 @@ let extractAllVariants = (schema: S.t<unknown>): array<variantInfo> =>
 // Check if a variant has no payload fields (only TAG)
 let isPayloadLess = (info: variantInfo): bool => info.fields->Dict.toArray->Array.length == 0
 
-// Compare two sury schema types for structural compatibility
+// Compare two sury schema types for structural compatibility. Objects and
+// unions recurse: previously any (Object, Object) / (Union, Union) pair was
+// declared compatible, so nested payload drift (a renamed/retyped nested field,
+// a changed variant) passed validation undetected.
 let rec schemasAreCompatible = (a: S.t<unknown>, b: S.t<unknown>): bool =>
   switch (a, b) {
   | (String(_), String(_)) => true
@@ -65,10 +59,35 @@ let rec schemasAreCompatible = (a: S.t<unknown>, b: S.t<unknown>): bool =>
   | (BigInt(_), BigInt(_)) => true
   | (Array({additionalItems: Schema(aItem)}), Array({additionalItems: Schema(bItem)})) =>
     schemasAreCompatible(aItem, bItem)
-  | (Union(_), Union(_)) => true
-  | (Object(_), Object(_)) => true
+  | (Object({properties: aProps}), Object({properties: bProps})) => propsCompatible(aProps, bProps)
+  | (Union(_), Union(_)) =>
+    // Same set of variant tags, and each shared variant's payload compatible.
+    let av = extractAllVariants(a)
+    let bv = extractAllVariants(b)
+    let at = av->Array.map(v => v.tagName)->Array.toSorted(String.compare)
+    let bt = bv->Array.map(v => v.tagName)->Array.toSorted(String.compare)
+    at == bt &&
+    at->Array.every(tag =>
+      switch (av->Array.find(v => v.tagName == tag), bv->Array.find(v => v.tagName == tag)) {
+      | (Some(x), Some(y)) => propsCompatible(x.fields, y.fields)
+      | _ => false
+      }
+    )
   | _ => false
   }
+// Two property maps are compatible when they carry the same field names and each
+// field's schema is compatible.
+and propsCompatible = (aProps: dict<S.t<unknown>>, bProps: dict<S.t<unknown>>): bool => {
+  let aKeys = aProps->Dict.keysToArray->Array.toSorted(String.compare)
+  let bKeys = bProps->Dict.keysToArray->Array.toSorted(String.compare)
+  aKeys == bKeys &&
+  aKeys->Array.every(k =>
+    switch (aProps->Dict.get(k), bProps->Dict.get(k)) {
+    | (Some(av), Some(bv)) => schemasAreCompatible(av, bv)
+    | _ => false
+    }
+  )
+}
 
 // Get a human-readable type name for a schema
 let schemaTypeName = (schema: S.t<unknown>): string =>

package/src/components/DcbValidation.res.mjs

@@ -11,17 +11,7 @@ function extractVariantInfo(variantSchema) {
     return;
   }
   let properties = variantSchema.properties;
-  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;
-    }
-  });
-  return Stdlib_Option.map(tagName, tagName => {
+  return Stdlib_Option.map(DcbTag$Reventless.variantTagName(variantSchema.items), tagName => {
     let taggedFields = Stdlib_Array.filterMap(Object.entries(properties), param => {
       if (DcbTag$Reventless.isTagged(param[1])) {
         return param[0];
@@ -95,15 +85,56 @@ function schemasAreCompatible(_a, _b) {
         _a = aItem;
         continue;
       case "object" :
-        return b.type === "object";
+        if (b.type === "object") {
+          return propsCompatible(a.properties, b.properties);
+        } else {
+          return false;
+        }
       case "union" :
-        return b.type === "union";
+        if (b.type !== "union") {
+          return false;
+        }
+        let av = extractAllVariants(a);
+        let bv = extractAllVariants(b);
+        let at = av.map(v => v.tagName).toSorted(Primitive_string.compare);
+        let bt = bv.map(v => v.tagName).toSorted(Primitive_string.compare);
+        if (Primitive_object.equal(at, bt)) {
+          return at.every(tag => {
+            let match = av.find(v => v.tagName === tag);
+            let match$1 = bv.find(v => v.tagName === tag);
+            if (match !== undefined && match$1 !== undefined) {
+              return propsCompatible(match.fields, match$1.fields);
+            } else {
+              return false;
+            }
+          });
+        } else {
+          return false;
+        }
       default:
         return false;
     }
   };
 }
 
+function propsCompatible(aProps, bProps) {
+  let aKeys = Object.keys(aProps).toSorted(Primitive_string.compare);
+  let bKeys = Object.keys(bProps).toSorted(Primitive_string.compare);
+  if (Primitive_object.equal(aKeys, bKeys)) {
+    return aKeys.every(k => {
+      let match = aProps[k];
+      let match$1 = bProps[k];
+      if (match !== undefined && match$1 !== undefined) {
+        return schemasAreCompatible(match, match$1);
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
 function schemaTypeName(schema) {
   switch (schema.type) {
     case "never" :
@@ -381,6 +412,7 @@ export {
   extractAllVariants,
   isPayloadLess,
   schemasAreCompatible,
+  propsCompatible,
   schemaTypeName,
   dedupeKeys,
   validateCompositeReads,

package/src/components/PluginName.res

@@ -0,0 +1,39 @@
+// Single source of truth for deriving a plugin's PascalCase name from its npm
+// package name, and for resolving the final plugin name from the (optional)
+// plugin.json `name` and package.json `name`. The plugin generator
+// (`generator/Config`) and the external tooling that reconstructs the domain
+// graph (`reventless-gwt`'s `LocalHost`) both derive from this, so the two can't
+// drift — a drift here silently breaks graph plugin keys (the graph would key
+// plugins under names that don't match the ones the generator bakes into
+// `Plugin.res`). See [[reference_ppx_spec_name_single_strip]] for the sibling
+// spec-name derivation.
+
+// "@scope/my-catalog" → "MyCatalog", "online-shop" → "OnlineShop".
+let fromPackageName = (packageName: string): string => {
+  let base = switch packageName->String.split("/") {
+  | [_scope, local] => local
+  | [local] => local
+  | parts => parts->Array.getUnsafe(parts->Array.length - 1)
+  }
+  base
+  ->String.split("-")
+  ->Array.flatMap(part => part->String.split("_"))
+  ->Array.map(word =>
+    if word === "" {
+      ""
+    } else {
+      word->String.slice(~start=0, ~end=1)->String.toUpperCase ++
+        word->String.slice(~start=1, ~end=word->String.length)
+    }
+  )
+  ->Array.join("")
+}
+
+// plugin.json `name` wins; else PascalCase(package.json `name`); else "Plugin".
+// The two callers each read the raw fields with their own node bindings, then
+// share this precedence so the resolution can never diverge.
+let resolve = (~pluginJsonName: option<string>, ~packageJsonName: option<string>): string =>
+  switch pluginJsonName {
+  | Some(name) => name
+  | None => packageJsonName->Option.map(fromPackageName)->Option.getOr("Plugin")
+  }

package/src/components/PluginName.res.mjs

@@ -0,0 +1,45 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function fromPackageName(packageName) {
+  let parts = packageName.split("/");
+  let len = parts.length;
+  let base;
+  if (len >= 3) {
+    base = parts[parts.length - 1 | 0];
+  } else {
+    switch (len) {
+      case 0 :
+        base = parts[parts.length - 1 | 0];
+        break;
+      case 1 :
+        base = parts[0];
+        break;
+      case 2 :
+        base = parts[1];
+        break;
+    }
+  }
+  return base.split("-").flatMap(part => part.split("_")).map(word => {
+    if (word === "") {
+      return "";
+    } else {
+      return word.slice(0, 1).toUpperCase() + word.slice(1, word.length);
+    }
+  }).join("");
+}
+
+function resolve(pluginJsonName, packageJsonName) {
+  if (pluginJsonName !== undefined) {
+    return pluginJsonName;
+  } else {
+    return Stdlib_Option.getOr(Stdlib_Option.map(packageJsonName, fromPackageName), "Plugin");
+  }
+}
+
+export {
+  fromPackageName,
+  resolve,
+}
+/* No side effect */

package/src/components/Snapshot.res

@@ -0,0 +1,26 @@
+// Per-aggregate persisted-snapshot configuration
+// (docs/plans/aggregate-snapshotting.md).
+//
+// Snapshotting is opt-in and lives on the Behavior module (where `state` is
+// defined): `Behavior.T.snapshot = None` (the default, auto-injected by
+// `@@reventless.behavior`) keeps full replay; `Some(config)` makes the
+// aggregate write a keep-one snapshot every `interval` events and seed cold
+// replays from the latest one. Snapshots are a read optimization only — the
+// OCC append remains the sole consistency primitive, and a missing, corrupt,
+// or schema-drifted snapshot degrades to full replay.
+//
+// Enable via the file-level attribute on a behavior file:
+//
+//   @@reventless.snapshots(100)
+//
+// which injects `let snapshot = Some({interval: 100, stateSchema})` (requires
+// `@schema type state` so sury generates the schema), or hand-write the
+// binding for full control.
+
+type config<'state> = {
+  /** Write a snapshot after every N appended events. Required — no default. */
+  interval: int,
+  /** Sury schema for the behavior's state — serializes the persisted snapshot
+      and (hashed) gates staleness across state-shape changes. */
+  stateSchema: S.t<'state>,
+}

package/src/components/Snapshot.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/generator/Config.res

@@ -12,25 +12,9 @@ type config = {
 
 // Convert npm package name to PascalCase plugin name.
 // "@scope/my-catalog" → "MyCatalog", "online-shop" → "OnlineShop"
-let packageNameToPluginName = (packageName: string): string => {
-  let base = switch packageName->String.split("/") {
-  | [_scope, local] => local
-  | [local] => local
-  | parts => parts->Array.getUnsafe(parts->Array.length - 1)
-  }
-  base
-  ->String.split("-")
-  ->Array.flatMap(part => part->String.split("_"))
-  ->Array.map(word =>
-    if word === "" {
-      ""
-    } else {
-      word->String.slice(~start=0, ~end=1)->String.toUpperCase ++
-        word->String.slice(~start=1, ~end=word->String.length)
-    }
-  )
-  ->Array.join("")
-}
+// Single-sourced with reventless-gwt's LocalHost via `PluginName` so the two
+// can't drift (a drift silently breaks graph plugin keys).
+let packageNameToPluginName = PluginName.fromPackageName
 
 let readJson = (path: string): option<JSON.t> =>
   try Some(Generator_Node.readFileSync(path)->JSON.parseOrThrow) catch {
@@ -58,13 +42,9 @@ let getStrArrayField = (json: JSON.t, key: string): option<array<string>> =>
   ->Option.map(arr => arr->Array.filterMap(JSON.Decode.string))
 
 let read = (~srcDir: string): config => {
-  // Derive plugin name from package.json in parent of srcDir
+  // Read package.json `name` from the parent of srcDir
   let packageJsonPath = Generator_Node.join([Generator_Node.dirname(srcDir), "package.json"])
-  let derivedName =
-    readJson(packageJsonPath)
-    ->Option.flatMap(j => getStrField(j, "name"))
-    ->Option.map(packageNameToPluginName)
-    ->Option.getOr("Plugin")
+  let packageJsonName = readJson(packageJsonPath)->Option.flatMap(j => getStrField(j, "name"))
 
   // Read plugin.json from srcDir (optional)
   let pluginJsonPath = Generator_Node.join([srcDir, "plugin.json"])
@@ -75,7 +55,10 @@ let read = (~srcDir: string): config => {
   }
 
   {
-    name: pluginJson->Option.flatMap(j => getStrField(j, "name"))->Option.getOr(derivedName),
+    name: PluginName.resolve(
+      ~pluginJsonName=pluginJson->Option.flatMap(j => getStrField(j, "name")),
+      ~packageJsonName,
+    ),
     heartbeatInterval: pluginJson
     ->Option.flatMap(j => getIntField(j, "heartbeatInterval"))
     ->Option.getOr(5),

package/src/generator/Config.res.mjs

@@ -5,34 +5,7 @@ import * as Nodepath from "node:path";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-
-function packageNameToPluginName(packageName) {
-  let parts = packageName.split("/");
-  let len = parts.length;
-  let base;
-  if (len >= 3) {
-    base = parts[parts.length - 1 | 0];
-  } else {
-    switch (len) {
-      case 0 :
-        base = parts[parts.length - 1 | 0];
-        break;
-      case 1 :
-        base = parts[0];
-        break;
-      case 2 :
-        base = parts[1];
-        break;
-    }
-  }
-  return base.split("-").flatMap(part => part.split("_")).map(word => {
-    if (word === "") {
-      return "";
-    } else {
-      return word.slice(0, 1).toUpperCase() + word.slice(1, word.length);
-    }
-  }).join("");
-}
+import * as PluginName$Reventless from "../components/PluginName.res.mjs";
 
 function readJson(path) {
   try {
@@ -56,17 +29,19 @@ function getStrArrayField(json, key) {
 
 function read(srcDir) {
   let packageJsonPath = Nodepath.join(Nodepath.dirname(srcDir), "package.json");
-  let derivedName = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(readJson(packageJsonPath), j => getStrField(j, "name")), packageNameToPluginName), "Plugin");
+  let packageJsonName = Stdlib_Option.flatMap(readJson(packageJsonPath), j => getStrField(j, "name"));
   let pluginJsonPath = Nodepath.join(srcDir, "plugin.json");
   let pluginJson = Nodefs.existsSync(pluginJsonPath) ? readJson(pluginJsonPath) : undefined;
   return {
-    name: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getStrField(j, "name")), derivedName),
+    name: PluginName$Reventless.resolve(Stdlib_Option.flatMap(pluginJson, j => getStrField(j, "name")), packageJsonName),
     heartbeatInterval: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getIntField(j, "heartbeatInterval")), 5),
     exclude: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getStrArrayField(j, "exclude")), []),
     variant: "Composition"
   };
 }
 
+let packageNameToPluginName = PluginName$Reventless.fromPackageName;
+
 export {
   packageNameToPluginName,
   readJson,

package/src/generator/Discovery.res

@@ -1,6 +1,9 @@
 // Directory scanner: walks src/, classifies .res files by parent folder name.
 
-type componentType =
+// Re-export the single-source `ComponentKind.t` (same constructors, so the bare
+// pattern matches in `Pairing` keep resolving via type inference) and derive the
+// folder classifier from it — one vocabulary shared with the gwt discovery.
+type componentType = ComponentKind.t =
   | StateChangeSlice
   | StateViewSlice
   | StateViewSliceStream
@@ -17,31 +20,7 @@ type componentType =
 // relPath: path relative to srcDir (e.g. "ReadModel/ProductsProjections.res")
 type discoveredFile = {stem: string, componentType: componentType, epGroup: option<string>, relPath: string}
 
-let folderToComponentType = (folder: string): option<componentType> =>
-  switch folder {
-  | "StateChange" | "StateChanges" | "StateChangeSlice" | "StateChangeSlices" =>
-    Some(StateChangeSlice)
-  | "StateView" | "StateViews" | "StateViewSlice" | "StateViewSlices" => Some(StateViewSlice)
-  | "StateViewSliceStream" | "StateViewSliceStreams" => Some(StateViewSliceStream)
-  | "Automation" | "Automations" | "AutomationSlice" | "AutomationSlices" => Some(AutomationSlice)
-  | "InboundTranslation"
-  | "InboundTranslations"
-  | "InboundTranslationSlice"
-  | "InboundTranslationSlices" =>
-    Some(InboundTranslationSlice)
-  | "OutboundTranslation"
-  | "OutboundTranslations"
-  | "OutboundTranslationSlice"
-  | "OutboundTranslationSlices" =>
-    Some(OutboundTranslationSlice)
-  | "Aggregate" | "Aggregates" => Some(Aggregate)
-  | "ReadModel" | "ReadModels" => Some(ReadModel)
-  | "ReadModelStream" | "ReadModelStreams" => Some(ReadModelStream)
-  | "Task" | "Tasks" => Some(Task)
-  | "ExtensionPoint" | "ExtensionPoints" => Some(ExtensionPoint)
-  | "Extension" | "Extensions" => Some(Extension)
-  | _ => None
-  }
+let folderToComponentType = ComponentKind.folderToKind
 
 let isAlwaysExcludedDir = (name: string): bool =>
   name === "Plugin" || name === "tests" || name === "lib"