@reventlessdev/reventless-aws 3.0.0-alpha.343 → 3.0.0-alpha.345

package/src/util/Util_Bundle.res.mjs

@@ -232,22 +232,28 @@ function isRuntimeProvided(specifier, pkgName) {
   }
 }
 
-let frameworkPackageCache = {};
+let filePath = new URL(import.meta.url).pathname;
 
-function isFrameworkPackage(pkgName) {
-  let known = frameworkPackageCache[pkgName];
-  if (known !== undefined) {
-    return known;
+let dirRef = Nodepath.dirname(filePath);
+
+let foundRef;
+
+while (dirRef !== "/" && Stdlib_Option.isNone(foundRef)) {
+  if (Nodefs.existsSync(Nodepath.join(dirRef, "package.json"))) {
+    foundRef = dirRef;
+  } else {
+    dirRef = Nodepath.dirname(dirRef);
   }
-  let known$1;
+};
+
+let frameworkPackageRoot = Stdlib_Option.getOr(foundRef, Nodepath.dirname(filePath));
+
+function declaredDependencies(packageRoot) {
   try {
-    localRequire.resolve(pkgName + "/package.json");
-    known$1 = true;
+    return Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(Nodepath.join(packageRoot, "package.json"), "utf8"))), o => o["dependencies"]), Stdlib_JSON.Decode.object), [], prim => Object.keys(prim));
   } catch (exn) {
-    known$1 = false;
+    return [];
   }
-  frameworkPackageCache[pkgName] = known$1;
-  return known$1;
 }
 
 let importedPackagesCache = {};
@@ -289,6 +295,47 @@ function resolvePackageRootFrom(fromRoot, pkgName) {
   }
 }
 
