@reventlessdev/reventless-aws 3.0.0-alpha.397 → 3.0.0-alpha.399

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res

@@ -45,7 +45,7 @@ type derivedScope = {
   crossPartitionTagKeys: array<string>,
   tagKeysByEventType: dict<array<string>>,
   /** `None` only for a Lambda hosting no StateChangeSlices, which never appends. */
-  partitionTag: option<Reventless.DcbTag.derivedPartitionTag>,
+  partitionTag?: Reventless.DcbTag.derivedPartitionTag,
   /** Slice name -> its partition: the handler's entity id and each command's envelope id. */
   partitionTagBySlice: dict<Reventless.DcbTag.derivedPartitionTag>,
 }
@@ -55,7 +55,6 @@ let deriveScope = (specs: array<specModule>): derivedScope =>
   | [] => {
       crossPartitionTagKeys: [],
       tagKeysByEventType: Dict.make(),
-      partitionTag: None,
       partitionTagBySlice: Dict.make(),
     }
   | _ =>
@@ -89,7 +88,7 @@ let deriveScope = (specs: array<specModule>): derivedScope =>
     {
       crossPartitionTagKeys: scope.crossPartitionTagKeys,
       tagKeysByEventType: scope.tagKeysByEventType,
-      partitionTag: Some(boundary.partitionTag),
+      partitionTag: boundary.partitionTag,
       partitionTagBySlice,
     }
   }
