@reventlessdev/reventless-core 3.0.0-alpha.166 → 3.0.0-alpha.167

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res

@@ -1,108 +0,0 @@
-@@reventless.behavior(ApiFragmentRegistrySpec)
-
-// NOTE: no `open Reventless.Plugin` — it would shadow the `encoded`/`protocol` labels reused
-// below when building the fragment snapshot (warning 45). The two Plugin types are qualified.
-
-// The current fragment for a plugin name plus its target API and the last recorded push
-// outcome (kept only to dedupe at-least-once redelivery of RecordApiFragmentPush).
-type registryEntry = {
-  fragment: Reventless.Plugin.apiSchemaFragment,
-  apiTarget: Reventless.Plugin.apiTarget,
-  lastPush: option<(bool, string, string)>, // (ok, message, at)
-}
-
-// Singleton aggregate: the WHOLE registry, keyed by pluginId, in one consistency boundary.
-type state = {entries: dict<registryEntry>}
-
-let initialState = {entries: Dict.make()}
-
-// Framework-internal aggregate outside an Aggregate/ folder — the Behavior.T snapshot/counter
-// fields are satisfied manually (mirrors PluginBehavior). The registry's history is short
-// (deploy-frequency writes), so persisted snapshots would buy nothing.
-let snapshot = None
-let atomicCounter = None
-
-// Immutable dict updates (no reliance on Dict.copy/Dict.delete): rebuild via toArray/fromArray
-// so evolve never mutates the replayed state.
-let entriesWith = (entries: dict<registryEntry>, pluginId, entry) =>
-  entries
-  ->Dict.toArray
-  ->Array.filter(((k, _)) => k != pluginId)
-  ->Array.concat([(pluginId, entry)])
-  ->Dict.fromArray
-
-let entriesWithout = (entries: dict<registryEntry>, pluginId) =>
-  entries->Dict.toArray->Array.filter(((k, _)) => k != pluginId)->Dict.fromArray
-
-let evolve = (state, event) =>
-  switch event {
-  | ApiFragmentRegistered({pluginId, fragment, apiTarget}) => {
-      entries: state.entries->entriesWith(pluginId, {fragment, apiTarget, lastPush: None}),
-    }
-  | ApiFragmentUpdated({pluginId, newFragment, apiTarget}) => {
-      entries: state.entries->entriesWith(pluginId, {fragment: newFragment, apiTarget, lastPush: None}),
-    }
-  | ApiFragmentDeregistered({pluginId}) => {entries: state.entries->entriesWithout(pluginId)}
-  | ApiFragmentPushRecorded({pluginId, ok, message, at}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | Some(entry) => {
-        entries: state.entries->entriesWith(pluginId, {...entry, lastPush: Some((ok, message, at))}),
-      }
-    | None => state
-    }
-  // Derived echo — no fold change.
-  | ApiSchemaComputed(_) => state
-  }
-
-// The consistent registry snapshot AFTER the triggering change — one entry per registered plugin.
-let snapshotOf = (entries: dict<registryEntry>): array<ApiFragmentRegistrySpec.fragmentSnapshotEntry> =>
-  entries
-  ->Dict.toArray
-  ->Array.map(((pluginId, e)) => {
-    ApiFragmentRegistrySpec.pluginId,
-    encoded: e.fragment.encoded,
-    protocol: e.fragment.protocol,
-    apiTarget: e.apiTarget,
-  })
-
-// Emit the fact event plus ApiSchemaComputed{snapshot} folded from the POST-change state, so the
-// reactive push SideEffect stitches from consistent state. Idempotent no-ops emit nothing (and
-// therefore no push). RecordApiFragmentPush records the outcome only — it changes no fragments,
-// so it emits no ApiSchemaComputed (which also avoids a recompute loop).
-let decide = (state, command) => {
-  let withSchema = (fact: ApiFragmentRegistrySpec.event) => {
-    let next = evolve(state, fact)
-    Ok([fact, ApiSchemaComputed({snapshot: snapshotOf(next.entries)})])
-  }
-  switch command {
-  | RegisterApiFragment({pluginId, fragment, apiTarget, at}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | None => withSchema(ApiFragmentRegistered({pluginId, fragment, apiTarget, at}))
-    // Idempotent: an unchanged re-registration (same fragment AND same target — a redeploy
-    // carrying the same schema, or a version supersession that didn't change the SDL) emits
-    // nothing. A target change with an identical fragment IS meaningful (the fields move between
-    // the Domain and Platform APIs), so it is not a no-op.
-    | Some({fragment: current, apiTarget: currentTarget})
-      if current == fragment && currentTarget == apiTarget =>
-      Ok([])
-    | Some({fragment: current}) =>
-      withSchema(
-        ApiFragmentUpdated({pluginId, previousFragment: current, newFragment: fragment, apiTarget, at}),
-      )
-    }
-  | DeregisterApiFragment({pluginId}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | None => Ok([]) // idempotent — nothing registered
-    | Some(_) => withSchema(ApiFragmentDeregistered({pluginId: pluginId}))
-    }
-  | RecordApiFragmentPush({pluginId, ok, message, at}) =>
-    switch state.entries->Dict.get(pluginId) {
-    | None => Ok([]) // fragment deregistered in the meantime — nowhere to record
-    // Idempotent: an at-least-once redelivery carries the identical payload.
-    | Some({lastPush: Some((lastOk, lastMessage, lastAt))})
-      if lastOk == ok && lastMessage == message && lastAt == at =>
-      Ok([])
-    | Some(_) => Ok([ApiFragmentPushRecorded({pluginId, ok, message, at})])
-    }
-  }
-}

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res.mjs

