@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Counter/Counter_Builder.res.mjs

@@ -0,0 +1,112 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Counter$ReventlessCore from "./Counter.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as QueryDb_Adapter$ReventlessCore from "../QueryDb/QueryDb_Adapter.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "../QueryDb/QueryDb_Builder.res.mjs";
+import * as Counter_Callback$ReventlessCore from "./Counter_Callback.res.mjs";
+import * as Counter_Operations$ReventlessCore from "./Counter_Operations.res.mjs";
+
+function Make(QueryDbStorage) {
+  return Api => (Handler => {
+    let make = (name, jsonEventsHandler, ttlOpt, specModulePathOpt, mappingsModulePathOpt, publishChannelIdOpt, opts) => {
+      let ttl = ttlOpt !== undefined ? ttlOpt : 604800;
+      let specModulePath = specModulePathOpt !== undefined ? specModulePathOpt : "";
+      let mappingsModulePath = mappingsModulePathOpt !== undefined ? mappingsModulePathOpt : "";
+      let publishChannelId = publishChannelIdOpt !== undefined ? publishChannelIdOpt : Pulumi.output("");
+      return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Counter$ReventlessCore.componentType), ComponentType$ReventlessCore.name(name, Counter$ReventlessCore.componentType), (extra, extra$1) => {
+        let ttl$1 = ttl;
+        let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts = {
+          parent: opts_parent
+        };
+        let opts2_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts2 = {
+          parent: opts2_parent
+        };
+        let name = extra$1 + "References";
+        let moduleUrl = import.meta.url;
+        let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+        let ReferencesDb = QueryDb_Builder$ReventlessCore.Make({
+          Id: {
+            schema: Id$Reventless.StringPure.schema,
+            make: prim => prim,
+            makeFromString: prim => prim,
+            toString: prim => prim,
+            cmp: Id$Reventless.StringPure.cmp
+          },
+          name: name,
+          moduleUrl: moduleUrl,
+          stateSchema: Counter_Operations$ReventlessCore.referencesStateSchema,
+          config: config,
+          subIdConfig: undefined,
+          authorization: "AllowAuthenticated",
+          visibility: "Public"
+        })(QueryDbStorage)(QueryDb_Adapter$ReventlessCore.NoResolvers(QueryDbStorage));
+        let name$1 = extra$1 + "Counts";
+        let moduleUrl$1 = import.meta.url;
+        let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+        let CountsDb = QueryDb_Builder$ReventlessCore.Make({
+          Id: {
+            schema: Id$Reventless.StringPure.schema,
+            make: prim => prim,
+            makeFromString: prim => prim,
+            toString: prim => prim,
+            cmp: Id$Reventless.StringPure.cmp
+          },
+          name: name$1,
+          moduleUrl: moduleUrl$1,
+          stateSchema: Counter_Callback$ReventlessCore.countsStateSchema,
+          config: config$1,
+          subIdConfig: undefined,
+          authorization: "AllowAuthenticated",
+          visibility: "Public"
+        })(QueryDbStorage)(QueryDb_Adapter$ReventlessCore.NoResolvers(QueryDbStorage));
+        let referencesDb = ReferencesDb.make(Api.api(), Api.apiRole(), ttl$1, opts);
+        let countsDb = CountsDb.make(Api.api(), Api.apiRole(), ttl$1, opts);
+        let handler = Component$ReventlessCore.operations(countsDb).apply(param => {
+          let Callback = Counter_Callback$ReventlessCore.Make({
+            name: extra$1,
+            countsDbCount: param.count,
+            jsonEventsHandler: jsonEventsHandler
+          });
+          return Handler.make(extra$1, name, Component$ReventlessCore.outputs(referencesDb), name$1, Component$ReventlessCore.outputs(countsDb), Callback.counterHandler, specModulePath, mappingsModulePath, publishChannelId, opts2);
+        });
+        Component$ReventlessCore.setOperations(extra, Pulumi.all([
+          Component$ReventlessCore.operations(referencesDb),
+          handler
+        ]).apply(param => {
+          let Operations = Counter_Operations$ReventlessCore.Make({
+            ttl: ttl$1,
+            saveBatch: param[0].saveBatch
+          });
+          return {
+            count: Operations.count,
+            addToCounterTarget: param[1].addToCounterTarget
+          };
+        }));
+        let outputs_referencesDb = Component$ReventlessCore.outputs(referencesDb);
+        let outputs_countsDb = Component$ReventlessCore.outputs(countsDb);
+        let outputs = {
+          referencesDb: outputs_referencesDb,
+          countsDb: outputs_countsDb
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+    };
+    return {
+      make: make,
+      outputs: Component$ReventlessCore.outputs,
+      operations: Component$ReventlessCore.operations
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Id-Reventless Not a pure module */

package/src/components/Counter/Counter_Callback.res

@@ -0,0 +1,94 @@
+@schema
+type countsState = {
+  id: string,
+  count: int,
+} //TODO: generalize
+
+type counterHandler = (~references: array<(string, int)>, ~counts: array<JSON.t>) => promise<unit>
+
+// Aggregates reference increments by counter ID: [("c1#ref-a", 1), ("c1#ref-b", 2)] → [("c1", 3)]
+let groupByCounterId = references => {
+  let dict = Dict.make()
+  references->Array.forEach(((reference, inc)) => {
+    let counterId = reference->Counter.unmakeId->Pair.first
+    let current = dict->Dict.get(counterId)->Option.getOr(0)
+    dict->Dict.set(counterId, current + inc)
+  })
+  dict->Dict.toArray
+}
+
+module type Spec = {
+  let name: string
+  let countsDbCount: QueryDb.count<string>
+  let jsonEventsHandler: Counter.jsonEventsHandler
+}
+
+module Make = (Spec: Spec) => {
+  // Handles a DynamoDB Streams batch of counter changes:
+  //   1. Decrements each counter's count in the QueryDb (grouped by counter ID)
+  //   2. Emits CountFinished events for any counters that reached zero
+  // Builds an Effect pipeline and converts to promise at the boundary (type = promise<unit>).
+  let counterHandler = (~references, ~counts) =>
+    EffectLogger.logInfo(
+      ~comp="Counter",
+      `counterHandler: references: ${references->Array.length->Int.toString}`,
+    )
+    ->Effect.zipRight(
+      EffectLogger.logInfo(
+        ~comp="Counter",
+        `counterHandler: counts: ${counts->JSON.stringifyAny->Option.getOr("[]")}`,
+      )
+    )
+    ->Effect.zipRight(
+      Effect.all(
+        references
+        ->groupByCounterId
+        ->Array.map(((counterId, dec)) =>
+          Effect.promise(() =>
+            Spec.countsDbCount(
+              counterId->Reventless.Id.StringPure.makeFromString,
+              Counter.countFieldName,
+              -dec,
+            )
+          )
+        ),
+        {"concurrency": "unbounded"},
+      )->Effect.map(_ => ())
+    )
+    ->Effect.zipRight(
+      Spec.jsonEventsHandler(
+        Stream.fromIterable(
+          counts->Array.filterMap(state =>
+            switch state->Message.decode(countsStateSchema) {
+            | {id, count} if count == 0 =>
+              let (counterId, _) = id->Counter.unmakeId
+              EffectLogger.logInfo(
+                ~comp=__MODULE__,
+                `counterHandler: counted down ${Spec.name}(${id}) to ${count->Int.toString}`,
+              )->Effect.runSync
+              let meta = Message.generateMeta(
+                ~service=ComponentType.Counter->ComponentType.toName,
+                ~user="Counter",
+              )
+              Some(
+                [
+                  ("id", counterId->JSON.Encode.string),
+                  ("meta", meta->Message.encode(Message.metaSchema)),
+                  ("event", Counter.CountFinished->Message.encode(Counter.counterEventSchema)),
+                ]
+                ->Dict.fromArray
+                ->JSON.Encode.object,
+              )
+            | {id, count} =>
+              EffectLogger.logInfo(
+                ~comp=__MODULE__,
+                `counterHandler: counted down ${Spec.name}(${id}) to ${count->Int.toString}`,
+              )->Effect.runSync
+              None
+            }
+          ),
+        ),
+      )
+    )
+    ->Effect.runPromise
+}

package/src/components/Counter/Counter_Callback.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Counter$ReventlessCore from "./Counter.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+
+let countsStateSchema = S.schema(s => ({
+  id: s.m(S.string),
+  count: s.m(S.int)
+}));
+
+function groupByCounterId(references) {
+  let dict = {};
+  references.forEach(param => {
+    let counterId = Counter$ReventlessCore.unmakeId(param[0])[0];
+    let current = Stdlib_Option.getOr(dict[counterId], 0);
+    dict[counterId] = current + param[1] | 0;
+  });
+  return Object.entries(dict);
+}
+
+function Make(Spec) {
+  let counterHandler = (references, counts) => Effect.runPromise(Effect.zipRight(Effect.zipRight(Effect.zipRight(EffectLogger$ReventlessCore.logInfo("Counter", undefined, `counterHandler: references: ` + references.length.toString()), EffectLogger$ReventlessCore.logInfo("Counter", undefined, `counterHandler: counts: ` + Stdlib_Option.getOr(JSON.stringify(counts), "[]"))), Effect.map(Effect.all(groupByCounterId(references).map(param => {
+    let dec = param[1];
+    let counterId = param[0];
+    return Effect.promise(() => Spec.countsDbCount(counterId, "count", -dec | 0));
+  }), {
+    concurrency: "unbounded"
+  }), param => {})), Spec.jsonEventsHandler(Stream.fromIterable(Stdlib_Array.filterMap(counts, state => {
+    let match = Message$ReventlessCore.decode(state, countsStateSchema);
+    let count = match.count;
+    let id = match.id;
+    if (count === 0) {
+      let match$1 = Counter$ReventlessCore.unmakeId(id);
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo("Counter_Callback-ReventlessCore", undefined, `counterHandler: counted down ` + Spec.name + `(` + id + `) to ` + count.toString()));
+      let meta = Message$ReventlessCore.generateMeta(ComponentType$ReventlessCore.toName("Counter"), undefined, "Counter", undefined, undefined, undefined, undefined, undefined);
+      return Object.fromEntries([
+        [
+          "id",
+          match$1[0]
+        ],
+        [
+          "meta",
+          Message$ReventlessCore.encode(meta, Message$ReventlessCore.metaSchema)
+        ],
+        [
+          "event",
+          Message$ReventlessCore.encode("CountFinished", Counter$ReventlessCore.counterEventSchema)
+        ]
+      ]);
+    }
+    Effect.runSync(EffectLogger$ReventlessCore.logInfo("Counter_Callback-ReventlessCore", undefined, `counterHandler: counted down ` + Spec.name + `(` + id + `) to ` + count.toString()));
+  })))));
+  return {
+    counterHandler: counterHandler
+  };
+}
+
+export {
+  countsStateSchema,
+  groupByCounterId,
+  Make,
+}
+/* countsStateSchema Not a pure module */

package/src/components/Counter/Counter_Operations.res

@@ -0,0 +1,70 @@
+@schema
+type referencesState = {
+  id: string,
+  inc: int,
+}
+
+let groupCountItemsByCounterId = countItems => {
+  let dict = Dict.make()
+  countItems->Array.forEach(({ReventlessInfra.Counter.counterId: counterId, reference}) => {
+    let currentReferences = dict->Dict.get(counterId)->Option.getOr([])
+    dict->Dict.set(counterId, currentReferences->Array.concat([reference]))
+  })
+  dict->Dict.toArray
+}
+
+let logCountItems = countItems =>
+  countItems
+  ->groupCountItemsByCounterId
+  ->Array.forEach(((counterId, references)) => {
+    let size = references->Array.length
+    let referencesStr = references->Array.joinUnsafe(",")
+    EffectLogger.logInfo(
+      ~comp="Counter",
+      `  ${size->Int.toString} reference(s) for counterId ${counterId}: ${referencesStr}`,
+    )->Effect.runSync
+  })
+
+exception NotCounted(string)
+
+module type Ops = {
+  let ttl: option<int>
+  let saveBatch: QueryDb.saveBatch<string, referencesState>
+}
+
+module Make = (Ops: Ops) => {
+  let count = async countItems => {
+    let result = await Ops.saveBatch(
+      countItems->Array.map(({ReventlessInfra.Counter.counterId: counterId, reference, inc}) => {
+        let id = Counter.makeId((counterId, reference))
+        let state: referencesState = {id, inc}
+        (id, state, Ops.ttl)
+      }),
+    )
+    switch result {
+    | Ok(_) =>
+      let batchSize = countItems->Array.length
+      EffectLogger.logInfo(
+        ~comp=__MODULE__,
+        `saved batch of ${batchSize->Int.toString} reference(s):`,
+      )->Effect.runSync
+      countItems->logCountItems
+    | Error(ReventlessInfra.QueryDb.NotSavedToStorage(err)) =>
+      let batchSize = countItems->Array.length
+      EffectLogger.logError(
+        ~comp="Counter",
+        `couldn't save batch of ${batchSize->Int.toString} reference(s):`,
+      )->Effect.runSync
+      countItems->logCountItems
+      throw(NotCounted(err))
+    | Error(_) =>
+      let batchSize = countItems->Array.length
+      EffectLogger.logError(
+        ~comp="Counter",
+        `Unknown error: couldn't save batch of ${batchSize->Int.toString} reference(s):`,
+      )->Effect.runSync
+      countItems->logCountItems
+      throw(NotCounted("Unknown error"))
+    }
+  }
+}

package/src/components/Counter/Counter_Operations.res.mjs

@@ -0,0 +1,91 @@
+// 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 Effect from "effect/Effect";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Counter$ReventlessCore from "./Counter.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+let referencesStateSchema = S.schema(s => ({
+  id: s.m(S.string),
+  inc: s.m(S.int)
+}));
+
+function groupCountItemsByCounterId(countItems) {
+  let dict = {};
+  countItems.forEach(param => {
+    let counterId = param.counterId;
+    let currentReferences = Stdlib_Option.getOr(dict[counterId], []);
+    dict[counterId] = currentReferences.concat([param.reference]);
+  });
+  return Object.entries(dict);
+}
+
+function logCountItems(countItems) {
+  groupCountItemsByCounterId(countItems).forEach(param => {
+    let references = param[1];
+    let size = references.length;
+    let referencesStr = references.join(",");
+    Effect.runSync(EffectLogger$ReventlessCore.logInfo("Counter", undefined, `  ` + size.toString() + ` reference(s) for counterId ` + param[0] + `: ` + referencesStr));
+  });
+}
+
+let NotCounted = /* @__PURE__ */Primitive_exceptions.create("Counter_Operations-ReventlessCore.NotCounted");
+
+function Make(Ops) {
+  let count = async countItems => {
+    let result = await Ops.saveBatch(countItems.map(param => {
+      let id = Counter$ReventlessCore.makeId([
+        param.counterId,
+        param.reference
+      ]);
+      let state_inc = param.inc;
+      let state = {
+        id: id,
+        inc: state_inc
+      };
+      return [
+        id,
+        state,
+        Ops.ttl
+      ];
+    }));
+    if (result.TAG === "Ok") {
+      let batchSize = countItems.length;
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo("Counter_Operations-ReventlessCore", undefined, `saved batch of ` + batchSize.toString() + ` reference(s):`));
+      return logCountItems(countItems);
+    }
+    let err = result._0;
+    if (typeof err === "object" && err.TAG === "NotSavedToStorage") {
+      let batchSize$1 = countItems.length;
+      Effect.runSync(EffectLogger$ReventlessCore.logError("Counter", undefined, `couldn't save batch of ` + batchSize$1.toString() + ` reference(s):`));
+      logCountItems(countItems);
+      throw {
+        RE_EXN_ID: NotCounted,
+        _1: err._0,
+        Error: new Error()
+      };
+    }
+    let batchSize$2 = countItems.length;
+    Effect.runSync(EffectLogger$ReventlessCore.logError("Counter", undefined, `Unknown error: couldn't save batch of ` + batchSize$2.toString() + ` reference(s):`));
+    logCountItems(countItems);
+    throw {
+      RE_EXN_ID: NotCounted,
+      _1: "Unknown error",
+      Error: new Error()
+    };
+  };
+  return {
+    count: count
+  };
+}
+
+export {
+  referencesStateSchema,
+  groupCountItemsByCounterId,
+  logCountItems,
+  NotCounted,
+  Make,
+}
+/* referencesStateSchema Not a pure module */