@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/StateViewSliceEntryPoint.mjs

@@ -0,0 +1,136 @@
+// StateViewSlice Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports Spec modules,
+// builds projection handler that decodes events and runs Projection.handleAction.
+// Routes DynamoDB Stream events by source URN.
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { parseJsonOrThrow } from "sury/src/S.res.mjs";
+import { makeTableRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { handleAction } from "@reventlessdev/reventless-core/src/Projection.res.mjs";
+import { load, loadStream, save, saveBatch, count, $$delete, deleteBatch } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// Set at handler entry; read by runEffect to tag logs with the Lambda request id.
+let _currentRequestId = "unknown";
+
+function runEffect(correlationId, effect) {
+  let e = effect
+    // Promote correlationId/requestId/plugin to top-level JSON log fields —
+    // decoded by EffectLogger.install() from Effect log annotations. Harmless
+    // no-op if the unified logger isn't installed.
+    .pipe(Effect.annotateLogs("correlationId", correlationId || "unknown"))
+    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
+  if (pluginName) e = e.pipe(Effect.annotateLogs("plugin", pluginName));
+  return e
+    .pipe(Effect.provideService(requestContextTag, { correlationId: correlationId || "unknown" }))
+    .pipe(Effect.runPromise);
+}
+
+function groupBySource(records) {
+  const dict = {};
+  records.forEach(record => {
+    const arn = record.eventSourceARN;
+    const existing = dict[arn] || [];
+    dict[arn] = existing.concat([record]);
+  });
+  return dict;
+}
+
+function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName) {
+  const table = makeTableRef(queryDbTableName);
+  const queryDbOps = {
+    load: load(table),
+    loadStream: loadStream(table),
+    save: save(table),
+    saveBatch: saveBatch(table),
+    count: count(table),
+    delete: $$delete(table),
+    deleteBatch: deleteBatch(table),
+  };
+  // Spec module exports `consumedEventSchema`; the `project` function lives in
+  // the sibling projection module (`<Name>_Projection.res`).
+  const eventSchema = specModule.consumedEventSchema;
+  const project = projectionModule.project;
+
+  return stream => Stream.runForEach(
+    Stream.flatMap(
+      Stream.mapEffect(stream, json => Effect.sync(() => {
+        try {
+          const eventJson = json.event != null ? json.event : json;
+          return project(parseJsonOrThrow(eventJson, eventSchema));
+        } catch (exn) {
+          log.error("failed to decode event", { comp: "StateViewSliceRuntime", detail: exn && exn.message ? exn.message : String(exn) });
+          return [];
+        }
+      })),
+      actions => Stream.fromIterable(actions)
+    ),
+    action => Effect.map(
+      Effect.promise(() => handleAction(action, queryDbOps, undefined)),
+      _ => {}
+    )
+  );
+}
+
+// HANDLER_CONFIG is emitted compact (StateViewSliceRuntime_Builder_Single) to
+// stay under AWS Lambda's 4KB env-var limit: a shared module-path `base` and a
+// shared `sourceUrn` are hoisted out, and per-handler keys are shortened to
+// s/p/q/u. Expand back to the full {specModule, projectionModule,
+// queryDbTableName, sourceUrn} shape. Legacy full-key entries pass through.
+function expandHandlers(config) {
+  const base = config.base || "";
+  const sharedUrn = config.sourceUrn || "";
+  return (config.handlers || []).map(h => {
+    if (h.specModule !== undefined) return h;
+    return {
+      specModule: base + h.s,
+      projectionModule: base + h.p,
+      queryDbTableName: h.q,
+      sourceUrn: h.u !== undefined ? h.u : sharedUrn,
+    };
+  });
+}
+
+async function buildAllHandlers() {
+  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
+  const config = JSON.parse(configStr);
+  const handlers = {};
+  await Promise.all(expandHandlers(config).map(async h => {
+    const [specModule, projectionModule] = await Promise.all([
+      dynamicImport(h.specModule),
+      dynamicImport(h.projectionModule),
+    ]);
+    const jsonEventsHandler = buildJsonEventsHandler(specModule, projectionModule, h.queryDbTableName);
+    const streamHandler = (event, context) => handleStreamEvent(jsonEventsHandler, event, context);
+    const existing = handlers[h.sourceUrn] || [];
+    existing.push(streamHandler);
+    handlers[h.sourceUrn] = existing;
+  }));
+  return handlers;
+}
+
+const initPromise = buildAllHandlers();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const handlers = await initPromise;
+  const records = event.Records || [];
+  const grouped = groupBySource(records);
+
+  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
+    const streamHandlers = handlers[arn];
+    if (streamHandlers !== undefined && streamHandlers.length > 0) {
+      log.debug("found " + streamHandlers.length + " handler(s) for " + arn, { comp: "StateViewSliceRuntime" });
+      await Promise.all(streamHandlers.map(h =>
+        runEffect(undefined, h({ Records: subRecords }, context))
+      ));
+    } else {
+      log.warn("no handler found: " + arn, { comp: "StateViewSliceRuntime" });
+    }
+  }));
+  return "";
+}