+let layerIncludedModules = new Set(["@rescript/runtime"]);
+
+let frameworkClosureCache = {
+  contents: undefined
+};
+
+function frameworkPackages() {
+  let closure = frameworkClosureCache.contents;
+  if (closure !== undefined) {
+    return closure;
+  }
+  let closure$1 = {};
+  let pending = [frameworkPackageRoot];
+  let next = 0;
+  while (next < pending.length) {
+    let root = pending[next];
+    next = next + 1 | 0;
+    declaredDependencies(root).forEach(dep => {
+      if (dep in closure$1) {
+        return;
+      }
+      closure$1[dep] = true;
+      let depRoot = resolvePackageRootFrom(root, dep);
+      if (depRoot !== undefined) {
+        pending.push(depRoot);
+        return;
+      }
+    });
+  };
+  frameworkClosureCache.contents = closure$1;
+  return closure$1;
+}
+
+function isFrameworkPackage(pkgName) {
+  if (pkgName === "@reventlessdev/reventless-aws" || layerIncludedModules.has(pkgName)) {
+    return true;
+  } else {
+    return pkgName in frameworkPackages();
+  }
+}
+
 function addImportedPackageClosure(packageDirs) {
   let pending = Object.entries(packageDirs).filter(param => !isFrameworkPackage(param[0]));
   let next = 0;
@@ -410,11 +457,15 @@ export {
   isBareSpecifier,
   nodeBuiltins,
   isRuntimeProvided,
-  frameworkPackageCache,
-  isFrameworkPackage,
+  frameworkPackageRoot,
+  declaredDependencies,
   importedPackagesCache,
   importedPackages,
   resolvePackageRootFrom,
+  layerIncludedModules,
+  frameworkClosureCache,
+  frameworkPackages,
+  isFrameworkPackage,
   addImportedPackageClosure,
   assertRuntimeExtensionImportsResolvable,
   buildCodeArchive,

package/src/util/Util_CognitoGroupUser_Runtime.res

@@ -9,27 +9,26 @@ let addUserToGroup = (
   ~groupName: string,
   ~userPoolId: string,
 ) =>
-  Effect.tryPromise(
-    ~catch=Cognito_Error.classify,
-    () => {
-      open CognitoIdentityServiceProvider
-      let client: CognitoIdentityServiceProvider.client = Raw.client(
-        ~options={endpoint: Util_Cognito_Runtime.userPoolEndpoint(region, userPoolId), region},
-      )
-      let addUserToGroupCommand: AdminAddUserToGroupCommand.t = {
-        username: userName,
-        groupName,
-        userPoolId,
-      }->AdminAddUserToGroupCommand.make
-      client->AdminAddUserToGroupCommand.Raw.send(addUserToGroupCommand)
-    },
-  )
+  Effect.tryPromise(~catch=Cognito_Error.classify, () => {
+    open CognitoIdentityServiceProvider
+    let client: CognitoIdentityServiceProvider.client = Raw.client(
+      ~options={endpoint: Util_Cognito_Runtime.userPoolEndpoint(region, userPoolId), region},
+    )
+    let addUserToGroupCommand: AdminAddUserToGroupCommand.t = {
+      username: userName,
+      groupName,
+      userPoolId,
+    }->AdminAddUserToGroupCommand.make
+    client->AdminAddUserToGroupCommand.Raw.send(addUserToGroupCommand)
+  })
   ->Effect.map(_ => ())
   ->Effect.retry(Cognito_Error.retrySchedule)
   ->Effect.catchAll(err => {
     let msg = Cognito_Error.message(err)
-    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, `addUserToGroup: ${msg}`)
-    ->Effect.flatMap(_ => Effect.fail(msg))
+    ReventlessCore.EffectLogger.logError(
+      ~comp=__MODULE__,
+      `addUserToGroup: ${msg}`,
+    )->Effect.flatMap(_ => Effect.fail(msg))
   })
   ->Effect.runPromise
 
@@ -40,26 +39,25 @@ let removeUserFromGroup = (
   ~groupName: string,
   ~userPoolId: string,
 ) =>
-  Effect.tryPromise(
-    ~catch=Cognito_Error.classify,
-    () => {
-      open CognitoIdentityServiceProvider
-      let client: CognitoIdentityServiceProvider.client = Raw.client(
-        ~options={endpoint: Util_Cognito_Runtime.userPoolEndpoint(region, userPoolId), region},
-      )
-      let removeUserFromGroupCommand = AdminRemoveUserFromGroupCommand.make({
-        username: userName,
-        groupName,
-        userPoolId,
-      })
-      client->AdminRemoveUserFromGroupCommand.Raw.send(removeUserFromGroupCommand)
-    },
-  )
+  Effect.tryPromise(~catch=Cognito_Error.classify, () => {
+    open CognitoIdentityServiceProvider
+    let client: CognitoIdentityServiceProvider.client = Raw.client(
+      ~options={endpoint: Util_Cognito_Runtime.userPoolEndpoint(region, userPoolId), region},
+    )
+    let removeUserFromGroupCommand = AdminRemoveUserFromGroupCommand.make({
+      username: userName,
+      groupName,
+      userPoolId,
+    })
+    client->AdminRemoveUserFromGroupCommand.Raw.send(removeUserFromGroupCommand)
+  })
   ->Effect.map(_ => ())
   ->Effect.retry(Cognito_Error.retrySchedule)
   ->Effect.catchAll(err => {
     let msg = Cognito_Error.message(err)
-    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, `removeUserFromGroup: ${msg}`)
-    ->Effect.flatMap(_ => Effect.fail(msg))
+    ReventlessCore.EffectLogger.logError(
+      ~comp=__MODULE__,
+      `removeUserFromGroup: ${msg}`,
+    )->Effect.flatMap(_ => Effect.fail(msg))
   })
   ->Effect.runPromise

package/src/util/Util_Cognito_Runtime.res

@@ -33,20 +33,24 @@ let signUp = (
 /** sign up a user to a given userPool, if the user is not already present
    NOTE: should be called in runtime
 */
-// Intentionally silent on failure: user may already exist (idempotent sign-up).
-let signUpIfMissing = (
+let // Intentionally silent on failure: user may already exist (idempotent sign-up).
+signUpIfMissing = (
   ~region: string,
   ~userPoolId: string,
   ~userPoolClientId: string,
   ~userName: string,
   ~password: string,
 ) =>
-  Effect.tryPromise(
-    ~catch=Cognito_Error.classify,
-    () => signUp(~region, ~userPoolId, ~userPoolClientId, ~userName, ~password),
+  Effect.tryPromise(~catch=Cognito_Error.classify, () =>
+    signUp(~region, ~userPoolId, ~userPoolClientId, ~userName, ~password)
   )
   ->Effect.flatMap(result =>
-    ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, `Created User ${userName} ${result.userSub->Option.getOr("")}`)
+    ReventlessCore.EffectLogger.logInfo(
+      ~comp=__MODULE__,
+      `Created User ${userName} ${result.userSub->Option.getOr("")}`,
+    )
+  )
+  ->Effect.catchAll(err =>
+    ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, Cognito_Error.message(err))
   )
-  ->Effect.catchAll(err => ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, Cognito_Error.message(err)))
   ->Effect.runPromise

