@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res

@@ -0,0 +1,242 @@
+// In-memory QueryDb storage.
+// Make(Bus) functor: registers ops and scan function in the Bus so that
+// QueryDbResolvers_GraphQL and LocalQueryEngine can look up data by read model name.
+//
+// Storage model: dict<dict<JSON.t>> — partition key → sub-key → item.
+// When no subIdField is configured, all items are stored under the implicit sub-key "".
+//
+// When BackendState is set to Sqlite, the `Make(Bus)` functor delegates to
+// QueryDbStorage_Sqlite at `make` time so the same builder wiring serves
+// both backends.
+
+// Extract sub-key from an item's JSON using the given field name.
+// Returns "" if the field is absent, not an object, or not a string.
+let getSubKey = (item: JSON.t, subIdField: option<string>): string =>
+  switch subIdField {
+  | None => ""
+  | Some(field) =>
+    switch item->JSON.Decode.object {
+    | Some(obj) =>
+      switch obj->Dict.get(field) {
+      | Some(v) => v->JSON.Decode.string->Option.getOr("")
+      | None => ""
+      }
+    | None => ""
+    }
+  }
+
+// Return items for a partition key, sorted alphabetically by sub-key.
+let sortedItems = (store: dict<dict<JSON.t>>, partitionKey: string): array<JSON.t> =>
+  switch store->Dict.get(partitionKey) {
+  | None => []
+  | Some(subMap) =>
+    subMap
+    ->Dict.toArray
+    ->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+    ->Array.map(((_, v)) => v)
+  }
+
+// Flatten partition → subKey → item store to a flat array.
+// Injects "id" attribute if not already present on each item.
+let flattenStore = (store: dict<dict<JSON.t>>): array<JSON.t> =>
+  store
+  ->Dict.toArray
+  ->Array.flatMap(((id, subMap)) =>
+    subMap
+    ->Dict.toArray
+    ->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+    ->Array.map(((_, item)) => {
+      let obj = item->JSON.Decode.object->Option.getOr(Dict.make())
+      if !(obj->Dict.get("id")->Option.isSome) {
+        let copy = Dict.make()
+        obj->Dict.toArray->Array.forEach(((k, v)) => copy->Dict.set(k, v))
+        copy->Dict.set("id", JSON.Encode.string(id))
+        JSON.Encode.object(copy)
+      } else {
+        item
+      }
+    })
+  )
+
+module Make = (Bus: LocalBus.T) => {
+  open ReventlessCore
+
+  type api = unit
+  type role = unit
+
+  let sqliteBusCallbacks: QueryDbStorage_Sqlite.busCallbacks = {
+    publishStateChange: Bus.publishStateChange,
+    registerQueryDb: Bus.registerQueryDb,
+    registerQueryDbScan: Bus.registerQueryDbScan,
+    registerQueryDbStream: Bus.registerQueryDbStream,
+  }
+
+  let makeMemory: QueryDb_Adapter.storageMaker<unit, unit> = (
+    ~name,
+    ~indexes as _,
+    ~subIdField=?,
+    ~ttl as _=?,
+    ~api as _,
+    ~apiRole as _,
+    ~opts as _,
+  ) => {
+    let store: ref<dict<dict<JSON.t>>> = ref(Dict.make())
+    let allItems: ref<array<JSON.t>> = ref([])
+
+    let syncAll = () => {
+      allItems.contents = flattenStore(store.contents)
+    }
+
+    let getOrCreateSubMap = (partitionKey: string): dict<JSON.t> =>
+      switch store.contents->Dict.get(partitionKey) {
+      | Some(m) => m
+      | None =>
+        let m = Dict.make()
+        store.contents->Dict.set(partitionKey, m)
+        m
+      }
+
+    let load: QueryDb.load<string, JSON.t> = async id =>
+      Ok(sortedItems(store.contents, id))
+
+    let loadStream: QueryDb.loadStream<string, JSON.t> = id =>
+      sortedItems(store.contents, id)->Stream.fromIterable
+
+    // Entity key matches the AWS StateTopic Lambda output (Phase 1):
+    // single-key tables → partition value; composite tables → `pk-sk`.
+    let entityKeyFor = (id: string, subKey: string): string =>
+      switch subIdField {
+      | Some(_) => id ++ "-" ++ subKey
+      | None => id
+      }
+
+    let publishUpdated = (id: string, state: JSON.t) => {
+      let subKey = getSubKey(state, subIdField)
+      let descriptor = LocalBus.makeStateChangeDescriptor(
+        ~changeKind="Updated",
+        ~id=entityKeyFor(id, subKey),
+        ~state=Some(state),
+      )
+      Bus.publishStateChange(~name, ~descriptor)
+    }
+
+    let publishRemoved = (id: string, subKey: string) => {
+      let descriptor = LocalBus.makeStateChangeDescriptor(
+        ~changeKind="Removed",
+        ~id=entityKeyFor(id, subKey),
+        ~state=None,
+      )
+      Bus.publishStateChange(~name, ~descriptor)
+    }
+
+    let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, _ttl) => {
+      let subKey = getSubKey(state, subIdField)
+      let subMap = getOrCreateSubMap(id)
+      subMap->Dict.set(subKey, state)
+      syncAll()
+      publishUpdated(id, state)
+      Ok()
+    }
+
+    let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
+      batch->Array.forEach(((id, state, _ttl)) => {
+        let subKey = getSubKey(state, subIdField)
+        let subMap = getOrCreateSubMap(id)
+        subMap->Dict.set(subKey, state)
+      })
+      syncAll()
+      // Notify subscribers for each saved item
+      batch->Array.forEach(((id, state, _)) => publishUpdated(id, state))
+      Ok()
+    }
+
+    let count: QueryDb.count<string> = async (_id, _fieldName, inc) => Ok(inc)
+
+    let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
+      switch subIdOpt {
+      | None =>
+        let subKeys = switch store.contents->Dict.get(id) {
+        | Some(subMap) => subMap->Dict.keysToArray
+        | None => []
+        }
+        store.contents->Dict.delete(id)
+        syncAll()
+        subKeys->Array.forEach(subKey => publishRemoved(id, subKey))
+      | Some((_, subValue)) =>
+        switch store.contents->Dict.get(id) {
+        | Some(subMap) =>
+          let hadIt = subMap->Dict.get(subValue)->Option.isSome
+          subMap->Dict.delete(subValue)
+          syncAll()
+          if hadIt {
+            publishRemoved(id, subValue)
+          }
+        | None => syncAll()
+        }
+      }
+      Ok()
+    }
+
+    let deleteBatch: QueryDb.deleteBatch<string> = async ids => {
+      let removed: array<(string, string)> = []
+      ids->Array.forEach(((id, subIdOpt)) => {
+        switch subIdOpt {
+        | None =>
+          switch store.contents->Dict.get(id) {
+          | Some(subMap) =>
+            subMap->Dict.keysToArray->Array.forEach(sk => removed->Array.push((id, sk)))
+          | None => ()
+          }
+          store.contents->Dict.delete(id)
+        | Some((_, subValue)) =>
+          switch store.contents->Dict.get(id) {
+          | Some(subMap) =>
+            if subMap->Dict.get(subValue)->Option.isSome {
+              removed->Array.push((id, subValue))
+            }
+            subMap->Dict.delete(subValue)
+          | None => ()
+          }
+        }
+      })
+      syncAll()
+      removed->Array.forEach(((id, subKey)) => publishRemoved(id, subKey))
+      Ok()
+    }
+
+    let ops: QueryDb_Adapter.operations = {
+      load,
+      loadStream,
+      save,
+      saveBatch,
+      count,
+      delete,
+      deleteBatch,
+    }
+
+    Bus.registerQueryDb(name, ops)
+    Bus.registerQueryDbScan(name, () => allItems.contents)
+    Bus.registerQueryDbStream(name, () => allItems.contents->Stream.fromIterable)
+
+    {
+      resources: [],
+      dataSourceName: ""->Pulumi.Output.make,
+      operations: Pulumi.Output.make(ops),
+    }
+  }
+
+  let make: QueryDb_Adapter.storageMaker<unit, unit> = (
+    ~name,
+    ~indexes,
+    ~subIdField=?,
+    ~ttl=?,
+    ~api,
+    ~apiRole,
+    ~opts,
+  ) =>
+    switch BackendState.getDb() {
+    | Some(db) =>
+      QueryDbStorage_Sqlite.makeStorage(~db, ~bus=sqliteBusCallbacks, ~name, ~indexes, ~subIdField)
+    | None => makeMemory(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)
+    }
+}

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs

@@ -0,0 +1,241 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stream from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as LocalBus$ReventlessLocal from "../LocalBus.res.mjs";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as QueryDbStorage_Sqlite$ReventlessLocal from "./QueryDbStorage_Sqlite.res.mjs";
+
+function getSubKey(item, subIdField) {
+  if (subIdField === undefined) {
+    return "";
+  }
+  let obj = Stdlib_JSON.Decode.object(item);
+  if (obj === undefined) {
+    return "";
+  }
+  let v = obj[subIdField];
+  if (v !== undefined) {
+    return Stdlib_Option.getOr(Stdlib_JSON.Decode.string(v), "");
+  } else {
+    return "";
+  }
+}
+
+function sortedItems(store, partitionKey) {
+  let subMap = store[partitionKey];
+  if (subMap !== undefined) {
+    return Object.entries(subMap).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => param[1]);
+  } else {
+    return [];
+  }
+}
+
+function flattenStore(store) {
+  return Object.entries(store).flatMap(param => {
+    let id = param[0];
+    return Object.entries(param[1]).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => {
+      let item = param[1];
+      let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(item), {});
+      if (Stdlib_Option.isSome(obj["id"])) {
+        return item;
+      }
+      let copy = {};
+      Object.entries(obj).forEach(param => {
+        copy[param[0]] = param[1];
+      });
+      copy["id"] = id;
+      return copy;
+    });
+  });
+}
+
+function Make(Bus) {
+  let sqliteBusCallbacks_publishStateChange = Bus.publishStateChange;
+  let sqliteBusCallbacks_registerQueryDb = Bus.registerQueryDb;
+  let sqliteBusCallbacks_registerQueryDbScan = Bus.registerQueryDbScan;
+  let sqliteBusCallbacks_registerQueryDbStream = Bus.registerQueryDbStream;
+  let sqliteBusCallbacks = {
+    publishStateChange: sqliteBusCallbacks_publishStateChange,
+    registerQueryDb: sqliteBusCallbacks_registerQueryDb,
+    registerQueryDbScan: sqliteBusCallbacks_registerQueryDbScan,
+    registerQueryDbStream: sqliteBusCallbacks_registerQueryDbStream
+  };
+  let makeMemory = (name, param, subIdField, param$1, param$2, param$3, param$4) => {
+    let store = {
+      contents: {}
+    };
+    let allItems = {
+      contents: []
+    };
+    let syncAll = () => {
+      allItems.contents = flattenStore(store.contents);
+    };
+    let getOrCreateSubMap = partitionKey => {
+      let m = store.contents[partitionKey];
+      if (m !== undefined) {
+        return m;
+      }
+      let m$1 = {};
+      store.contents[partitionKey] = m$1;
+      return m$1;
+    };
+    let load = async id => ({
+      TAG: "Ok",
+      _0: sortedItems(store.contents, id)
+    });
+    let loadStream = id => Stream.fromIterable(sortedItems(store.contents, id));
+    let entityKeyFor = (id, subKey) => {
+      if (subIdField !== undefined) {
+        return id + "-" + subKey;
+      } else {
+        return id;
+      }
+    };
+    let publishUpdated = (id, state) => {
+      let subKey = getSubKey(state, subIdField);
+      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", entityKeyFor(id, subKey), state);
+      Bus.publishStateChange(name, descriptor);
+    };
+    let publishRemoved = (id, subKey) => {
+      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
+      Bus.publishStateChange(name, descriptor);
+    };
+    let save = async (id, state, _saveMode, _ttl) => {
+      let subKey = getSubKey(state, subIdField);
+      let subMap = getOrCreateSubMap(id);
+      subMap[subKey] = state;
+      syncAll();
+      publishUpdated(id, state);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    };
+    let saveBatch = async batch => {
+      batch.forEach(param => {
+        let state = param[1];
+        let subKey = getSubKey(state, subIdField);
+        let subMap = getOrCreateSubMap(param[0]);
+        subMap[subKey] = state;
+      });
+      syncAll();
+      batch.forEach(param => publishUpdated(param[0], param[1]));
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    };
+    let count = async (_id, _fieldName, inc) => ({
+      TAG: "Ok",
+      _0: inc
+    });
+    let $$delete = async (id, subIdOpt) => {
+      if (subIdOpt !== undefined) {
+        let subValue = subIdOpt[1];
+        let subMap = store.contents[id];
+        if (subMap !== undefined) {
+          let hadIt = Stdlib_Option.isSome(subMap[subValue]);
+          Stdlib_Dict.$$delete(subMap, subValue);
+          syncAll();
+          if (hadIt) {
+            publishRemoved(id, subValue);
+          }
+        } else {
+          syncAll();
+        }
+      } else {
+        let subMap$1 = store.contents[id];
+        let subKeys = subMap$1 !== undefined ? Object.keys(subMap$1) : [];
+        Stdlib_Dict.$$delete(store.contents, id);
+        syncAll();
+        subKeys.forEach(subKey => publishRemoved(id, subKey));
+      }
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    };
+    let deleteBatch = async ids => {
+      let removed = [];
+      ids.forEach(param => {
+        let subIdOpt = param[1];
+        let id = param[0];
+        if (subIdOpt !== undefined) {
+          let subValue = subIdOpt[1];
+          let subMap = store.contents[id];
+          if (subMap !== undefined) {
+            if (Stdlib_Option.isSome(subMap[subValue])) {
+              removed.push([
+                id,
+                subValue
+              ]);
+            }
+            return Stdlib_Dict.$$delete(subMap, subValue);
+          } else {
+            return;
+          }
+        }
+        let subMap$1 = store.contents[id];
+        if (subMap$1 !== undefined) {
+          Object.keys(subMap$1).forEach(sk => {
+            removed.push([
+              id,
+              sk
+            ]);
+          });
+        }
+        Stdlib_Dict.$$delete(store.contents, id);
+      });
+      syncAll();
+      removed.forEach(param => publishRemoved(param[0], param[1]));
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    };
+    let ops = {
+      load: load,
+      loadStream: loadStream,
+      save: save,
+      saveBatch: saveBatch,
+      count: count,
+      delete: $$delete,
+      deleteBatch: deleteBatch
+    };
+    Bus.registerQueryDb(name, ops);
+    Bus.registerQueryDbScan(name, () => allItems.contents);
+    Bus.registerQueryDbStream(name, () => Stream.fromIterable(allItems.contents));
+    return {
+      resources: [],
+      dataSourceName: Pulumi.output(""),
+      operations: Pulumi.output(ops)
+    };
+  };
+  let make = (name, indexes, subIdField, ttl, api, apiRole, opts) => {
+    let db = BackendState$ReventlessLocal.getDb();
+    if (db !== undefined) {
+      return QueryDbStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), sqliteBusCallbacks, name, indexes, subIdField);
+    } else {
+      return makeMemory(name, indexes, subIdField, ttl, api, apiRole, opts);
+    }
+  };
+  return {
+    sqliteBusCallbacks: sqliteBusCallbacks,
+    makeMemory: makeMemory,
+    make: make
+  };
+}
+
+export {
+  getSubKey,
+  sortedItems,
+  flattenStore,
+  Make,
+}
+/* effect/Stream Not a pure module */