@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/Scheduler/LocalScheduledPublisher.res.mjs

@@ -0,0 +1,84 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+
+function Make(Bus) {
+  let activeTimers = {
+    contents: {}
+  };
+  let rateToMs = rate => {
+    switch (rate.TAG) {
+      case "Single" :
+        return 0;
+      case "Minutes" :
+        return (rate._0 * 60 | 0) * 1000 | 0;
+      case "Hours" :
+        return ((rate._0 * 60 | 0) * 60 | 0) * 1000 | 0;
+      case "Days" :
+        return (((rate._0 * 24 | 0) * 60 | 0) * 60 | 0) * 1000 | 0;
+      default:
+        return 86400000;
+    }
+  };
+  let isSingleShot = rate => rate.TAG === "Single";
+  let scheduleMeta = {
+    service: "Scheduler",
+    time: "",
+    ip: "",
+    user: "Scheduler",
+    msgId: "",
+    correlationId: ""
+  };
+  let make = (param, param$1) => {
+    let createSchedule = async (channelResources, schedule) => {
+      let topicName = channelResources.length !== 0 ? channelResources[0].name : "";
+      let payloadJson;
+      try {
+        payloadJson = JSON.parse(schedule.payload);
+      } catch (exn) {
+        payloadJson = schedule.payload;
+      }
+      let fire = () => {
+        Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson);
+      };
+      let handle = isSingleShot(schedule.rate) ? setTimeout(fire, 0) : setInterval(fire, rateToMs(schedule.rate));
+      activeTimers.contents[schedule.name] = handle;
+    };
+    let deleteSchedule = async (param, name) => {
+      let handle = activeTimers.contents[name];
+      if (handle !== undefined) {
+        clearTimeout(Primitive_option.valFromOption(handle));
+        return Stdlib_Dict.$$delete(activeTimers.contents, name);
+      }
+    };
+    return {
+      resource: Adapter$ReventlessInfra.make(Pulumi.output(""), Pulumi.output(""), Pulumi.output(""), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined),
+      operations: Pulumi.output({
+        createSchedule: createSchedule,
+        deleteSchedule: deleteSchedule
+      })
+    };
+  };
+  let reset = () => {
+    Object.values(activeTimers.contents).forEach(prim => {
+      clearTimeout(prim);
+    });
+    activeTimers.contents = {};
+  };
+  return {
+    activeTimers: activeTimers,
+    rateToMs: rateToMs,
+    isSingleShot: isSingleShot,
+    scheduleMeta: scheduleMeta,
+    make: make,
+    reset: reset
+  };
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/adapter/SqliteDriver.res

@@ -0,0 +1,52 @@
+// Wraps node:sqlite (Node ≥ 22.5). Synchronous API on purpose: it preserves
+// the same-tick settling guarantees the in-memory adapters rely on.
+
+type t
+type statement
+
+@module("node:sqlite") @new
+external openDatabaseSync: string => t = "DatabaseSync"
+
+@module("node:path") external dirname: string => string = "dirname"
+type mkdirOpts = {recursive: bool}
+@module("node:fs") external mkdirSync: (string, mkdirOpts) => unit = "mkdirSync"
+
+@send external _close: t => unit = "close"
+@send external _exec: (t, string) => unit = "exec"
+@send external _prepare: (t, string) => statement = "prepare"
+
+// node:sqlite accepts ...positional bound values. Use Function.prototype.apply
+// via a small inline helper so the array is splatted without ReScript's
+// `@send` syntax accidentally treating `run.apply` as a single property name.
+let _runApply: (statement, array<JSON.t>) => unit = %raw(`function(s, a) { return s.run.apply(s, a); }`)
+let _getApply: (statement, array<JSON.t>) => Nullable.t<dict<JSON.t>> = %raw(`function(s, a) { return s.get.apply(s, a); }`)
+let _allApply: (statement, array<JSON.t>) => array<dict<JSON.t>> = %raw(`function(s, a) { return s.all.apply(s, a); }`)
+let _iterateApply: (statement, array<JSON.t>) => Iterator.t<dict<JSON.t>> = %raw(`function(s, a) { return s.iterate.apply(s, a); }`)
+
+let openDb = (~path) => {
+  if path !== ":memory:" {
+    mkdirSync(dirname(path), {recursive: true})
+  }
+  openDatabaseSync(path)
+}
+let close = db => _close(db)
+let exec = (db, sql) => _exec(db, sql)
+let prepare = (db, sql) => _prepare(db, sql)
+
+let run = (stmt, args) => _runApply(stmt, args)
+let get = (stmt, args) => _getApply(stmt, args)->Nullable.toOption
+let all = (stmt, args) => _allApply(stmt, args)
+let iterate = (stmt, args) => _iterateApply(stmt, args)
+
+let transaction = (db, fn) => {
+  exec(db, "BEGIN")
+  try {
+    let result = fn()
+    exec(db, "COMMIT")
+    result
+  } catch {
+  | exn =>
+    exec(db, "ROLLBACK")
+    throw(exn)
+  }
+}

