velocious 1.0.404 → 1.0.405

package/build/src/database/initializer-from-require-context.d.ts

@@ -7,6 +7,7 @@ export default class VelociousDatabaseInitializerFromRequireContext {
         requireContext: ModelClassRequireContextType;
     });
     requireContext: ModelClassRequireContextType;
+    logger: Logger;
     /**
      * @param {object} args - Options object.
      * @param {import("../configuration.js").default} args.configuration - Configuration instance.
@@ -15,6 +16,33 @@ export default class VelociousDatabaseInitializerFromRequireContext {
     initialize({ configuration, ...restArgs }: {
         configuration: import("../configuration.js").default;
     }): Promise<void>;
+    /**
+     * Initializes a model's record metadata and its translation table (if any).
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {typeof import("./record/index.js").default} args.modelClass - Model class to initialize.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _initializeModelRecord({ configuration, modelClass }: {
+        configuration: import("../configuration.js").default;
+        modelClass: typeof import("./record/index.js").default;
+    }): Promise<void>;
+    /**
+     * Models opting out of eager metadata loading (`setEagerLoadRecordMetadata(false)`)
+     * are still initialized at startup when their (optional) table is present, so that
+     * synchronous query building such as `.where(...)` works without callers having to
+     * call `ensureInitialized()` first. When the table — or its connection — is not
+     * available the model is left deferred so startup still succeeds; it can then
+     * initialize lazily the first time a terminal query method (find/create/etc.) runs.
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {typeof import("./record/index.js").default} args.modelClass - Model class to initialize.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _bestEffortInitializeDeferredModel({ configuration, modelClass }: {
+        configuration: import("../configuration.js").default;
+        modelClass: typeof import("./record/index.js").default;
+    }): Promise<void>;
 }
 export type ModelClassRequireContextIDFunctionType = (id: string) => {
     default: typeof import("./record/index.js").default;
@@ -23,4 +51,5 @@ export type ModelClassRequireContextType = ModelClassRequireContextIDFunctionTyp
     keys: () => string[];
     id: string;
 };
+import Logger from "../logger.js";
 //# sourceMappingURL=initializer-from-require-context.d.ts.map

package/build/src/database/initializer-from-require-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initializer-from-require-context.d.ts","sourceRoot":"","sources":["../../../src/database/initializer-from-require-context.js"],"names":[],"mappings":"AAYA;IACE;;;OAGG;IACH,6CAFG;QAA2C,cAAc,EAAjD,4BAA4B;KACtC,EAKA;IADC,6CAAoC;IAGtC;;;;OAIG;IACH,2CAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,OAAO,CAAC,IAAI,CAAC,CA2BzB;CACF;qDAnDY,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,mBAAmB,EAAE,OAAO,CAAA;CAAC;2CACrE,sCAAsC,GAAG;IACjD,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX"}
+{"version":3,"file":"initializer-from-require-context.d.ts","sourceRoot":"","sources":["../../../src/database/initializer-from-require-context.js"],"names":[],"mappings":"AAaA;IACE;;;OAGG;IACH,6CAFG;QAA2C,cAAc,EAAjD,4BAA4B;KACtC,EAMA;IAFC,6CAAoC;IACpC,eAA8B;IAGhC;;;;OAIG;IACH,2CAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;;;OAMG;IACH,sDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACY,UAAU,EAA3D,cAAc,mBAAmB,EAAE,OAAO;KAClD,GAAU,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;;;;;OAWG;IACH,kEAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACY,UAAU,EAA3D,cAAc,mBAAmB,EAAE,OAAO;KAClD,GAAU,OAAO,CAAC,IAAI,CAAC,CAmBzB;CACF;qDA9FY,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,mBAAmB,EAAE,OAAO,CAAA;CAAC;2CACrE,sCAAsC,GAAG;IACjD,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX;mBAGe,cAAc"}

package/build/src/database/initializer-from-require-context.js

@@ -6,6 +6,7 @@
  *   id: string
  * }} ModelClassRequireContextType
  */