@@ -257,6 +256,7 @@ type inboundCallback = {
   receive: (
     ReventlessInfra.CommandTopic.publishJsons,
     JSON.t,
+    ~capabilities: Reventless.Capabilities.t,
     ~caller: Reventless.Identity.t=?,
     ~door: ReventlessInfra.InboundTranslationSlice.door=?,
   ) => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
@@ -265,7 +265,7 @@ type inboundCallback = {
     ~errorCode: string,
     string,
   ) => ReventlessInfra.InboundTranslationSlice.receiveResult,
-  webhook: option<ReventlessCore.InboundTranslationSlice_Webhook.route>,
+  webhook?: ReventlessCore.InboundTranslationSlice_Webhook.route,
   auditLog: dict<ReventlessCore.InboundTranslationSlice_Callback.auditRow>,
 }
 @module(
@@ -324,9 +324,12 @@ let buildInboundReceiver = (
 ) => {
   let callback = makeInboundCallback(spec)(translation)
   async (args: JSON.t, identity: Nullable.t<Reventless.Identity.t>): JSON.t => {
+    // No capabilities in this Lambda: a slice declaring a need is refused at
+    // deploy, so `none` is what every slice reaching here expects.
     let result = await callback.receive(
       publishJsons,
       args,
+      ~capabilities=Reventless.Capabilities.none,
       ~caller=ReventlessCore.InboundTranslationSlice_Callback.doorCaller(identity),
     )
     await persistAudit(callback, auditQueryDbOps, result)
@@ -354,7 +357,15 @@ let buildWebhookSlice = (
   ->Option.map((route): ReventlessCore.InboundTranslationSlice_Webhook.slice => {
     route,
     receive: async (input, ~caller) =>
-      await persisted(await callback.receive(publishJsons, input, ~caller, ~door=Webhook)),
+      await persisted(
+        await callback.receive(
+          publishJsons,
+          input,
+          ~capabilities=Reventless.Capabilities.none,
+          ~caller,
+          ~door=Webhook,
+        ),
+      ),
     refuse: async (~body, ~errorCode, error) =>
       await persisted(callback.refuse(~body, ~errorCode, error)),
   })

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res.mjs

@@ -12,6 +12,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb.res.mjs";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 import * as InboundTranslationSlice_Webhook$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Webhook.res.mjs";
@@ -26,7 +27,6 @@ function deriveScope(specs) {
     return {
       crossPartitionTagKeys: [],
       tagKeysByEventType: {},
-      partitionTag: undefined,
       partitionTagBySlice: {}
     };
   }
@@ -147,7 +147,7 @@ async function persistAudit(callback, auditQueryDbOps, result) {
 function buildInboundReceiver(spec, translation, publishJsons, auditQueryDbOps) {
   let callback = InboundTranslationSlice_CallbackResMjs.Make(spec)(translation);
   return async (args, identity) => {
-    let result = await callback.receive(publishJsons, args, InboundTranslationSlice_Callback$ReventlessCore.doorCaller(identity), undefined);
+    let result = await callback.receive(publishJsons, args, Capabilities$Reventless.none, InboundTranslationSlice_Callback$ReventlessCore.doorCaller(identity), undefined);
     await persistAudit(callback, auditQueryDbOps, result);
     return CommandTopic_Helpers$ReventlessCore.commandOutcomeToJson(InboundTranslationSlice_Callback$ReventlessCore.receiveResultToOutcome(result));
   };
@@ -161,7 +161,7 @@ function buildWebhookSlice(spec, translation, publishJsons, auditQueryDbOps) {
   };
   return Stdlib_Nullable.fromOption(Stdlib_Option.map(callback.webhook, route => ({
     route: route,
-    receive: async (input, caller) => await persisted(await callback.receive(publishJsons, input, caller, "Webhook")),
+    receive: async (input, caller) => await persisted(await callback.receive(publishJsons, input, Capabilities$Reventless.none, caller, "Webhook")),
     refuse: async (body, errorCode, error) => await persisted(callback.refuse(body, errorCode, error))
   })));
 }

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res

@@ -106,7 +106,7 @@ type handlerConfig = {
   schedulerQueueArn: string,
   schedulerQueueName: string,
   extensionPoints: array<extensionPointConfig>,
-  connectExtension: option<connectExtensionConfig>,
+  connectExtension?: connectExtensionConfig,
   extensions: array<extensionConfig>,
   readModelNamesForSourceName: dict<array<string>>,
 }
@@ -234,7 +234,7 @@ let parseHandlerConfig = (rawJson: string): handlerConfig => {
     schedulerQueueArn: obj->strOf("schedulerQueueArn")->Option.getOr(""),
     schedulerQueueName: obj->strOf("schedulerQueueName")->Option.getOr(""),
     extensionPoints,
-    connectExtension,
+    ?connectExtension,
     extensions,
     readModelNamesForSourceName,
   }
@@ -253,7 +253,7 @@ type pluginProjection = {
   eventCollector: string,
   extensions: array<Reventless.Plugin.extensionDefinition>,
   extensionPoints: array<Reventless.Plugin.extensionPointDefinition>,
-  dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
+  dcbEventLog?: Reventless.Plugin.dcbEventLogDefinition,
 }
 
 let projectPluginRow = (row: JSON.t): option<pluginProjection> =>
@@ -323,7 +323,7 @@ let projectPluginRow = (row: JSON.t): option<pluginProjection> =>
         eventCollector: obj->strOf("eventCollector")->Option.getOr(""),
         extensions,
         extensionPoints,
-        dcbEventLog,
+        ?dcbEventLog,
       })
     | _ => None
     }
@@ -339,7 +339,7 @@ let projectionOfDefinition = (d: Reventless.Plugin.pluginDefinition): pluginProj
   eventCollector: d.eventCollector,
   extensions: d.extensions,
   extensionPoints: d.extensionPoints,
-  dcbEventLog: d.dcbEventLog->jsOption,
+  dcbEventLog: ?(d.dcbEventLog->jsOption),
 }
 
 // ── Cross-plugin SNS subscription manager ───────────────────────────────────

package/src/adapter/Runtime/PgQueryResolverEntryPoint_Ops.res

@@ -26,7 +26,7 @@ type handlerEntry = {
 }
 
 type resolverConfig = {
-  pgConnection: option<PgConnection.connectionConfig>,
+  pgConnection?: PgConnection.connectionConfig,
   handlers: array<handlerEntry>,
   nodeTypes: dict<string>,
 }
@@ -59,10 +59,12 @@ let parseResolverConfig = (rawJson: string): resolverConfig => {
     ->JSON.Decode.object
     ->Option.getOr(Dict.make())
   {
-    pgConnection: obj
-    ->Dict.get("pgConnection")
-    ->Option.filter(j => j != JSON.Null)
-    ->Option.map(asPgConnection),
+    pgConnection: ?(
+      obj
+      ->Dict.get("pgConnection")
+      ->Option.filter(j => j != JSON.Null)
+      ->Option.map(asPgConnection)
+    ),
     handlers: obj
     ->Dict.get("handlers")
     ->Option.flatMap(JSON.Decode.array)
@@ -118,8 +120,8 @@ let makePushdowns = (
 // Reventless.Authorization.isAllowed matches on.
 
 type specInfo = {
-  config: option<ProjectionEntryPoint_Ops.specConfig>,
-  subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+  config?: ProjectionEntryPoint_Ops.specConfig,
+  subIdConfig?: Reventless.ReadModel.subIdConfig<JSON.t>,
   stateSchema: S.t<unknown>,
   authorization: Reventless.Authorization.permission,
 }
@@ -143,7 +145,7 @@ let registerBinding = (
       ),
       pushdowns,
       indexes,
-      subIdField,
+      ?subIdField,
       capability: ReventlessCore.GraphQL_FragmentGenerator.deriveServerCapability(
         ~entityName=entry.readModelName,
         spec.stateSchema,
@@ -153,24 +155,28 @@ let registerBinding = (
       authorization: spec.authorization->Reventless.Authorization.named,
       // From the same schema `capability` is derived from, one line above, so the
       // two cannot end up disagreeing about this read model's fields.
-      ownerField: Reventless.Owner.fieldNames(spec.stateSchema)->Array.get(0),
-      retiredField: spec.stateSchema
-      ->Reventless.StateAnnotations.getSpec
-      ->Option.flatMap(a => a.retired)
-      ->Option.map(r => r.field),
+      ownerField: ?(Reventless.Owner.fieldNames(spec.stateSchema)->Array.get(0)),
+      retiredField: ?(
+        spec.stateSchema
+        ->Reventless.StateAnnotations.getSpec
+        ->Option.flatMap(a => a.retired)
+        ->Option.map(r => r.field)
+      ),
       // The state form's other half. Carried beside the field rather than
       // re-derived at predicate time, so one place decides which rows are retired.
-      retiredValues: spec.stateSchema
-      ->Reventless.StateAnnotations.getSpec
-      ->Option.flatMap(a => a.retired)
-      ->Option.flatMap(r => r.values),
+      retiredValues: ?(
+        spec.stateSchema
+        ->Reventless.StateAnnotations.getSpec
+        ->Option.flatMap(a => a.retired)
+        ->Option.flatMap(r => r.values)
+      ),
       // Read off the retirement rather than from a second annotation: a record
       // cannot declare the reach of a retirement it does not have.
       namedWhenRetired: spec.stateSchema
       ->Reventless.StateAnnotations.getSpec
       ->Option.flatMap(a => a.retired)
       ->Option.mapOr(false, r => r.namedWhenRetired),
-      imageSource: spec.stateSchema->Reventless.RowImage.sourceFrom,
+      imageSource: ?(spec.stateSchema->Reventless.RowImage.sourceFrom),
     },
   )
   logDebug("registered resolver binding for " ++ entry.readModelName, {comp: "PgQueryResolver"})

package/src/adapter/Runtime/ReadModelEntryPoint_Ops.res

@@ -22,10 +22,10 @@ type handlerEntry = {
   // ReScript dispatch boundary's `EventCollector(<Name>)` byte for byte. This
   // Lambda hosts every read model, so the comp is what separates their log
   // lines; the plugin beats the Lambda-name-derived fallback in runEffect.
-  comp: option<string>,
-  plugin: option<string>,
-  pgConnection: option<PgConnection.connectionConfig>,
-  stateTopicName: option<string>,
+  comp?: string,
+  plugin?: string,
+  pgConnection?: PgConnection.connectionConfig,
+  stateTopicName?: string,
 }
 
 // The builder writes `pgConnection` via PgConnection.connectionConfigToJson, so
@@ -44,13 +44,15 @@ let decodeEntry = (json: JSON.t): option<handlerEntry> =>
     mappingsModule: h->strOf("mappingsModule")->Option.getOr(""),
     queryDbTableName: h->strOf("queryDbTableName")->Option.getOr(""),
     sourceUrn: h->strOf("sourceUrn")->Option.getOr(""),
-    comp: h->strOf("comp"),
-    plugin: h->strOf("plugin"),
-    pgConnection: h
-    ->Dict.get("pgConnection")
-    ->Option.filter(j => j != JSON.Null)
-    ->Option.map(asPgConnection),
-    stateTopicName: h->strOf("stateTopicName"),
+    comp: ?(h->strOf("comp")),
+    plugin: ?(h->strOf("plugin")),
+    pgConnection: ?(
+      h
+      ->Dict.get("pgConnection")
+      ->Option.filter(j => j != JSON.Null)
+      ->Option.map(asPgConnection)
+    ),
+    stateTopicName: ?(h->strOf("stateTopicName")),
   })
 
 let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
@@ -88,10 +90,10 @@ let withInjectedId = (
 }
 
 type specInfo = {
-  config: option<ProjectionEntryPoint_Ops.specConfig>,
-  subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+  config?: ProjectionEntryPoint_Ops.specConfig,
+  subIdConfig?: Reventless.ReadModel.subIdConfig<JSON.t>,
   // Read off the runtime-loaded spec module; `None` on a module that predates it.
-  stateSchema: option<S.t<unknown>>,
+  stateSchema?: S.t<unknown>,
 }
 
 let buildOperations = (

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res

@@ -269,8 +269,8 @@ let makeFromCodeAsset: (
   // registered — an extension-free deployment gets the env it always had.
   if !ReventlessCore.RuntimeExtension.isEmpty() {
     let {
-      ReventlessCore.ResourceAttribution.plugin: plugin,
-      platform,
+      ReventlessCore.ResourceAttribution.plugin: ?plugin,
+      ?platform,
     } = ReventlessCore.ResourceAttribution.current.contents
     let orNull = o => o->Option.mapOr(JSON.Null, s => JSON.String(s))
     let config = JSON.Object(

package/src/adapter/Runtime/RuntimeExtensionEntryPoint_Ops.res

@@ -29,8 +29,8 @@ type config = {
   modules: array<string>,
   runtimeKind: string,
   component: string,
-  plugin: option<string>,
-  platform: option<string>,
+  plugin?: string,
+  platform?: string,
 }
 
 let decodeString = (obj: dict<JSON.t>, key: string): option<string> =>
@@ -70,8 +70,8 @@ let parseConfig = (raw: option<string>): option<config> =>
           modules,
           runtimeKind,
           component,
-          plugin: obj->decodeString("plugin"),
-          platform: obj->decodeString("platform"),
+          plugin: ?(obj->decodeString("plugin")),
+          platform: ?(obj->decodeString("platform")),
         })
       | _ =>
         log.error(

package/src/adapter/Runtime/SideEffectEntryPoint_Ops.res

@@ -14,8 +14,8 @@ type handlerEntry = {
   // Resolved at deploy time and baked into HANDLER_CONFIG
   // (SideEffectHandlerRuntime_Builder_Single) — the shell has only module paths
   // to identify a handler by.
-  comp: option<string>,
-  plugin: option<string>,
+  comp?: string,
+  plugin?: string,
 }
 
 let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
@@ -31,8 +31,8 @@ let decodeEntry = (json: JSON.t): option<handlerEntry> =>
     ->Option.flatMap(JSON.Decode.array)
     ->Option.getOr([])
     ->Array.filterMap(JSON.Decode.string),
-    comp: h->strOf("comp"),
-    plugin: h->strOf("plugin"),
+    comp: ?(h->strOf("comp")),
+    plugin: ?(h->strOf("plugin")),
   })
 
 let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res

@@ -17,8 +17,8 @@ type handlerEntry = {
   sourceUrn: string,
   // B3.3: per-slice AppSync Events channel root (list field name). Present only
   // for subscription-enabled (Stream) Postgres view slices.
-  stateTopicName: option<string>,
-  pgConnection: option<PgConnection.connectionConfig>,
+  stateTopicName?: string,
+  pgConnection?: PgConnection.connectionConfig,
 }
 
 // The builder writes `pgConnection` via PgConnection.connectionConfigToJson, so
@@ -67,16 +67,16 @@ let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
                 projectionModule: h->strOf("projectionModule")->Option.getOr(""),
                 queryDbTableName: h->strOf("queryDbTableName")->Option.getOr(""),
                 sourceUrn: h->strOf("sourceUrn")->Option.getOr(""),
-                stateTopicName: h->strOf("stateTopicName"),
-                pgConnection: h->pgConnectionOf,
+                stateTopicName: ?(h->strOf("stateTopicName")),
+                pgConnection: ?(h->pgConnectionOf),
               }
             | None => {
                 specModule: base ++ h->strOf("s")->Option.getOr(""),
                 projectionModule: base ++ h->strOf("p")->Option.getOr(""),
                 queryDbTableName: h->strOf("q")->Option.getOr(""),
                 sourceUrn: h->strOf("u")->Option.getOr(sharedUrn),
-                stateTopicName: h->strOf("t"),
-                pgConnection: sharedPgConnection,
+                stateTopicName: ?(h->strOf("t")),
+                pgConnection: ?sharedPgConnection,
               }
             }
           )
