@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/QueryDb/QueryDb.res

@@ -0,0 +1,74 @@
+let componentType = ComponentType.QueryDb
+
+type outputs = ReventlessInfra.QueryDb.outputs
+type allOutputs = ReventlessInfra.QueryDb.allOutputs
+type resolversResourcesMaker = ReventlessInfra.QueryDb.resolversResourcesMaker
+
+type t
+
+type saveMode =
+  | Init
+  | Overwrite
+  | Any
+
+type load<'id, 'state> = 'id => promise<result<array<'state>, ReventlessInfra.QueryDb.storageError>>
+type loadStream<'id, 'state> = 'id => Stream.t<'state, ReventlessInfra.QueryDb.storageError, unit>
+type save<'id, 'state> = (
+  'id,
+  'state,
+  saveMode,
+  option<int>,
+) => promise<result<unit, ReventlessInfra.QueryDb.storageError>>
+type saveBatch<'id, 'state> = array<('id, 'state, option<int>)> => promise<
+  result<unit, ReventlessInfra.QueryDb.storageError>,
+>
+type count<'id> = ('id, string, int) => promise<result<int, ReventlessInfra.QueryDb.storageError>>
+type delete<'id> = (
+  'id,
+  option<(string, string)>,
+) => promise<result<unit, ReventlessInfra.QueryDb.storageError>>
+type deleteBatch<'id> = array<('id, option<(string, string)>)> => promise<
+  result<unit, ReventlessInfra.QueryDb.storageError>,
+>
+
+type operations<'id, 'state> = {
+  load: load<'id, 'state>,
+  loadStream: loadStream<'id, 'state>,
+  save: save<'id, 'state>,
+  saveBatch: saveBatch<'id, 'state>,
+  count: count<'id>,
+  delete: delete<'id>,
+  deleteBatch: deleteBatch<'id>,
+}
+
+module type T = {
+  module Spec: Reventless.ReadModel.Spec
+
+  type api
+  type role
+  type operations = operations<Spec.Id.t, Spec.state>
+  type component = Component.t<t, outputs, operations>
+
+  let make: (
+    ~api: api,
+    ~apiRole: role,
+    ~ttl: int=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}
+
+let allResolversMakers = allQueryDbs =>
+  allQueryDbs
+  ->Dict.valuesToArray
+  ->Array.map((queryDb: outputs) => queryDb.resolversMaker)
+
+let storageErrorToString: ReventlessInfra.QueryDb.storageError => string = err =>
+  switch err {
+  | NotSavedToStorage(s) => `NotSavedToStorage(${s})`
+  | NotLoadedFromStorage(s) => `NotLoadedFromStorage(${s})`
+  | NotCountedOnStorage(s) => `NotCountedOnStorage(${s})`
+  | NotDeletedFromStorage(s) => `NotDeletedFromStorage(${s})`
+  | BatchNotFullyWrittenToStorage(s) => `BatchNotFullyWrittenToStorage(${s})`
+  | StaleState => `StaleState`
+  | MissingSubIdConfig => `MissingSubIdConfig`
+  }

package/src/components/QueryDb/QueryDb.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function allResolversMakers(allQueryDbs) {
+  return Object.values(allQueryDbs).map(queryDb => queryDb.resolversMaker);
+}
+
+function storageErrorToString(err) {
+  if (typeof err !== "object") {
+    if (err === "StaleState") {
+      return `StaleState`;
+    } else {
+      return `MissingSubIdConfig`;
+    }
+  }
+  switch (err.TAG) {
+    case "NotSavedToStorage" :
+      return `NotSavedToStorage(` + err._0 + `)`;
+    case "NotLoadedFromStorage" :
+      return `NotLoadedFromStorage(` + err._0 + `)`;
+    case "NotCountedOnStorage" :
+      return `NotCountedOnStorage(` + err._0 + `)`;
+    case "NotDeletedFromStorage" :
+      return `NotDeletedFromStorage(` + err._0 + `)`;
+    case "BatchNotFullyWrittenToStorage" :
+      return `BatchNotFullyWrittenToStorage(` + err._0 + `)`;
+  }
+}
+
+let componentType = "QueryDb";
+
+export {
+  componentType,
+  allResolversMakers,
+  storageErrorToString,
+}
+/* No side effect */

package/src/components/QueryDb/QueryDb_Adapter.res

@@ -0,0 +1,78 @@
+open Reventless.ReadModel
+
+type operations = QueryDb.operations<string, JSON.t>
+
+type storage = {
+  resources: array<ReventlessInfra.Adapter.resource>,
+  dataSourceName: Pulumi.Output.t<string>, // TODO create in API
+  operations: Pulumi.Output.t<operations>,
+}
+type storageMaker<'api, 'role> = (
+  ~name: string,
+  ~indexes: array<indexConfig>,
+  ~subIdField: string=?,
+  ~ttl: int=?,
+  ~api: 'api,
+  ~apiRole: 'role,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => storage
+
+module type Storage = {
+  type api
+  type role
+
+  let make: storageMaker<api, role>
+}
+
+type queryEngineMaker = dict<QueryDb.outputs> => Pulumi.Output.t<
+  Reventless.QueryEngine.operations,
+>
+
+module type QueryEngineAdapter = {
+  let make: queryEngineMaker
+}
+
+type resolvers = {
+  resources: array<ReventlessInfra.Adapter.resource>,
+  resourcesMaker: QueryDb.resolversResourcesMaker,
+}
+type resolversMaker<'api, 'role> = (
+  ~name: string,
+  ~api: 'api,
+  ~apiRole: 'role,
+  ~dataSourceName: Pulumi.Output.t<string>,
+  ~indexes: array<indexConfig>,
+  ~subIdField: option<string>,
+  ~idResolverConfigs: array<idResolverConfig>,
+  ~idsResolverConfigs: array<idsResolverConfig>,
+  ~authorization: Reventless.Authorization.permission,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => resolvers
+
+module type Resolvers = {
+  type api
+  type role
+
+  let make: resolversMaker<api, role>
+}
+
+module NoResolvers = (Storage: Storage) => {
+  type api = Storage.api
+  type role = Storage.role
+
+  let make: resolversMaker<api, role> = (
+    ~name as _: string,
+    ~api as _: api,
+    ~apiRole as _: role,
+    ~dataSourceName as _,
+    ~indexes as _: array<indexConfig>,
+    ~subIdField as _,
+    ~idResolverConfigs as _: array<idResolverConfig>,
+    ~idsResolverConfigs as _: array<idsResolverConfig>,
+    ~authorization as _: Reventless.Authorization.permission,
+    ~opts as _,
+  ) => {
+    resources: [],
+    resourcesMaker: _ => [],
+  }
+}

package/src/components/QueryDb/QueryDb_Adapter.res.mjs

@@ -0,0 +1,17 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function NoResolvers(Storage) {
+  let make = (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) => ({
+    resources: [],
+    resourcesMaker: param => []
+  });
+  return {
+    make: make
+  };
+}
+
+export {
+  NoResolvers,
+}
+/* No side effect */

package/src/components/QueryDb/QueryDb_Builder.res

@@ -0,0 +1,76 @@
+module Make = (
+  Spec: Reventless.ReadModel.Spec,
+  Storage: QueryDb_Adapter.Storage,
+  Resolvers: QueryDb_Adapter.Resolvers with type api = Storage.api and type role = Storage.role,
+): (QueryDb.T with module Spec = Spec and type api = Storage.api and type role = Storage.role) => {
+  module Spec = Spec
+
+  type api = Storage.api
+  type role = Storage.role
+  type operations = QueryDb.operations<Spec.Id.t, Spec.state>
+  type component = Component.t<QueryDb.t, QueryDb.outputs, operations>
+
+  let construct = (self, name, ~api, ~apiRole, ~ttl=?) => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let subIdField = Spec.subIdConfig->Option.map(config => config.subIdField)
+
+    let storage = Storage.make(
+      ~name,
+      ~indexes=Spec.config.indexes,
+      ~subIdField?,
+      ~ttl?,
+      ~api,
+      ~apiRole,
+      ~opts,
+    )
+
+    self->Component.setOperations(
+      storage.operations->Pulumi.Output.apply(jsonOps => {
+        module Operations = QueryDb_Operations.Make(
+          Spec,
+          {
+            let jsonOps = jsonOps
+          },
+        )
+        {
+          QueryDb.load: Operations.load,
+          loadStream: Operations.loadStream,
+          save: Operations.save,
+          saveBatch: Operations.saveBatch,
+          count: Operations.count,
+          delete: Operations.delete,
+          deleteBatch: Operations.deleteBatch,
+        }
+      }),
+    )
+
+    let resolvers = Resolvers.make(
+      ~name,
+      ~api,
+      ~apiRole,
+      ~dataSourceName=storage.dataSourceName,
+      ~indexes=Spec.config.indexes,
+      ~subIdField,
+      ~idResolverConfigs=Spec.config.idResolvers,
+      ~idsResolverConfigs=Spec.config.idsResolvers,
+      ~authorization=Spec.authorization,
+      ~opts,
+    )
+
+    let outputs: QueryDb.outputs = {
+      resources: storage.resources->Array.concat(resolvers.resources),
+      resolversMaker: resolvers.resourcesMaker,
+      dataSourceName: storage.dataSourceName,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (~api: Storage.api, ~apiRole: Storage.role, ~ttl=?, ~opts=?): component =>
+    Component.make(
+      ~componentType=QueryDb.componentType->ComponentType.toString,
+      ~name=Spec.name,
+      ~construct=construct(~api, ~apiRole, ~ttl?, ...),
+      ~opts,
+    )
+}

package/src/components/QueryDb/QueryDb_Builder.res.mjs

@@ -0,0 +1,53 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as QueryDb$ReventlessCore from "./QueryDb.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as QueryDb_Operations$ReventlessCore from "./QueryDb_Operations.res.mjs";
+
+function Make(Spec) {
+  return Storage => (Resolvers => {
+    let make = (api, apiRole, ttl, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(QueryDb$ReventlessCore.componentType), Spec.name, (none, none$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(none);
+      let opts = {
+        parent: opts_parent
+      };
+      let subIdField = Stdlib_Option.map(Spec.subIdConfig, config => config.subIdField);
+      let storage = Storage.make(none$1, Spec.config.indexes, subIdField, ttl, api, apiRole, opts);
+      Component$ReventlessCore.setOperations(none, storage.operations.apply(jsonOps => {
+        let Operations = QueryDb_Operations$ReventlessCore.Make(Spec)({
+          jsonOps: jsonOps
+        });
+        return {
+          load: Operations.load,
+          loadStream: Operations.loadStream,
+          save: Operations.save,
+          saveBatch: Operations.saveBatch,
+          count: Operations.count,
+          delete: Operations.$$delete,
+          deleteBatch: Operations.deleteBatch
+        };
+      }));
+      let resolvers = Resolvers.make(none$1, api, apiRole, storage.dataSourceName, Spec.config.indexes, subIdField, Spec.config.idResolvers, Spec.config.idsResolvers, Spec.authorization, opts);
+      let outputs_resources = storage.resources.concat(resolvers.resources);
+      let outputs_resolversMaker = resolvers.resourcesMaker;
+      let outputs_dataSourceName = storage.dataSourceName;
+      let outputs = {
+        resources: outputs_resources,
+        resolversMaker: outputs_resolversMaker,
+        dataSourceName: outputs_dataSourceName
+      };
+      return Component$ReventlessCore.setOutputs(none, outputs);
+    }, opts);
+    return {
+      Spec: Spec,
+      make: make
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/QueryDb/QueryDb_Callback.res

@@ -0,0 +1,18 @@
+type interceptResult = Allow | Deny(string)
+
+type queryInterceptor = (
+  ~identity: Reventless.Identity.t,
+  ~readModelName: string,
+  ~args: JSON.t,
+) => promise<interceptResult>
+
+/** Module-level interceptor hook. None = passthrough (default). */
+let queryInterceptorHook: ref<option<queryInterceptor>> = ref(None)
+
+let registerQueryInterceptor = (interceptor: queryInterceptor) => {
+  queryInterceptorHook.contents = Some(interceptor)
+}
+
+let clearQueryInterceptor = () => {
+  queryInterceptorHook.contents = None
+}

package/src/components/QueryDb/QueryDb_Callback.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let queryInterceptorHook = {
+  contents: undefined
+};
+
+function registerQueryInterceptor(interceptor) {
+  queryInterceptorHook.contents = interceptor;
+}
+
+function clearQueryInterceptor() {
+  queryInterceptorHook.contents = undefined;
+}
+
+export {
+  queryInterceptorHook,
+  registerQueryInterceptor,
+  clearQueryInterceptor,
+}
+/* No side effect */

package/src/components/QueryDb/QueryDb_Operations.res

@@ -0,0 +1,116 @@
+module type Ops = {
+  let jsonOps: QueryDb.operations<string, JSON.t>
+}
+
+module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
+  // Returns result<state, storageError> — decode errors are surfaced rather than silently dropped.
+  let decode = (id, stateJson) =>
+    switch stateJson->Message.decode(ReadModelSpec.stateSchema) {
+    | state => Ok(state)
+    | exception err =>
+      let errStr = err->JSON.stringifyAny->Option.getOr("unknown error")
+      Error(
+        ReventlessInfra.QueryDb.NotLoadedFromStorage(
+          `QueryDb: Error: Couldn't decode state for ${id->ReadModelSpec.Id.toString}: ${errStr}`,
+        ),
+      )
+    }
+
+  let loadStream = id =>
+    Ops.jsonOps.loadStream(id->ReadModelSpec.Id.toString)
+    ->Stream.mapEffect(json =>
+      switch decode(id, json) {
+      | Ok(s) => Effect.succeed(s)
+      | Error(e) => Effect.fail(e)
+      }
+    )
+
+  let load = async id =>
+    switch await Ops.jsonOps.load(id->ReadModelSpec.Id.toString) {
+    | result =>
+      result->Result.flatMap(states =>
+        states->Array.reduce(Ok([]), (acc, state) =>
+          acc->Result.flatMap(arr =>
+            decode(id, state)->Result.map(s => arr->Array.concat([s]))
+          )
+        )
+      )
+    }
+
+  let injectSubId = (dict, state) =>
+    switch ReadModelSpec.subIdConfig {
+    | Some({subIdField, getSubId}) =>
+      dict->Dict.set(subIdField, JSON.Encode.string(getSubId(state)))
+    | None => ()
+    }
+
+  let injectCompositeIndexAttrs = dict => {
+    let getStr = field =>
+      dict->Dict.get(field)->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+    ReadModelSpec.config.indexes->Array.forEach(idx => {
+      switch idx.pkFields {
+      | Some(fs) when fs->Array.length > 1 =>
+        let sep = idx.pkSep->Option.getOr("/")
+        let value = fs->Array.map(getStr)->Array.join(sep)
+        let attrName = idx.idField->Option.getOr("_pk")
+        dict->Dict.set(attrName, JSON.Encode.string(value))
+      | _ => ()
+      }
+      switch idx.skFields {
+      | Some(fs) when fs->Array.length > 1 =>
+        let sep = idx.skSep->Option.getOr("/")
+        let value = fs->Array.map(getStr)->Array.join(sep)
+        let attrName = idx.subIdField->Option.getOr("_sk")
+        dict->Dict.set(attrName, JSON.Encode.string(value))
+      | _ => ()
+      }
+    })
+  }
+
+  let save = async (id, state, saveMode, ttl) =>
+    switch state->Message.encode(ReadModelSpec.stateSchema)->JSON.Decode.object {
+    | Some(dict) =>
+      dict->Dict.set("id", id->Message.encode(ReadModelSpec.Id.schema))
+      injectSubId(dict, state)
+      injectCompositeIndexAttrs(dict)
+      let json = JSON.Encode.object(dict)
+      await Ops.jsonOps.save(id->ReadModelSpec.Id.toString, json, saveMode, ttl)
+    | None =>
+      Error(ReventlessInfra.QueryDb.NotSavedToStorage("Couldn't encode state as JSON object"))
+    }
+
+  let saveBatch = async states => {
+    let batchResult = states->Array.reduce(Ok([]), (acc, (id, state, ttl)) =>
+      acc->Result.flatMap(batch =>
+        switch state->Message.encode(ReadModelSpec.stateSchema)->JSON.Decode.object {
+        | Some(dict) =>
+          dict->Dict.set("id", id->Message.encode(ReadModelSpec.Id.schema))
+          injectSubId(dict, state)
+          injectCompositeIndexAttrs(dict)
+          let json = JSON.Encode.object(dict)
+          Ok(batch->Array.concat([(id->ReadModelSpec.Id.toString, json, ttl)]))
+        | None =>
+          Error(
+            ReventlessInfra.QueryDb.NotSavedToStorage(
+              `Couldn't encode state for ${id->ReadModelSpec.Id.toString}`,
+            ),
+          )
+        }
+      )
+    )
+    switch batchResult {
+    | Ok(batch) => await Ops.jsonOps.saveBatch(batch)
+    | Error(e) => Error(e)
+    }
+  }
+
+  let count = async (id, fieldName, inc) =>
+    await Ops.jsonOps.count(id->ReadModelSpec.Id.toString, fieldName, inc)
+
+  let delete = async (id, subId) => await Ops.jsonOps.delete(id->ReadModelSpec.Id.toString, subId)
+
+  let deleteBatch = async ids => {
+    let ids = ids->Array.map(((id, sort)) => (id->ReadModelSpec.Id.toString, sort))
+    await Ops.jsonOps.deleteBatch(ids)
+  }
+}

package/src/components/QueryDb/QueryDb_Operations.res.mjs

@@ -0,0 +1,165 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+
+function Make(ReadModelSpec) {
+  return Ops => {
+    let decode = (id, stateJson) => {
+      let state;
+      try {
+        state = Message$ReventlessCore.decode(stateJson, ReadModelSpec.stateSchema);
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        let errStr = Stdlib_Option.getOr(JSON.stringify(err), "unknown error");
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "NotLoadedFromStorage",
+            _0: `QueryDb: Error: Couldn't decode state for ` + ReadModelSpec.Id.toString(id) + `: ` + errStr
+          }
+        };
+      }
+      return {
+        TAG: "Ok",
+        _0: state
+      };
+    };
+    let loadStream = id => Stream.mapEffect(Ops.jsonOps.loadStream(ReadModelSpec.Id.toString(id)), json => {
+      let s = decode(id, json);
+      if (s.TAG === "Ok") {
+        return Effect.succeed(s._0);
+      } else {
+        return Effect.fail(s._0);
+      }
+    });
+    let load = async id => {
+      let result = await Ops.jsonOps.load(ReadModelSpec.Id.toString(id));
+      return Stdlib_Result.flatMap(result, states => Stdlib_Array.reduce(states, {
+        TAG: "Ok",
+        _0: []
+      }, (acc, state) => Stdlib_Result.flatMap(acc, arr => Stdlib_Result.map(decode(id, state), s => arr.concat([s])))));
+    };
+    let injectSubId = (dict, state) => {
+      let match = ReadModelSpec.subIdConfig;
+      if (match !== undefined) {
+        dict[match.subIdField] = match.getSubId(state);
+        return;
+      }
+    };
+    let injectCompositeIndexAttrs = dict => {
+      let getStr = field => Stdlib_Option.getOr(Stdlib_Option.flatMap(dict[field], Stdlib_JSON.Decode.string), "");
+      ReadModelSpec.config.indexes.forEach(idx => {
+        let fs = idx.pkFields;
+        if (fs !== undefined && fs.length > 1) {
+          let sep = Stdlib_Option.getOr(idx.pkSep, "/");
+          let value = fs.map(getStr).join(sep);
+          let attrName = Stdlib_Option.getOr(idx.idField, "_pk");
+          dict[attrName] = value;
+        }
+        let fs$1 = idx.skFields;
+        if (fs$1 === undefined) {
+          return;
+        }
+        if (fs$1.length <= 1) {
+          return;
+        }
+        let sep$1 = Stdlib_Option.getOr(idx.skSep, "/");
+        let value$1 = fs$1.map(getStr).join(sep$1);
+        let attrName$1 = Stdlib_Option.getOr(idx.subIdField, "_sk");
+        dict[attrName$1] = value$1;
+      });
+    };
+    let save = async (id, state, saveMode, ttl) => {
+      let dict = Stdlib_JSON.Decode.object(Message$ReventlessCore.encode(state, ReadModelSpec.stateSchema));
+      if (dict !== undefined) {
+        dict["id"] = Message$ReventlessCore.encode(id, ReadModelSpec.Id.schema);
+        injectSubId(dict, state);
+        injectCompositeIndexAttrs(dict);
+        return await Ops.jsonOps.save(ReadModelSpec.Id.toString(id), dict, saveMode, ttl);
+      } else {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "NotSavedToStorage",
+            _0: "Couldn't encode state as JSON object"
+          }
+        };
+      }
+    };
+    let saveBatch = async states => {
+      let batchResult = Stdlib_Array.reduce(states, {
+        TAG: "Ok",
+        _0: []
+      }, (acc, param) => {
+        let ttl = param[2];
+        let state = param[1];
+        let id = param[0];
+        return Stdlib_Result.flatMap(acc, batch => {
+          let dict = Stdlib_JSON.Decode.object(Message$ReventlessCore.encode(state, ReadModelSpec.stateSchema));
+          if (dict !== undefined) {
+            dict["id"] = Message$ReventlessCore.encode(id, ReadModelSpec.Id.schema);
+            injectSubId(dict, state);
+            injectCompositeIndexAttrs(dict);
+            return {
+              TAG: "Ok",
+              _0: batch.concat([[
+                  ReadModelSpec.Id.toString(id),
+                  dict,
+                  ttl
+                ]])
+            };
+          } else {
+            return {
+              TAG: "Error",
+              _0: {
+                TAG: "NotSavedToStorage",
+                _0: `Couldn't encode state for ` + ReadModelSpec.Id.toString(id)
+              }
+            };
+          }
+        });
+      });
+      if (batchResult.TAG === "Ok") {
+        return await Ops.jsonOps.saveBatch(batchResult._0);
+      } else {
+        return {
+          TAG: "Error",
+          _0: batchResult._0
+        };
+      }
+    };
+    let count = async (id, fieldName, inc) => await Ops.jsonOps.count(ReadModelSpec.Id.toString(id), fieldName, inc);
+    let $$delete = async (id, subId) => await Ops.jsonOps.delete(ReadModelSpec.Id.toString(id), subId);
+    let deleteBatch = async ids => {
+      let ids$1 = ids.map(param => [
+        ReadModelSpec.Id.toString(param[0]),
+        param[1]
+      ]);
+      return await Ops.jsonOps.deleteBatch(ids$1);
+    };
+    return {
+      decode: decode,
+      loadStream: loadStream,
+      load: load,
+      injectSubId: injectSubId,
+      injectCompositeIndexAttrs: injectCompositeIndexAttrs,
+      save: save,
+      saveBatch: saveBatch,
+      count: count,
+      $$delete: $$delete,
+      deleteBatch: deleteBatch
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */