@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

package/src/engine/registry-facade.ts

@@ -0,0 +1,362 @@
+import type { IncomingRelation, RegistryState } from "./registry-state";
+import { filterByPhase, filterOwned } from "./registry-state";
+import type {
+  AuthClaimsHookDef,
+  ClaimKeyDefinition,
+  ConfigKeyDefinition,
+  ConfigSeedDef,
+  EntityDefinition,
+  EntityRelations,
+  EventDef,
+  FeatureDefinition,
+  HookPhase,
+  JobDefinition,
+  MultiStreamProjectionDefinition,
+  NavDefinition,
+  NotificationDefinition,
+  PostDeleteHookFn,
+  PostQueryHookFn,
+  PostSaveHookFn,
+  PreDeleteHookFn,
+  PreQueryHookFn,
+  PreSaveHookFn,
+  ProjectionDefinition,
+  QueryHandlerDef,
+  ReferenceDataDef,
+  RegistrarExtensionDef,
+  RegistrarExtensionRegistration,
+  Registry,
+  ScreenDefinition,
+  SearchPayloadContributorFn,
+  SecretKeyDefinition,
+  StoreTableDef,
+  StreamHandlerDef,
+  TranslationKeys,
+  TreeActionDef,
+  WorkspaceDefinition,
+  WriteHandlerDef,
+} from "./types";
+
+// Builds the public Registry surface (64 getters) bound to a specific
+// RegistryState instance — pure move-diff from createRegistry's former
+// return-object literal, only the closure-captured variable changed
+// (state.X instead of bare X, done in the RegistryState-threading step).
+export function buildRegistryFacade(state: RegistryState): Registry {
+  return {
+    features: state.featureMap,
+
+    getFeature(name: string): FeatureDefinition | undefined {
+      return state.featureMap.get(name);
+    },
+
+    hasRateLimitedHandler(): boolean {
+      return state.hasRateLimitedHandlerCached;
+    },
+
+    getEntity(name: string): EntityDefinition | undefined {
+      return state.entityMap.get(name);
+    },
+
+    getAllEntities(): ReadonlyMap<string, EntityDefinition> {
+      return state.entityMap;
+    },
+
+    getWriteHandler(name: string): WriteHandlerDef | undefined {
+      return state.writeHandlerMap.get(name);
+    },
+
+    getQueryHandler(name: string): QueryHandlerDef | undefined {
+      return state.queryHandlerMap.get(name);
+    },
+
+    getAllQueryHandlers(): ReadonlyMap<string, QueryHandlerDef> {
+      return state.queryHandlerMap;
+    },
+
+    getStreamHandler(name: string): StreamHandlerDef | undefined {
+      return state.streamHandlerMap.get(name);
+    },
+
+    getAllStreamHandlers(): ReadonlyMap<string, StreamHandlerDef> {
+      return state.streamHandlerMap;
+    },
+
+    getSearchableFields(entityName: string): readonly string[] {
+      return state.searchableFieldsCache.get(entityName) ?? [];
+    },
+
+    getSortableFields(entityName: string): readonly string[] {
+      return state.sortableFieldsCache.get(entityName) ?? [];
+    },
+
+    getRelations(entityName: string): EntityRelations {
+      return (state.relationMap.get(entityName) ?? {}) as EntityRelations; // @cast-boundary schema-walk
+    },
+
+    getSearchIncludes(entityName: string): ReadonlyMap<string, readonly string[]> {
+      return state.searchIncludesCache.get(entityName) ?? new Map();
+    },
+
+    getIncomingRelations(entityName: string): readonly IncomingRelation[] {
+      return state.incomingRelationsCache.get(entityName) ?? [];
+    },
+
+    getPreSaveHooks(
+      name: string,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PreSaveHookFn[] {
+      return filterOwned(state.preSaveHooks.get(name), effectiveFeatures);
+    },
+
+    getPostSaveHooks(
+      name: string,
+      phase?: HookPhase,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PostSaveHookFn[] {
+      return filterByPhase(state.postSaveHooks.get(name), phase, effectiveFeatures);
+    },
+
+    getPreDeleteHooks(
+      name: string,
+      phase?: HookPhase,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PreDeleteHookFn[] {
+      return filterByPhase(state.preDeleteHooks.get(name), phase, effectiveFeatures);
+    },
+
+    getPostDeleteHooks(
+      name: string,
+      phase?: HookPhase,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PostDeleteHookFn[] {
+      return filterByPhase(state.postDeleteHooks.get(name), phase, effectiveFeatures);
+    },
+
+    getPreQueryHooks(
+      name: string,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PreQueryHookFn[] {
+      return filterOwned(state.preQueryHooks.get(name), effectiveFeatures);
+    },
+
+    getPostQueryHooks(
+      name: string,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PostQueryHookFn[] {
+      return filterOwned(state.postQueryHooks.get(name), effectiveFeatures);
+    },
+
+    // Entity hooks — fire for all writes on an entity
+    getEntityPostSaveHooks(
+      entityName: string,
+      phase?: HookPhase,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PostSaveHookFn[] {
+      return filterByPhase(state.entityPostSaveHooks.get(entityName), phase, effectiveFeatures);
+    },
+
+    getEntityPreDeleteHooks(
+      entityName: string,
+      phase?: HookPhase,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PreDeleteHookFn[] {
+      return filterByPhase(state.entityPreDeleteHooks.get(entityName), phase, effectiveFeatures);
+    },
+
+    getEntityPostDeleteHooks(
+      entityName: string,
+      phase?: HookPhase,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PostDeleteHookFn[] {
+      return filterByPhase(state.entityPostDeleteHooks.get(entityName), phase, effectiveFeatures);
+    },
+
+    getEntityPostQueryHooks(
+      entityName: string,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly PostQueryHookFn[] {
+      return filterOwned(state.entityPostQueryHooks.get(entityName), effectiveFeatures);
+    },
+
+    // F3 — Search-Payload-Extension contributors for an entity. Used by
+    // `buildSearchDocument` in system-hooks.ts to enrich the indexed payload.
+    // `effectiveFeatures` filters out contributors owned by feature-toggle-
+    // disabled features (parallel to getEntityPostQueryHooks etc.).
+    getSearchPayloadExtensions(
+      entityName: string,
+      effectiveFeatures?: ReadonlySet<string>,
+    ): readonly SearchPayloadContributorFn[] {
+      return filterOwned(state.searchPayloadExtensions.get(entityName), effectiveFeatures);
+    },
+
+    getAllTranslations(): TranslationKeys {
+      return state.mergedTranslations;
+    },
+
+    getHandlerEntity(qualifiedHandler: string): string | undefined {
+      return state.handlerEntityMap.get(qualifiedHandler);
+    },
+
+    isHandlerSystemScoped(qualifiedHandler: string): boolean {
+      const featureName = state.handlerFeatureMap.get(qualifiedHandler);
+      if (!featureName) return false;
+      return state.featureMap.get(featureName)?.systemScope ?? false;
+    },
+
+    getHandlerFeature(qualifiedHandler: string): string | undefined {
+      return state.handlerFeatureMap.get(qualifiedHandler);
+    },
+
+    getAllMetrics() {
+      return state.metricMap;
+    },
+
+    getAllSecretKeys(): ReadonlyMap<string, SecretKeyDefinition> {
+      return state.secretKeyMap;
+    },
+
+    getSecretKey(qualifiedName: string): SecretKeyDefinition | undefined {
+      return state.secretKeyMap.get(qualifiedName);
+    },
+
+    getConfigKey(qualifiedKey: string): ConfigKeyDefinition | undefined {
+      return state.configKeyMap.get(qualifiedKey);
+    },
+
+    getAllConfigKeys(): ReadonlyMap<string, ConfigKeyDefinition> {
+      return state.configKeyMap;
+    },
+
+    getJob(qualifiedName: string): JobDefinition | undefined {
+      return state.jobMap.get(qualifiedName);
+    },
+
+    getAllJobs(): ReadonlyMap<string, JobDefinition> {
+      return state.jobMap;
+    },
+
+    getEvent(qualifiedName: string): EventDef | undefined {
+      return state.eventMap.get(qualifiedName);
+    },
+
+    getEventUpcasters() {
+      return state.eventUpcasterMap;
+    },
+
+    getExtension(name: string): RegistrarExtensionDef | undefined {
+      return state.extensionMap.get(name);
+    },
+
+    getExtensionUsages(extensionName: string): readonly RegistrarExtensionRegistration[] {
+      return state.extensionUsages.filter((u) => u.extensionName === extensionName);
+    },
+
+    getAllExtensionSelectors(): ReadonlyMap<string, string> {
+      return state.extensionSelectorMap;
+    },
+
+    getAllNotifications(): ReadonlyMap<string, NotificationDefinition> {
+      return state.notificationMap;
+    },
+
+    getAllReferenceData(): readonly ReferenceDataDef[] {
+      return state.allReferenceData;
+    },
+
+    getAllConfigSeeds(): readonly ConfigSeedDef[] {
+      return state.allConfigSeeds;
+    },
+
+    getProjectionsForSource(entityName: string): readonly ProjectionDefinition[] {
+      return state.projectionsBySource.get(entityName) ?? [];
+    },
+
+    getAllProjections(): ReadonlyMap<string, ProjectionDefinition> {
+      return state.projectionMap;
+    },
+
+    getAllStoreTables(): ReadonlyMap<string, StoreTableDef> {
+      return state.storeTableMap;
+    },
+
+    getAllMultiStreamProjections(): ReadonlyMap<string, MultiStreamProjectionDefinition> {
+      return state.multiStreamProjectionMap;
+    },
+
+    getMultiStreamProjectionFeature(qualifiedName: string): string | undefined {
+      return state.multiStreamProjectionFeatureMap.get(qualifiedName);
+    },
+
+    getAuthClaimsHooks(): readonly AuthClaimsHookDef[] {
+      return state.authClaimsHooks;
+    },
+
+    getAllClaimKeys(): ReadonlyMap<string, ClaimKeyDefinition> {
+      return state.claimKeyMap;
+    },
+
+    getClaimKey(qualifiedName: string): ClaimKeyDefinition | undefined {
+      return state.claimKeyMap.get(qualifiedName);
+    },
+
+    getAllScreens(): ReadonlyMap<string, ScreenDefinition> {
+      return state.screenMap;
+    },
+
+    getScreen(qualifiedName: string): ScreenDefinition | undefined {
+      return state.screenMap.get(qualifiedName);
+    },
+
+    getScreenFeature(qualifiedName: string): string | undefined {
+      return state.screenFeatureMap.get(qualifiedName);
+    },
+
+    getScreensByEntity(entityName: string): readonly ScreenDefinition[] {
+      return state.screensByEntity.get(entityName) ?? [];
+    },
+
+    getAllNavs(): ReadonlyMap<string, NavDefinition> {
+      return state.navMap;
+    },
+
+    getNav(qualifiedName: string): NavDefinition | undefined {
+      return state.navMap.get(qualifiedName);
+    },
+
+    getNavFeature(qualifiedName: string): string | undefined {
+      return state.navFeatureMap.get(qualifiedName);
+    },
+
+    getNavsByParent(parentQualifiedName: string): readonly NavDefinition[] {
+      return state.navsByParent.get(parentQualifiedName) ?? [];
+    },
+
+    getTopLevelNavs(): readonly NavDefinition[] {
+      return state.topLevelNavs;
+    },
+
+    getAllWorkspaces(): ReadonlyMap<string, WorkspaceDefinition> {
+      return state.workspaceMap;
+    },
+
+    getWorkspace(qualifiedName: string): WorkspaceDefinition | undefined {
+      return state.workspaceMap.get(qualifiedName);
+    },
+
+    getWorkspaceFeature(qualifiedName: string): string | undefined {
+      return state.workspaceFeatureMap.get(qualifiedName);
+    },
+
+    getWorkspaceNavs(workspaceQualifiedName: string): readonly string[] {
+      return state.navsByWorkspace.get(workspaceQualifiedName) ?? [];
+    },
+
+    getDefaultWorkspace(): WorkspaceDefinition | undefined {
+      return state.defaultWorkspace;
+    },
+
+    getTreeActions(featureName: string): Readonly<Record<string, TreeActionDef>> | undefined {
+      return state.treeActionsMap.get(featureName);
+    },
+  };
+}