@@ -197,10 +197,10 @@ type sliceModules<'event> = {
   project: Reventless.StateViewSlice.consumed<'event> => array<
     Reventless.Projection.action<string, JSON.t>,
   >,
-  config: option<ProjectionEntryPoint_Ops.specConfig>,
-  subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+  config?: ProjectionEntryPoint_Ops.specConfig,
+  subIdConfig?: Reventless.ReadModel.subIdConfig<JSON.t>,
   // Same union stamp the read-model path needs; a slice's state can hold one too.
-  stateSchema: option<S.t<unknown>>,
+  stateSchema?: S.t<unknown>,
 }
 
 let makeRegisteredHandler = (

package/src/adapter/Runtime/TaskBucketEntryPoint_Ops.res

@@ -24,7 +24,7 @@ type handlerConfig = {
   callbackModule: string,
   // aggregateName → env-var name holding the aggregate's cmd-topic SQS URL.
   publishToAggregates: dict<string>,
-  scheduler: option<schedulerEnvConfig>,
+  scheduler?: schedulerEnvConfig,
 }
 
 let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
@@ -45,14 +45,16 @@ let parseHandlerConfig = (rawJson: string): handlerConfig => {
     ->Dict.toArray
     ->Array.filterMap(((k, v)) => v->JSON.Decode.string->Option.map(s => (k, s)))
     ->Dict.fromArray,
-    scheduler: obj
-    ->Dict.get("scheduler")
-    ->Option.flatMap(JSON.Decode.object)
-    ->Option.map(s => {
-      roleArnEnv: s->strOf("roleArnEnv")->Option.getOr(""),
-      targetArnEnv: s->strOf("targetArnEnv")->Option.getOr(""),
-      targetNameEnv: s->strOf("targetNameEnv")->Option.getOr(""),
-    }),
+    scheduler: ?(
+      obj
+      ->Dict.get("scheduler")
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.map(s => {
+        roleArnEnv: s->strOf("roleArnEnv")->Option.getOr(""),
+        targetArnEnv: s->strOf("targetArnEnv")->Option.getOr(""),
+        targetNameEnv: s->strOf("targetNameEnv")->Option.getOr(""),
+      })
+    ),
   }
 }
 