+import Logger from "../logger.js";
 import restArgsError from "../utils/rest-args-error.js";
 export default class VelociousDatabaseInitializerFromRequireContext {
     /**
@@ -15,6 +16,7 @@ export default class VelociousDatabaseInitializerFromRequireContext {
     constructor({ requireContext, ...restArgs }) {
         restArgsError(restArgs);
         this.requireContext = requireContext;
+        this.logger = new Logger(this);
     }
     /**
      * @param {object} args - Options object.
@@ -32,14 +34,54 @@ export default class VelociousDatabaseInitializerFromRequireContext {
                 throw new Error(`Model wasn't exported from: ${fileName}`);
             if (!modelClass.getEagerLoadRecordMetadata()) {
                 modelClass.registerRecordClass({ configuration });
+                await this._bestEffortInitializeDeferredModel({ configuration, modelClass });
                 continue;
             }
-            await modelClass.initializeRecord({ configuration });
-            if (await modelClass.hasTranslationsTable()) {
-                const translationClass = modelClass.getTranslationClass();
-                await translationClass.initializeRecord({ configuration });
-            }
+            await this._initializeModelRecord({ configuration, modelClass });
+        }
+    }
+    /**
+     * Initializes a model's record metadata and its translation table (if any).
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {typeof import("./record/index.js").default} args.modelClass - Model class to initialize.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _initializeModelRecord({ configuration, modelClass }) {
+        await modelClass.initializeRecord({ configuration });
+        if (await modelClass.hasTranslationsTable()) {
+            await modelClass.getTranslationClass().initializeRecord({ configuration });
+        }
+    }
+    /**
+     * Models opting out of eager metadata loading (`setEagerLoadRecordMetadata(false)`)
+     * are still initialized at startup when their (optional) table is present, so that
+     * synchronous query building such as `.where(...)` works without callers having to
+     * call `ensureInitialized()` first. When the table — or its connection — is not
+     * available the model is left deferred so startup still succeeds; it can then
+     * initialize lazily the first time a terminal query method (find/create/etc.) runs.
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {typeof import("./record/index.js").default} args.modelClass - Model class to initialize.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _bestEffortInitializeDeferredModel({ configuration, modelClass }) {
+        try {
+            const connection = modelClass.connection({ enforceTenantDatabaseScope: false });
+            const table = await connection.getTableByName(modelClass.tableName(), { throwError: false });
+            if (!table)
+                return;
+            await this._initializeModelRecord({ configuration, modelClass });
+        }
+        catch (error) {
+            // The optional table - or, for a translated model, its <table>_translations
+            // table (initializeRecord -> _defineTranslationMethods initializes the
+            // translation class) - is missing, or its connection is unavailable. Re-register
+            // to drop any partial metadata and leave the model deferred so startup still
+            // succeeds; it initializes lazily on first terminal use.
+            this.logger.debug(`Leaving ${modelClass.name} deferred - table metadata unavailable at startup`, error);
+            modelClass.registerRecordClass({ configuration });
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initializer-from-require-context.js","sourceRoot":"","sources":["../../../src/database/initializer-from-require-context.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;;;;;GAMG;AAEH,OAAO,MAAM,MAAM,cAAc,CAAA;AACjC,OAAO,aAAa,MAAM,6BAA6B,CAAA;AAEvD,MAAM,CAAC,OAAO,OAAO,8CAA8C;IACjE;;;OAGG;IACH,YAAY,EAAC,cAAc,EAAE,GAAG,QAAQ,EAAC;QACvC,aAAa,CAAC,QAAQ,CAAC,CAAA;QAEvB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAA;QACpC,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,EAAC,aAAa,EAAE,GAAG,QAAQ,EAAC;QAC3C,aAAa,CAAC,QAAQ,CAAC,CAAA;QAEvB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC;YAClD,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;YAEtD,IAAI,CAAC,gBAAgB;gBAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,QAAQ,EAAE,CAAC,CAAA;YAEtF,MAAM,UAAU,GAAG,gBAAgB,CAAC,OAAO,CAAA;YAE3C,IAAI,CAAC,UAAU;gBAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,QAAQ,EAAE,CAAC,CAAA;YAE3E,IAAI,CAAC,UAAU,CAAC,0BAA0B,EAAE,EAAE,CAAC;gBAC7C,UAAU,CAAC,mBAAmB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;gBAC/C,MAAM,IAAI,CAAC,kCAAkC,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,CAAC,CAAA;gBAC1E,SAAQ;YACV,CAAC;YAED,MAAM,IAAI,CAAC,sBAAsB,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,CAAC,CAAA;QAChE,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,sBAAsB,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC;QACtD,MAAM,UAAU,CAAC,gBAAgB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;QAElD,IAAI,MAAM,UAAU,CAAC,oBAAoB,EAAE,EAAE,CAAC;YAC5C,MAAM,UAAU,CAAC,mBAAmB,EAAE,CAAC,gBAAgB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;QAC1E,CAAC;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,kCAAkC,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC;QAClE,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,EAAC,0BAA0B,EAAE,KAAK,EAAC,CAAC,CAAA;YAC7E,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,EAAE,EAAE,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;YAE1F,IAAI,CAAC,KAAK;gBAAE,OAAM;YAElB,MAAM,IAAI,CAAC,sBAAsB,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,CAAC,CAAA;QAChE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,4EAA4E;YAC5E,uEAAuE;YACvE,iFAAiF;YACjF,6EAA6E;YAC7E,yDAAyD;YACzD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,UAAU,CAAC,IAAI,mDAAmD,EAAE,KAAK,CAAC,CAAA;YACvG,UAAU,CAAC,mBAAmB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;QACjD,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\n/**\n * @typedef {(id: string) => {default: typeof import(\"./record/index.js\").default}} ModelClassRequireContextIDFunctionType\n * @typedef {ModelClassRequireContextIDFunctionType & {\n *   keys: () => string[],\n *   id: string\n * }} ModelClassRequireContextType\n */\n\nimport Logger from \"../logger.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\nexport default class VelociousDatabaseInitializerFromRequireContext {\n  /**\n   * @param {object} args - Options object.\n   * @param {ModelClassRequireContextType} args.requireContext - Require context.\n   */\n  constructor({requireContext, ...restArgs}) {\n    restArgsError(restArgs)\n\n    this.requireContext = requireContext\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize({configuration, ...restArgs}) {\n    restArgsError(restArgs)\n\n    for (const fileName of this.requireContext.keys()) {\n      const modelClassImport = this.requireContext(fileName)\n\n      if (!modelClassImport) throw new Error(`Couldn't import model class from ${fileName}`)\n\n      const modelClass = modelClassImport.default\n\n      if (!modelClass) throw new Error(`Model wasn't exported from: ${fileName}`)\n\n      if (!modelClass.getEagerLoadRecordMetadata()) {\n        modelClass.registerRecordClass({configuration})\n        await this._bestEffortInitializeDeferredModel({configuration, modelClass})\n        continue\n      }\n\n      await this._initializeModelRecord({configuration, modelClass})\n    }\n  }\n\n  /**\n   * Initializes a model's record metadata and its translation table (if any).\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {typeof import(\"./record/index.js\").default} args.modelClass - Model class to initialize.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _initializeModelRecord({configuration, modelClass}) {\n    await modelClass.initializeRecord({configuration})\n\n    if (await modelClass.hasTranslationsTable()) {\n      await modelClass.getTranslationClass().initializeRecord({configuration})\n    }\n  }\n\n  /**\n   * Models opting out of eager metadata loading (`setEagerLoadRecordMetadata(false)`)\n   * are still initialized at startup when their (optional) table is present, so that\n   * synchronous query building such as `.where(...)` works without callers having to\n   * call `ensureInitialized()` first. When the table — or its connection — is not\n   * available the model is left deferred so startup still succeeds; it can then\n   * initialize lazily the first time a terminal query method (find/create/etc.) runs.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {typeof import(\"./record/index.js\").default} args.modelClass - Model class to initialize.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _bestEffortInitializeDeferredModel({configuration, modelClass}) {\n    try {\n      const connection = modelClass.connection({enforceTenantDatabaseScope: false})\n      const table = await connection.getTableByName(modelClass.tableName(), {throwError: false})\n\n      if (!table) return\n\n      await this._initializeModelRecord({configuration, modelClass})\n    } catch (error) {\n      // The optional table - or, for a translated model, its <table>_translations\n      // table (initializeRecord -> _defineTranslationMethods initializes the\n      // translation class) - is missing, or its connection is unavailable. Re-register\n      // to drop any partial metadata and leave the model deferred so startup still\n      // succeeds; it initializes lazily on first terminal use.\n      this.logger.debug(`Leaving ${modelClass.name} deferred - table metadata unavailable at startup`, error)\n      modelClass.registerRecordClass({configuration})\n    }\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.404",
+  "version": "1.0.405",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [