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

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) {

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -1,22 +1,16 @@
 let log = ReventlessCore.Logger.fromEnv()
 
 type adminConfig = {
-  eventTopicArn: option<Pulumi.Output.t<string>>,
-  pluginReadModelTableName: option<Pulumi.Output.t<string>>,
-  schedulerRoleArn: option<Pulumi.Output.t<string>>,
-  schedulerQueueArn: option<Pulumi.Output.t<string>>,
-  schedulerQueueName: option<Pulumi.Output.t<string>>,
-  appSyncApiId: option<Pulumi.Output.t<string>>,
+  eventTopicArn?: Pulumi.Output.t<string>,
+  pluginReadModelTableName?: Pulumi.Output.t<string>,
+  schedulerRoleArn?: Pulumi.Output.t<string>,
+  schedulerQueueArn?: Pulumi.Output.t<string>,
+  schedulerQueueName?: Pulumi.Output.t<string>,
+  appSyncApiId?: Pulumi.Output.t<string>,
   clonerEnabled: bool,
 }
 
 let configRef: ref<adminConfig> = ref({
-  eventTopicArn: None,
-  pluginReadModelTableName: None,
-  schedulerRoleArn: None,
-  schedulerQueueArn: None,
-  schedulerQueueName: None,
-  appSyncApiId: None,
   clonerEnabled: false,
 })
 
@@ -121,13 +115,12 @@ type sliceModulePaths = {
 
 type dcbConfig = {
   pluginName: string,
-  dcbTableName: option<Pulumi.Output.t<string>>,
+  dcbTableName?: Pulumi.Output.t<string>,
   stateChangeSliceModulePaths: array<sliceModulePaths>,
 }
 
 let dcbConfigRef: ref<dcbConfig> = ref({
   pluginName: "",
-  dcbTableName: None,
   stateChangeSliceModulePaths: [],
 })
 
@@ -219,23 +212,22 @@ compiles; slated for removal.
   "pluginName is auto-registered by Plugin_Builder.make; use registerDcbTableName / registerStateChangeSliceSpec for the other fields. This call is unnecessary and will be removed."
 )
 let registerDcbConfig = (~pluginName, ~dcbTableName=?, ~stateChangeSliceModulePaths=[], ()) => {
-  dcbConfigRef := {pluginName, dcbTableName, stateChangeSliceModulePaths}
+  dcbConfigRef := {pluginName, ?dcbTableName, stateChangeSliceModulePaths}
   stateChangeSliceModulePaths->Array.length
 }
 
 let registerDcbTableName = (dcbTableName: Pulumi.Output.t<string>) =>
-  dcbConfigRef := {...dcbConfigRef.contents, dcbTableName: Some(dcbTableName)}
+  dcbConfigRef := {...dcbConfigRef.contents, dcbTableName}
 
 type heartbeatConfig = {
   pluginId: string,
   heartbeatTimeout: int,
-  epQueueUrl: option<Pulumi.Output.t<string>>,
+  epQueueUrl?: Pulumi.Output.t<string>,
 }
 
 let heartbeatConfigRef: ref<heartbeatConfig> = ref({
   pluginId: "",
   heartbeatTimeout: 10,
-  epQueueUrl: None,
 })
 
 // heartbeatTimeout is mandatory: it drives the HEARTBEAT_TIMEOUT env var (and thus
@@ -244,7 +236,7 @@ let heartbeatConfigRef: ref<heartbeatConfig> = ref({
 // silently decoupled the two (schedule every 60min, Heartbeat(10) → 12min grace →
 // flapping); make callers supply it so the values can't diverge.
 let registerHeartbeatConfig = (~pluginId, ~heartbeatTimeout, ~epQueueUrl=?, ()) =>
-  heartbeatConfigRef := {pluginId, heartbeatTimeout, epQueueUrl}
+  heartbeatConfigRef := {pluginId, heartbeatTimeout, ?epQueueUrl}
 
 // Resolves once this plugin's EventCollector Lambda exists at its new code.
 // `Platform.deployPlugin` gates the deploy-time re-detect on it: the re-detect
@@ -285,12 +277,12 @@ let registerConfig = (
   (),
 ) =>
   configRef := {
-      eventTopicArn,
-      pluginReadModelTableName,
-      schedulerRoleArn,
-      schedulerQueueArn,
-      schedulerQueueName,
-      appSyncApiId,
+      ?eventTopicArn,
+      ?pluginReadModelTableName,
+      ?schedulerRoleArn,
+      ?schedulerQueueArn,
+      ?schedulerQueueName,
+      ?appSyncApiId,
       clonerEnabled,
     }
 
@@ -351,7 +343,6 @@ module Make = (
           aggregateNames: [ReventlessCore.PluginSpec.name],
         },
       ],
-      connectExtension: None,
       extensions: [],
       pluginExtensionPointCmdTopicUrl: Pulumi.Output.make(""),
       publishToAggregates: Dict.make(),

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

@@ -29,12 +29,6 @@ let log = Logger$ReventlessCore.fromEnv();
 
 let configRef = {
   contents: {
-    eventTopicArn: undefined,
-    pluginReadModelTableName: undefined,
-    schedulerRoleArn: undefined,
-    schedulerQueueArn: undefined,
-    schedulerQueueName: undefined,
-    appSyncApiId: undefined,
     clonerEnabled: false
   }
 };
@@ -118,7 +112,6 @@ function identityProviderProvisioned() {
 let dcbConfigRef = {
   contents: {
     pluginName: "",
-    dcbTableName: undefined,
     stateChangeSliceModulePaths: []
   }
 };
@@ -192,19 +185,15 @@ function registerDcbConfig(pluginName, dcbTableName, stateChangeSliceModulePaths
 }
 
 function registerDcbTableName(dcbTableName) {
-  let init = dcbConfigRef.contents;
-  dcbConfigRef.contents = {
-    pluginName: init.pluginName,
-    dcbTableName: dcbTableName,
-    stateChangeSliceModulePaths: init.stateChangeSliceModulePaths
-  };
+  let newrecord = {...dcbConfigRef.contents};
+  newrecord.dcbTableName = dcbTableName;
+  dcbConfigRef.contents = newrecord;
 }
 
 let heartbeatConfigRef = {
   contents: {
     pluginId: "",
-    heartbeatTimeout: 10,
-    epQueueUrl: undefined
+    heartbeatTimeout: 10
   }
 };
 
@@ -252,12 +241,9 @@ function registerConfig(eventTopicArn, pluginReadModelTableName, schedulerRoleAr
 
 function Make(EventCollectorChannel) {
   let registerPluginName = pluginName => {
-    let init = dcbConfigRef.contents;
-    dcbConfigRef.contents = {
-      pluginName: pluginName,
-      dcbTableName: init.dcbTableName,
-      stateChangeSliceModulePaths: init.stateChangeSliceModulePaths
-    };
+    let newrecord = {...dcbConfigRef.contents};
+    newrecord.pluginName = pluginName;
+    dcbConfigRef.contents = newrecord;
   };
   let outputOrPlaceholder = opt => {
     if (opt !== undefined) {
@@ -280,7 +266,6 @@ function Make(EventCollectorChannel) {
           eventTopicArn: adminEpEventTopicArn,
           aggregateNames: [PluginSpec$ReventlessCore.name]
         }],
-      connectExtension: undefined,
       extensions: [],
       pluginExtensionPointCmdTopicUrl: Pulumi.output(""),
       publishToAggregates: {},

package/tests/AppSyncEventsSigner_OpsTest.res

@@ -33,7 +33,7 @@ let assertParity = (
   ~secretAccessKey,
   ~sessionToken,
 ) => {
-  let creds: AppSyncEventsSigner_Ops.creds = {accessKeyId, secretAccessKey, sessionToken}
+  let creds: AppSyncEventsSigner_Ops.creds = {accessKeyId, secretAccessKey, ?sessionToken}
   let mine = AppSyncEventsSigner_Ops.signedHeaders(~host, ~path, ~body, ~region, ~isoNow, ~creds)
   let jsCreds: jsCreds = {accessKeyId, secretAccessKey, ?sessionToken}
   let ref = signedHeadersJs(~host, ~path, ~body, ~region, ~isoNow, ~creds=jsCreds)

package/tests/AppSync_AdapterTest.res

@@ -961,10 +961,10 @@ describe("AppSync_Adapter.waitForMergeSuccess", () => {
   }
 
   let response = (~status, ~detail=?): AppSync_Adapter.getSourceApiAssociationResult => {
-    sourceApiAssociation: Some({
-      sourceApiAssociationStatus: Some(status),
-      sourceApiAssociationStatusDetail: detail,
-    }),
+    sourceApiAssociation: {
+      sourceApiAssociationStatus: status,
+      sourceApiAssociationStatusDetail: ?detail,
+    },
   }
 
   test("resolves once the association reports MERGE_SUCCESS", async () => {