package/src/util/Util_DeadLetterQueue.res

@@ -158,7 +158,12 @@ let handler = Lambda.Function.make(
     memorySize: 128->Pulumi.Input.make,
     timeout: 30->Pulumi.Input.make,
     layers,
-    tags: AWS.Tags.make(~name, ~kind=ReventlessCore.ComponentType.Plugin, ~role=DeadLetter, ~scope=Plugin),
+    tags: AWS.Tags.make(
+      ~name,
+      ~kind=ReventlessCore.ComponentType.Plugin,
+      ~role=DeadLetter,
+      ~scope=Plugin,
+    ),
     environment: (
       {
         Lambda.Function.variables: Dict.fromArray([
@@ -176,7 +181,12 @@ let handler = Lambda.Function.make(
 // kind, mechanism-agnostic resource — no-op unless a backend is registered.
 let deadLetterResource = Util_Lambda.functionToResource(
   handler,
-  ~tags=AWS.Tags.make(~name, ~kind=ReventlessCore.ComponentType.Plugin, ~role=DeadLetter, ~scope=Plugin)->Pulumi.Output.fromInput,
+  ~tags=AWS.Tags.make(
+    ~name,
+    ~kind=ReventlessCore.ComponentType.Plugin,
+    ~role=DeadLetter,
+    ~scope=Plugin,
+  )->Pulumi.Output.fromInput,
 )
 
 ReventlessCore.Monitoring.notify(

package/src/util/Util_DynamoDb.res

@@ -4,7 +4,10 @@ open ReventlessInfra.Adapter
 
 let log = ReventlessCore.Logger.fromEnv()
 
-let toResourceInfo: table => Pulumi.Output.t<ReventlessInfra.Adapter.resourceInfo> = ({hashKey, rangeKey}) =>
+let toResourceInfo: table => Pulumi.Output.t<ReventlessInfra.Adapter.resourceInfo> = ({
+  hashKey,
+  rangeKey,
+}) =>
   (hashKey, rangeKey)
   ->Pulumi.Output.all2
   ->Pulumi.Output.apply(((hashKey, rangeKey)) => ReventlessInfra.Adapter.StorageKeys({
@@ -33,10 +36,9 @@ let toResource = (~tags=?, {id, name, arn} as table) =>
     ~service=name->Pulumi.Output.apply(_ => AWS.DynamoDb.service),
     ~resourceInfo=table->toResourceInfo,
     ~resourceType="aws:dynamodb:Table"->Pulumi.Output.make,
-    ~tags=?tags,
+    ~tags?,
   )
 
-
 let arn2tableName = arn =>
   switch arn->String.split(":") {
   | [_, _, _service, _region, _account, tableName] => tableName

package/src/util/Util_DynamoDbStream.res

@@ -1,5 +1,7 @@
 let toResourceInfo = (table: PulumiAws.DynamoDb.Table.t) =>
-  table.streamArn->Pulumi.Output.apply(streamArn => ReventlessInfra.Adapter.StreamSource({sourceUrn: streamArn}))
+  table.streamArn->Pulumi.Output.apply(streamArn => ReventlessInfra.Adapter.StreamSource({
+    sourceUrn: streamArn,
+  }))
 
 // The table name rides IN the apply rather than being read with `Output.get` on
 // the failure arm: `get` throws "Cannot call '.get' during update or preview" on
@@ -23,10 +25,12 @@ let toResource = (~tags=?, table: PulumiAws.DynamoDb.Table.t): ReventlessInfra.A
     ~service=table.name->Pulumi.Output.apply(_ => AWS.DynamoDbStream.service),
     ~resourceInfo=table->toResourceInfo,
     ~resourceType="aws:dynamodb:Table"->Pulumi.Output.make,
-    ~tags=?tags,
+    ~tags?,
   )
 
-let toStreamResource = (table: ReventlessInfra.Adapter.resource): ReventlessInfra.Adapter.resource => {
+let toStreamResource = (
+  table: ReventlessInfra.Adapter.resource,
+): ReventlessInfra.Adapter.resource => {
   let streamArn = table->streamArnFromDynamoDbTableResource
 
   ReventlessInfra.Adapter.make(

package/src/util/Util_DynamoDbStream_Runtime.res

@@ -37,8 +37,7 @@ let buildJsonEvent' = dict => {
     // Carry the stored `recorded_at` column into the envelope so StateViewSlice
     // projections receive it as `consumed.recordedAt` (the authoritative storage
     // time on the AWS path). Absent on non-event rows → empty string.
-    let recordedAt =
-      dict->Dict.get("recordedAt")->Option.getOr(""->JSON.Encode.string)
+    let recordedAt = dict->Dict.get("recordedAt")->Option.getOr(""->JSON.Encode.string)
     Some(
       [
         ("id", dict->Dict.get("id")->Option.getOrThrow),

package/src/util/Util_DynamoDb_Runtime.res

@@ -31,19 +31,16 @@ let putWithRetries = (table, id, item) => {
       ReventlessCore.EffectLogger.logError(
         ~comp=__MODULE__,
         `putWithRetries: id=${id}: ${msg}`,
-      )
-      ->Effect.map(_ => Error(`put id=${id} failed: ${msg}`))
-    | StaleState(msg) =>
-      Effect.succeed(Error(`Stale State: id=${id}: ${msg}`))
+      )->Effect.map(_ => Error(`put id=${id} failed: ${msg}`))
+    | StaleState(msg) => Effect.succeed(Error(`Stale State: id=${id}: ${msg}`))
     }
   )
 }
 
 let putIfNotExistsWithRetries = (~idKey, ~sortKey=?, table, id, item) => {
   let item = item->injectId(idKey, id)
-  Effect.tryPromise(
-    ~catch=DynamoDb_Error.classify,
-    () => putIfNotExists(table.name, idKey, sortKey, item),
+  Effect.tryPromise(~catch=DynamoDb_Error.classify, () =>
+    putIfNotExists(table.name, idKey, sortKey, item)
   )
   ->Effect.map(_ => Ok())
   ->Effect.retry(DynamoDb_Error.retrySchedule)
@@ -54,8 +51,7 @@ let putIfNotExistsWithRetries = (~idKey, ~sortKey=?, table, id, item) => {
       ReventlessCore.EffectLogger.logError(
         ~comp=__MODULE__,
         `putIfNotExistsWithRetries: id=${id}: ${msg}`,
-      )
-      ->Effect.map(_ => Error(`putIfNotExists id=${id} failed: ${msg}`))
+      )->Effect.map(_ => Error(`putIfNotExists id=${id} failed: ${msg}`))
     }
   )
 }
@@ -65,10 +61,7 @@ let delete = (table, ~sort=?, id) => {
 }
 
 let deleteWithRetries = (~sort=?, table, id) =>
-  Effect.tryPromise(
-    ~catch=DynamoDb_Error.classify,
-    () => table->delete(id, ~sort?),
-  )
+  Effect.tryPromise(~catch=DynamoDb_Error.classify, () => table->delete(id, ~sort?))
   ->Effect.map(_ => Ok())
   ->Effect.retry(DynamoDb_Error.retrySchedule)
   ->Effect.catchAll(err => {
@@ -76,24 +69,20 @@ let deleteWithRetries = (~sort=?, table, id) =>
     ReventlessCore.EffectLogger.logError(
       ~comp=__MODULE__,
       `delete: id=${id}: ${msg}`,
-    )
-    ->Effect.map(_ => Error(`delete id=${id} failed: ${msg}`))
+    )->Effect.map(_ => Error(`delete id=${id} failed: ${msg}`))
   })
 
 // Streams all items matching a QueryCommand, fetching one DynamoDB page at a time.
 // Each page fetch retries independently on transient errors.
 let queryStream = (params: QueryCommand.input): Stream.t<JSON.t, DynamoDb_Error.t, unit> =>
   Stream.paginateEffect((None: option<dict<JSON.t>>), cursor =>
-    Effect.tryPromise(
-      ~catch=DynamoDb_Error.classify,
-      () => {
-        let p = switch cursor {
-        | None => params
-        | Some(key) => {...params, exclusiveStartKey: key}
-        }
-        QueryCommand.send(p->QueryCommand.make)
-      },
-    )
+    Effect.tryPromise(~catch=DynamoDb_Error.classify, () => {
+      let p = switch cursor {
+      | None => params
+      | Some(key) => {...params, exclusiveStartKey: key}
+      }
+      QueryCommand.send(p->QueryCommand.make)
+    })
     ->Effect.retry(DynamoDb_Error.retrySchedule)
     ->Effect.map(res => (
       res.items->Option.getOr([]),
@@ -105,16 +94,13 @@ let queryStream = (params: QueryCommand.input): Stream.t<JSON.t, DynamoDb_Error.
 // Each page fetch retries independently on transient errors.
 let scanStream = (params: ScanCommand.input): Stream.t<JSON.t, DynamoDb_Error.t, unit> =>
   Stream.paginateEffect((None: option<dict<JSON.t>>), cursor =>
-    Effect.tryPromise(
-      ~catch=DynamoDb_Error.classify,
-      () => {
-        let p = switch cursor {
-        | None => params
-        | Some(key) => {...params, exclusiveStartKey: key}
-        }
-        ScanCommand.send(ScanCommand.make(p))
-      },
-    )
+    Effect.tryPromise(~catch=DynamoDb_Error.classify, () => {
+      let p = switch cursor {
+      | None => params
+      | Some(key) => {...params, exclusiveStartKey: key}
+      }
+      ScanCommand.send(ScanCommand.make(p))
+    })
     ->Effect.retry(DynamoDb_Error.retrySchedule)
     ->Effect.map(res => (
       res.items->Option.getOr([]),
@@ -180,10 +166,7 @@ let hasUnprocessedItems = writeOutput =>
 let batchWriteWithRetries = batchWriteRequests => {
   let all = batchWriteRequests->Dict.valuesToArray->Array.flat->Array.length->Int.toString
   let rec attempt = (retry, requests) =>
-    Effect.tryPromise(
-      ~catch=DynamoDb_Error.classify,
-      () => batchWrite(requests),
-    )
+    Effect.tryPromise(~catch=DynamoDb_Error.classify, () => batchWrite(requests))
     ->Effect.retry(DynamoDb_Error.retrySchedule)
     ->Effect.flatMap(writeOutput =>
       if writeOutput->hasUnprocessedItems {
@@ -192,8 +175,7 @@ let batchWriteWithRetries = batchWriteRequests => {
         ReventlessCore.EffectLogger.logInfo(
           ~comp=__MODULE__,
           `batchWriteWithRetries: retry ${retry->Int.toString}: ${count} unprocessed items`,
-        )
-        ->Effect.flatMap(_ => attempt(retry + 1, unprocessedRequests))
+        )->Effect.flatMap(_ => attempt(retry + 1, unprocessedRequests))
       } else {
         Effect.succeed(Ok())
       }

package/src/util/Util_HostUiDomain.res

@@ -13,7 +13,12 @@
 let defaultProdStacks = ["prod", "main"]
 
 /** Pure FQDN derivation. */
-let deriveFqdn = (~baseName: string, ~stack: string, ~baseDomain: string, ~prodStacks: array<string>): string =>
+let deriveFqdn = (
+  ~baseName: string,
+  ~stack: string,
+  ~baseDomain: string,
+  ~prodStacks: array<string>,
+): string =>
   prodStacks->Array.includes(stack)
     ? `${baseName}.${baseDomain}`
     : `${baseName}-${stack}.${baseDomain}`

package/src/util/Util_Kinesis_Runtime.res

@@ -1,20 +1,19 @@
 let putRecord = (stream, ~data) =>
-  Effect.tryPromise(
-    ~catch=Kinesis_Error.classify,
-    () =>
-      AwsSdk.Kinesis.PutRecordCommand.make({
-        data,
-        //FIXME: remove JST after merge of rescript-v11 upgrade
-        streamName: stream["name"]->Pulumi.Output.get,
-        partitionKey: "",
-      })->AwsSdk.Kinesis.PutRecordCommand.send,
+  Effect.tryPromise(~catch=Kinesis_Error.classify, () =>
+    AwsSdk.Kinesis.PutRecordCommand.make({
+      data,
+      //FIXME: remove JST after merge of rescript-v11 upgrade
+      streamName: stream["name"]->Pulumi.Output.get,
+      partitionKey: "",
+    })->AwsSdk.Kinesis.PutRecordCommand.send
   )
   ->Effect.map(_ => ())
   ->Effect.retry(Kinesis_Error.retrySchedule)
   ->Effect.catchAll(err => {
     let msg = Kinesis_Error.message(err)
-    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, `putRecord: ${msg}`)
-    ->Effect.flatMap(_ => Effect.fail(msg))
+    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, `putRecord: ${msg}`)->Effect.flatMap(_ =>
+      Effect.fail(msg)
+    )
   })
   ->Effect.runPromise
 /* TODO partitionKey */

package/src/util/Util_Lambda.res

@@ -3,16 +3,20 @@ type runtimeParts = {
   lambdaRole: PulumiAws.IAM.Role.t,
 }
 
-let findResource = resources => resources->ReventlessCore.Util.Adapter.findResource(AWS.Lambda.service)
+let findResource = resources =>
+  resources->ReventlessCore.Util.Adapter.findResource(AWS.Lambda.service)
 
-let toResource = (~tags=?, {id, name, arn}: PulumiAws.Lambda.Function.t): ReventlessInfra.Adapter.resource =>
+let toResource = (
+  ~tags=?,
+  {id, name, arn}: PulumiAws.Lambda.Function.t,
+): ReventlessInfra.Adapter.resource =>
   ReventlessInfra.Adapter.make(
     ~name,
     ~id,
     ~urn=arn,
     ~service=name->Pulumi.Output.apply(_ => AWS.Lambda.service),
     ~resourceType="aws:lambda:Function"->Pulumi.Output.make,
-    ~tags=?tags,
+    ~tags?,
   )
 
 let fromResource = ({id, name}: ReventlessInfra.Adapter.resource) => {
@@ -41,12 +45,15 @@ let fromOutput = (output: Pulumi.Output.t<PulumiAws.Lambda.Function.t>) => {
 let updateLanded = (lambda: Pulumi.Output.t<PulumiAws.Lambda.Function.t>): Pulumi.Output.t<unit> =>
   lambda->Pulumi.Output.flatMap(({lastModified}) => lastModified)->Pulumi.Output.apply(_ => ())
 
-let functionToResource = (~tags=?, {id, name, arn}: PulumiAws.Lambda.Function.t): ReventlessInfra.Adapter.resource =>
+let functionToResource = (
+  ~tags=?,
+  {id, name, arn}: PulumiAws.Lambda.Function.t,
+): ReventlessInfra.Adapter.resource =>
   ReventlessInfra.Adapter.make(
     ~name,
     ~id,
     ~urn=arn,
     ~service=name->Pulumi.Output.apply(_ => AWS.Lambda.service),
     ~resourceType="aws:lambda:Function"->Pulumi.Output.make,
-    ~tags=?tags,
+    ~tags?,
   )

package/src/util/Util_LambdaEnvBudget.res

@@ -59,16 +59,16 @@ let check = (
       `${outputValuedKeys->Array.length->Int.toString} queue-URL vars are resolved, over the ` ++
       `${limit->Int.toString}-byte limit. HANDLER_CONFIG is ${handlerConfigBytes->Int.toString} ` ++
       `bytes of it — move the term that grows with the plugin into a code-archive asset ` ++
-      `(Util_Bundle.buildCodeArchive ~extraStringAssets), as pluginDefinition.json and ` ++
-      `sliceModules.json already are.`,
+      `(Util_Bundle.buildCodeArchive ~extraStringAssets), as pluginDefinition.json and ` ++ `sliceModules.json already are.`,
     )
   } else if estimated > limit {
     log.warn(
       ~comp="Util_LambdaEnvBudget",
       `${lambdaName}: Lambda environment is about ${estimated->Int.toString} bytes ` ++
-      `(${exact->Int.toString} exact + ${outputValuedKeys->Array.length->Int.toString} queue-URL ` ++
-      `vars), at or over the ${limit->Int.toString}-byte limit. The deploy may fail on ` ++
-      `UpdateFunctionConfiguration; move a plugin-sized term out of HANDLER_CONFIG.`,
+      `(${exact->Int.toString} exact + ${outputValuedKeys
+        ->Array.length
+        ->Int.toString} queue-URL ` ++
+      `vars), at or over the ${limit->Int.toString}-byte limit. The deploy may fail on ` ++ `UpdateFunctionConfiguration; move a plugin-sized term out of HANDLER_CONFIG.`,
     )
   }
 }

package/src/util/Util_LambdaLogging.res

@@ -131,8 +131,7 @@ let makeManagedLogGroup = (
     Kept here, beside `logGroupNameFor`, so both naming shapes a Lambda's logs can
     take live in the one module that owns log-group naming and neither is
     reconstructed at a call site. */
-let autoCreatedLogGroupNameFor = (~physicalName: string): string =>
-  `/aws/lambda/${physicalName}`
+let autoCreatedLogGroupNameFor = (~physicalName: string): string => `/aws/lambda/${physicalName}`
 
 /** Where a function's logs actually land, for a caller that wants to point
     somebody at them (a monitoring backend stamping an address into an alert).

package/src/util/Util_LogGroup_Adopting.res

@@ -38,7 +38,6 @@
     run the **serialised** version, not current source. A fix here reaches a
     given resource only once that resource is next created or updated. Keep each
     step able to handle state written by earlier versions. */
-
 let log = ReventlessCore.Logger.fromEnv()
 
 // ── AWS SDK bindings (lazily imported — see AppSync_SourceApiAssociation_Retrying) ──
@@ -266,9 +265,7 @@ let create = async (inputs: providerInputs): createResultOut => {
   let {logGroupName, retentionInDays, tags} = inputs
 
   let adopted = try {
-    await runWithRetry(() =>
-      client->sendCreate(newCommand(sdk.createCtor, {logGroupName, tags}))
-    )
+    await runWithRetry(() => client->sendCreate(newCommand(sdk.createCtor, {logGroupName, tags})))
     false
   } catch {
   | exn if exn->JsExn.fromException->Option.mapOr(false, isAlreadyExistsError) => true

package/src/util/Util_ResourceNaming.res

@@ -5,8 +5,7 @@ let invalidNameChars = /[^.\-_a-zA-Z0-9]/g
 let validateName = String.replaceRegExp(_, invalidNameChars, "_")
 
 // Example ARN: arn:aws:sqs:eu-west-1:xxxxxx:MarketplaceServiceExtensionPointCommandTopic-0101023
-let urnName: string => string = arn =>
-  arn->String.split(":")->Array.get(5)->Option.getOr("unknown")
+let urnName: string => string = arn => arn->String.split(":")->Array.get(5)->Option.getOr("unknown")
 
 // Export as operations interface
 let operations: ReventlessInfra.ResourceNaming.operations = {

package/src/util/Util_SNS.res

@@ -7,14 +7,17 @@ let toResolvedTopicOutput = ({name, id, arn}: PulumiAws.SNS.Topic.t) =>
     arn,
   })
 
-let toResource = (~tags=?, {id, name, arn}: PulumiAws.SNS.Topic.t): ReventlessInfra.Adapter.resource =>
+let toResource = (
+  ~tags=?,
+  {id, name, arn}: PulumiAws.SNS.Topic.t,
+): ReventlessInfra.Adapter.resource =>
   ReventlessInfra.Adapter.make(
     ~name,
     ~id,
     ~urn=arn,
     ~service=name->Pulumi.Output.apply(_ => AWS.SNS.service),
     ~resourceType="aws:sns:Topic"->Pulumi.Output.make,
-    ~tags=?tags,
+    ~tags?,
   )
 
 let findResolvedResource = resources =>
@@ -23,7 +26,9 @@ let findResolvedResource = resources =>
 let log = ReventlessCore.Logger.fromEnv()
 
 let findTopicInResolvedResources = resources =>
-  switch resources->ReventlessCore.Util_Adapter.filterSupportedResolvedResources([AWS.SNS.service]) {
+  switch resources->ReventlessCore.Util_Adapter.filterSupportedResolvedResources([
+    AWS.SNS.service,
+  ]) {
   | [] =>
     let err = "Couldn't find SNS Topic in resources"
     log.error(~comp="SNS", err)

package/src/util/Util_SNS_FIFO.res

@@ -5,7 +5,7 @@ let toResource = (~tags=?, {PulumiAws.SNS.Topic.id: id, name, arn}) =>
     ~urn=arn,
     ~service=name->Pulumi.Output.apply(_ => AWS.SNS_FIFO.service),
     ~resourceType="aws:sns:Topic"->Pulumi.Output.make,
-    ~tags=?tags,
+    ~tags?,
   )
 
 let findTopicInResolvedResources = resources =>