@reventlessdev/reventless-aws 3.0.0-alpha.210 → 3.0.0-alpha.212

package/tests/AppSync_SdlDecorateTest.res

@@ -67,10 +67,10 @@ describe("AppSync_SdlDecorate.injectAwsSubscribe", () => {
   })
 })
 
-describe("AppSync_Adapter.stitchWithAwsDirectives", () => {
-  testSync("assembles neutral fragments into AWS-dialect SDL", () => {
-    let baseFragment = ReventlessCore.GraphQL_Stitcher.encode({
-      types: [],
+describe("AppSync_Adapter.stitchStandaloneWithAwsDirectives", () => {
+  testSync("assembles a neutral fragment into an AWS-dialect standalone document", () => {
+    let fragment = ReventlessCore.GraphQL_Stitcher.encode({
+      types: [`type PluginStatusChangeEvent {\n  pluginId: ID!\n}`],
       mutations: [`  Platform_PluginStatusChanged(pluginId: ID!, status: PluginStatus!): PluginStatusChangeEvent`],
       queries: [],
       subscriptions: [`  onPluginStatusChange: PluginStatusChangeEvent`],
@@ -78,19 +78,11 @@ describe("AppSync_Adapter.stitchWithAwsDirectives", () => {
         {field: "onPluginStatusChange", mutations: ["Platform_PluginStatusChanged"]},
       ],
     })
-    let pluginFragment = ReventlessCore.GraphQL_Stitcher.encode({
-      types: [`type PluginStatusChangeEvent {\n  pluginId: ID!\n}`],
-      mutations: [`  Catalog_AddProduct(input: AddInput): CommandResult`],
-      queries: [],
-      subscriptions: [`  onCatalog_AddProduct(id: ID): CommandResult`],
-      subscriptionSources: [{field: "onCatalog_AddProduct", mutations: ["Catalog_AddProduct"]}],
-    })
-    let sdl = AppSync_Adapter.stitchWithAwsDirectives(
-      ~baseFragment,
-      ~pluginFragments=[pluginFragment],
-    )
+    let sdl = AppSync_Adapter.stitchStandaloneWithAwsDirectives(~fragment)
     expect(sdl)->toContain(`@aws_subscribe(mutations: ["Platform_PluginStatusChanged"])`)
-    expect(sdl)->toContain(`@aws_subscribe(mutations: ["Catalog_AddProduct"])`)
+    // Standalone documents never carry the global node query (dropped on AWS —
+    // see the merged-api plan's Relay node resolution).
+    expect(sdl)->not_->toContain("node(id: ID!): Node")
   })
 })
 
@@ -126,81 +118,9 @@ describe("AppSync_SdlDecorate.injectAwsAuthAll", () => {
   })
 })
 
-describe("AppSync_SdlDecorate.planAwsPushes", () => {
-  // Neutral admin base: a system-callable mutation + a shared traversal type.
-  let rawAdminBase = ReventlessCore.GraphQL_Stitcher.encode({
-    types: [`type CommandAccepted {\n  id: ID!\n}`],
-    mutations: [`  Platform_RegisterApiFragment(input: ApiFragmentInput): CommandResult`],
-    queries: [],
-    subscriptions: [],
-    subscriptionSources: [],
-  })
-  let iamFieldNames = ["Platform_RegisterApiFragment"]
-  let mkFrag = (~mutation, ~target): AppSync_SdlDecorate.targetedFragmentInput => {
-    encoded: ReventlessCore.GraphQL_Stitcher.encode({
-      types: [],
-      mutations: [mutation],
-      queries: [],
-      subscriptions: [],
-      subscriptionSources: [],
-    }).encoded,
-    protocol: "graphql",
-    target,
-  }
-  let platformFrag = mkFrag(~mutation=`  Inspector_Ping: CommandResult`, ~target="Platform")
-  let domainFrag = mkFrag(~mutation=`  Catalog_AddProduct(input: AddInput): CommandResult`, ~target="Domain")
-
-  testSync("split mode: Platform API carries admin base (dual-auth) + Platform frags; Domain API excludes the admin base", () => {
-    let plans = AppSync_SdlDecorate.planAwsPushes(
-      ~rawAdminBase,
-      ~iamFieldNames,
-      ~fragments=[platformFrag, domainFrag],
-      ~splitApi=true,
-    )
-    expect(plans->Array.length)->toBe(2)
-    let platformPlan = plans->Array.find(p => p.api == "PlatformApi")->Option.getOrThrow
-    let domainPlan = plans->Array.find(p => p.api == "DomainApi")->Option.getOrThrow
-    // Admin base mutation lands on the Platform API with dual-auth (system caller).
-    expect(platformPlan.sdl)->toContain("Platform_RegisterApiFragment")
-    expect(platformPlan.sdl)->toContain(`@aws_cognito_user_pools(cognito_groups: ["Admin"]) @aws_iam`)
-    // Platform-target plugin field present on the Platform API.
-    expect(platformPlan.sdl)->toContain("Inspector_Ping")
-    // Shared traversal type stamped once on the assembled SDL.
-    expect(platformPlan.sdl)->toContain(`type CommandAccepted @aws_cognito_user_pools @aws_iam {`)
-    // Domain-target field on the Domain API; admin base absent (empty base in split mode).
-    expect(domainPlan.sdl)->toContain("Catalog_AddProduct")
-    expect(domainPlan.sdl->String.includes("Platform_RegisterApiFragment"))->toBe(false)
-  })
-
-  testSync("unified mode: a single Domain API carries admin base + all frags", () => {
-    let plans = AppSync_SdlDecorate.planAwsPushes(
-      ~rawAdminBase,
-      ~iamFieldNames,
-      ~fragments=[platformFrag, domainFrag],
-      ~splitApi=false,
-    )
-    expect(plans->Array.length)->toBe(1)
-    let plan = plans->Array.getUnsafe(0)
-    expect(plan.api)->toBe("DomainApi")
-    expect(plan.sdl)->toContain("Platform_RegisterApiFragment")
-    expect(plan.sdl)->toContain("Inspector_Ping")
-    expect(plan.sdl)->toContain("Catalog_AddProduct")
-  })
-})
 
 describe("AppSync_SdlDecorate.stampSharedIamTypes", () => {
-  // Regression: the deploy waiter polls the IAM-callable Platform_ApiFragments query via
-  // SigV4; its return type Platform_ApiFragmentEntry must carry the type-level @aws_iam or
-  // the SigV4 caller reaches the query field but gets "Not Authorized to access <field> on
-  // type Platform_ApiFragmentEntry" (deploy validation #7).
-  testSync("stamps Platform_ApiFragmentEntry with dual-auth", () => {
-    let sdl = AppSync_SdlDecorate.stampSharedIamTypes(
-      "type Platform_ApiFragmentEntry {\n  pluginId: String!\n  pushStatus: String!\n}",
-    )
-    expect(sdl)->toContain("type Platform_ApiFragmentEntry @aws_cognito_user_pools @aws_iam {")
-  })
-
-  testSync("still stamps the CommandResult members", () => {
+  testSync("stamps the CommandResult members", () => {
     let sdl = AppSync_SdlDecorate.stampSharedIamTypes("type CommandAccepted {\n  id: ID!\n}")
     expect(sdl)->toContain("type CommandAccepted @aws_cognito_user_pools @aws_iam {")
   })

package/tests/AppSync_SdlDecorateTest.res.mjs

@@ -61,10 +61,10 @@ globalThis.describe("AppSync_SdlDecorate.injectAwsSubscribe", () => {
   });
 });
 
-globalThis.describe("AppSync_Adapter.stitchWithAwsDirectives", () => {
-  globalThis.test("assembles neutral fragments into AWS-dialect SDL", () => {
-    let baseFragment = GraphQL_Stitcher$ReventlessCore.encode({
-      types: [],
+globalThis.describe("AppSync_Adapter.stitchStandaloneWithAwsDirectives", () => {
+  globalThis.test("assembles a neutral fragment into an AWS-dialect standalone document", () => {
+    let fragment = GraphQL_Stitcher$ReventlessCore.encode({
+      types: [`type PluginStatusChangeEvent {\n  pluginId: ID!\n}`],
       mutations: [`  Platform_PluginStatusChanged(pluginId: ID!, status: PluginStatus!): PluginStatusChangeEvent`],
       queries: [],
       subscriptions: [`  onPluginStatusChange: PluginStatusChangeEvent`],
@@ -73,19 +73,9 @@ globalThis.describe("AppSync_Adapter.stitchWithAwsDirectives", () => {
           mutations: ["Platform_PluginStatusChanged"]
         }]
     });
-    let pluginFragment = GraphQL_Stitcher$ReventlessCore.encode({
-      types: [`type PluginStatusChangeEvent {\n  pluginId: ID!\n}`],
-      mutations: [`  Catalog_AddProduct(input: AddInput): CommandResult`],
-      queries: [],
-      subscriptions: [`  onCatalog_AddProduct(id: ID): CommandResult`],
-      subscriptionSources: [{
-          field: "onCatalog_AddProduct",
-          mutations: ["Catalog_AddProduct"]
-        }]
-    });
-    let sdl = AppSync_Adapter$ReventlessAws.stitchWithAwsDirectives(baseFragment, [pluginFragment]);
+    let sdl = AppSync_Adapter$ReventlessAws.stitchStandaloneWithAwsDirectives(fragment);
     globalThis.expect(sdl).toContain(`@aws_subscribe(mutations: ["Platform_PluginStatusChanged"])`);
-    globalThis.expect(sdl).toContain(`@aws_subscribe(mutations: ["Catalog_AddProduct"])`);
+    globalThis.expect(sdl).not.toContain("node(id: ID!): Node");
   });
 });
 
@@ -115,63 +105,8 @@ globalThis.describe("AppSync_SdlDecorate.injectAwsAuthAll", () => {
   });
 });
 
-globalThis.describe("AppSync_SdlDecorate.planAwsPushes", () => {
-  let rawAdminBase = GraphQL_Stitcher$ReventlessCore.encode({
-    types: [`type CommandAccepted {\n  id: ID!\n}`],
-    mutations: [`  Platform_RegisterApiFragment(input: ApiFragmentInput): CommandResult`],
-    queries: [],
-    subscriptions: [],
-    subscriptionSources: []
-  });
-  let iamFieldNames = ["Platform_RegisterApiFragment"];
-  let mkFrag = (mutation, target) => ({
-    encoded: GraphQL_Stitcher$ReventlessCore.encode({
-      types: [],
-      mutations: [mutation],
-      queries: [],
-      subscriptions: [],
-      subscriptionSources: []
-    }).encoded,
-    protocol: "graphql",
-    target: target
-  });
-  let platformFrag = mkFrag(`  Inspector_Ping: CommandResult`, "Platform");
-  let domainFrag = mkFrag(`  Catalog_AddProduct(input: AddInput): CommandResult`, "Domain");
-  globalThis.test("split mode: Platform API carries admin base (dual-auth) + Platform frags; Domain API excludes the admin base", () => {
-    let plans = AppSync_SdlDecorate$ReventlessAws.planAwsPushes(rawAdminBase, iamFieldNames, [
-      platformFrag,
-      domainFrag
-    ], true);
-    globalThis.expect(plans.length).toBe(2);
-    let platformPlan = Stdlib_Option.getOrThrow(plans.find(p => p.api === "PlatformApi"), undefined);
-    let domainPlan = Stdlib_Option.getOrThrow(plans.find(p => p.api === "DomainApi"), undefined);
-    globalThis.expect(platformPlan.sdl).toContain("Platform_RegisterApiFragment");
-    globalThis.expect(platformPlan.sdl).toContain(`@aws_cognito_user_pools(cognito_groups: ["Admin"]) @aws_iam`);
-    globalThis.expect(platformPlan.sdl).toContain("Inspector_Ping");
-    globalThis.expect(platformPlan.sdl).toContain(`type CommandAccepted @aws_cognito_user_pools @aws_iam {`);
-    globalThis.expect(domainPlan.sdl).toContain("Catalog_AddProduct");
-    globalThis.expect(domainPlan.sdl.includes("Platform_RegisterApiFragment")).toBe(false);
-  });
-  globalThis.test("unified mode: a single Domain API carries admin base + all frags", () => {
-    let plans = AppSync_SdlDecorate$ReventlessAws.planAwsPushes(rawAdminBase, iamFieldNames, [
-      platformFrag,
-      domainFrag
-    ], false);
-    globalThis.expect(plans.length).toBe(1);
-    let plan = plans[0];
-    globalThis.expect(plan.api).toBe("DomainApi");
-    globalThis.expect(plan.sdl).toContain("Platform_RegisterApiFragment");
-    globalThis.expect(plan.sdl).toContain("Inspector_Ping");
-    globalThis.expect(plan.sdl).toContain("Catalog_AddProduct");
-  });
-});
-
 globalThis.describe("AppSync_SdlDecorate.stampSharedIamTypes", () => {
-  globalThis.test("stamps Platform_ApiFragmentEntry with dual-auth", () => {
-    let sdl = AppSync_SdlDecorate$ReventlessAws.stampSharedIamTypes("type Platform_ApiFragmentEntry {\n  pluginId: String!\n  pushStatus: String!\n}");
-    globalThis.expect(sdl).toContain("type Platform_ApiFragmentEntry @aws_cognito_user_pools @aws_iam {");
-  });
-  globalThis.test("still stamps the CommandResult members", () => {
+  globalThis.test("stamps the CommandResult members", () => {
     let sdl = AppSync_SdlDecorate$ReventlessAws.stampSharedIamTypes("type CommandAccepted {\n  id: ID!\n}");
     globalThis.expect(sdl).toContain("type CommandAccepted @aws_cognito_user_pools @aws_iam {");
   });

package/tests/MCP_LambdaTest.res

@@ -7,9 +7,8 @@ describe("MCP_Lambda.generateAdminConfig", () => {
       ~serverVersion="1.0.0",
       ~cloner=false,
     )
-    // Admin has Plugin_Activate, Plugin_Deactivate, Plugin_Retire +
-    // ApiFragmentRegistry_Register/DeregisterApiFragment mutations
-    expect(config.tools)->toHaveLength(5)
+    // Admin has Plugin_Activate, Plugin_Deactivate, Plugin_Retire
+    expect(config.tools)->toHaveLength(3)
   })
 
   testSync("produces additional clone tool when cloner=true", () => {
@@ -18,9 +17,8 @@ describe("MCP_Lambda.generateAdminConfig", () => {
       ~serverVersion="1.0.0",
       ~cloner=true,
     )
-    // Plugin_Activate, Plugin_Deactivate, Plugin_Retire,
-    // ApiFragmentRegistry_Register/DeregisterApiFragment, Clone
-    expect(config.tools)->toHaveLength(6)
+    // Plugin_Activate, Plugin_Deactivate, Plugin_Retire, Clone
+    expect(config.tools)->toHaveLength(4)
   })
 
   testSync("produces resources from admin query entries", () => {

package/tests/MCP_LambdaTest.res.mjs

@@ -6,11 +6,11 @@ import * as MCP_Lambda$ReventlessAws from "../src/adapter/Mcp/MCP_Lambda.res.mjs
 globalThis.describe("MCP_Lambda.generateAdminConfig", () => {
   globalThis.test("produces tools from admin mutation entries (no cloner)", () => {
     let config = MCP_Lambda$ReventlessAws.generateAdminConfig("test", "1.0.0", false, undefined, undefined);
-    globalThis.expect(config.tools).toHaveLength(5);
+    globalThis.expect(config.tools).toHaveLength(3);
   });
   globalThis.test("produces additional clone tool when cloner=true", () => {
     let config = MCP_Lambda$ReventlessAws.generateAdminConfig("test", "1.0.0", true, undefined, undefined);
-    globalThis.expect(config.tools).toHaveLength(6);
+    globalThis.expect(config.tools).toHaveLength(4);
   });
   globalThis.test("produces resources from admin query entries", () => {
     let config = MCP_Lambda$ReventlessAws.generateAdminConfig("test", "1.0.0", undefined, undefined, undefined);

package/src/adapter/Api/ApiFragmentDeregistration.res

@@ -1,138 +0,0 @@
-/** Pulumi dynamic resource whose sole purpose is to deregister a plugin's
-    API-schema fragment on `pulumi destroy` (final retirement of the plugin
-    stack). `create` / `update` are no-ops — registration is done by
-    `Platform.registerFragmentViaApi` at deploy time; only `delete` matters,
-    and it calls `Platform_DeregisterApiFragment` on the platform's Platform API
-    (SigV4), whose event triggers the platform-side reactive single writer (2e)
-    to re-stitch the schema WITHOUT this plugin's fields.
-
-    Serialization: Pulumi serialises the provider object (and its captured import
-    closure) into stack state, so it must NOT statically capture the AWS SDK —
-    that breaks Pulumi's closure serialiser (the CJS/ESM dual-export confusion
-    documented in AppSync_Resolver_Retrying). The delete handler therefore
-    DYNAMICALLY imports the signed caller at invocation time; only the string
-    specifier lands in state.
-
-    Version supersession must NOT deregister: `diff` never reports changes/replaces
-    (pluginId, endpoint, and region are all version-stable), so a version bump is
-    an in-place no-op and the `delete` handler fires only on a genuine stack
-    destroy — the "final retirement, resolvers gone" trigger. */
-
-let log = ReventlessCore.Logger.fromEnv()
-
-type providerInputs = {
-  pluginId: string,
-  endpoint: string,
-  region: string,
-}
-
-// Pulumi passes OUTPUTS (possibly undefined) to delete/read handlers, so encode
-// the carrier fields into the resource id — always available. "|" cannot appear
-// in a plugin name, an AWS region, or an AppSync GraphQL endpoint URL.
-let encodeId = (i: providerInputs): string => `${i.pluginId}|${i.region}|${i.endpoint}`
-let decodeId = (id: string): option<providerInputs> =>
-  switch id->String.split("|") {
-  | [pluginId, region, endpoint] => Some({pluginId, region, endpoint})
-  | _ => None
-  }
-
-// Dynamically import the signed caller and send Platform_DeregisterApiFragment.
-// The `import(...)` keeps Util_AppSync_Caller (and its transitive @aws-sdk/@smithy
-// deps) OUT of the serialised provider closure — only this string is captured.
-// Positional call matches the compiled signature
-// `sendMutation(endpoint, region, mutation, selection, variables)`.
-let sendDeregister: (JSON.t, string, string) => promise<unit> = %raw(`
-  async function (variables, endpoint, region) {
-    const mod = await import("@reventlessdev/reventless-aws/src/util/Util_AppSync_Caller.res.mjs");
-    await mod.sendMutation(endpoint, region, "Platform_ApiFragmentRegistry_DeregisterApiFragment", "{ __typename }", variables);
-  }
-`)
-
-let errMessage: 'a => string = %raw(`(e) => (e && e.message) ? String(e.message) : String(e)`)
-
-type createResult = {id: string, outs: providerInputs}
-type updateResult = {outs: providerInputs}
-type diffResult = {changes: bool, replaces: array<string>, deleteBeforeReplace: bool}
-
-let create = async (inputs: providerInputs): createResult => {id: encodeId(inputs), outs: inputs}
-
-let update = async (_id: string, _olds: providerInputs, news: providerInputs): updateResult => {
-  outs: news,
-}
-
-// Never change/replace — see the module note: keeps version bumps from deleting
-// (and therefore deregistering) the fragment.
-let diff = (_id: string, _olds: providerInputs, _news: providerInputs): diffResult => {
-  changes: false,
-  replaces: [],
-  deleteBeforeReplace: false,
-}
-
-let delete_ = async (id: string, props: providerInputs): unit => {
-  let carrier = switch decodeId(id) {
-  | Some(c) => c
-  | None => props
-  }
-  let variables =
-    Dict.fromArray([
-      // Platform_ApiFragmentRegistry_DeregisterApiFragment(id: ID!, pluginId: ID!) — the
-      // registry is a SINGLETON aggregate, so `id` is the fixed constant; `pluginId`
-      // (payload) names the plugin whose fragment is removed.
-      ("id", JSON.Encode.string("registry")),
-      ("pluginId", JSON.Encode.string(carrier.pluginId)),
-    ])->JSON.Encode.object
-  // Best-effort: on a full teardown the platform API may already be gone, and a
-  // destroy must not fail because deregistration could not reach it.
-  try {
-    await sendDeregister(variables, carrier.endpoint, carrier.region)
-    log.info(~comp="ApiFragmentDeregistration", `Deregistered API fragment for ${carrier.pluginId}`)
-  } catch {
-  | exn =>
-    log.warn(
-      ~comp="ApiFragmentDeregistration",
-      `deregister for ${carrier.pluginId} failed (best-effort; platform may be gone): ${errMessage(
-          exn,
-        )}`,
-    )
-  }
-}
-
-// Provider as a plain JS object — no Pulumi Output captures; all state flows
-// through inputs / id.
-let provider = {
-  "create": create,
-  "update": update,
-  "delete": delete_,
-  "diff": diff,
-}
-
-// ── Pulumi dynamic resource binding ──────────────────────────────────────────
-
-type t
-
-type constructorProps = {
-  pluginId: Pulumi.Input.t<string>,
-  endpoint: Pulumi.Input.t<string>,
-  region: Pulumi.Input.t<string>,
-}
-
-// pulumi.dynamic.Resource constructor: (provider, name, props, opts). Explicit
-// /index.js path because @pulumi/pulumi/dynamic is a directory import not
-// resolvable in ESM mode.
-@module("@pulumi/pulumi/dynamic/index.js") @new
-external _newResource: ('provider, string, 'props, Pulumi.CustomResourceOptions.t) => t = "Resource"
-
-let make = (
-  ~name: string,
-  ~pluginId: string,
-  ~endpoint: Pulumi.Input.t<string>,
-  ~region: string,
-  ~opts: Pulumi.CustomResourceOptions.t={},
-): t => {
-  let props: constructorProps = {
-    pluginId: pluginId->Pulumi.Input.make,
-    endpoint,
-    region: region->Pulumi.Input.make,
-  }
-  _newResource(provider, name, props, opts)
-}

package/src/adapter/Api/ApiFragmentDeregistration.res.mjs

@@ -1,108 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
-import * as IndexJs from "@pulumi/pulumi/dynamic/index.js";
-
-let log = Logger$ReventlessCore.fromEnv();
-
-function encodeId(i) {
-  return i.pluginId + `|` + i.region + `|` + i.endpoint;
-}
-
-function decodeId(id) {
-  let match = id.split("|");
-  if (match.length !== 3) {
-    return;
-  }
-  let pluginId = match[0];
-  let region = match[1];
-  let endpoint = match[2];
-  return {
-    pluginId: pluginId,
-    endpoint: endpoint,
-    region: region
-  };
-}
-
-let sendDeregister = (async function (variables, endpoint, region) {
-    const mod = await import("@reventlessdev/reventless-aws/src/util/Util_AppSync_Caller.res.mjs");
-    await mod.sendMutation(endpoint, region, "Platform_ApiFragmentRegistry_DeregisterApiFragment", "{ __typename }", variables);
-  });
-
-let errMessage = ((e) => (e && e.message) ? String(e.message) : String(e));
-
-async function create(inputs) {
-  return {
-    id: encodeId(inputs),
-    outs: inputs
-  };
-}
-
-async function update(_id, _olds, news) {
-  return {
-    outs: news
-  };
-}
-
-function diff(_id, _olds, _news) {
-  return {
-    changes: false,
-    replaces: [],
-    deleteBeforeReplace: false
-  };
-}
-
-async function delete_(id, props) {
-  let c = decodeId(id);
-  let carrier = c !== undefined ? c : props;
-  let variables = Object.fromEntries([
-    [
-      "id",
-      "registry"
-    ],
-    [
-      "pluginId",
-      carrier.pluginId
-    ]
-  ]);
-  try {
-    await sendDeregister(variables, carrier.endpoint, carrier.region);
-    return log.info("ApiFragmentDeregistration", undefined, `Deregistered API fragment for ` + carrier.pluginId);
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    return log.warn("ApiFragmentDeregistration", undefined, `deregister for ` + carrier.pluginId + ` failed (best-effort; platform may be gone): ` + errMessage(exn));
-  }
-}
-
-let provider = {
-  create: create,
-  update: update,
-  delete: delete_,
-  diff: diff
-};
-
-function make(name, pluginId, endpoint, region, optsOpt) {
-  let opts = optsOpt !== undefined ? optsOpt : ({});
-  let props = {
-    pluginId: pluginId,
-    endpoint: endpoint,
-    region: region
-  };
-  return new IndexJs.Resource(provider, name, props, opts);
-}
-
-export {
-  log,
-  encodeId,
-  decodeId,
-  sendDeregister,
-  errMessage,
-  create,
-  update,
-  diff,
-  delete_,
-  provider,
-  make,
-}
-/* log Not a pure module */

package/src/adapter/Api/ApiSchemaPush.res

@@ -1,79 +0,0 @@
-// ApiSchemaPush — the admin reactive schema-push SideEffect
-// (docs/plans/event-sourced-fragment-registries.md § Reactive writer design).
-//
-// Source = the ApiFragmentRegistry singleton aggregate. On every ApiSchemaComputed
-// { snapshot } (emitted by the aggregate behaviour alongside each ApiFragment* fact,
-// carrying the WHOLE consistent per-plugin fragment set), this hands the snapshot to
-// the runtime-pure push engine (ApiSchemaPush_Runtime.mjs), which stitches one
-// AWS-decorated schema per target API, pushes each behind the shrink guard, and writes
-// the outcome back via RecordApiFragmentPush.
-//
-// The generic SideEffect.T context (`queryEngine`) is unused: this bespoke platform
-// side effect self-acquires its config (API ids, split flag, command-topic URL) from
-// Lambda env injected by the admin SideEffectHandler (~extraEnvVars). The push module
-// is loaded via dynamic import so no @aws-sdk / provider code is statically captured
-// beyond what the SideEffectHandler Lambda already bundles (runtime-purity — see
-// reference_pulumi_leaks_into_lambda_runtime_graph).
-module Spec = ReventlessCore.ApiFragmentRegistrySpec
-
-// Source is built EXPLICITLY rather than aliasing/including the spec. SideEffectHandler_Callback
-// reads Source.{name,eventSchema,Id.schema} reflectively off this module's compiled export at
-// Lambda cold start, but the spec uses these only at the TYPE level, so ReScript dead-shakes
-// them: a bare `module Source = Spec` alias erases the whole binding to `let Source;`, and even
-// the spec's own @@reventless.spec-injected `module Id` compiles to `let Id;` (undefined) — the
-// cross-module runtime reflection is invisible to ReScript's optimiser (deploy-time is fine
-// because Platform.res hand-wires these values). Both surfaced on deploy as "Cannot read
-// properties of undefined (reading 'eventSchema' / 'schema')". Forwarding name/eventSchema (real
-// spec exports) and re-binding Id (String — the singleton registry id, matching Platform.res's
-// hand-wiring) materialises all three, while the type aliases keep full transparency for the
-// pattern match below.
-module Source = {
-  type event = Spec.event
-  type fragmentSnapshotEntry = Spec.fragmentSnapshotEntry
-  // `include` (not `module Id = Reventless.Id.String`) — a bare module alias compiles to
-  // `Id: undefined` in the Source record (Id is only type-projected via Source.Id.t), and
-  // SideEffectHandler_Callback's `Source.Id.schema` reflective read crashes at cold start.
-  // `include` materialises the Id module's runtime values into the record.
-  module Id = {
-    include Reventless.Id.String
-  }
-  let name = Spec.name
-  let eventSchema = Spec.eventSchema
-}
-
-let moduleUrl: string = %raw(`import.meta.url`)
-
-type jsEntry = {pluginId: string, encoded: string, protocol: string, apiTarget: string}
-
-let pushApiSchema: array<jsEntry> => promise<unit> = %raw(`
-  async function (snapshot) {
-    const mod = await import("@reventlessdev/reventless-aws/src/adapter/Runtime/ApiSchemaPush_Runtime.mjs");
-    await mod.pushApiSchema(snapshot);
-  }
-`)
-
-let execute = async (
-  _id: Source.Id.t,
-  _meta: Reventless.Message.meta,
-  event: Source.event,
-  _queryEngine: Reventless.QueryEngine.operations,
-) =>
-  switch event {
-  | ApiSchemaComputed({snapshot}) =>
-    let jsSnapshot = snapshot->Array.map((e: Source.fragmentSnapshotEntry) => {
-      pluginId: e.pluginId,
-      encoded: e.encoded,
-      protocol: e.protocol,
-      apiTarget: switch e.apiTarget {
-      | Reventless.Plugin.Domain => "Domain"
-      | Reventless.Plugin.Platform => "Platform"
-      },
-    })
-    await pushApiSchema(jsSnapshot)
-  // Fact events are handled via the ApiSchemaComputed echo (which carries the
-  // consistent snapshot); the write-back and lifecycle facts are no-ops here.
-  | ApiFragmentRegistered(_)
-  | ApiFragmentUpdated(_)
-  | ApiFragmentDeregistered(_)
-  | ApiFragmentPushRecorded(_) => ()
-  }

package/src/adapter/Api/ApiSchemaPush.res.mjs

@@ -1,64 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
-import * as ApiFragmentRegistrySpec$ReventlessCore from "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentRegistrySpec.res.mjs";
-
-let Id_schema = Id$Reventless.$$String.schema;
-
-let Id_make = Id$Reventless.$$String.make;
-
-let Id_makeFromString = Id$Reventless.$$String.makeFromString;
-
-let Id_toString = Id$Reventless.$$String.toString;
-
-let Id_cmp = Id$Reventless.$$String.cmp;
-
-let Id = {
-  schema: Id_schema,
-  make: Id_make,
-  makeFromString: Id_makeFromString,
-  toString: Id_toString,
-  cmp: Id_cmp
-};
-
-let Source = {
-  Id: Id,
-  name: ApiFragmentRegistrySpec$ReventlessCore.name,
-  eventSchema: ApiFragmentRegistrySpec$ReventlessCore.eventSchema
-};
-
-let moduleUrl = import.meta.url;
-
-let pushApiSchema = (async function (snapshot) {
-    const mod = await import("@reventlessdev/reventless-aws/src/adapter/Runtime/ApiSchemaPush_Runtime.mjs");
-    await mod.pushApiSchema(snapshot);
-  });
-
-async function execute(_id, _meta, event, _queryEngine) {
-  if (event.TAG !== "ApiSchemaComputed") {
-    return;
-  }
-  let jsSnapshot = event.snapshot.map(e => {
-    let match = e.apiTarget;
-    let tmp;
-    tmp = match === "Domain" ? "Domain" : "Platform";
-    return {
-      pluginId: e.pluginId,
-      encoded: e.encoded,
-      protocol: e.protocol,
-      apiTarget: tmp
-    };
-  });
-  return await pushApiSchema(jsSnapshot);
-}
-
-let Spec;
-
-export {
-  Spec,
-  Source,
-  moduleUrl,
-  pushApiSchema,
-  execute,
-}
-/* moduleUrl Not a pure module */