@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/components/Api/AppSync_Adapter.res.mjs

@@ -0,0 +1,396 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Nodecrypto from "node:crypto";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as ClientAppsync from "@aws-sdk/client-appsync";
+import * as Auth_Cognito$ReventlessAws from "../../adapter/Auth/Auth_Cognito.res.mjs";
+import * as AppSync_Error$ReventlessAws from "../../errors/AppSync_Error.res.mjs";
+import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function sha256Hex(input) {
+  return Nodecrypto.createHash("sha256").update(input).digest("hex");
+}
+
+function startSchemaCreation(client, input) {
+  return client.send(new ClientAppsync.StartSchemaCreationCommand(input));
+}
+
+function startSchemaCreationRetrying(client, input) {
+  return Effect$1.runPromise(Effect$1.retry(Effect.tryPromise(AppSync_Error$ReventlessAws.classify, () => client.send(new ClientAppsync.StartSchemaCreationCommand(input)).then(param => Promise.resolve())), AppSync_Error$ReventlessAws.retrySchedule));
+}
+
+async function waitForSchemaActive(client, apiId, maxAttemptsOpt, attemptOpt) {
+  let maxAttempts = maxAttemptsOpt !== undefined ? maxAttemptsOpt : 30;
+  let attempt = attemptOpt !== undefined ? attemptOpt : 0;
+  let result = await client.send(new ClientAppsync.GetSchemaCreationStatusCommand({
+    apiId: apiId
+  }));
+  let status = result.status;
+  switch (status) {
+    case "FAILED" :
+      let details = Stdlib_Option.getOr(result.details, "(no details)");
+      return Stdlib_JsError.throwWithMessage(`Schema creation failed for API ` + apiId + `: ` + details);
+    case "ACTIVE" :
+    case "SUCCESS" :
+      return;
+    default:
+      if (attempt >= maxAttempts) {
+        return Stdlib_JsError.throwWithMessage(`Schema creation timed out after ` + maxAttempts.toString() + ` attempts (status: ` + status + `)`);
+      } else {
+        await new Promise((resolve, param) => {
+          setTimeout(resolve, 500);
+        });
+        return await waitForSchemaActive(client, apiId, maxAttempts, attempt + 1 | 0);
+      }
+  }
+}
+
+async function getIntrospectionSdl(client, apiId) {
+  try {
+    let resp = await client.send(new ClientAppsync.GetIntrospectionSchemaCommand({
+      apiId: apiId,
+      format: "SDL"
+    }));
+    let blob = resp.schema;
+    if (blob !== undefined) {
+      return Buffer.from(Primitive_option.valFromOption(blob)).toString("utf-8");
+    } else {
+      return "";
+    }
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+    log.warn("AppSync_Adapter", undefined, `getIntrospectionSdl failed for ` + apiId + `: ` + msg);
+    return "";
+  }
+}
+
+function deploySchemaWithRetry(client, apiId, definition) {
+  return Effect$1.retry(Effect.tryPromise(AppSync_Error$ReventlessAws.classify, () => client.send(new ClientAppsync.StartSchemaCreationCommand({
+    apiId: apiId,
+    definition: definition
+  })).then(param => Promise.resolve())), AppSync_Error$ReventlessAws.retrySchedule);
+}
+
+function schemaLockSleep(ms) {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+let _schemaLockCounter = {
+  contents: 0
+};
+
+async function withSchemaPushLock(tableName, apiId, leaseMsOpt, maxWaitMsOpt, fn) {
+  let leaseMs = leaseMsOpt !== undefined ? leaseMsOpt : 120000;
+  let maxWaitMs = maxWaitMsOpt !== undefined ? maxWaitMsOpt : 180000;
+  let lockId = `schema-push-lock:` + apiId;
+  _schemaLockCounter.contents = _schemaLockCounter.contents + 1 | 0;
+  let holder = apiId + `#` + Date.now().toString() + `#` + _schemaLockCounter.contents.toString();
+  let acquire = async () => {
+    let deadline = Date.now() + maxWaitMs;
+    let acquired = false;
+    while (!acquired) {
+      let now = Date.now();
+      let ok = await Stdlib_Promise.$$catch(DynamoDb_DocumentClient$AwsSdk.PutCommand.send(new LibDynamodb.PutCommand({
+        Item: Object.fromEntries([
+          [
+            "id",
+            lockId
+          ],
+          [
+            "holder",
+            holder
+          ],
+          [
+            "expiresAt",
+            now + leaseMs
+          ]
+        ]),
+        TableName: tableName,
+        ConditionExpression: "attribute_not_exists(id) OR expiresAt < :now",
+        ExpressionAttributeValues: Object.fromEntries([[
+            ":now",
+            now
+          ]])
+      })).then(param => true), param => Promise.resolve(false));
+      if (ok) {
+        acquired = true;
+      } else if (Date.now() > deadline) {
+        log.warn("AppSync_Adapter", undefined, `schema-push lock for ` + apiId + ` not acquired within ` + maxWaitMs.toString() + `ms — proceeding best-effort`);
+        acquired = true;
+      } else {
+        await schemaLockSleep(1000);
+      }
+    };
+  };
+  let release = async () => {
+    await Stdlib_Promise.$$catch(DynamoDb_DocumentClient$AwsSdk.DeleteCommand.send(new LibDynamodb.DeleteCommand({
+      TableName: tableName,
+      Key: Object.fromEntries([[
+          "id",
+          lockId
+        ]]),
+      ConditionExpression: "holder = :holder",
+      ExpressionAttributeValues: Object.fromEntries([[
+          ":holder",
+          holder
+        ]])
+    })).then(param => {}), param => Promise.resolve());
+  };
+  await acquire();
+  try {
+    let r = await fn();
+    await release();
+    return r;
+  } catch (exn) {
+    await release();
+    throw exn;
+  }
+}
+
+let _client = {
+  contents: undefined
+};
+
+function getClient() {
+  let c = _client.contents;
+  if (c !== undefined) {
+    return Primitive_option.valFromOption(c);
+  }
+  let c$1 = new ClientAppsync.AppSyncClient();
+  _client.contents = Primitive_option.some(c$1);
+  return c$1;
+}
+
+function _permissionToCognitoGroups(permission) {
+  if (typeof permission !== "object") {
+    switch (permission) {
+      case "AllowAuthenticated" :
+      case "AllowAnonymous" :
+        return;
+      case "DenyAll" :
+        return ["__deny_all__"];
+    }
+  } else {
+    let groups = permission._0;
+    if (groups.length !== 0) {
+      return groups;
+    } else {
+      return ["__deny_all__"];
+    }
+  }
+}
+
+function _formatGroupsDirective(groups) {
+  let quoted = groups.map(g => `"` + g + `"`).join(", ");
+  return `@aws_auth(cognito_groups: [` + quoted + `])`;
+}
+
+function injectAwsAuth(fragment, mutationEntries, queryEntries) {
+  let parts = GraphQL_Stitcher$ReventlessCore.decode(fragment);
+  let mutationAuthMap = {};
+  mutationEntries.forEach(entry => {
+    let match = entry.authorization;
+    if (match !== undefined) {
+      let group = match.group;
+      entry.fieldNames.forEach(fieldName => {
+        mutationAuthMap[fieldName] = [group];
+      });
+    }
+    let fp = entry.fieldPermissions;
+    if (fp !== undefined) {
+      Object.entries(fp).forEach(param => {
+        let fieldName = param[0];
+        let groups = _permissionToCognitoGroups(param[1]);
+        if (groups !== undefined) {
+          mutationAuthMap[fieldName] = groups;
+          return;
+        } else {
+          return Stdlib_Dict.$$delete(mutationAuthMap, fieldName);
+        }
+      });
+      return;
+    }
+  });
+  let queryAuthMap = {};
+  queryEntries.forEach(entry => {
+    let match = entry.authorization;
+    if (match !== undefined) {
+      let group = match.group;
+      queryAuthMap[entry.singleFieldName] = [group];
+      queryAuthMap[entry.listFieldName] = [group];
+    }
+    let permission = entry.permission;
+    if (permission === undefined) {
+      return;
+    }
+    let groups = _permissionToCognitoGroups(permission);
+    if (groups !== undefined) {
+      queryAuthMap[entry.singleFieldName] = groups;
+      queryAuthMap[entry.listFieldName] = groups;
+      return;
+    } else {
+      Stdlib_Dict.$$delete(queryAuthMap, entry.singleFieldName);
+      return Stdlib_Dict.$$delete(queryAuthMap, entry.listFieldName);
+    }
+  });
+  let augmentedMutations = parts.mutations.map(field => {
+    let fieldName = GraphQL_Stitcher$ReventlessCore.extractLeadingName(field);
+    let groups = mutationAuthMap[fieldName];
+    if (groups !== undefined) {
+      return field + `\n    ` + _formatGroupsDirective(groups);
+    } else {
+      return field;
+    }
+  });
+  let augmentedQueries = parts.queries.map(field => {
+    let fieldName = GraphQL_Stitcher$ReventlessCore.extractLeadingName(field);
+    let groups = queryAuthMap[fieldName];
+    if (groups !== undefined) {
+      return field + ` ` + _formatGroupsDirective(groups);
+    } else {
+      return field;
+    }
+  });
+  let encoded = JSON.stringify(Object.fromEntries([
+    [
+      "types",
+      parts.types.map(prim => prim)
+    ],
+    [
+      "mutations",
+      augmentedMutations.map(prim => prim)
+    ],
+    [
+      "queries",
+      augmentedQueries.map(prim => prim)
+    ],
+    [
+      "subscriptions",
+      parts.subscriptions.map(prim => prim)
+    ]
+  ]));
+  return {
+    encoded: encoded,
+    protocol: "graphql"
+  };
+}
+
+function injectAwsAuthAll(fragment, group) {
+  let parts = GraphQL_Stitcher$ReventlessCore.decode(fragment);
+  let augmentedMutations = parts.mutations.map(field => field + `\n    @aws_auth(cognito_groups: ["` + group + `"])`);
+  let augmentedQueries = parts.queries.map(field => field + ` @aws_auth(cognito_groups: ["` + group + `"])`);
+  let augmentedSubscriptions = parts.subscriptions.map(field => field + `\n    @aws_auth(cognito_groups: ["` + group + `"])`);
+  let encoded = JSON.stringify(Object.fromEntries([
+    [
+      "types",
+      parts.types.map(prim => prim)
+    ],
+    [
+      "mutations",
+      augmentedMutations.map(prim => prim)
+    ],
+    [
+      "queries",
+      augmentedQueries.map(prim => prim)
+    ],
+    [
+      "subscriptions",
+      augmentedSubscriptions.map(prim => prim)
+    ]
+  ]));
+  return {
+    encoded: encoded,
+    protocol: "graphql"
+  };
+}
+
+function makeApiResource(name, opts) {
+  let customOpts_parent = opts.parent;
+  let customOpts = {
+    parent: customOpts_parent
+  };
+  let iamRole = new (Aws.iam.Role)(name + `-appsync-role`, {
+    assumeRolePolicy: `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"appsync.amazonaws.com"},"Action":"sts:AssumeRole"}]}`
+  }, customOpts);
+  let authConfigOut = Auth_Cognito$ReventlessAws.make(name + `-auth`, undefined);
+  let userPoolConfigOut = authConfigOut.apply(c => ({
+    userPoolId: c.userPoolId,
+    defaultAction: "ALLOW",
+    awsRegion: c.region
+  }));
+  let apiArgs_userPoolConfig = userPoolConfigOut;
+  let apiArgs_additionalAuthenticationProviders = [{
+      authenticationType: "AWS_IAM"
+    }];
+  let apiArgs = {
+    authenticationType: "AMAZON_COGNITO_USER_POOLS",
+    userPoolConfig: apiArgs_userPoolConfig,
+    additionalAuthenticationProviders: apiArgs_additionalAuthenticationProviders
+  };
+  let graphQLApi = new (Aws.appsync.GraphQLApi)(name, apiArgs, customOpts);
+  return [
+    Pulumi.output(graphQLApi),
+    Pulumi.output(iamRole)
+  ];
+}
+
+function generateFragment(mutationEntries, queryEntries) {
+  let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries, queryEntries);
+  return injectAwsAuth(fragment, mutationEntries, queryEntries);
+}
+
+function updateSchema(api, baseFragment, pluginFragments) {
+  let augmentedBaseFragment = injectAwsAuthAll(baseFragment, "Admin");
+  let sdl = GraphQL_Stitcher$ReventlessCore.stitch(augmentedBaseFragment, pluginFragments);
+  let resultPromise = {
+    contents: Promise.resolve()
+  };
+  api.apply(graphQLApi => graphQLApi.id.apply(apiId => {
+    let effect = deploySchemaWithRetry(getClient(), apiId, sdl);
+    let p = Effect$1.runPromise(effect);
+    resultPromise.contents = p;
+  }));
+  return resultPromise.contents;
+}
+
+export {
+  log,
+  sha256Hex,
+  startSchemaCreation,
+  startSchemaCreationRetrying,
+  waitForSchemaActive,
+  getIntrospectionSdl,
+  deploySchemaWithRetry,
+  schemaLockSleep,
+  _schemaLockCounter,
+  withSchemaPushLock,
+  _client,
+  getClient,
+  _permissionToCognitoGroups,
+  _formatGroupsDirective,
+  injectAwsAuth,
+  injectAwsAuthAll,
+  makeApiResource,
+  generateFragment,
+  updateSchema,
+}
+/* log Not a pure module */

package/src/components/AutomationSlice_Builder.res

@@ -0,0 +1,52 @@
+// AutomationSlice_Builder (AWS)
+// Wires AWS adapters and delegates to the core ReventlessCore.AutomationSlice_Builder.
+
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+module EventCollectorRuntimeBuilder = AutomationSliceRuntime_Builder_Single
+
+module Make = (Api: {
+  let api: unit => Types.AppSync.api
+  let apiRole: unit => Types.AppSync.role
+}) => {
+  module Inner = ReventlessCore.AutomationSlice_Builder.Make(
+    RuntimeEnvironment,
+    QueryDbStorage.DynamoDb,
+    QueryDbResolvers.AppSync,
+    EventCollectorChannel,
+    EventCollectorRuntimeBuilder,
+    Api,
+  )
+
+  module Make = (
+    Spec: Reventless.AutomationSlice.Spec,
+    Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+  ): (ReventlessCore.AutomationSlice.T with module Spec = Spec) => {
+    module InnerMake = Inner.Make(Spec, Automation)
+
+    module Spec = Spec
+    module Automation = Automation
+    type component = InnerMake.component
+    let queryDbName = InnerMake.queryDbName
+    let sourceNames = InnerMake.sourceNames
+
+    let make = (~allEventTopics, ~publishJsons, ~context, ~opts=?): component => {
+      let as_ = InnerMake.make(~allEventTopics, ~publishJsons, ~context, ~opts?)
+
+      let queryDbOutputs = (as_->ReventlessCore.Component.outputs).queryDb
+      let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
+      let queryDbTableName = tableResource.name
+
+      EventCollectorRuntimeBuilder.registerAutomationSlice(
+        ~name=Spec.name,
+        ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
+        ~callbackType="automation",
+        ~queryDbTableName,
+      )
+
+      as_
+    }
+  }
+
+  let finish = () => EventCollectorRuntimeBuilder.finish()
+}