package/src/adapter/SqliteDriver.res.mjs

@@ -0,0 +1,76 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Nodesqlite from "node:sqlite";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let _runApply = (function(s, a) { return s.run.apply(s, a); });
+
+let _getApply = (function(s, a) { return s.get.apply(s, a); });
+
+let _allApply = (function(s, a) { return s.all.apply(s, a); });
+
+let _iterateApply = (function(s, a) { return s.iterate.apply(s, a); });
+
+function openDb(path) {
+  if (path !== ":memory:") {
+    Nodefs.mkdirSync(Nodepath.dirname(path), {
+      recursive: true
+    });
+  }
+  return new Nodesqlite.DatabaseSync(path);
+}
+
+function close(db) {
+  db.close();
+}
+
+function exec(db, sql) {
+  db.exec(sql);
+}
+
+function prepare(db, sql) {
+  return db.prepare(sql);
+}
+
+function run(stmt, args) {
+  _runApply(stmt, args);
+}
+
+function get(stmt, args) {
+  return Primitive_option.fromNullable(_getApply(stmt, args));
+}
+
+function all(stmt, args) {
+  return _allApply(stmt, args);
+}
+
+function iterate(stmt, args) {
+  return _iterateApply(stmt, args);
+}
+
+function transaction(db, fn) {
+  db.exec("BEGIN");
+  try {
+    let result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (exn) {
+    db.exec("ROLLBACK");
+    throw exn;
+  }
+}
+
+export {
+  openDb,
+  close,
+  exec,
+  prepare,
+  run,
+  get,
+  all,
+  iterate,
+  transaction,
+}
+/* node:fs Not a pure module */

package/src/adapter/SqliteDriver.resi

@@ -0,0 +1,31 @@
+// Sealed wrapper around an embedded SQLite driver.
+//
+// Currently uses Node's built-in node:sqlite (Node ≥ 22.5). The interface is
+// kept tight enough that other drivers (better-sqlite3, bun:sqlite) can be
+// dropped in later without callers changing.
+
+type t
+type statement
+
+let openDb: (~path: string) => t
+let close: t => unit
+
+// Execute one or more statements without parameter binding (DDL, PRAGMA, BEGIN/COMMIT).
+let exec: (t, string) => unit
+
+let prepare: (t, string) => statement
+
+// Bind positional parameters and run a non-SELECT statement.
+let run: (statement, array<JSON.t>) => unit
+
+// Bind and return the first row, or None.
+let get: (statement, array<JSON.t>) => option<dict<JSON.t>>
+
+// Bind and return all rows.
+let all: (statement, array<JSON.t>) => array<dict<JSON.t>>
+
+// Bind and return rows lazily as a JS iterator. Caller is responsible for draining.
+let iterate: (statement, array<JSON.t>) => Iterator.t<dict<JSON.t>>
+
+// Run a function inside BEGIN/COMMIT. Rolls back on any thrown exception.
+let transaction: (t, unit => 'a) => 'a

package/src/adapter/Task/LocalTaskBucket.res

@@ -0,0 +1,75 @@
+// In-memory task bucket.
+// No S3 buckets created; makeHandler calls the callback with extracted event fields.
+
+open ReventlessCore
+
+type runtimeParts = LocalRuntimeEnvironment.parts
+type callbackEvent = JSON.t
+type context = unit
+type bucketParts = unit
+
+let connect: Task_Adapter.connect<bucketParts, runtimeParts> = (
+  ~name as _,
+  ~bucket as _,
+  ~bucketMode as _,
+  ~commandTopics as _,
+  ~runtime as _,
+  ~opts as _,
+) => ()
+
+let makeHandler = (callback: Task.bucketCallback): Runtime.eventHandler<
+  callbackEvent,
+  context,
+  array<Task.taskAction>,
+> => {
+  async (json, _ctx) => {
+    let eventName = switch json {
+    | JSON.Object(d) =>
+      d
+      ->Dict.get("eventName")
+      ->Option.flatMap(j =>
+        switch j {
+        | JSON.String(s) => Some(s)
+        | _ => None
+        }
+      )
+      ->Option.getOr("ObjectCreated")
+    | _ => "ObjectCreated"
+    }
+    let key = switch json {
+    | JSON.Object(d) =>
+      d
+      ->Dict.get("key")
+      ->Option.flatMap(j =>
+        switch j {
+        | JSON.String(s) => Some(s)
+        | _ => None
+        }
+      )
+      ->Option.getOr("")
+    | _ => ""
+    }
+    await callback(~eventName, ~key)
+  }
+}
+
+let make: Task_Adapter.bucketMaker<bucketParts> = (~name, ~opts as _) => {
+  // When SQLite is the active backend, eagerly provision the task_object
+  // table so put/get helpers can be used outside the bucketMaker contract.
+  switch BackendState.getDb() {
+  | Some(db) => TaskBucket_Sqlite.ensureSchema(db)
+  | None => ()
+  }
+  // Return a single dummy resource so Task_Builder can access Array.getUnsafe(0).id.
+  {
+    resources: [
+      ReventlessInfra.Adapter.make(
+        ~name=name->Pulumi.Output.make,
+        ~id=name->Pulumi.Output.make,
+        ~urn=("urn:" ++ name)->Pulumi.Output.make,
+        ~service="memory:InMemory"->Pulumi.Output.make,
+      ),
+    ],
+    parts: (),
+  }
+}

package/src/adapter/Task/LocalTaskBucket.res.mjs

@@ -0,0 +1,48 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as TaskBucket_Sqlite$ReventlessLocal from "./TaskBucket_Sqlite.res.mjs";
+
+function connect(param, param$1, param$2, param$3, param$4, param$5) {
+  
+}
+
+function makeHandler(callback) {
+  return async (json, _ctx) => {
+    let eventName;
+    eventName = typeof json === "object" && json !== null && !Array.isArray(json) ? Stdlib_Option.getOr(Stdlib_Option.flatMap(json["eventName"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      }), "ObjectCreated") : "ObjectCreated";
+    let key;
+    key = typeof json === "object" && json !== null && !Array.isArray(json) ? Stdlib_Option.getOr(Stdlib_Option.flatMap(json["key"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      }), "") : "";
+    return await callback(eventName, key);
+  };
+}
+
+function make(name, param) {
+  let db = BackendState$ReventlessLocal.getDb();
+  if (db !== undefined) {
+    TaskBucket_Sqlite$ReventlessLocal.ensureSchema(Primitive_option.valFromOption(db));
+  }
+  return {
+    resources: [Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output("urn:" + name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined)],
+    parts: undefined
+  };
+}
+
+export {
+  connect,
+  makeHandler,
+  make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/adapter/Task/TaskBucket_Sqlite.res

@@ -0,0 +1,47 @@
+// SQLite-backed task bucket.
+//
+// The in-memory Task_Builder treats the bucket as opaque: it only needs a
+// resource to identify the bucket. There is no read/write contract on the
+// bucketMaker today, so the SQLite variant just provisions a table for
+// future task-replay tooling and exposes plain put/get helpers that
+// callers can use directly.
+//
+// Schema:
+//   CREATE TABLE task_object (
+//     bucket TEXT NOT NULL,
+//     key    TEXT NOT NULL,
+//     body   BLOB NOT NULL,
+//     PRIMARY KEY (bucket, key)
+//   )
+
+let ensureSchema = (db: SqliteDriver.t) =>
+  db->SqliteDriver.exec(
+    "CREATE TABLE IF NOT EXISTS task_object (bucket TEXT NOT NULL, key TEXT NOT NULL, body BLOB NOT NULL, PRIMARY KEY (bucket, key))",
+  )
+
+let put = (~db: SqliteDriver.t, ~bucket: string, ~key: string, ~body: string): unit => {
+  ensureSchema(db)
+  let stmt = db->SqliteDriver.prepare(
+    "INSERT INTO task_object(bucket, key, body) VALUES(?, ?, ?) ON CONFLICT(bucket, key) DO UPDATE SET body = excluded.body",
+  )
+  stmt->SqliteDriver.run([
+    JSON.Encode.string(bucket),
+    JSON.Encode.string(key),
+    JSON.Encode.string(body),
+  ])
+}
+
+let get = (~db: SqliteDriver.t, ~bucket: string, ~key: string): option<string> => {
+  ensureSchema(db)
+  let stmt = db->SqliteDriver.prepare(
+    "SELECT body FROM task_object WHERE bucket = ? AND key = ?",
+  )
+  switch stmt->SqliteDriver.get([JSON.Encode.string(bucket), JSON.Encode.string(key)]) {
+  | Some(row) =>
+    switch row->Dict.get("body") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    }
+  | None => None
+  }
+}

package/src/adapter/Task/TaskBucket_Sqlite.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+
+function ensureSchema(db) {
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS task_object (bucket TEXT NOT NULL, key TEXT NOT NULL, body BLOB NOT NULL, PRIMARY KEY (bucket, key))");
+}
+
+function put(db, bucket, key, body) {
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS task_object (bucket TEXT NOT NULL, key TEXT NOT NULL, body BLOB NOT NULL, PRIMARY KEY (bucket, key))");
+  let stmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO task_object(bucket, key, body) VALUES(?, ?, ?) ON CONFLICT(bucket, key) DO UPDATE SET body = excluded.body");
+  SqliteDriver$ReventlessLocal.run(stmt, [
+    bucket,
+    key,
+    body
+  ]);
+}
+
+function get(db, bucket, key) {
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS task_object (bucket TEXT NOT NULL, key TEXT NOT NULL, body BLOB NOT NULL, PRIMARY KEY (bucket, key))");
+  let stmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT body FROM task_object WHERE bucket = ? AND key = ?");
+  let row = SqliteDriver$ReventlessLocal.get(stmt, [
+    bucket,
+    key
+  ]);
+  if (row === undefined) {
+    return;
+  }
+  let match = row["body"];
+  if (typeof match === "string") {
+    return match;
+  }
+}
+
+export {
+  ensureSchema,
+  put,
+  get,
+}
+/* SqliteDriver-ReventlessLocal Not a pure module */

package/src/components/Aggregate_Builder.res

@@ -0,0 +1,55 @@
+// In-memory aggregate builder.
+// Wires in-memory adapters and delegates to ReventlessCore.Aggregate_Builder.Make.
+
+let noHooks: ReventlessCore.Plugin_Helpers.platformHooks = {
+  adminExtensionPoints: ref(Pulumi.Output.make(Dict.make())),
+  scheduler: ref(None),
+  schedulerRoleUrn: ref(Pulumi.Output.make("")),
+  api: ref(None),
+  apiRole: ref(None),
+  deployTarget: ref("Domain"),
+}
+
+// MakeWithHooks — full version used by the Platform (passes hook callbacks to core builder).
+module MakeWithHooks = (
+  Bus: LocalBus.T,
+  HooksConfig: ReventlessCore.Plugin_Helpers.HooksConfig,
+) => {
+  module RuntimeEnvironment = LocalRuntimeEnvironment
+  module CommandTopicChannel = LocalCommandTopicChannel.Make(Bus)
+  module EventTopicPublisher = LocalEventTopicPublisher.Make(Bus)
+  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  module AggregateRuntimeBuilder = LocalAggregateRuntime_Builder.Make(
+    Bus,
+    CommandTopicChannel,
+    EventCollectorChannel,
+  )
+
+  module Make = (
+    Spec: Reventless.Aggregate.Spec,
+    Behavior: Reventless.Behavior.T with module Spec := Spec,
+    EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
+  ) => {
+    include ReventlessCore.Aggregate_Builder.Make(
+      Spec,
+      Behavior,
+      EventMappings,
+      RuntimeEnvironment,
+      CommandGeneratorResolvers_GraphQL,
+      CommandTopicChannel,
+      EventLogStorage_InMemory.Make(Bus),
+      EventTopicPublisher,
+      EventCollectorChannel,
+      AggregateRuntimeBuilder,
+      HooksConfig,
+    )
+    // Re-shadow `operations` with explicit spec return type so callers without
+    // reventless in scope can still access ops.publishJsons (transparent alias).
+    let operations: component => Pulumi.Output.t<ReventlessInfra.Aggregate.operations> = operations
+  }
+}
+
+// Make — simple version for standalone tests and examples (no hook callbacks).
+module Make = (Bus: LocalBus.T) => {
+  include MakeWithHooks(Bus, {let hooks = noHooks})
+}

package/src/components/Aggregate_Builder.res.mjs

@@ -0,0 +1,140 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Aggregate_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/Aggregate/Aggregate_Builder.res.mjs";
+import * as LocalRuntimeEnvironment$ReventlessLocal from "../adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "../adapter/EventLog/EventLogStorage_InMemory.res.mjs";
+import * as LocalCommandTopicChannel$ReventlessLocal from "../adapter/CommandTopic/LocalCommandTopicChannel.res.mjs";
+import * as LocalEventTopicPublisher$ReventlessLocal from "../adapter/EventTopic/LocalEventTopicPublisher.res.mjs";
+import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
+import * as LocalAggregateRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalAggregateRuntime_Builder.res.mjs";
+import * as CommandGeneratorResolvers_GraphQL$ReventlessLocal from "../adapter/CommandGenerator/CommandGeneratorResolvers_GraphQL.res.mjs";
+
+let noHooks_adminExtensionPoints = {
+  contents: Pulumi.output({})
+};
+
+let noHooks_scheduler = {
+  contents: undefined
+};
+
+let noHooks_schedulerRoleUrn = {
+  contents: Pulumi.output("")
+};
+
+let noHooks_api = {
+  contents: undefined
+};
+
+let noHooks_apiRole = {
+  contents: undefined
+};
+
+let noHooks_deployTarget = {
+  contents: "Domain"
+};
+
+let noHooks = {
+  adminExtensionPoints: noHooks_adminExtensionPoints,
+  scheduler: noHooks_scheduler,
+  schedulerRoleUrn: noHooks_schedulerRoleUrn,
+  api: noHooks_api,
+  apiRole: noHooks_apiRole,
+  deployTarget: noHooks_deployTarget
+};
+
+function MakeWithHooks(Bus) {
+  return HooksConfig => {
+    let CommandTopicChannel = LocalCommandTopicChannel$ReventlessLocal.Make(Bus);
+    let EventTopicPublisher = LocalEventTopicPublisher$ReventlessLocal.Make(Bus);
+    let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
+    let AggregateRuntimeBuilder = LocalAggregateRuntime_Builder$ReventlessLocal.Make(Bus)({
+      make: CommandTopicChannel.make
+    })(EventCollectorChannel);
+    let Make = Spec => (Behavior => (EventMappings => {
+      let include = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+        mappings: EventMappings.mappings,
+        counter: EventMappings.counter
+      })({
+        make: LocalRuntimeEnvironment$ReventlessLocal.make,
+        groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+        extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+        asEventHandler: prim => prim,
+        asEffectHandler: prim => prim
+      })({
+        handleResolversEvent: CommandGeneratorResolvers_GraphQL$ReventlessLocal.handleResolversEvent,
+        make: CommandGeneratorResolvers_GraphQL$ReventlessLocal.make
+      })({
+        make: CommandTopicChannel.make
+      })(EventLogStorage_InMemory$ReventlessLocal.Make(Bus))(EventTopicPublisher)(EventCollectorChannel)(AggregateRuntimeBuilder)(HooksConfig);
+      return {
+        Spec: include.Spec,
+        AggregateRuntimeBuilder: include.AggregateRuntimeBuilder,
+        make: include.make,
+        outputs: include.outputs,
+        finish: include.finish,
+        operations: include.operations
+      };
+    }));
+    return {
+      RuntimeEnvironment: undefined,
+      CommandTopicChannel: CommandTopicChannel,
+      EventTopicPublisher: EventTopicPublisher,
+      EventCollectorChannel: EventCollectorChannel,
+      AggregateRuntimeBuilder: AggregateRuntimeBuilder,
+      Make: Make
+    };
+  };
+}
+
+function Make(Bus) {
+  let HooksConfig = {
+    hooks: noHooks
+  };
+  let CommandTopicChannel = LocalCommandTopicChannel$ReventlessLocal.Make(Bus);
+  let EventTopicPublisher = LocalEventTopicPublisher$ReventlessLocal.Make(Bus);
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
+  let AggregateRuntimeBuilder = LocalAggregateRuntime_Builder$ReventlessLocal.Make(Bus)({
+    make: CommandTopicChannel.make
+  })(EventCollectorChannel);
+  let Make$1 = Spec => (Behavior => (EventMappings => {
+    let include = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+      mappings: EventMappings.mappings,
+      counter: EventMappings.counter
+    })({
+      make: LocalRuntimeEnvironment$ReventlessLocal.make,
+      groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+      extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+      asEventHandler: prim => prim,
+      asEffectHandler: prim => prim
+    })({
+      handleResolversEvent: CommandGeneratorResolvers_GraphQL$ReventlessLocal.handleResolversEvent,
+      make: CommandGeneratorResolvers_GraphQL$ReventlessLocal.make
+    })({
+      make: CommandTopicChannel.make
+    })(EventLogStorage_InMemory$ReventlessLocal.Make(Bus))(EventTopicPublisher)(EventCollectorChannel)(AggregateRuntimeBuilder)(HooksConfig);
+    return {
+      Spec: include.Spec,
+      AggregateRuntimeBuilder: include.AggregateRuntimeBuilder,
+      make: include.make,
+      outputs: include.outputs,
+      finish: include.finish,
+      operations: include.operations
+    };
+  }));
+  return {
+    RuntimeEnvironment: undefined,
+    CommandTopicChannel: CommandTopicChannel,
+    EventTopicPublisher: EventTopicPublisher,
+    EventCollectorChannel: EventCollectorChannel,
+    AggregateRuntimeBuilder: AggregateRuntimeBuilder,
+    Make: Make$1
+  };
+}
+
+export {
+  noHooks,
+  MakeWithHooks,
+  Make,
+}
+/* noHooks Not a pure module */