@nextage/nx-frame-be 1.0.41 → 1.0.43

package/build/common/constants.js

@@ -18,7 +18,7 @@ exports.APP = {
     dataScr: process.env.SECRET,
     nxPubSub: new pubsub_manager_1.PubSubManager(),
     shutdownMng: new shutdown_manager_1.ShutdownManager(),
-    config: { endpoint: {}, email: {}, jwt: {}, aws: {}, mongo: {}, logging: {}, invite: {}, msg: {} }
+    config: { endpoint: {}, email: {}, jwt: {}, aws: {}, mongo: {}, logging: {}, invite: {}, msg: {}, app: {} }
 };
 exports.FILE_CONTENT_TYPES = {
     none: '',

package/build/common/graphql/__test__/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/common/graphql/__test__/registry.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const coded_entity_controller_1 = require("../../models/coded-entity.controller");
+const loader_1 = require("../loader");
+const registry_1 = require("../registry");
+/**
+ * `SchemaRegistry` defers `generateSchema`/`loadSchema` until `apply`, so module
+ * LOADING is decoupled from schema MUTATION. These tests assert the deferral,
+ * the single-shot application and the reset semantics used for test isolation.
+ */
+describe('SchemaRegistry', () => {
+    afterEach(() => registry_1.schemaRegistry.reset());
+    it('starts empty', () => {
+        expect(registry_1.schemaRegistry.count).toBe(0);
+    });
+    it('defers registerSchema until apply', () => {
+        const marker = 'registryProbeField: String';
+        registry_1.schemaRegistry.registerSchema({ typeDefs: { query: marker } });
+        // registration is recorded but NOT yet folded into mainSchema
+        expect(registry_1.schemaRegistry.count).toBe(1);
+        expect(loader_1.mainSchema.typeDefs.query).not.toContain('registryProbeField');
+        registry_1.schemaRegistry.apply();
+        expect(loader_1.mainSchema.typeDefs.query).toContain('registryProbeField');
+    });
+    it('defers register (controller) until apply', () => {
+        const params = {
+            fields: { type: 'id: String', query: 'code: String', input: 'code: String' }
+        };
+        registry_1.schemaRegistry.register(coded_entity_controller_1.ceCtrl, params);
+        // the CRUD query name is generated by generateSchema at apply time only
+        expect(registry_1.schemaRegistry.count).toBe(1);
+        expect(loader_1.mainSchema.typeDefs.query).not.toContain('codedEntityList');
+        registry_1.schemaRegistry.apply();
+        expect(loader_1.mainSchema.typeDefs.query).toContain('codedEntityList');
+    });
+    it('reset clears every registration', () => {
+        registry_1.schemaRegistry.registerSchema({ typeDefs: { query: 'a: String' } });
+        registry_1.schemaRegistry.registerSchema({ typeDefs: { query: 'b: String' } });
+        expect(registry_1.schemaRegistry.count).toBe(2);
+        registry_1.schemaRegistry.reset();
+        expect(registry_1.schemaRegistry.count).toBe(0);
+    });
+    it('exposes a class for isolated instances', () => {
+        const local = new registry_1.SchemaRegistry();
+        local.registerSchema({ typeDefs: { query: 'c: String' } });
+        expect(local.count).toBe(1);
+        expect(registry_1.schemaRegistry.count).toBe(0);
+    });
+});

package/build/common/graphql/index.d.ts

@@ -1,4 +1,5 @@
 export * from './directives';
 export * from './loader';
 export * from './generator';
+export * from './registry';
 export * from './utils';

package/build/common/graphql/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./directives"), exports);
 __exportStar(require("./loader"), exports);
 __exportStar(require("./generator"), exports);
+__exportStar(require("./registry"), exports);
 __exportStar(require("./utils"), exports);
 //export * from './scalars';

package/build/common/graphql/registry.d.ts

@@ -0,0 +1,47 @@
+import { BaseController } from '../base/base.controller';
+import { NxGraphQLSchemaData, NxGraphQLSchemaExtension } from './interfaces';
+/**
+ * Deferred GraphQL schema-assembly registry.
+ *
+ * Historically every nx-app GraphQL leaf mutated the global `mainSchema` at
+ * import time by calling `generateSchema`/`loadSchema` as a module side-effect.
+ * That coupled module LOADING (which files get imported, and in what order) with
+ * schema MUTATION, and left the registered set invisible and non-resettable.
+ *
+ * With this registry a leaf instead REGISTERS its module — a controller plus a
+ * schema extension, or a raw typeDefs/resolvers block — deferring the actual
+ * `generateSchema`/`loadSchema` call. The bootstrap `graphql` phase discovers and
+ * imports the leaves (which call {@link register}/{@link registerSchema}) and then
+ * calls {@link apply} ONCE to fold every module into `mainSchema`.
+ *
+ * Benefits: loading is order-independent (filesystem discovery), mutation is a
+ * single explicit logged step, and the registered set is inspectable ({@link count})
+ * and resettable ({@link reset}) for test isolation.
+ */
+export declare class SchemaRegistry {
+    private deferred;
+    /**
+     * Register a controller-backed module. Mirrors {@link generateSchema}'s
+     * signature verbatim; the call is deferred until {@link apply}.
+     */
+    register<T extends BaseController<any, any, any>>(controller: T, schema?: NxGraphQLSchemaExtension, mergeCodedEntity?: boolean, readOnly?: boolean): void;
+    /**
+     * Register a raw typeDefs/resolvers block (no controller). Mirrors
+     * {@link loadSchema}; the call is deferred until {@link apply}.
+     */
+    registerSchema(data: NxGraphQLSchemaData): void;
+    /**
+     * Fold every registered module into the global `mainSchema`. Call ONCE from
+     * the bootstrap `graphql` phase, after all leaves have been imported.
+     */
+    apply(): void;
+    /** Clear all registrations (test isolation). */
+    reset(): void;
+    /** Number of modules registered so far. */
+    get count(): number;
+}
+/**
+ * Process-wide GraphQL schema registry singleton. nx-app leaves import this and
+ * call `register`/`registerSchema`; the bootstrap `graphql` phase calls `apply`.
+ */
+export declare const schemaRegistry: SchemaRegistry;

package/build/common/graphql/registry.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaRegistry = exports.SchemaRegistry = void 0;
+const constants_1 = require("../constants");
+const generator_1 = require("./generator");
+const loader_1 = require("./loader");
+/**
+ * Deferred GraphQL schema-assembly registry.
+ *
+ * Historically every nx-app GraphQL leaf mutated the global `mainSchema` at
+ * import time by calling `generateSchema`/`loadSchema` as a module side-effect.
+ * That coupled module LOADING (which files get imported, and in what order) with
+ * schema MUTATION, and left the registered set invisible and non-resettable.
+ *
+ * With this registry a leaf instead REGISTERS its module — a controller plus a
+ * schema extension, or a raw typeDefs/resolvers block — deferring the actual
+ * `generateSchema`/`loadSchema` call. The bootstrap `graphql` phase discovers and
+ * imports the leaves (which call {@link register}/{@link registerSchema}) and then
+ * calls {@link apply} ONCE to fold every module into `mainSchema`.
+ *
+ * Benefits: loading is order-independent (filesystem discovery), mutation is a
+ * single explicit logged step, and the registered set is inspectable ({@link count})
+ * and resettable ({@link reset}) for test isolation.
+ */
+class SchemaRegistry {
+    constructor() {
+        this.deferred = [];
+    }
+    /**
+     * Register a controller-backed module. Mirrors {@link generateSchema}'s
+     * signature verbatim; the call is deferred until {@link apply}.
+     */
+    register(controller, schema = {}, mergeCodedEntity = false, readOnly = false) {
+        this.deferred.push(() => (0, generator_1.generateSchema)(controller, schema, mergeCodedEntity, readOnly));
+    }
+    /**
+     * Register a raw typeDefs/resolvers block (no controller). Mirrors
+     * {@link loadSchema}; the call is deferred until {@link apply}.
+     */
+    registerSchema(data) {
+        this.deferred.push(() => (0, loader_1.loadSchema)(data));
+    }
+    /**
+     * Fold every registered module into the global `mainSchema`. Call ONCE from
+     * the bootstrap `graphql` phase, after all leaves have been imported.
+     */
+    apply() {
+        this.deferred.forEach(run => run());
+        constants_1.APP.logger.info(`🧩 GraphQL registry: applied ${this.deferred.length} schema module(s)`);
+    }
+    /** Clear all registrations (test isolation). */
+    reset() {
+        this.deferred = [];
+    }
+    /** Number of modules registered so far. */
+    get count() {
+        return this.deferred.length;
+    }
+}
+exports.SchemaRegistry = SchemaRegistry;
+/**
+ * Process-wide GraphQL schema registry singleton. nx-app leaves import this and
+ * call `register`/`registerSchema`; the bootstrap `graphql` phase calls `apply`.
+ */
+exports.schemaRegistry = new SchemaRegistry();

package/build/common/types.d.ts

@@ -42,7 +42,20 @@ export type AppConfig = {
     mongo: AppMongoDB;
     invite: AppInvitation;
     logging: AppLogging;
+    app: AppCustomConfig;
 };
+/**
+ * Application-specific configuration slot.
+ *
+ * Intentionally EMPTY in the framework: each consuming application augments this
+ * interface (declaration merging: `declare module '@nextage/nx-frame-be'`) to
+ * add its own strongly-typed settings, and populates `APP.config.app` at bootstrap
+ * (after env is read). This keeps CORE config (`endpoint`, `jwt`, `mongo`, …) in
+ * the framework while APP-ONLY settings live here — typed by the app, not by env
+ * reads scattered across the codebase.
+ */
+export interface AppCustomConfig {
+}
 export type AppMongoDB = {
     auth?: {
         us: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextage/nx-frame-be",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",