@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Aggregate/Aggregate_Callback.res

@@ -0,0 +1,273 @@
+module type Ops = {
+  module Spec: Reventless.Aggregate.Spec
+  module EventLog: EventLog.T with module Spec.Id = Spec.Id and type Spec.event = Spec.event
+  let eventLog: EventLog.operations
+}
+
+module type T = {
+  module Spec: Reventless.Aggregate.Spec
+  let handleCommands: CommandTopic.commandsHandler<Message.command'<Spec.Id.t, Spec.command>>
+}
+
+module Make = (
+  Spec: Reventless.Aggregate.Spec,
+  Behavior: Behavior.T with module Spec := Spec,
+  Ops: Ops with module Spec = Spec,
+): (T with module Spec = Spec) => {
+  module Spec = Spec
+
+  let comp = `Aggregate(${Spec.name})`
+
+  let eventJson = (event': Message.event'<Spec.Id.t, Spec.event>): JSON.t =>
+    event'.event->Message.encode(Spec.eventSchema)
+
+  let eventDetail = (event': Message.event'<Spec.Id.t, Spec.event>): string => {
+    let json = event'->eventJson
+    let name = json->Message.variantNameOfJson->LogFormat.bold
+    let id = event'.id->Spec.Id.toString
+    `${name}(${id}${LogFormat.variantFields(json)})`
+  }
+
+  // Collects the incoming command stream into groups keyed by aggregate ID.
+  // Returns Effect.t<array<(Id.t, array<topicItem>)>>.
+  let groupTopicItemsByIdStream = stream =>
+    stream
+    ->Stream.runFold(Dict.make(), (
+      dict,
+      item: CommandTopic.topicItem<Message.command'<Spec.Id.t, Spec.command>>,
+    ) => {
+      let id = item.command.id->Spec.Id.toString
+      let existing = dict->Dict.get(id)->Option.getOr([])
+      dict->Dict.set(id, Array.concat(existing, [item]))
+      dict
+    })
+    ->Effect.map(dict =>
+      dict->Dict.toArray->Array.map(((id, items)) => (id->Spec.Id.makeFromString, items))
+    )
+
+  // Derive meta for an event emitted from a command:
+  //   - fresh msgId + time
+  //   - correlationId, ip, user, traceparent, schemaVersion, headers inherited from the command
+  //   - causationId = the command's msgId (the *direct* parent of this event)
+  let updateMeta = (command': Message.command'<'id, 'command>) =>
+    Message.deriveMeta(~parent=command'.meta)
+
+  // Per-command outcome carried through the fold, paired with the originating reference and meta.
+  type cmdOutcome =
+    | CmdOk(array<Spec.event>)
+    | CmdRejected({errorCode: string, errorDetail: string})
+
+  // Folds a single command into the running accumulator: (currentState, perCommandOutcomes).
+  // A domain rejection from Behavior.decide is recorded as `CmdRejected` (no state change,
+  // surviving commands in the batch continue); a successful decide records `CmdOk(events)`
+  // and advances state via `Behavior.evolve`.
+  let processCommand = (
+    (state, outcomes): (Behavior.state, array<(string, cmdOutcome, Message.meta)>),
+    topicItem: CommandTopic.topicItem<Message.command'<Spec.Id.t, Spec.command>>,
+  ) => {
+    let {reference, command: command'} = topicItem
+    let meta = command'->updateMeta
+    EffectLogger.logDebug(
+      ~comp,
+      `deciding on state: ${state->JSON.stringifyAny->Option.getOr("<unserializable>")}`,
+    )->Effect.runSync
+    switch Behavior.decide(state, command'.command) {
+    | Ok(generatedEvents) =>
+      let newState = generatedEvents->Array.reduce(state, Behavior.evolve)
+      (newState, Array.concat(outcomes, [(reference, CmdOk(generatedEvents), meta)]))
+    | Error(error) =>
+      let errorJson = error->Message.encode(Spec.errorSchema)
+      let errorCode = errorJson->Message.variantNameOfJson
+      // Strip the TAG so detail carries only the rejection payload (empty for unit errors).
+      let (_, payloadDict) = errorJson->Message.splitMessage
+      let errorDetail =
+        payloadDict->Dict.toArray->Array.length == 0
+          ? ""
+          : payloadDict->JSON.Encode.object->JSON.stringify
+      let id = command'.id->Spec.Id.toString
+      EffectLogger.logError(
+        ~comp,
+        `decide rejected: ${errorCode} ${errorDetail} id=${id}`,
+      )->Effect.runSync
+      (state, Array.concat(outcomes, [(reference, CmdRejected({errorCode, errorDetail}), meta)]))
+    }
+  }
+
+  let maxConflictRetries = 3
+
+  // Reports per-command outcomes on the inline side-channels and produces the
+  // per-reference Ok/Error array consumed by SQS-style consumers. Domain rejections
+  // are always Ok(reference) — SQS deletes the message because retry would not help —
+  // and the rich error code/detail flows to producers via reportRejected.
+  let reportFinalOutcomes = (
+    outcomes: array<(string, cmdOutcome, Message.meta)>,
+    ~entityId: string,
+    ~appendSucceeded: bool,
+    ~appendedEventCount: int,
+    ~appendErrorDetail: string="",
+  ): array<result<string, string>> =>
+    outcomes->Array.map(((reference, outcome, _meta)) =>
+      switch outcome {
+      | CmdRejected({errorCode, errorDetail}) =>
+        CommandTopic_Helpers.reportRejected(reference, {errorCode, errorDetail})
+        Ok(reference)
+      | CmdOk(_) if appendSucceeded =>
+        CommandTopic_Helpers.reportAccepted(reference, {entityId, eventCount: appendedEventCount})
+        Ok(reference)
+      | CmdOk(_) =>
+        CommandTopic_Helpers.reportRejected(
+          reference,
+          {errorCode: "AppendFailed", errorDetail: appendErrorDetail},
+        )
+        Error(reference)
+      }
+    )
+
+  // Replays the event log, processes commands, and attempts to append.
+  // Returns Ok(references) on success or non-conflict failure (per-reference Ok/Error
+  // reflects per-command success), Error("conflict") on optimistic-locking failure
+  // (caller retries the whole replay+process+append cycle).
+  let replayProcessAppend = (
+    id,
+    topicItemsForId: array<CommandTopic.topicItem<Message.command'<Spec.Id.t, Spec.command>>>,
+  ) => {
+    let idStr = id->Spec.Id.toString
+
+    Ops.eventLog.replayStream(id)
+    ->Stream.runFold((Behavior.initialState, 0), ((st, n), ev) => (Behavior.evolve(st, ev), n + 1))
+    ->Effect.tap(((_, n)) =>
+      EffectLogger.logInfo(~comp, `replay: id=${idStr}, ${n->Int.toString} event(s)`)
+    )
+    ->Effect.flatMap(((initialState, sequenceNr)) => {
+      let (_finalState, outcomes) =
+        topicItemsForId->Array.reduce((initialState, []), processCommand)
+
+      let eventsToAppend =
+        outcomes
+        ->Array.map(((_reference, outcome, meta)) =>
+          switch outcome {
+          | CmdOk(events) => events->Array.map(event => {Message.id, meta, event})
+          | CmdRejected(_) => []
+          }
+        )
+        ->Array.flat
+
+      switch eventsToAppend {
+      | [] =>
+        let perRef = reportFinalOutcomes(
+          outcomes,
+          ~entityId=idStr,
+          ~appendSucceeded=true,
+          ~appendedEventCount=0,
+        )
+        EffectLogger.logInfo(~comp, `no events produced: id=${idStr}`)->Effect.map(_ => Ok(perRef))
+      | generatedEvents' =>
+        let eventCount = generatedEvents'->Array.length->Int.toString
+        let eventDetails =
+          generatedEvents'->Array.map(event' => event'->eventDetail)->Array.join(", ")
+        let eventJsons = generatedEvents'->Array.map(event' => event'->eventJson)->JSON.Encode.array
+        EffectLogger.logInfo(
+          ~comp,
+          ~detail=eventJsons,
+          `produced ${eventCount} event(s): [${eventDetails}]`,
+        )
+        ->Effect.flatMap(
+          _ => Effect.promise(() => Ops.eventLog.append(sequenceNr, id, generatedEvents')),
+        )
+        ->Effect.flatMap(
+          appendResult =>
+            switch appendResult {
+            | Ok(_) =>
+              let perRef = reportFinalOutcomes(
+                outcomes,
+                ~entityId=idStr,
+                ~appendSucceeded=true,
+                ~appendedEventCount=generatedEvents'->Array.length,
+              )
+              EffectLogger.logInfo(~comp, `append: id=${idStr}`)->Effect.map(_ => Ok(perRef))
+            | Error(msg) if msg->String.includes("conflict") =>
+              EffectLogger.logWarn(~comp, `conflict: id=${idStr}, will retry`)->Effect.map(
+                _ => Error(msg),
+              )
+            | Error(msg) =>
+              let perRef = reportFinalOutcomes(
+                outcomes,
+                ~entityId=idStr,
+                ~appendSucceeded=false,
+                ~appendedEventCount=0,
+                ~appendErrorDetail=msg,
+              )
+              EffectLogger.logError(~comp, `append failed: id=${idStr}: ${msg}`)->Effect.map(_ => Ok(perRef))
+            },
+        )
+      }
+    })
+  }
+
+  // CommandTopic handler — processes a stream of incoming commands:
+  //   1. Groups commands by aggregate ID
+  //   2. For each aggregate (concurrently):
+  //      a. Replays the event log to rebuild current state + sequence number
+  //      b. Sequentially folds each command through processCommand
+  //      c. Appends generated events to the event log (optimistic concurrency via sequenceNr)
+  //      d. On conflict: retries the full replay+process+append cycle (up to 3 times)
+  //   3. Returns Ok(reference) for successful commands, Error(reference) for failures
+  let handleCommands: CommandTopic.commandsHandler<
+    Message.command'<Spec.Id.t, Spec.command>,
+  > = stream =>
+    stream
+    ->groupTopicItemsByIdStream
+    ->Effect.flatMap(groups =>
+      Effect.all(
+        groups->Array.map(((id, topicItemsForId)) => {
+          let idStr = id->Spec.Id.toString
+          // Log commands once (outside retry loop)
+          let cmdJsons =
+            topicItemsForId->Array.map(
+              ({command}) =>
+                command->Message.commandJsonOfCommand'(
+                  ~idToString=Spec.Id.toString,
+                  ~commandSchema=Spec.commandSchema,
+                ),
+            )
+          let count = cmdJsons->Array.length->Int.toString
+          cmdJsons->Array.forEachWithIndex(
+            (cmdJson, idx) => {
+              let idxStr = (idx + 1)->Int.toString
+              EffectLogger.logInfo(
+                ~comp,
+                ~detail=cmdJson.commandJson,
+                `handling command ${idxStr}/${count}: ${LogFormat.cmdDetail(cmdJson)}`,
+              )->Effect.runSync
+            },
+          )
+
+          // Extract references once for the exhaustion branch
+          let references = topicItemsForId->Array.map(item => item.reference)
+
+          // Retry loop for conflict resolution
+          let rec attempt = retryCount =>
+            replayProcessAppend(id, topicItemsForId)->Effect.flatMap(
+              result =>
+                switch result {
+                | Ok(refs) => Effect.succeed(refs)
+                | Error(_) if retryCount < maxConflictRetries =>
+                  EffectLogger.logWarn(
+                    ~comp,
+                    `conflict retry id=${idStr} ${(retryCount + 1)
+                        ->Int.toString}/${maxConflictRetries->Int.toString}`,
+                  )->Effect.flatMap(_ => attempt(retryCount + 1))
+                | Error(msg) =>
+                  let detail = `concurrent modification (${maxConflictRetries->Int.toString} retries exhausted): ${msg}`
+                  EffectLogger.logError(
+                    ~comp,
+                    `max conflict retries exhausted id=${idStr}: ${msg}`,
+                  )->Effect.map(_ => references->Array.map(_ => Error(detail)))
+                },
+            )
+          attempt(0)
+        }),
+        {"concurrency": "unbounded"},
+      )->Effect.map(Array.flat)
+    )
+}

package/src/components/Aggregate/Aggregate_Callback.res.mjs

@@ -0,0 +1,208 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
+
+function Make(Spec) {
+  return Behavior => (Ops => {
+    let comp = `Aggregate(` + Spec.name + `)`;
+    let groupTopicItemsByIdStream = stream => Effect.map(Stream.runFold(stream, {}, (dict, item) => {
+      let id = Spec.Id.toString(item.command.id);
+      let existing = Stdlib_Option.getOr(dict[id], []);
+      dict[id] = existing.concat([item]);
+      return dict;
+    }), dict => Object.entries(dict).map(param => [
+      Spec.Id.makeFromString(param[0]),
+      param[1]
+    ]));
+    let processCommand = (param, topicItem) => {
+      let reference = topicItem.reference;
+      let command$p = topicItem.command;
+      let outcomes = param[1];
+      let state = param[0];
+      let meta = Message$ReventlessCore.deriveMeta(command$p.meta, undefined);
+      Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `deciding on state: ` + Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>")));
+      let generatedEvents = Behavior.decide(state, command$p.command);
+      if (generatedEvents.TAG === "Ok") {
+        let generatedEvents$1 = generatedEvents._0;
+        let newState = Stdlib_Array.reduce(generatedEvents$1, state, Behavior.evolve);
+        return [
+          newState,
+          outcomes.concat([[
+              reference,
+              {
+                TAG: "CmdOk",
+                _0: generatedEvents$1
+              },
+              meta
+            ]])
+        ];
+      }
+      let errorJson = Message$ReventlessCore.encode(generatedEvents._0, Spec.errorSchema);
+      let errorCode = Message$ReventlessCore.variantNameOfJson(errorJson);
+      let match = Message$ReventlessCore.splitMessage(errorJson);
+      let payloadDict = match[1];
+      let errorDetail = Object.entries(payloadDict).length === 0 ? "" : JSON.stringify(payloadDict);
+      let id = Spec.Id.toString(command$p.id);
+      Effect.runSync(EffectLogger$ReventlessCore.logError(comp, undefined, `decide rejected: ` + errorCode + ` ` + errorDetail + ` id=` + id));
+      return [
+        state,
+        outcomes.concat([[
+            reference,
+            {
+              TAG: "CmdRejected",
+              errorCode: errorCode,
+              errorDetail: errorDetail
+            },
+            meta
+          ]])
+      ];
+    };
+    let reportFinalOutcomes = (outcomes, entityId, appendSucceeded, appendedEventCount, appendErrorDetailOpt) => {
+      let appendErrorDetail = appendErrorDetailOpt !== undefined ? appendErrorDetailOpt : "";
+      return outcomes.map(param => {
+        let outcome = param[1];
+        let reference = param[0];
+        if (outcome.TAG === "CmdOk") {
+          if (appendSucceeded) {
+            CommandTopic_Helpers$ReventlessCore.reportAccepted(reference, {
+              entityId: entityId,
+              eventCount: appendedEventCount
+            });
+            return {
+              TAG: "Ok",
+              _0: reference
+            };
+          } else {
+            CommandTopic_Helpers$ReventlessCore.reportRejected(reference, {
+              errorCode: "AppendFailed",
+              errorDetail: appendErrorDetail
+            });
+            return {
+              TAG: "Error",
+              _0: reference
+            };
+          }
+        }
+        CommandTopic_Helpers$ReventlessCore.reportRejected(reference, {
+          errorCode: outcome.errorCode,
+          errorDetail: outcome.errorDetail
+        });
+        return {
+          TAG: "Ok",
+          _0: reference
+        };
+      });
+    };
+    let replayProcessAppend = (id, topicItemsForId) => {
+      let idStr = Spec.Id.toString(id);
+      return Effect.flatMap(Effect.tap(Stream.runFold(Ops.eventLog.replayStream(id), [
+        Behavior.initialState,
+        0
+      ], (param, ev) => [
+        Behavior.evolve(param[0], ev),
+        param[1] + 1 | 0
+      ]), param => EffectLogger$ReventlessCore.logInfo(comp, undefined, `replay: id=` + idStr + `, ` + param[1].toString() + ` event(s)`)), param => {
+        let sequenceNr = param[1];
+        let match = Stdlib_Array.reduce(topicItemsForId, [
+          param[0],
+          []
+        ], processCommand);
+        let outcomes = match[1];
+        let eventsToAppend = outcomes.map(param => {
+          let meta = param[2];
+          let outcome = param[1];
+          if (outcome.TAG === "CmdOk") {
+            return outcome._0.map(event => ({
+              id: id,
+              meta: meta,
+              event: event
+            }));
+          } else {
+            return [];
+          }
+        }).flat();
+        if (eventsToAppend.length !== 0) {
+          let eventCount = eventsToAppend.length.toString();
+          let eventDetails = eventsToAppend.map(event$p => {
+            let json = Message$ReventlessCore.encode(event$p.event, Spec.eventSchema);
+            let name = LogFormat$ReventlessCore.bold(Message$ReventlessCore.variantNameOfJson(json));
+            let id = Spec.Id.toString(event$p.id);
+            return name + `(` + id + LogFormat$ReventlessCore.variantFields(json) + `)`;
+          }).join(", ");
+          let eventJsons = eventsToAppend.map(event$p => Message$ReventlessCore.encode(event$p.event, Spec.eventSchema));
+          return Effect.flatMap(Effect.flatMap(EffectLogger$ReventlessCore.logInfo(comp, eventJsons, `produced ` + eventCount + ` event(s): [` + eventDetails + `]`), () => Effect.promise(() => Ops.eventLog.append(sequenceNr, id, eventsToAppend))), appendResult => {
+            if (appendResult.TAG === "Ok") {
+              let perRef = reportFinalOutcomes(outcomes, idStr, true, eventsToAppend.length, undefined);
+              return Effect.map(EffectLogger$ReventlessCore.logInfo(comp, undefined, `append: id=` + idStr), () => ({
+                TAG: "Ok",
+                _0: perRef
+              }));
+            }
+            let msg = appendResult._0;
+            if (msg.includes("conflict")) {
+              return Effect.map(EffectLogger$ReventlessCore.logWarn(comp, undefined, `conflict: id=` + idStr + `, will retry`), () => ({
+                TAG: "Error",
+                _0: msg
+              }));
+            }
+            let perRef$1 = reportFinalOutcomes(outcomes, idStr, false, 0, msg);
+            return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `append failed: id=` + idStr + `: ` + msg), () => ({
+              TAG: "Ok",
+              _0: perRef$1
+            }));
+          });
+        }
+        let perRef = reportFinalOutcomes(outcomes, idStr, true, 0, undefined);
+        return Effect.map(EffectLogger$ReventlessCore.logInfo(comp, undefined, `no events produced: id=` + idStr), () => ({
+          TAG: "Ok",
+          _0: perRef
+        }));
+      });
+    };
+    let handleCommands = stream => Effect.flatMap(groupTopicItemsByIdStream(stream), groups => Effect.map(Effect.all(groups.map(param => {
+      let topicItemsForId = param[1];
+      let id = param[0];
+      let idStr = Spec.Id.toString(id);
+      let cmdJsons = topicItemsForId.map(param => Message$ReventlessCore.commandJsonOfCommand$p(Spec.Id.toString, Spec.commandSchema, param.command));
+      let count = cmdJsons.length.toString();
+      cmdJsons.forEach((cmdJson, idx) => {
+        let idxStr = (idx + 1 | 0).toString();
+        Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, cmdJson.commandJson, `handling command ` + idxStr + `/` + count + `: ` + LogFormat$ReventlessCore.cmdDetail(cmdJson)));
+      });
+      let references = topicItemsForId.map(item => item.reference);
+      let attempt = retryCount => Effect.flatMap(replayProcessAppend(id, topicItemsForId), result => {
+        if (result.TAG === "Ok") {
+          return Effect.succeed(result._0);
+        }
+        let msg = result._0;
+        if (retryCount < 3) {
+          return Effect.flatMap(EffectLogger$ReventlessCore.logWarn(comp, undefined, `conflict retry id=` + idStr + ` ` + (retryCount + 1 | 0).toString() + `/` + (3).toString()), () => attempt(retryCount + 1 | 0));
+        }
+        let detail = `concurrent modification (` + (3).toString() + ` retries exhausted): ` + msg;
+        return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `max conflict retries exhausted id=` + idStr + `: ` + msg), () => references.map(param => ({
+          TAG: "Error",
+          _0: detail
+        })));
+      });
+      return attempt(0);
+    }), {
+      concurrency: "unbounded"
+    }), prim => prim.flat()));
+    return {
+      Spec: Spec,
+      handleCommands: handleCommands
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/components/Api/ApiAllowedStatesHelpers.res

@@ -0,0 +1,19 @@
+// Read per-variant `allowedStates` metadata that the reventless-ppx
+// `@allowedStates([…])` attribute attaches to a command schema. Consumed by
+// `Plugin_Structure.toCommandDef` when building the `commandDef` records that
+// land in `Platform_ComponentDefinitions` so AutoUI can filter the per-row command
+// menu by the row's status.
+
+open ReventlessInfra.Api
+
+/** Returns the allowed-state list for a given command-variant name, or None
+    when the variant has no `@allowedStates` annotation (back-compat default
+    — the command shows on every row). */
+let getAllowedStates = (
+  commandSchema: S.t<unknown>,
+  ~variantName: string,
+): option<array<string>> =>
+  switch commandSchema->S.Metadata.get(~id=allowedStatesId) {
+  | None => None
+  | Some(entries) => entries->Dict.get(variantName)
+  }

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

@@ -0,0 +1,16 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+function getAllowedStates(commandSchema, variantName) {
+  let entries = S.Metadata.get(commandSchema, Api$ReventlessInfra.allowedStatesId);
+  if (entries !== undefined) {
+    return entries[variantName];
+  }
+}
+
+export {
+  getAllowedStates,
+}
+/* S Not a pure module */

package/src/components/Api/ApiNoApiHelpers.res

@@ -0,0 +1,13 @@
+open ReventlessInfra.Api
+
+let isNoApi = (commandSchema: S.t<unknown>): bool =>
+  commandSchema->S.Metadata.get(~id=noApiId)->Option.getOr(false)
+
+let getExcludedVariants = (commandSchema: S.t<unknown>): option<Set.t<string>> =>
+  commandSchema->S.Metadata.get(~id=noApiVariantsId)
+
+let filterNoApiVariants = (fieldNames: array<string>, commandSchema: S.t<unknown>): array<string> =>
+  switch commandSchema->S.Metadata.get(~id=noApiVariantsId) {
+  | None => fieldNames
+  | Some(excluded) => fieldNames->Array.filter(name => !(excluded->Set.has(name)))
+  }

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

@@ -0,0 +1,29 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+function isNoApi(commandSchema) {
+  return Stdlib_Option.getOr(S.Metadata.get(commandSchema, Api$ReventlessInfra.noApiId), false);
+}
+
+function getExcludedVariants(commandSchema) {
+  return S.Metadata.get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+}
+
+function filterNoApiVariants(fieldNames, commandSchema) {
+  let excluded = S.Metadata.get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+  if (excluded !== undefined) {
+    return fieldNames.filter(name => !excluded.has(name));
+  } else {
+    return fieldNames;
+  }
+}
+
+export {
+  isNoApi,
+  getExcludedVariants,
+  filterNoApiVariants,
+}
+/* S Not a pure module */

package/src/components/Api/Api_Builder.res

@@ -0,0 +1,40 @@
+// Api_Builder — creates the Api component backed by a Provider (AppSync / in-memory yoga).
+//
+// Usage:
+//   module AwsApi = Api_Builder.Make(AppSync_Adapter)
+//   let api = AwsApi.make(~name="MyApi", ~baseFragment, ~opts)
+
+module Make = (Provider: ReventlessInfra.Api_Adapter.Provider) => {
+  let construct = (~name, ~baseFragment: Reventless.Plugin.apiSchemaFragment, self) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let (api, _role) = Provider.makeApiResource(~name, ~opts)
+
+    // Outputs — the cloud API ID
+    let apiId = api->Pulumi.Output.apply(a => (a->Obj.magic)["id"]->Option.getOr(name))
+    let _ = self->Component.setOutputs({ReventlessInfra.Api.apiId: apiId})
+
+    // Operations — updateSchema rebuilds the stitched SDL and publishes it
+    self->Component.setOperations(
+      api->Pulumi.Output.apply(apiValue => {
+        ReventlessInfra.Api.updateSchema: pluginFragments =>
+          Provider.updateSchema(
+            ~api=Pulumi.Output.make(apiValue),
+            ~baseFragment,
+            ~pluginFragments,
+          ),
+      }),
+    )
+  }
+
+  let make = (
+    ~name: string,
+    ~baseFragment: Reventless.Plugin.apiSchemaFragment,
+    ~opts: option<Pulumi.ComponentResource.options>=?,
+  ): ReventlessInfra.Api.component =>
+    Component.make(
+      ~componentType="reventless:index:Api",
+      ~name,
+      ~construct=construct(~name, ~baseFragment, ...),
+      ~opts,
+    )
+}

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

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+
+function Make(Provider) {
+  let construct = (name, baseFragment, self) => {
+    let opts_parent = Component$ReventlessCore.toPulumiResource(self);
+    let opts = {
+      parent: opts_parent
+    };
+    let match = Provider.makeApiResource(name, opts);
+    let api = match[0];
+    let apiId = api.apply(a => Stdlib_Option.getOr(a.id, name));
+    Component$ReventlessCore.setOutputs(self, {
+      apiId: apiId
+    });
+    Component$ReventlessCore.setOperations(self, api.apply(apiValue => ({
+      updateSchema: pluginFragments => Provider.updateSchema(Pulumi.output(apiValue), baseFragment, pluginFragments)
+    })));
+  };
+  let make = (name, baseFragment, opts) => Component$ReventlessCore.make("reventless:index:Api", name, extra => construct(name, baseFragment, extra), opts);
+  return {
+    construct: construct,
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */