velocious 1.0.479 → 1.0.480

package/package.json

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

package/src/configuration-types.js

@@ -475,6 +475,7 @@
 /**
  * @typedef {object} TenantDatabaseProviderType
  * @property {function({configuration: import("./configuration.js").default, identifier: string}) : Array<?> | Promise<Array<?>>} listTenants - Lists tenants that should be created, checked, or migrated for this database identifier.
+ * @property {function({configuration: import("./configuration.js").default, identifier: string}) : Array<?> | Promise<Array<?>>} [listRestrictTenants] - Lists existing tenants that should be checked for dependent restrict destroys. Defaults to listTenants.
  * @property {function({configuration: import("./configuration.js").default, databaseConfiguration: DatabaseConfigurationType, identifier: string, tenant: ?}) : void | Promise<void>} [createDatabase] - Creates the tenant database/schema for one tenant.
  * @property {function({configuration: import("./configuration.js").default, databaseConfiguration: DatabaseConfigurationType, identifier: string, tenant: ?}) : void | Promise<void>} [dropDatabase] - Drops the tenant database/schema for one tenant.
  * @property {function({configuration: import("./configuration.js").default, databaseConfiguration: DatabaseConfigurationType, identifier: string, tenant: ?}) : void | Promise<void>} [checkTenant] - Checks one tenant database before generic connection validation.

package/src/database/record/index.js

@@ -17,6 +17,13 @@
  * @typedef {{new (changes?: Record<string, unknown>): T}} ModelConstructor
  */
 
+/**
+ * RestrictInstanceRelationship type.
+ * @typedef {import("./instance-relationships/base.js").default & {query: () => ModelClassQuery<typeof VelociousDatabaseRecord>}} RestrictInstanceRelationship
+ */
+
+/** @typedef {import("../../configuration-types.js").TenantDatabaseProviderType} TenantDatabaseProviderType */
+
 import timeout from "awaitery/build/timeout.js"
 import BelongsToInstanceRelationship from "./instance-relationships/belongs-to.js"
 import BelongsToRelationship from "./relationships/belongs-to.js"
@@ -1628,6 +1635,14 @@ class VelociousDatabaseRecord {
     this._tenantDatabaseIdentifierResolver = databaseIdentifierOrResolver
   }
 