@@ -1,190 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-
-let initialState = {
-  entries: {}
-};
-
-function entriesWith(entries, pluginId, entry) {
-  return Object.fromEntries(Object.entries(entries).filter(param => param[0] !== pluginId).concat([[
-      pluginId,
-      entry
-    ]]));
-}
-
-function entriesWithout(entries, pluginId) {
-  return Object.fromEntries(Object.entries(entries).filter(param => param[0] !== pluginId));
-}
-
-function evolve(state, event) {
-  switch (event.TAG) {
-    case "ApiFragmentRegistered" :
-      return {
-        entries: entriesWith(state.entries, event.pluginId, {
-          fragment: event.fragment,
-          apiTarget: event.apiTarget,
-          lastPush: undefined
-        })
-      };
-    case "ApiFragmentUpdated" :
-      return {
-        entries: entriesWith(state.entries, event.pluginId, {
-          fragment: event.newFragment,
-          apiTarget: event.apiTarget,
-          lastPush: undefined
-        })
-      };
-    case "ApiFragmentDeregistered" :
-      return {
-        entries: entriesWithout(state.entries, event.pluginId)
-      };
-    case "ApiFragmentPushRecorded" :
-      let pluginId = event.pluginId;
-      let entry = state.entries[pluginId];
-      if (entry !== undefined) {
-        return {
-          entries: entriesWith(state.entries, pluginId, {
-            fragment: entry.fragment,
-            apiTarget: entry.apiTarget,
-            lastPush: [
-              event.ok,
-              event.message,
-              event.at
-            ]
-          })
-        };
-      } else {
-        return state;
-      }
-    case "ApiSchemaComputed" :
-      return state;
-  }
-}
-
-function snapshotOf(entries) {
-  return Object.entries(entries).map(param => {
-    let e = param[1];
-    return {
-      pluginId: param[0],
-      encoded: e.fragment.encoded,
-      protocol: e.fragment.protocol,
-      apiTarget: e.apiTarget
-    };
-  });
-}
-
-function decide(state, command) {
-  let withSchema = fact => {
-    let next = evolve(state, fact);
-    return {
-      TAG: "Ok",
-      _0: [
-        fact,
-        {
-          TAG: "ApiSchemaComputed",
-          snapshot: snapshotOf(next.entries)
-        }
-      ]
-    };
-  };
-  switch (command.TAG) {
-    case "RegisterApiFragment" :
-      let at = command.at;
-      let apiTarget = command.apiTarget;
-      let fragment = command.fragment;
-      let pluginId = command.pluginId;
-      let match = state.entries[pluginId];
-      if (match === undefined) {
-        return withSchema({
-          TAG: "ApiFragmentRegistered",
-          pluginId: pluginId,
-          fragment: fragment,
-          apiTarget: apiTarget,
-          at: at
-        });
-      }
-      let current = match.fragment;
-      if (Primitive_object.equal(current, fragment) && match.apiTarget === apiTarget) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      } else {
-        return withSchema({
-          TAG: "ApiFragmentUpdated",
-          pluginId: pluginId,
-          previousFragment: current,
-          newFragment: fragment,
-          apiTarget: apiTarget,
-          at: at
-        });
-      }
-    case "DeregisterApiFragment" :
-      let pluginId$1 = command.pluginId;
-      let match$1 = state.entries[pluginId$1];
-      if (match$1 !== undefined) {
-        return withSchema({
-          TAG: "ApiFragmentDeregistered",
-          pluginId: pluginId$1
-        });
-      } else {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-    case "RecordApiFragmentPush" :
-      let at$1 = command.at;
-      let message = command.message;
-      let ok = command.ok;
-      let pluginId$2 = command.pluginId;
-      let match$2 = state.entries[pluginId$2];
-      if (match$2 === undefined) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-      let match$3 = match$2.lastPush;
-      if (match$3 !== undefined && match$3[0] === ok && match$3[1] === message && match$3[2] === at$1) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      }
-      return {
-        TAG: "Ok",
-        _0: [{
-            TAG: "ApiFragmentPushRecorded",
-            pluginId: pluginId$2,
-            ok: ok,
-            message: message,
-            at: at$1
-          }]
-      };
-      break;
-  }
-}
-
-let Spec;
-
-let snapshot;
-
-let atomicCounter;
-
-let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentRegistryBehavior.res.mjs";
-
-export {
-  Spec,
-  initialState,
-  snapshot,
-  atomicCounter,
-  entriesWith,
-  entriesWithout,
-  evolve,
-  snapshotOf,
-  decide,
-  moduleUrl,
-}
-/* No side effect */

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistrySpec.res

