@reventlessdev/reventless-spec 3.0.0-alpha.63 → 3.0.0-alpha.65

package/src/components/DcbTag.res.mjs

@@ -14,6 +14,10 @@ let tagSchema = S.schema(s => ({
   value: s.m(S.string)
 }));
 
+let partitionTagSchema = S.schema(s => ({
+  key: s.m(S.string)
+}));
+
 let dcbTagId = S.Metadata.Id.make("dcb", "tag");
 
 let dcbPartitionTagId = S.Metadata.Id.make("dcb", "partitionTag");
@@ -48,6 +52,22 @@ function isCompositePartitionMember(fieldSchema) {
   return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbCompositePartitionMemberId));
 }
 
+let compositePartitionSpecSchema = S.schema(s => ({
+  keys: s.m(S.array(S.string)),
+  seps: s.m(S.array(S.string))
+}));
+
+let derivedPartitionTagSchema = S.union([
+  S.schema(s => ({
+    TAG: "Simple",
+    _0: s.m(partitionTagSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Composite",
+    _0: s.m(compositePartitionSpecSchema)
+  }))
+]);
+
 function isTagged(fieldSchema) {
   return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbTagId));
 }
@@ -130,6 +150,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 +185,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;
+        } else if (variantSchema.type === "object") {
+          if (Primitive_object.equal(variantTagName(variantSchema.items), jsonTag)) {
+            return extractTagsFromProperties(variantSchema.properties, jsonDict$1);
+          } else {
+            return [];
           }
-          let $$const = match.const;
-          if ($$const !== undefined) {
-            return $$const;
-          }
-        });
-        if (Primitive_object.equal(variantTag, jsonTag)) {
-          return extractTagsFromProperties(variantSchema.properties, jsonDict$1);
         } else {
           return [];
         }
@@ -185,29 +208,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 +230,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 +242,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 +259,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 +328,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;
+        } else if (variantSchema.type === "object") {
+          if (Primitive_object.equal(variantTagName(variantSchema.items), jsonTag)) {
+            return extractTagsFromPropertiesExpanded(variantSchema.properties, jsonDict$1);
+          } else {
+            return [];
           }
-          let $$const = match.const;
-          if ($$const !== undefined) {
-            return $$const;
-          }
-        });
-        if (Primitive_object.equal(variantTag, jsonTag)) {
-          return extractTagsFromPropertiesExpanded(variantSchema.properties, jsonDict$1);
         } else {
           return [];
         }
@@ -427,16 +386,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 +558,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 +643,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") {
@@ -888,6 +820,7 @@ function getPartitionTagValue(query, pt) {
 
 export {
   tagSchema,
+  partitionTagSchema,
   dcbTagId,
   dcbPartitionTagId,
   dcbCrossPartitionId,
@@ -900,6 +833,8 @@ export {
   crossPartition,
   compositePartitionMember,
   isCompositePartitionMember,
+  compositePartitionSpecSchema,
+  derivedPartitionTagSchema,
   isTagged,
   isTaggedArray,
   isPartitionTag,
@@ -909,6 +844,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

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];

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/Codegen.res

@@ -672,6 +672,16 @@ let renderComposition = (~config: Config.config, ~resolved: Pairing.resolved): s
       ~moduleSuffix="Slice",
     ),
     hasPluginStructure ? Some("      ~pluginStructure=pluginStructure,") : None,
+    // Components carrying `@@reventless.systemCallable` — only emitted when at
+    // least one opts in, so existing generated Plugin.res files stay identical.
+    resolved.systemCallableComponents->Array.length > 0
+      ? Some(
+          "      ~systemCallableComponents=[" ++
+          resolved.systemCallableComponents
+          ->Array.map(n => "\"" ++ n ++ "\"")
+          ->Array.join(", ") ++ "],",
+        )
+      : None,
   ]
 
   makeParams->Array.filterMap(x => x)->Array.forEach(line => lines->Array.push(line))

package/src/generator/Codegen.res.mjs

@@ -428,7 +428,8 @@ function renderComposition(config, resolved) {
     renderMakeParam("automationSlices", resolved.automationSlices, "Slice"),
     renderMakeParam("outboundTranslationSlices", resolved.outboundTranslationSlices, "Slice"),
     renderMakeParam("inboundTranslationSlices", resolved.inboundTranslationSlices, "Slice"),
-    hasPluginStructure ? "      ~pluginStructure=pluginStructure," : undefined
+    hasPluginStructure ? "      ~pluginStructure=pluginStructure," : undefined,
+    resolved.systemCallableComponents.length !== 0 ? "      ~systemCallableComponents=[" + resolved.systemCallableComponents.map(n => "\"" + n + "\"").join(", ") + "]," : undefined
   ];
   Stdlib_Array.filterMap(makeParams, x => x).forEach(line => {
     lines.push(line);

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"