velocious 1.0.580 → 1.0.581

package/build/src/database/generation-context.js

@@ -0,0 +1,102 @@
+// @ts-check
+import Tenant from "../tenants/tenant.js";
+/**
+ * Immutable selection of one logical tenant database and one provider-resolved
+ * physical tenant. Schema tools can share this contract without ambient or
+ * process-global selection state.
+ */
+export default class DatabaseGenerationContext {
+    /**
+     * Resolves one tenant-only database from its provider and captures its physical identity.
+     * @param {object} args - Selection arguments.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {string} args.databaseIdentifier - Logical tenant-only database identifier.
+     * @returns {Promise<DatabaseGenerationContext>} - Immutable selected database context.
+     */
+    static async resolve({ configuration, databaseIdentifier }) {
+        const databaseConfiguration = configuration.getDatabaseConfiguration()[databaseIdentifier];
+        if (!databaseConfiguration) {
+            throw new Error(`No such tenant database identifier configured: ${databaseIdentifier}`);
+        }
+        if (!databaseConfiguration.tenantOnly) {
+            throw new Error(`Database identifier ${databaseIdentifier} is not configured with tenantOnly: true`);
+        }
+        if (configuration.getDisabledDatabaseIdentifiers().has(databaseIdentifier)) {
+            throw new Error(`Tenant database identifier ${databaseIdentifier} is disabled by VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS`);
+        }
+        const provider = configuration.getTenantDatabaseProvider(databaseIdentifier);
+        await configuration.initialize({ type: "database-generation" });
+        const tenants = await configuration.ensureConnections({ name: `Resolve database generation context: ${databaseIdentifier}` }, async () => {
+            if (provider.resolveGenerationTenant) {
+                const tenant = await provider.resolveGenerationTenant({ configuration, identifier: databaseIdentifier });
+                return tenant === undefined ? [] : [tenant];
+            }
+            return await provider.listTenants({ configuration, identifier: databaseIdentifier });
+        });
+        if (!Array.isArray(tenants)) {
+            throw new Error(`Tenant database provider for ${databaseIdentifier} must return an array from listTenants`);
+        }
+        if (tenants.length === 0) {
+            throw new Error(`Tenant database selection ${databaseIdentifier} resolved no tenants`);
+        }
+        if (tenants.length !== 1) {
+            throw new Error(`Tenant database selection ${databaseIdentifier} is ambiguous: provider returned ${tenants.length} tenants`);
+        }
+        const tenant = tenants[0];
+        if (!tenant || typeof tenant !== "object" || Array.isArray(tenant)) {
+            throw new Error(`Tenant database selection ${databaseIdentifier} returned an invalid tenant descriptor`);
+        }
+        const handle = Tenant.handle(tenant, configuration);
+        // Resolve now so an inactive/stale descriptor fails before a selected
+        // schema connection can be checked out or read.
+        handle.databaseConfiguration(databaseIdentifier);
+        return new DatabaseGenerationContext({ configuration, databaseIdentifier, handle });
+    }
+    /**
+     * Runs constructor.
+     * @param {object} args - Captured selection.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {string} args.databaseIdentifier - Logical database identifier.
+     * @param {ReturnType<typeof Tenant.handle>} args.handle - Captured tenant handle.
+     */
+    constructor({ configuration, databaseIdentifier, handle }) {
+        this._configuration = configuration;
+        this._databaseIdentifier = databaseIdentifier;
+        this._handle = handle;
+        Object.freeze(this);
+    }
+    /**
+     * Returns the captured logical database identifier.
+     * @returns {string} - Captured logical database identifier.
+     */
+    databaseIdentifier() { return this._databaseIdentifier; }
+    /**
+     * Returns the captured physical database configuration.
+     * @returns {import("../configuration-types.js").DatabaseConfigurationType} - Captured physical database configuration.
+     */
+    databaseConfiguration() { return this._handle.databaseConfiguration(this._databaseIdentifier); }
+    /**
+     * Returns the captured tenant descriptor.
+     * @returns {ReturnType<ReturnType<typeof Tenant.handle>["tenant"]>} - Captured immutable tenant descriptor.
+     */
+    tenant() { return this._handle.tenant(); }
+    /**
+     * Runs work on one connection pinned to the captured physical database.
+     * @template T
+     * @param {object} args - Work arguments.
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} args.callback - Selected database work.
+     * @param {string} args.name - Checkout name.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async run({ callback, name }) {
+        return await this._configuration.runWithTenant(this.tenant(), async () => {
+            return await this._configuration.withDatabaseOperation({
+                databaseConfiguration: this.databaseConfiguration(),
+                databaseIdentifier: this.databaseIdentifier(),
+                name,
+                tenant: this.tenant()
+            }, async (operation) => await callback(operation.connection()));
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generation-context.js","sourceRoot":"","sources":["../../../src/database/generation-context.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Tenant from \"../tenants/tenant.js\"\n\n/**\n * Immutable selection of one logical tenant database and one provider-resolved\n * physical tenant. Schema tools can share this contract without ambient or\n * process-global selection state.\n */\nexport default class DatabaseGenerationContext {\n  /**\n   * Resolves one tenant-only database from its provider and captures its physical identity.\n   * @param {object} args - Selection arguments.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {string} args.databaseIdentifier - Logical tenant-only database identifier.\n   * @returns {Promise<DatabaseGenerationContext>} - Immutable selected database context.\n   */\n  static async resolve({configuration, databaseIdentifier}) {\n    const databaseConfiguration = configuration.getDatabaseConfiguration()[databaseIdentifier]\n\n    if (!databaseConfiguration) {\n      throw new Error(`No such tenant database identifier configured: ${databaseIdentifier}`)\n    }\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`Database identifier ${databaseIdentifier} is not configured with tenantOnly: true`)\n    }\n    if (configuration.getDisabledDatabaseIdentifiers().has(databaseIdentifier)) {\n      throw new Error(`Tenant database identifier ${databaseIdentifier} is disabled by VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS`)\n    }\n\n    const provider = configuration.getTenantDatabaseProvider(databaseIdentifier)\n\n    await configuration.initialize({type: \"database-generation\"})\n\n    const tenants = await configuration.ensureConnections({name: `Resolve database generation context: ${databaseIdentifier}`}, async () => {\n      if (provider.resolveGenerationTenant) {\n        const tenant = await provider.resolveGenerationTenant({configuration, identifier: databaseIdentifier})\n\n        return tenant === undefined ? [] : [tenant]\n      }\n\n      return await provider.listTenants({configuration, identifier: databaseIdentifier})\n    })\n\n    if (!Array.isArray(tenants)) {\n      throw new Error(`Tenant database provider for ${databaseIdentifier} must return an array from listTenants`)\n    }\n    if (tenants.length === 0) {\n      throw new Error(`Tenant database selection ${databaseIdentifier} resolved no tenants`)\n    }\n    if (tenants.length !== 1) {\n      throw new Error(`Tenant database selection ${databaseIdentifier} is ambiguous: provider returned ${tenants.length} tenants`)\n    }\n\n    const tenant = tenants[0]\n\n    if (!tenant || typeof tenant !== \"object\" || Array.isArray(tenant)) {\n      throw new Error(`Tenant database selection ${databaseIdentifier} returned an invalid tenant descriptor`)\n    }\n\n    const handle = Tenant.handle(tenant, configuration)\n\n    // Resolve now so an inactive/stale descriptor fails before a selected\n    // schema connection can be checked out or read.\n    handle.databaseConfiguration(databaseIdentifier)\n\n    return new DatabaseGenerationContext({configuration, databaseIdentifier, handle})\n  }\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Captured selection.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {string} args.databaseIdentifier - Logical database identifier.\n   * @param {ReturnType<typeof Tenant.handle>} args.handle - Captured tenant handle.\n   */\n  constructor({configuration, databaseIdentifier, handle}) {\n    this._configuration = configuration\n    this._databaseIdentifier = databaseIdentifier\n    this._handle = handle\n\n    Object.freeze(this)\n  }\n\n  /**\n   * Returns the captured logical database identifier.\n   * @returns {string} - Captured logical database identifier.\n   */\n  databaseIdentifier() { return this._databaseIdentifier }\n\n  /**\n   * Returns the captured physical database configuration.\n   * @returns {import(\"../configuration-types.js\").DatabaseConfigurationType} - Captured physical database configuration.\n   */\n  databaseConfiguration() { return this._handle.databaseConfiguration(this._databaseIdentifier) }\n\n  /**\n   * Returns the captured tenant descriptor.\n   * @returns {ReturnType<ReturnType<typeof Tenant.handle>[\"tenant\"]>} - Captured immutable tenant descriptor.\n   */\n  tenant() { return this._handle.tenant() }\n\n  /**\n   * Runs work on one connection pinned to the captured physical database.\n   * @template T\n   * @param {object} args - Work arguments.\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} args.callback - Selected database work.\n   * @param {string} args.name - Checkout name.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async run({callback, name}) {\n    return await this._configuration.runWithTenant(this.tenant(), async () => {\n      return await this._configuration.withDatabaseOperation({\n        databaseConfiguration: this.databaseConfiguration(),\n        databaseIdentifier: this.databaseIdentifier(),\n        name,\n        tenant: this.tenant()\n      }, async (operation) => await callback(operation.connection()))\n    })\n  }\n}\n"]}

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":"AAIG,YAAiF,sCAAsC,GAA7G,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,mBAAmB,EAAE,OAAO,CAAA;CAAC,CAAwC;AACvH,YAGG,4BAA4B,GAHrB,sCAAsC,GAAG;IACjD,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX,CAA8B;AANlC;;;;;;;GAOG;AAEH,OAAO,MAAM,MAAM,cAAc,CAAA;AAGjC,MAAM,CAAC,OAAO,OAAO,8CAA8C;IAS1D,cAAc;IACd,MAAM;IATb;;;;OAIG;IACH,YAAY,EAAC,cAAc,EAAE,GAAG,QAAQ,EAAC,EAFtC;QAA2C,cAAc,EAAjD,4BAA4B,CACtC;KACwC,EAKxC;IAED;;;;;OAKG;IACG,UAAU,CAAC,EAAC,aAAa,EAAE,GAAG,QAAQ,EAAC,EAH1C;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;KAE0C,GAFhC,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;;;OAMG;IACG,sBAAsB,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,EAJrD;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAyD,UAAU,EAA3D,cAAc,mBAAmB,EAAE,OAAO,CAClD;KAEqD,GAF3C,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;;;;;OAWG;IACG,kCAAkC,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,EAJjE;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAyD,UAAU,EAA3D,cAAc,mBAAmB,EAAE,OAAO,CAClD;KAEiE,GAFvD,OAAO,CAAC,IAAI,CAAC,CAmBzB;CACF"}
+{"version":3,"file":"initializer-from-require-context.d.ts","sourceRoot":"","sources":["../../../src/database/initializer-from-require-context.js"],"names":[],"mappings":"AAIG,YAAiF,sCAAsC,GAA7G,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,mBAAmB,EAAE,OAAO,CAAA;CAAC,CAAwC;AACvH,YAGG,4BAA4B,GAHrB,sCAAsC,GAAG;IACjD,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX,CAA8B;AANlC;;;;;;;GAOG;AAEH,OAAO,MAAM,MAAM,cAAc,CAAA;AAGjC,MAAM,CAAC,OAAO,OAAO,8CAA8C;IAS1D,cAAc;IACd,MAAM;IATb;;;;OAIG;IACH,YAAY,EAAC,cAAc,EAAE,GAAG,QAAQ,EAAC,EAFtC;QAA2C,cAAc,EAAjD,4BAA4B,CACtC;KACwC,EAKxC;IAED;;;;;OAKG;IACG,UAAU,CAAC,EAAC,aAAa,EAAE,GAAG,QAAQ,EAAC,EAH1C;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;KAE0C,GAFhC,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAED;;;;;;OAMG;IACG,sBAAsB,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,EAJrD;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAyD,UAAU,EAA3D,cAAc,mBAAmB,EAAE,OAAO,CAClD;KAEqD,GAF3C,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;;;;;OAWG;IACG,kCAAkC,CAAC,EAAC,aAAa,EAAE,UAAU,EAAC,EAJjE;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAyD,UAAU,EAA3D,cAAc,mBAAmB,EAAE,OAAO,CAClD;KAEiE,GAFvD,OAAO,CAAC,IAAI,CAAC,CAmBzB;CACF"}

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

@@ -35,6 +35,11 @@ export default class VelociousDatabaseInitializerFromRequireContext {
             const modelClass = modelClassImport.default;
             if (!modelClass)
                 throw new Error(`Model wasn't exported from: ${fileName}`);
+            const configuredDatabase = configuration.getDatabaseConfiguration()[modelClass.getConfiguredDatabaseIdentifier()];
+            if (configuredDatabase?.tenantOnly && !configuration.isDatabaseIdentifierActive(modelClass.getConfiguredDatabaseIdentifier())) {
+                modelClass.registerRecordClass({ configuration });
+                continue;
+            }
             if (!modelClass.getEagerLoadRecordMetadata()) {
                 modelClass.registerRecordClass({ configuration });
                 await this._bestEffortInitializeDeferredModel({ configuration, modelClass });
@@ -87,4 +92,4 @@ export default class VelociousDatabaseInitializerFromRequireContext {
         }
     }
 }
-//# 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;;;;;;;GAOG;AAEH,OAAO,MAAM,MAAM,cAAc,CAAA;AACjC,OAAO,aAAa,MAAM,6BAA6B,CAAA;AAEvD,MAAM,CAAC,OAAO,OAAO,8CAA8C;IACjE;;;;OAIG;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;;;;;OAKG;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 * Defines this typedef.\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   * Runs constructor.\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   * Runs initialize.\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initializer-from-require-context.js","sourceRoot":"","sources":["../../../src/database/initializer-from-require-context.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Defines this typedef.\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   * Runs constructor.\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   * Runs initialize.\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      const configuredDatabase = configuration.getDatabaseConfiguration()[modelClass.getConfiguredDatabaseIdentifier()]\n\n      if (configuredDatabase?.tenantOnly && !configuration.isDatabaseIdentifierActive(modelClass.getConfiguredDatabaseIdentifier())) {\n        modelClass.registerRecordClass({configuration})\n        continue\n      }\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/build/src/environment-handlers/node/cli/commands/db/schema/dump.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dump.d.ts","sourceRoot":"","sources":["../../../../../../../../src/environment-handlers/node/cli/commands/db/schema/dump.js"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,uCAAuC,CAAA;AAI/D,2DAA2D;AAC3D,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,WAAW;IACnD;;kCAE8B;IACxB,OAAO,IADA,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;;;OAKG;IACG,0BAA0B,CAAC,EAAC,GAAG,EAAC,EAHnC;QAA2F,GAAG,EAAtF,MAAM,CAAC,MAAM,EAAE,OAAO,4CAA4C,EAAE,OAAO,CAAC,CACpF;KAEmC,GAFzB,OAAO,CAAC,OAAO,CAAC,CAkB5B;CACF"}
+{"version":3,"file":"dump.d.ts","sourceRoot":"","sources":["../../../../../../../../src/environment-handlers/node/cli/commands/db/schema/dump.js"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,uCAAuC,CAAA;AAM/D,2DAA2D;AAC3D,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,WAAW;IACnD;;kCAE8B;IACxB,OAAO,IADA,OAAO,CAAC,IAAI,CAAC,CAgCzB;IAED;;;;;OAKG;IACG,0BAA0B,CAAC,EAAC,GAAG,EAAC,EAHnC;QAA2F,GAAG,EAAtF,MAAM,CAAC,MAAM,EAAE,OAAO,4CAA4C,EAAE,OAAO,CAAC,CACpF;KAEmC,GAFzB,OAAO,CAAC,OAAO,CAAC,CAkB5B;CACF"}

package/build/src/environment-handlers/node/cli/commands/db/schema/dump.js

@@ -1,4 +1,6 @@
 import BaseCommand from "../../../../../../cli/base-command.js";
+import commandArguments from "../../../../../../cli/command-arguments.js";
+import DatabaseGenerationContext from "../../../../../../database/generation-context.js";
 import fileExists from "../../../../../../utils/file-exists.js";
 import path from "path";
 /** Node CLI command for dumping DB structure SQL files. */
@@ -7,6 +9,25 @@ export default class DbSchemaDump extends BaseCommand {
      * Runs execute.
      * @returns {Promise<void>} */
     async execute() {
+        const parsedArguments = commandArguments({
+            definition: { valueOptions: ["--tenant"] },
+            processArgs: this.processArgs || []
+        });
+        const tenantDatabaseIdentifier = parsedArguments.tenant;
+        if (typeof tenantDatabaseIdentifier === "string") {
+            const context = await DatabaseGenerationContext.resolve({
+                configuration: this.getConfiguration(),
+                databaseIdentifier: tenantDatabaseIdentifier
+            });
+            await context.run({ name: "DB selected tenant schema dump", callback: async (db) => {
+                    const dbs = { [context.databaseIdentifier()]: db };
+                    const shouldGenerate = await this.shouldGenerateStructureSql({ dbs });
+                    if (!shouldGenerate)
+                        return;
+                    await this.getEnvironmentHandler().afterMigrations({ dbs, reason: "schemaDump" });
+                } });
+            return;
+        }
         await this.getConfiguration().ensureConnections({ name: "DB schema dump" }, async (dbs) => {
             const shouldGenerate = await this.shouldGenerateStructureSql({ dbs });
             if (!shouldGenerate)
@@ -35,4 +56,4 @@ export default class DbSchemaDump extends BaseCommand {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/environment-handlers/node/cli/commands/db/schema/load.d.ts

@@ -5,5 +5,16 @@ export default class DbSchemaLoad extends BaseCommand {
      * Runs execute.
      * @returns {Promise<void>} */
     execute(): Promise<void>;
+    /**
+     * Loads one identifier's explicit structure file into one selected connection.
+     * @param {object} args - Load arguments.
+     * @param {import("../../../../../../database/drivers/base.js").default} args.db - Target connection.
+     * @param {string} args.identifier - Logical database identifier used in the file name.
+     * @returns {Promise<void>} - Resolves after loading.
+     */
+    loadStructureSql({ db, identifier }: {
+        db: import("../../../../../../database/drivers/base.js").default;
+        identifier: string;
+    }): Promise<void>;
 }
 //# sourceMappingURL=load.d.ts.map

package/build/src/environment-handlers/node/cli/commands/db/schema/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../../../../../src/environment-handlers/node/cli/commands/db/schema/load.js"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,uCAAuC,CAAA;AAK/D,2DAA2D;AAC3D,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,WAAW;IACnD;;kCAE8B;IACxB,OAAO,IADA,OAAO,CAAC,IAAI,CAAC,CAczB;CACF"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../../../../../src/environment-handlers/node/cli/commands/db/schema/load.js"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,uCAAuC,CAAA;AAO/D,2DAA2D;AAC3D,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,WAAW;IACnD;;kCAE8B;IACxB,OAAO,IADA,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;OAMG;IACG,gBAAgB,CAAC,EAAC,EAAE,EAAE,UAAU,EAAC,EAJpC;QAA2E,EAAE,EAArE,OAAO,4CAA4C,EAAE,OAAO,CACpE;QAAqB,UAAU,EAAvB,MAAM,CACd;KAEoC,GAF1B,OAAO,CAAC,IAAI,CAAC,CASzB;CACF"}

package/build/src/environment-handlers/node/cli/commands/db/schema/load.js

@@ -1,4 +1,6 @@
 import BaseCommand from "../../../../../../cli/base-command.js";
+import commandArguments from "../../../../../../cli/command-arguments.js";
+import DatabaseGenerationContext from "../../../../../../database/generation-context.js";
 import fs from "fs/promises";
 import path from "path";
 import StructureSqlLoader from "../../../../../../database/structure-sql-loader.js";
@@ -8,16 +10,40 @@ export default class DbSchemaLoad extends BaseCommand {
      * Runs execute.
      * @returns {Promise<void>} */
     async execute() {
+        const parsedArguments = commandArguments({
+            definition: { valueOptions: ["--tenant"] },
+            processArgs: this.processArgs || []
+        });
+        const tenantDatabaseIdentifier = parsedArguments.tenant;
+        if (typeof tenantDatabaseIdentifier === "string") {
+            const context = await DatabaseGenerationContext.resolve({
+                configuration: this.getConfiguration(),
+                databaseIdentifier: tenantDatabaseIdentifier
+            });
+            await context.run({ name: "DB selected tenant schema load", callback: async (db) => {
+                    await this.loadStructureSql({ db, identifier: context.databaseIdentifier() });
+                } });
+            return;
+        }
         await this.getConfiguration().ensureConnections({ name: "DB schema load" }, async (dbs) => {
-            const dbDir = path.join(this.directory(), "db");
-            const loader = new StructureSqlLoader();
             for (const identifier of Object.keys(dbs)) {
-                const db = dbs[identifier];
-                const structureFilePath = path.join(dbDir, `structure-${identifier}.sql`);
-                const structureSql = await fs.readFile(structureFilePath, "utf8");
-                await loader.load({ db, structureSql });
+                await this.loadStructureSql({ db: dbs[identifier], identifier });
             }
         });
     }
+    /**
+     * Loads one identifier's explicit structure file into one selected connection.
+     * @param {object} args - Load arguments.
+     * @param {import("../../../../../../database/drivers/base.js").default} args.db - Target connection.
+     * @param {string} args.identifier - Logical database identifier used in the file name.
+     * @returns {Promise<void>} - Resolves after loading.
+     */
+    async loadStructureSql({ db, identifier }) {
+        const dbDir = path.join(this.directory(), "db");
+        const loader = new StructureSqlLoader();
+        const structureFilePath = path.join(dbDir, `structure-${identifier}.sql`);
+        const structureSql = await fs.readFile(structureFilePath, "utf8");
+        await loader.load({ db, structureSql });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/environment-handlers/node/cli/commands/generate/base-models.d.ts

@@ -1,6 +1,20 @@
 import BaseCommand from "../../../../../cli/base-command.js";
+import DatabaseGenerationContext from "../../../../../database/generation-context.js";
 export default class DbGenerateModel extends BaseCommand {
     execute(): Promise<void>;
+    /**
+     * Generates model bases from explicit connections.
+     * @param {object} args - Generation arguments.
+     * @param {boolean} args.allowMissingTables - Whether absent tables are skipped.
+     * @param {Record<string, import("../../../../../database/drivers/base.js").default>} args.connections - Connections keyed by logical identifier.
+     * @param {DatabaseGenerationContext} [args.context] - Selected tenant database context.
+     * @returns {Promise<void>} - Resolves after writing generated bases.
+     */
+    generateBaseModels({ allowMissingTables, connections, context }: {
+        allowMissingTables: boolean;
+        connections: Record<string, import("../../../../../database/drivers/base.js").default>;
+        context?: DatabaseGenerationContext;
+    }): Promise<void>;
     /**
      * Runs js doc type from column.
      * @param {import("../../../../../database/drivers/base-column.js").default} column - Column.

package/build/src/environment-handlers/node/cli/commands/generate/base-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-models.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/base-models.js"],"names":[],"mappings":"AAEA,OAAO,WAAW,MAAM,oCAAoC,CAAA;AA4D5D,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IAChD,OAAO,kBA8YZ;IAED;;;;;OAKG;IACH,mBAAmB,CAAC,MAAM,EAJf,OAAO,gDAAgD,EAAE,OAI1C,EAAE,UAAU,EAH3B,cAAc,yCAAyC,EAAE,OAG9B,GAFzB,MAAM,GAAG,SAAS,CAa9B;IAED;;;;;OAKG;IACH,yBAAyB,CAAC,MAAM,EAJrB,OAAO,gDAAgD,EAAE,OAIpC,EAAE,UAAU,EAHjC,cAAc,yCAAyC,EAAE,OAGxB,GAF/B,MAAM,GAAG,SAAS,CAU9B;IAED;;;;;;OAMG;IACG,gCAAgC,CAAC,EAAC,UAAU,EAAE,SAAS,EAAC,EAJ3D;QAA+E,UAAU,EAAjF,cAAc,yCAAyC,EAAE,OAAO,CACxE;QAAqB,SAAS,EAAtB,MAAM,CACd;KAE2D,GAFjD,OAAO,CAAC,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAyBlG;IAED;;;;;OAKG;IACH,6BAA6B,CAAC,EAAC,UAAU,EAAC,EAHvC;QAA+E,UAAU,EAAjF,cAAc,yCAAyC,EAAE,OAAO,CACxE;KAEuC,GAF7B,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAC,CAAC,CAyBzF;CACF"}
+{"version":3,"file":"base-models.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/base-models.js"],"names":[],"mappings":"AAEA,OAAO,WAAW,MAAM,oCAAoC,CAAA;AAE5D,OAAO,yBAAyB,MAAM,+CAA+C,CAAA;AA4DrF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IAChD,OAAO,kBAyCZ;IAED;;;;;;;OAOG;IACG,kBAAkB,CAAC,EAAC,kBAAkB,EAAE,WAAW,EAAE,OAAO,EAAC,EALhE;QAAsB,kBAAkB,EAAhC,OAAO,CACf;QAAwF,WAAW,EAA3F,MAAM,CAAC,MAAM,EAAE,OAAO,yCAAyC,EAAE,OAAO,CAAC,CACjF;QAAyC,OAAO,AAAhD,CACA,EADQ,yBAAyB,CACjC;KAEgE,GAFtD,OAAO,CAAC,IAAI,CAAC,CAgazB;IAED;;;;;OAKG;IACH,mBAAmB,CAAC,MAAM,EAJf,OAAO,gDAAgD,EAAE,OAI1C,EAAE,UAAU,EAH3B,cAAc,yCAAyC,EAAE,OAG9B,GAFzB,MAAM,GAAG,SAAS,CAa9B;IAED;;;;;OAKG;IACH,yBAAyB,CAAC,MAAM,EAJrB,OAAO,gDAAgD,EAAE,OAIpC,EAAE,UAAU,EAHjC,cAAc,yCAAyC,EAAE,OAGxB,GAF/B,MAAM,GAAG,SAAS,CAU9B;IAED;;;;;;OAMG;IACG,gCAAgC,CAAC,EAAC,UAAU,EAAE,SAAS,EAAC,EAJ3D;QAA+E,UAAU,EAAjF,cAAc,yCAAyC,EAAE,OAAO,CACxE;QAAqB,SAAS,EAAtB,MAAM,CACd;KAE2D,GAFjD,OAAO,CAAC,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAyBlG;IAED;;;;;OAKG;IACH,6BAA6B,CAAC,EAAC,UAAU,EAAC,EAHvC;QAA+E,UAAU,EAAjF,cAAc,yCAAyC,EAAE,OAAO,CACxE;KAEuC,GAF7B,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAC,CAAC,CAyBzF;CACF"}