@@ -1,71 +0,0 @@
-// ApiFragmentRegistry aggregate — the platform API-schema fragment registry, replacing the
-// raw `deploy-schema:*` keyspace (see docs/plans/event-sourced-fragment-registries.md).
-//
-// Modelled as a SINGLETON aggregate (fixed id, e.g. "registry"): the whole registry lives in
-// one consistency boundary / one event stream, so a fragment change reads the whole registry
-// with a single strongly-consistent partition read + snapshot — fixing the lagging-read
-// consistency AND the unbounded-scan cost of the earlier per-plugin DCB-slice design (deploy
-// validation #4). `pluginId` is a payload field here, not the aggregate id.
-//
-// Transitions are driven by the DEPLOY / DESTROY of a plugin stack: the deploy registers its
-// fragment as a SigV4 system caller against the Platform API, and only final retirement
-// (`pulumi destroy`, resolvers gone) deregisters. Version supersession must NOT deregister —
-// the registry is keyed by plugin NAME, so a successor's deploy overwrites its predecessor's
-// fragment in place. The registry is idempotent: re-registering an identical fragment is a
-// no-op, deregistering an absent fragment is a no-op — it never rejects a command.
-//
-// `RecordApiFragmentPush` is the write-back of the reactive schema-push SideEffect: after
-// stitching and pushing the composed schema it records the outcome (ok / error + message) on
-// the row of the plugin whose fragment change triggered the push, so the deploy waiter can
-// poll the push status instead of timing out on introspection. It is `@noApi` — dispatched
-// platform-side, never by a GraphQL caller.
-@@reventless.spec("ApiFragmentRegistry")
-
-open Reventless.Plugin
-
-// One entry of the consistent registry snapshot carried on `ApiSchemaComputed` — the whole
-// per-plugin fragment set AFTER the triggering change, folded from the aggregate's own
-// consistent state. The push SideEffect stitches per target from this snapshot (splitApi +
-// admin base are its deploy concerns), so consistency is guaranteed without any
-// eventually-consistent read.
-@schema
-type fragmentSnapshotEntry = {
-  pluginId: string,
-  encoded: string,
-  protocol: string,
-  apiTarget: apiTarget,
-}
-
-// `RegisterApiFragment` / `DeregisterApiFragment` ARE the GraphQL surface — the deploy calls
-// them as a SigV4 system caller against the Platform API (exposed via the standard admin-aggregate
-// path as `Platform_RegisterApiFragment` / `Platform_DeregisterApiFragment`; IAM via
-// `systemCallerFieldNames`). `at` is the registration timestamp, threaded so the read-model row
-// can surface registered/updated times.
-@schema
-type command =
-  | RegisterApiFragment({pluginId: string, fragment: apiSchemaFragment, apiTarget: apiTarget, at: string})
-  | DeregisterApiFragment({pluginId: string})
-  | @noApi RecordApiFragmentPush({pluginId: string, ok: bool, message: string, at: string})
-
-// The registry never rejects (idempotent register/deregister/record); this variant is never
-// returned.
-@schema
-type error = | RegistryError
-
-@schema
-type event =
-  | ApiFragmentRegistered({pluginId: string, fragment: apiSchemaFragment, apiTarget: apiTarget, at: string})
-  | ApiFragmentUpdated({
-      pluginId: string,
-      previousFragment: apiSchemaFragment,
-      newFragment: apiSchemaFragment,
-      apiTarget: apiTarget,
-      at: string,
-    })
-  | ApiFragmentDeregistered({pluginId: string})
-  | ApiFragmentPushRecorded({pluginId: string, ok: bool, message: string, at: string})
-  // Derived echo of the consistent registry contents after a fragment change — the reactive
-  // push SideEffect's trigger. Carries the full per-plugin snapshot so the SideEffect stitches
-  // from consistent state without a read. Does NOT change fold state (evolve ignores it), and
-  // is NOT projected by the ApiFragments read model.
-  | ApiSchemaComputed({snapshot: array<fragmentSnapshotEntry>})