package/src/components/Api/AppSync_Adapter.res

@@ -68,7 +68,7 @@ let startSchemaCreationRetrying = (client: appSyncClient, input: startSchemaCrea
 // GetSchemaCreationStatus — poll until schema is ACTIVE
 type getSchemaCreationStatusInput = {apiId: string}
 type getSchemaCreationStatusCommand
-type getSchemaCreationStatusResult = {status: string, details: option<string>}
+type getSchemaCreationStatusResult = {status: string, details?: string}
 
 @module("@aws-sdk/client-appsync") @new
 external makeGetSchemaCreationStatusCommand: getSchemaCreationStatusInput => getSchemaCreationStatusCommand =
@@ -119,10 +119,10 @@ type getSourceApiAssociationInput = {
 }
 type getSourceApiAssociationCommand
 type sourceApiAssociationSummary = {
-  sourceApiAssociationStatus: option<string>,
-  sourceApiAssociationStatusDetail: option<string>,
+  sourceApiAssociationStatus?: string,
+  sourceApiAssociationStatusDetail?: string,
 }
-type getSourceApiAssociationResult = {sourceApiAssociation: option<sourceApiAssociationSummary>}
+type getSourceApiAssociationResult = {sourceApiAssociation?: sourceApiAssociationSummary}
 
 @module("@aws-sdk/client-appsync") @new
 external makeGetSourceApiAssociationCommand: getSourceApiAssociationInput => getSourceApiAssociationCommand =

package/src/components/InboundTranslationSlice_Builder.res

@@ -7,16 +7,35 @@ module Make = (
     let apiRole: unit => Types.AppSync.role
   },
 ) => {
+  // The deployed slice runs in the shared DCB command Lambda, which builds its
+  // own callback and is handed no capabilities; this in-process path answers the
+  // same, so the two cannot differ. A spec that declares a need is refused below.
   module Inner = ReventlessCore.InboundTranslationSlice_Builder.Make(
     QueryDbStorage.DynamoDb,
     QueryDbResolvers.AppSync,
     Api,
+    {
+      let capabilities = () => Reventless.Capabilities.none
+    },
   )
 
   module Make = (
     Spec: Reventless.InboundTranslationSlice.Spec,
     Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
   ): (ReventlessCore.InboundTranslationSlice.T with module Spec = Spec) => {
+    // Refused rather than deployed to fail quietly: the DCB command Lambda this
+    // slice runs in has neither the capability settings nor the grants the
+    // automation Lambda gets, so every call would answer `Unavailable` at run
+    // time with nothing at deploy time to say why.
+    if Spec.capabilityNeeds != [] {
+      JsError.throwWithMessage(
+        `${Spec.name}: an inbound translation slice that declares capability needs (${Spec.capabilityNeeds
+          ->Array.map(Reventless.CapabilityNeed.toString)
+          ->Array.join(
+            ", ",
+          )}) cannot be deployed to AWS yet — the DCB command Lambda it runs in is handed no capabilities. Host it on the local platform.`,
+      )
+    }
     // Register spec + translation module paths so the shared DCB command Lambda's
     // entry point can import them and route `__inboundTranslation` payloads to this
     // slice's `receive` (mirrors StateChangeSlice_Builder's path registration).

package/src/components/InboundTranslationSlice_Builder.res.mjs

@@ -1,6 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as CapabilityNeed$Reventless from "@reventlessdev/reventless-spec/src/semantic/CapabilityNeed.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
 import * as PluginRuntime_Builder$ReventlessAws from "../plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
@@ -8,12 +12,18 @@ import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/Quer
 import * as InboundTranslationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res.mjs";
 
 function Make(Api) {
+  let capabilities = () => Capabilities$Reventless.none;
   let Inner = InboundTranslationSlice_Builder$ReventlessCore.Make({
     make: QueryDbStorage_DynamoDb$ReventlessAws.make
   })({
     make: QueryDbResolvers_AppSync$ReventlessAws.make
-  })(Api);
+  })(Api)({
+    capabilities: capabilities
+  });
   let Make$1 = Spec => (Translation => {
+    if (Primitive_object.notequal(Spec.capabilityNeeds, [])) {
+      Stdlib_JsError.throwWithMessage(Spec.name + `: an inbound translation slice that declares capability needs (` + Spec.capabilityNeeds.map(CapabilityNeed$Reventless.toString).join(", ") + `) cannot be deployed to AWS yet — the DCB command Lambda it runs in is handed no capabilities. Host it on the local platform.`);
+    }
     PluginRuntime_Builder$ReventlessAws.registerInboundTranslationSliceSpec(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl));
     let match = Spec.endpoint;
     if (match !== undefined) {
@@ -50,4 +60,4 @@ function Make(Api) {
 export {
   Make,
 }
-/* Component-ReventlessCore Not a pure module */
+/* Capabilities-Reventless Not a pure module */

package/src/plugin/runtime/PluginExtensionPointRuntime_Builder.res

@@ -10,17 +10,14 @@ type runtimeParts = Util.Lambda.runtimeParts
 // scheduler resources; consumed lazily at deploy-resolve time when
 // `forCommandTopic` runs inside its `Pulumi.Output.apply`.
 type adminExtras = {
-  pluginReadModelTableName: option<Pulumi.Output.t<string>>,
-  schedulerRoleArn: option<Pulumi.Output.t<string>>,
+  pluginReadModelTableName?: Pulumi.Output.t<string>,
+  schedulerRoleArn?: Pulumi.Output.t<string>,
 }
 
-let adminExtras: ref<adminExtras> = ref({
-  pluginReadModelTableName: None,
-  schedulerRoleArn: None,
-})
+let adminExtras: ref<adminExtras> = ref(({}: adminExtras))
 
 let registerPluginExtensionPoint = (~pluginReadModelTableName=?, ~schedulerRoleArn=?, ()) =>
-  adminExtras := {pluginReadModelTableName, schedulerRoleArn}
+  adminExtras := {?pluginReadModelTableName, ?schedulerRoleArn}
 
 let forCommandTopic = (
   ~handler as _,

package/src/plugin/runtime/PluginExtensionPointRuntime_Builder.res.mjs

@@ -8,10 +8,7 @@ import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "../../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
 
 let adminExtras = {
-  contents: {
-    pluginReadModelTableName: undefined,
-    schedulerRoleArn: undefined
-  }
+  contents: {}
 };
 
 function registerPluginExtensionPoint(pluginReadModelTableName, schedulerRoleArn, param) {