package/src/adapter/Runtime/StateViewSliceRuntime_Builder_Single.res

@@ -0,0 +1,344 @@
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+// One StateViewSlice handler, carried structured (not pre-serialized) so
+// buildLambda can hoist shared fields before emitting HANDLER_CONFIG.
+type handlerEntry = {
+  specModule: string,
+  projectionModule: string,
+  queryDbTableName: string,
+  sourceUrn: string,
+}
+
+// Longest common prefix of a set of strings. Used to factor the shared
+// module-path prefix out of the per-handler config so the serialized
+// HANDLER_CONFIG stays under AWS Lambda's 4KB env-var ceiling.
+let commonPrefix = (strings: array<string>): string =>
+  switch strings->Array.get(0) {
+  | None => ""
+  | Some(first) =>
+    strings->Array.reduce(first, (prefix, s) => {
+      let p = ref(prefix)
+      while p.contents != "" && !(s->String.startsWith(p.contents)) {
+        p := p.contents->String.slice(~start=0, ~end=String.length(p.contents) - 1)
+      }
+      p.contents
+    })
+  }
+
+type sliceInfo = {
+  specModulePath: string,
+  projectionModulePath: string,
+  queryDbTableName: Pulumi.Output.t<string>,
+  queryDbResources: array<ReventlessInfra.Adapter.resource>,
+}
+
+let sliceInfos: dict<sliceInfo> = Dict.make()
+
+let registerStateViewSlice = (
+  ~name,
+  ~specModulePath,
+  ~projectionModulePath,
+  ~queryDbTableName,
+  ~queryDbResources=[],
+) =>
+  sliceInfos->Dict.set(
+    name,
+    {specModulePath, projectionModulePath, queryDbTableName, queryDbResources},
+  )
+
+type storedSpec = {
+  componentName: string,
+  parentResource: Pulumi.Resource.t,
+  sourceUrns: Pulumi.Output.t<array<string>>,
+  channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<
+    EventCollectorChannel.callbackEvent,
+    context,
+    EventCollectorChannel.channelParts,
+  >,
+  memorySize: int,
+  timeout: int,
+}
+
+let storedSpecs: array<storedSpec> = []
+let grandParent = ref(None)
+
+let forEventCollector: ReventlessCore.Runtime.forEventCollector<
+  ReventlessCore.Runtime.effectHandler<
+    EventCollectorChannel.callbackEvent,
+    context,
+    unit,
+    string,
+  >,
+  ReventlessCore.EventCollector.component,
+> = (
+  ~handler as _,
+  ~eventTopics,
+  ~resources,
+  ~memorySize=1024,
+  ~timeout=30,
+  eventCollector,
+) => {
+  let eventCollectorResource = eventCollector->ReventlessCore.Component.toPulumiResource
+  let channel = eventCollector->ReventlessCore.EventCollector_Adapter.channel
+  let eventCollectorName = eventCollectorResource.name->Option.getOr("Unnamed")
+
+  switch eventCollectorResource.parent {
+  | Some(parentResource) =>
+    let parentName = parentResource.name->Option.getOr("Unnamed")
+    if grandParent.contents == None {
+      grandParent := parentResource.parent
+    }
+
+    let sourceUrns =
+      (eventCollector->ReventlessCore.Component.outputs).resources
+      ->Array.map(({urn}) => urn)
+      ->Pulumi.Output.all
+
+    storedSpecs
+    ->Array.push({
+      componentName: parentName,
+      parentResource,
+      sourceUrns,
+      channelSpec: {channel, eventTopics, resources},
+      memorySize,
+      timeout,
+    })
+    ->ignore
+
+    log.info(
+      ~comp="StateViewSliceRuntime_Builder_Single",
+      `registered ${eventCollectorName} for ${parentName}`,
+    )
+  | None =>
+    JsError.throwWithMessage(
+      `forEventCollector(single): eventCollector ${eventCollectorName} has no parent`,
+    )
+  }
+}
+
+let finished = ref(false)
+
+let buildLambda = (
+  ~parent,
+  ~handlerOutputs: array<Pulumi.Output.t<handlerEntry>>,
+  ~packageDirs,
+  ~channelSpecs,
+  ~memorySize=1024,
+  ~timeout=30,
+) => {
+  let opts = {Pulumi.ComponentResource.parent: parent}
+  // Compress HANDLER_CONFIG to stay under AWS Lambda's 4KB env-var ceiling:
+  // hoist the common module-path prefix (`base`) and the shared DCB stream
+  // `sourceUrn` (identical across a plugin's slices) out of the per-handler
+  // entries, and use short keys (s/p/q/u). StateViewSliceEntryPoint re-expands
+  // these. Durable fix (externalize to S3/SSM) tracked in docs/plans.
+  let handlerConfigOutput =
+    Pulumi.Output.all(handlerOutputs)
+    ->Pulumi.Output.apply(handlers => {
+      let paths = []
+      handlers->Array.forEach(h => {
+        paths->Array.push(h.specModule)->ignore
+        paths->Array.push(h.projectionModule)->ignore
+      })
+      let base = commonPrefix(paths)
+      let baseLen = String.length(base)
+      let firstUrn = handlers->Array.get(0)->Option.map(h => h.sourceUrn)
+      let sharedUrn =
+        handlers->Array.every(h => Some(h.sourceUrn) == firstUrn) ? firstUrn->Option.getOr("") : ""
+      let entries =
+        handlers
+        ->Array.map(h => {
+          let s =
+            h.specModule
+            ->String.slice(~start=baseLen, ~end=String.length(h.specModule))
+            ->JSON.stringifyAny
+            ->Option.getOr(`""`)
+          let p =
+            h.projectionModule
+            ->String.slice(~start=baseLen, ~end=String.length(h.projectionModule))
+            ->JSON.stringifyAny
+            ->Option.getOr(`""`)
+          let q = h.queryDbTableName->JSON.stringifyAny->Option.getOr(`""`)
+          if sharedUrn != "" {
+            `{"s":${s},"p":${p},"q":${q}}`
+          } else {
+            let u = h.sourceUrn->JSON.stringifyAny->Option.getOr(`""`)
+            `{"s":${s},"p":${p},"q":${q},"u":${u}}`
+          }
+        })
+        ->Array.join(",")
+      let baseJson = base->JSON.stringifyAny->Option.getOr(`""`)
+      let urnJson = sharedUrn->JSON.stringifyAny->Option.getOr(`""`)
+      `{"v":2,"base":${baseJson},"sourceUrn":${urnJson},"handlers":[${entries}]}`
+    })
+
+  let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+  envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+
+  // Bundle the framework packages alongside the entry point so the deployed
+  // Lambda picks up local edits without waiting for a Lambda Layer rebuild
+  // (the layer fetches @reventlessdev/reventless-* from GitHub Packages, not
+  // the local pnpm workspace). Mirrors the DCB asset pattern in
+  // StateChangeSliceRuntime_Builder_Single. Util_Bundle co-bundles `effect`
+  // automatically when reventless-aws is present.
+  packageDirs->Dict.set(
+    "@reventlessdev/reventless-aws",
+    Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws"),
+  )
+  packageDirs->Dict.set(
+    "@reventlessdev/reventless-core",
+    Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-core"),
+  )
+
+  let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+    ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs",
+    ~packageDirs,
+  )
+
+  let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+    ~name="AllStateViewSlices",
+    ~code,
+    ~sourceCodeHash,
+    ~envVars,
+    ~memorySize,
+    ~timeout,
+    ~opts,
+  )
+
+  let _connectResources = EventCollectorChannel.connect(
+    ~name="AllStateViewSlices",
+    ~channelSpecs,
+    ~runtime,
+    ~opts,
+  )
+}
+
+let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component) =>
+  if !finished.contents {
+    let infoCount = sliceInfos->Dict.keysToArray->Array.length
+    if infoCount > 0 {
+      let dcbResource = dcbEventLog->ReventlessCore.Component.toPulumiResource
+      switch dcbResource.parent {
+      | Some(parent) =>
+        let dcbOutputs: ReventlessCore.DcbEventLog.outputs = dcbEventLog->ReventlessCore.Component.outputs
+        let eventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
+          ("DcbEventLog", dcbOutputs.eventTopic),
+        ])
+        let channel = EventCollectorChannel.make(
+          ~name="AllStateViewSlices",
+          ~eventTopics,
+          ~opts={Pulumi.ComponentResource.parent: parent},
+        )
+
+        let handlerOutputs: array<Pulumi.Output.t<handlerEntry>> = []
+        let packageDirs: dict<string> = Dict.make()
+        let allQueryDbResources: array<ReventlessInfra.Adapter.resource> = []
+
+        sliceInfos->Dict.forEachWithKey((info, _name) => {
+          info.queryDbResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
+          let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+          packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+          let projectionPkg = Util_Bundle.extractPackageName(info.projectionModulePath)
+          packageDirs->Dict.set(projectionPkg, Util_Bundle.resolvePackageRoot(projectionPkg))
+
+          let etResources: array<ReventlessInfra.Adapter.resource> = dcbOutputs.eventTopic.resources
+          let sourceUrn = etResources->Array.getUnsafe(0)
+          let sourceUrn = sourceUrn.urn
+
+          let handlerJson =
+            Pulumi.Output.all2((info.queryDbTableName, sourceUrn))
+            ->Pulumi.Output.apply(((tableName, urn)) => {
+              let entry: handlerEntry = {
+                specModule: info.specModulePath,
+                projectionModule: info.projectionModulePath,
+                queryDbTableName: tableName,
+                sourceUrn: urn,
+              }
+              entry
+            })
+          let _ = handlerOutputs->Array.push(handlerJson)
+        })
+
+        buildLambda(
+          ~parent,
+          ~handlerOutputs,
+          ~packageDirs,
+          ~channelSpecs=[{channel: channel, eventTopics, resources: allQueryDbResources}],
+        )
+      | None =>
+        log.warn(
+          ~comp="StateViewSliceRuntime_Builder_Single",
+          "finishWithDcbEventLog: DCB EventLog has no parent",
+        )
+      }
+    }
+    finished := true
+  }
+
+let finish = () =>
+  if !finished.contents {
+    log.info(
+      ~comp="StateViewSliceRuntime_Builder_Single",
+      `finish: ${storedSpecs->Array.length->Int.toString} storedSpecs, ${sliceInfos->Dict.keysToArray->Array.length->Int.toString} sliceInfos, grandParent=${grandParent.contents->Option.map(_ => "Some")->Option.getOr("None")}`,
+    )
+    if storedSpecs->Array.length > 0 {
+      let (maxMemorySize, maxTimeout) = storedSpecs->Array.reduce((0, 0), (
+        (accMemorySize, accTimeout),
+        {memorySize, timeout},
+      ) => {
+        (Math.Int.max(accMemorySize, memorySize), Math.Int.max(accTimeout, timeout))
+      })
+
+      switch grandParent.contents {
+      | Some(parent) =>
+        let handlerOutputs: array<Pulumi.Output.t<handlerEntry>> = []
+        let packageDirs: dict<string> = Dict.make()
+
+        storedSpecs->Array.forEach(spec => {
+          switch sliceInfos->Dict.get(spec.componentName) {
+          | Some(info) =>
+            let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+            packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+            let projectionPkg = Util_Bundle.extractPackageName(info.projectionModulePath)
+            packageDirs->Dict.set(projectionPkg, Util_Bundle.resolvePackageRoot(projectionPkg))
+
+            let handlerJson =
+              Pulumi.Output.all2((info.queryDbTableName, spec.sourceUrns))
+              ->Pulumi.Output.apply(((tableName, urns)) => {
+                let entry: handlerEntry = {
+                  specModule: info.specModulePath,
+                  projectionModule: info.projectionModulePath,
+                  queryDbTableName: tableName,
+                  sourceUrn: urns->Array.getUnsafe(0),
+                }
+                entry
+              })
+            let _ = handlerOutputs->Array.push(handlerJson)
+          | None =>
+            log.warn(
+              ~comp="StateViewSliceRuntime_Builder_Single",
+              `no handler registered for ${spec.componentName}`,
+            )
+          }
+        })
+
+        buildLambda(
+          ~parent,
+          ~handlerOutputs,
+          ~packageDirs,
+          ~channelSpecs=storedSpecs->Array.map(({channelSpec}) => channelSpec),
+          ~memorySize=maxMemorySize,
+          ~timeout=maxTimeout,
+        )
+      | None =>
+        log.warn(~comp="StateViewSliceRuntime_Builder_Single", `finish: grandParent not set`)
+      }
+    }
+    finished := true
+  }