package/src/admin/ApiFragmentRegistry/ApiFragmentRegistrySpec.res.mjs

@@ -1,92 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as S from "sury/src/S.res.mjs";
-import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
-import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
-
-let fragmentSnapshotEntrySchema = S.schema(s => ({
-  pluginId: s.m(S.string),
-  encoded: s.m(S.string),
-  protocol: s.m(S.string),
-  apiTarget: s.m(Plugin$Reventless.apiTargetSchema)
-}));
-
-let commandSchema = S.union([
-  S.schema(s => ({
-    TAG: "RegisterApiFragment",
-    pluginId: s.m(S.string),
-    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
-    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
-    at: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "DeregisterApiFragment",
-    pluginId: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "RecordApiFragmentPush",
-    pluginId: s.m(S.string),
-    ok: s.m(S.bool),
-    message: s.m(S.string),
-    at: s.m(S.string)
-  }))
-]);
-
-let errorSchema = S.literal("RegistryError");
-
-let eventSchema = S.union([
-  S.schema(s => ({
-    TAG: "ApiFragmentRegistered",
-    pluginId: s.m(S.string),
-    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
-    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
-    at: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ApiFragmentUpdated",
-    pluginId: s.m(S.string),
-    previousFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
-    newFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
-    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
-    at: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ApiFragmentDeregistered",
-    pluginId: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ApiFragmentPushRecorded",
-    pluginId: s.m(S.string),
-    ok: s.m(S.bool),
-    message: s.m(S.string),
-    at: s.m(S.string)
-  })),
-  S.schema(s => ({
-    TAG: "ApiSchemaComputed",
-    snapshot: s.m(S.array(fragmentSnapshotEntrySchema))
-  }))
-]);
-
-let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, ["RecordApiFragmentPush"]);
-
-function commandAuthorization(param) {
-  return "AllowAuthenticated";
-}
-
-let name = "ApiFragmentRegistry";
-
-let Id;
-
-let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/ApiFragmentRegistrySpec.res.mjs";
-
-export {
-  name,
-  Id,
-  fragmentSnapshotEntrySchema,
-  errorSchema,
-  eventSchema,
-  commandSchema$1 as commandSchema,
-  moduleUrl,
-  commandAuthorization,
-}
-/* fragmentSnapshotEntrySchema Not a pure module */

package/src/admin/ApiFragmentRegistry/ApiFragmentsProjection.res

@@ -1,63 +0,0 @@
-// ApiFragments projection — maps ApiFragmentRegistry aggregate events to per-plugin rows of
-// the ApiFragments read model. Manual Mapping.Make form (mirrors PluginsProjection; no ppx —
-// this file lives outside a ReadModel/ folder). Rows are keyed by the payload `pluginId`, not
-// the (singleton) aggregate id. `ApiSchemaComputed` is the reactive push's trigger only — it
-// carries no per-plugin row change, so it is Ignored here.
-//
-// A fragment change resets the row to "pending"; the push outcome arrives as a subsequent
-// ApiFragmentPushRecorded. An Update on a deleted row (a push recorded after deregistration) is
-// a no-op by Update semantics.
-
-open Reventless.Projection
-open Reventless.Message // brings the projection input record ({event, id, meta}) labels into scope
-
-let moduleUrl: string = %raw(`import.meta.url`)
-
-module ApiFragmentsMapping = Reventless.Projection.Mapping.Make(
-  ApiFragmentRegistrySpec,
-  ApiFragmentsReadModelSpec,
-  {
-    let project = ({event, _}) =>
-      switch event {
-      | ApiFragmentRegistrySpec.ApiFragmentRegistered({pluginId, fragment, apiTarget, at}) =>
-        Set(
-          pluginId,
-          {
-            ApiFragmentsReadModelSpec.pluginId,
-            encoded: fragment.encoded,
-            protocol: fragment.protocol,
-            apiTarget,
-            registeredAt: at,
-            updatedAt: at,
-            pushStatus: "pending",
-            pushMessage: "",
-            pushedAt: "",
-          },
-        )
-      | ApiFragmentUpdated({pluginId, newFragment, apiTarget, at}) =>
-        Update(pluginId, state => {
-          ...state,
-          encoded: newFragment.encoded,
-          protocol: newFragment.protocol,
-          apiTarget,
-          updatedAt: at,
-          pushStatus: "pending",
-          pushMessage: "",
-        })
-      | ApiFragmentDeregistered({pluginId}) => Delete(pluginId)
-      | ApiFragmentPushRecorded({pluginId, ok, message, at}) =>
-        Update(pluginId, state => {
-          ...state,
-          pushStatus: ok ? "ok" : "error",
-          pushMessage: message,
-          pushedAt: at,
-        })
-      // Reactive push trigger only — no row change.
-      | ApiSchemaComputed(_) => Ignore
-      }
-  },
-)
-
-module Mappings = Reventless.Projection.Mappings.Make(ApiFragmentsReadModelSpec)
-
-let mappings: array<module(Mappings.Mapping)> = [module(ApiFragmentsMapping)]

package/src/admin/ApiFragmentRegistry/ApiFragmentsProjection.res.mjs

@@ -1,108 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
-import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
-import * as ApiFragmentRegistrySpec$ReventlessCore from "./ApiFragmentRegistrySpec.res.mjs";
-import * as ApiFragmentsReadModelSpec$ReventlessCore from "./ApiFragmentsReadModelSpec.res.mjs";
-
-let moduleUrl = import.meta.url;
-
-function project(param) {
-  let event = param.event;
-  switch (event.TAG) {
-    case "ApiFragmentRegistered" :
-      let at = event.at;
-      let fragment = event.fragment;
-      let pluginId = event.pluginId;
-      return {
-        TAG: "Set",
-        _0: pluginId,
-        _1: {
-          pluginId: pluginId,
-          encoded: fragment.encoded,
-          protocol: fragment.protocol,
-          apiTarget: event.apiTarget,
-          registeredAt: at,
-          updatedAt: at,
-          pushStatus: "pending",
-          pushMessage: "",
-          pushedAt: ""
-        }
-      };
-    case "ApiFragmentUpdated" :
-      let at$1 = event.at;
-      let apiTarget = event.apiTarget;
-      let newFragment = event.newFragment;
-      return {
-        TAG: "Update",
-        _0: event.pluginId,
-        _1: state => ({
-          pluginId: state.pluginId,
-          encoded: newFragment.encoded,
-          protocol: newFragment.protocol,
-          apiTarget: apiTarget,
-          registeredAt: state.registeredAt,
-          updatedAt: at$1,
-          pushStatus: "pending",
-          pushMessage: "",
-          pushedAt: state.pushedAt
-        })
-      };
-    case "ApiFragmentDeregistered" :
-      return {
-        TAG: "Delete",
-        _0: event.pluginId
-      };
-    case "ApiFragmentPushRecorded" :
-      let at$2 = event.at;
-      let message = event.message;
-      let ok = event.ok;
-      return {
-        TAG: "Update",
-        _0: event.pluginId,
-        _1: state => ({
-          pluginId: state.pluginId,
-          encoded: state.encoded,
-          protocol: state.protocol,
-          apiTarget: state.apiTarget,
-          registeredAt: state.registeredAt,
-          updatedAt: state.updatedAt,
-          pushStatus: ok ? "ok" : "error",
-          pushMessage: message,
-          pushedAt: at$2
-        })
-      };
-    case "ApiSchemaComputed" :
-      return "Ignore";
-  }
-}
-
-let ApiFragmentsMapping = Projection$Reventless.Mapping.Make({
-  Id: Id$Reventless.$$String,
-  name: ApiFragmentRegistrySpec$ReventlessCore.name,
-  eventSchema: ApiFragmentRegistrySpec$ReventlessCore.eventSchema
-})({
-  Id: Id$Reventless.$$String,
-  name: ApiFragmentsReadModelSpec$ReventlessCore.name,
-  stateSchema: ApiFragmentsReadModelSpec$ReventlessCore.stateSchema,
-  subIdConfig: undefined
-})({
-  project: project
-});
-
-let Mappings = Projection$Reventless.Mappings.Make({
-  Id: Id$Reventless.$$String,
-  name: ApiFragmentsReadModelSpec$ReventlessCore.name,
-  stateSchema: ApiFragmentsReadModelSpec$ReventlessCore.stateSchema,
-  subIdConfig: undefined
-});
-
-let mappings = [ApiFragmentsMapping];
-
-export {
-  moduleUrl,
-  ApiFragmentsMapping,
-  Mappings,
-  mappings,
-}
-/* moduleUrl Not a pure module */

package/src/admin/ApiFragmentRegistry/ApiFragmentsReadModelSpec.res

@@ -1,23 +0,0 @@
-// ApiFragments read model — the read side of the platform API-schema fragment registry:
-// one row per plugin name holding its current fragment plus the outcome of the last schema
-// push that included it. Projected off the ApiFragmentRegistry singleton aggregate (keyed by
-// pluginId from the event payload, NOT by the aggregate id — the aggregate is a singleton).
-// Backs the `Platform_ApiFragments` status query the deploy waiter polls.
-//
-// `pushStatus` is "pending" from registration/update until the reactive push SideEffect records
-// the outcome ("ok" / "error"); `pushMessage`/`pushedAt` are "" until then (plain strings, no
-// option fields — matches the aggregate's wire contract).
-@@reventless.spec("ApiFragments")
-
-@schema
-type state = {
-  pluginId: string,
-  encoded: string,
-  protocol: string,
-  apiTarget: Reventless.Plugin.apiTarget,
-  registeredAt: string,
-  updatedAt: string,
-  pushStatus: string,
-  pushMessage: string,
-  pushedAt: string,
-}