package/src/components/AutomationSlice_Builder.res.mjs

@@ -0,0 +1,72 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
+import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
+import * as AutomationSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs";
+
+function Make(Api) {
+  let Inner = AutomationSlice_Builder$ReventlessCore.Make({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: QueryDbStorage_DynamoDb$ReventlessAws.make
+  })({
+    make: QueryDbResolvers_AppSync$ReventlessAws.make
+  })({
+    make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+    connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+  })({
+    EventCollectorChannel: {
+      make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+      connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+    },
+    forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
+    finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
+  })(Api);
+  let Make$1 = Spec => (Automation => {
+    let InnerMake = Inner.Make(Spec)(Automation);
+    let make = (allEventTopics, publishJsons, context, opts) => {
+      let as_ = InnerMake.make(allEventTopics, publishJsons, context, opts);
+      let queryDbOutputs = Component$ReventlessCore.outputs(as_).queryDb;
+      let tableResource = queryDbOutputs.resources[0];
+      let queryDbTableName = tableResource.name;
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), "automation", queryDbTableName);
+      return as_;
+    };
+    return {
+      Spec: Spec,
+      Automation: Automation,
+      queryDbName: InnerMake.queryDbName,
+      sourceNames: InnerMake.sourceNames,
+      make: make
+    };
+  });
+  let finish = () => AutomationSliceRuntime_Builder_Single$ReventlessAws.finish();
+  return {
+    Inner: Inner,
+    Make: Make$1,
+    finish: finish
+  };
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+let EventCollectorRuntimeBuilder;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  EventCollectorRuntimeBuilder,
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/AutomationSlice_Builder_Bundled.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
+import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
+import * as AutomationSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs";
+
+function Make(Api) {
+  let Inner = AutomationSlice_Builder$ReventlessCore.Make({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: QueryDbStorage_DynamoDb$ReventlessAws.make
+  })({
+    make: QueryDbResolvers_AppSync$ReventlessAws.make
+  })({
+    make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+    connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+  })({
+    EventCollectorChannel: {
+      make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
+      connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
+    },
+    forEventCollector: AutomationSliceRuntime_Builder_Single$ReventlessAws.forEventCollector,
+    finish: AutomationSliceRuntime_Builder_Single$ReventlessAws.finish
+  })(Api);
+  let Make$1 = Spec => {
+    let InnerMake = Inner.Make(Spec);
+    let make = (dcbEventLog, publishJsons, opts) => {
+      let as_ = InnerMake.make(dcbEventLog, publishJsons, opts);
+      let queryDbOutputs = Component$ReventlessCore.outputs(as_).queryDb;
+      let tableResource = queryDbOutputs.resources[0];
+      let queryDbTableName = tableResource.name;
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(InnerMake.Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(InnerMake.Spec.moduleUrl), "automation", queryDbTableName);
+      return as_;
+    };
+    return {
+      Spec: InnerMake.Spec,
+      queryDbName: InnerMake.queryDbName,
+      make: make
+    };
+  };
+  let finish = () => AutomationSliceRuntime_Builder_Single$ReventlessAws.finish();
+  return {
+    Inner: Inner,
+    Make: Make$1,
+    finish: finish
+  };
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+let EventCollectorRuntimeBuilder;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  EventCollectorRuntimeBuilder,
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/Counter_Builder.res

@@ -0,0 +1,10 @@
+module Make = (
+  Api: {
+    let api: unit => Types.AppSync.api
+    let apiRole: unit => Types.AppSync.role
+  },
+) => ReventlessCore.Counter_Builder.Make(
+  QueryDbStorage_DynamoDbStream,
+  Api,
+  CounterHandler_DynamoDbStream,
+)

package/src/components/Counter_Builder.res.mjs

@@ -0,0 +1,16 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Counter_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/Counter/Counter_Builder.res.mjs";
+import * as CounterHandler_DynamoDbStream$ReventlessAws from "../adapter/Counter/CounterHandler_DynamoDbStream.res.mjs";
+import * as QueryDbStorage_DynamoDbStream$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDbStream.res.mjs";
+
+function Make(Api) {
+  return Counter_Builder$ReventlessCore.Make({
+    make: QueryDbStorage_DynamoDbStream$ReventlessAws.make
+  })(Api)(CounterHandler_DynamoDbStream$ReventlessAws);
+}
+
+export {
+  Make,
+}
+/* Counter_Builder-ReventlessCore Not a pure module */