+  /**
+   * Runs has tenant database identifier resolver.
+   * @returns {boolean} - Whether this model resolves its database from the current tenant.
+   */
+  static hasTenantDatabaseIdentifierResolver() {
+    return Boolean(this._tenantDatabaseIdentifierResolver)
+  }
+
   /**
    * Runs get tenant database identifier.
    * @param {?} [tenant] - Tenant override.
@@ -3359,6 +3374,148 @@ class VelociousDatabaseRecord {
     return this.getModelClass().connection()
   }
 
+  /**
+   * Counts dependent records for a `dependent: "restrict"` relationship.
+   * @param {RestrictInstanceRelationship} instanceRelationship - Relationship instance to count.
+   * @returns {Promise<number>} - Dependent row count.
+   */
+  async _dependentRestrictCount(instanceRelationship) {
+    const TargetModelClass = instanceRelationship.getTargetModelClass()
+
+    if (!TargetModelClass || !TargetModelClass.hasTenantDatabaseIdentifierResolver()) {
+      return await instanceRelationship.query().count()
+    }
+
+    if (this.getModelClass().hasTenantDatabaseIdentifierResolver()) {
+      return await instanceRelationship.query().count()
+    }
+
+    return await this._dependentRestrictTenantCount(instanceRelationship, TargetModelClass)
+  }
+
+  /**
+   * Counts tenant-scoped dependent records across all provider-listed tenants.
+   * @param {RestrictInstanceRelationship} instanceRelationship - Relationship instance to count.
+   * @param {typeof VelociousDatabaseRecord} TargetModelClass - Related model class.
+   * @returns {Promise<number>} - Dependent row count.
+   */
+  async _dependentRestrictTenantCount(instanceRelationship, TargetModelClass) {
+    const configuration = this.getModelClass()._getConfiguration()
+    const tenantDatabaseProviders = configuration.getTenantDatabaseProviders()
+    const providerEntries = Object.entries(tenantDatabaseProviders)
+    const targetIdentifier = TargetModelClass.getTenantDatabaseIdentifier(null)
+
+    if (providerEntries.length == 0) {
+      throw new Error(`Cannot check dependent ${instanceRelationship.getRelationship().getRelationshipName()} because ${TargetModelClass.getModelName()} switches tenant databases but no tenant database providers are configured`)
+    }
+
+    if (targetIdentifier) {
+      const provider = tenantDatabaseProviders[targetIdentifier]
+
+      if (!provider) {
+        throw new Error(`Cannot check dependent ${instanceRelationship.getRelationship().getRelationshipName()} because ${TargetModelClass.getModelName()} switches tenant database ${targetIdentifier} but no tenant database provider is configured for ${targetIdentifier}`)
+      }
+
+      return await this._dependentRestrictProviderCount(instanceRelationship, TargetModelClass, targetIdentifier, provider)
+    }
+
+    let matchingProviderSeen = false
+
+    for (const [identifier, provider] of providerEntries) {
+      const tenants = await this._dependentRestrictProviderTenants(instanceRelationship, TargetModelClass, identifier, provider)
+
+      for (const tenant of tenants) {
+        if (TargetModelClass.getTenantDatabaseIdentifier(tenant) != identifier) {
+          continue
+        }
+
+        matchingProviderSeen = true
+
+        const count = await configuration.runWithTenant(tenant, async () => {
+          if (!configuration.isDatabaseIdentifierActive(identifier)) {
+            throw new Error(`Tenant database identifier ${identifier} is inactive while checking dependent ${instanceRelationship.getRelationship().getRelationshipName()}`)
+          }
+
+          return await configuration.ensureConnections({name: `Dependent restrict count: ${TargetModelClass.getModelName()}`}, async () => {
+            return await instanceRelationship.query().count()
+          })
+        })
+
+        if (count > 0) return count
+      }
+    }
+
+    if (!matchingProviderSeen) {
+      throw new Error(`Cannot check dependent ${instanceRelationship.getRelationship().getRelationshipName()} because no tenant database provider matched ${TargetModelClass.getModelName()}`)
+    }
+
+    return 0
+  }
+
+  /**
+   * Counts tenant-scoped dependent records for one configured tenant provider.
+   * @param {RestrictInstanceRelationship} instanceRelationship - Relationship instance to count.
+   * @param {typeof VelociousDatabaseRecord} TargetModelClass - Related model class.
+   * @param {string} identifier - Tenant database identifier.
+   * @param {TenantDatabaseProviderType} provider - Tenant database provider.
+   * @returns {Promise<number>} - Dependent row count.
+   */
+  async _dependentRestrictProviderCount(instanceRelationship, TargetModelClass, identifier, provider) {
+    const configuration = this.getModelClass()._getConfiguration()
+    const tenants = await this._dependentRestrictProviderTenants(instanceRelationship, TargetModelClass, identifier, provider)
+
+    for (const tenant of tenants) {
+      const count = await configuration.runWithTenant(tenant, async () => {
+        if (!configuration.isDatabaseIdentifierActive(identifier)) {
+          throw new Error(`Tenant database identifier ${identifier} is inactive while checking dependent ${instanceRelationship.getRelationship().getRelationshipName()}`)
+        }
+
+        return await configuration.ensureConnections({name: `Dependent restrict count: ${TargetModelClass.getModelName()}`}, async () => {
+          return await instanceRelationship.query().count()
+        })
+      })
+
+      if (count > 0) return count
+    }
+
+    return 0
+  }
+
+  /**
+   * Lists restrict-check tenants for one configured tenant provider.
+   * @param {RestrictInstanceRelationship} instanceRelationship - Relationship instance to count.
+   * @param {typeof VelociousDatabaseRecord} TargetModelClass - Related model class.
+   * @param {string} identifier - Tenant database identifier.
+   * @param {TenantDatabaseProviderType} provider - Tenant database provider.
+   * @returns {Promise<Array<?>>} - Listed tenant objects.
+   */
+  async _dependentRestrictProviderTenants(instanceRelationship, TargetModelClass, identifier, provider) {
+    const configuration = this.getModelClass()._getConfiguration()
+    const listTenants = typeof provider.listRestrictTenants == "function"
+      ? provider.listRestrictTenants
+      : provider.listTenants
+    const listTenantsMethodName = typeof provider.listRestrictTenants == "function"
+      ? "listRestrictTenants"
+      : "listTenants"
+
+    if (typeof listTenants != "function") {
+      throw new Error(`Tenant database provider for ${identifier} must define listTenants or listRestrictTenants before dependent restrict can check ${instanceRelationship.getRelationship().getRelationshipName()}`)
+    }
+
+    const tenants = await configuration.ensureConnections({name: `Dependent restrict tenants: ${TargetModelClass.getModelName()}`}, async () => {
+      return await listTenants({
+        configuration,
+        identifier
+      })
+    })
+
+    if (!Array.isArray(tenants)) {
+      throw new Error(`Tenant database provider for ${identifier} must return an array from ${listTenantsMethodName}`)
+    }
+
+    return tenants
+  }
+
   /**
    * Destroys the record in the database and all of its dependent records.
    * @returns {Promise<void>} - Resolves when complete.
@@ -3368,8 +3525,8 @@ class VelociousDatabaseRecord {
 
     for (const relationship of this.getModelClass().getRelationships()) {
       if (relationship.getDependent() == "restrict") {
-        const instanceRelationship = /** @type {?} */ (this.getRelationshipByName(relationship.getRelationshipName()))
-        const count = await instanceRelationship.query().count()
+        const instanceRelationship = /** @type {RestrictInstanceRelationship} */ (this.getRelationshipByName(relationship.getRelationshipName()))
+        const count = await this._dependentRestrictCount(instanceRelationship)
 
         if (count > 0) {
           throw new Error(`Cannot delete record because dependent ${relationship.getRelationshipName()} exist`)