velocious 1.0.567 → 1.0.569

package/build/database/drivers/sqlite/index.web.js

@@ -64,6 +64,80 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
     }
   }
 
+  /**
+   * Starts an outer transaction after draining SQL.js persistence admission.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [options] - Transaction ownership.
+   * @returns {Promise<void>} - Resolves when the transaction starts.
+   */
+  async startTransaction(options = {}) {
+    if (!this.args?.getConnection) {
+      if (!this._connection) throw new Error("SQLite web connection has not been initialized")
+
+      try {
+        await super.startTransaction(options)
+      } finally {
+        this._connection.completeTransactionStart()
+      }
+
+      return
+    }
+
+    await super.startTransaction(options)
+  }
+
+  /**
+   * Coordinates SQL BEGIN with active and queued persistence exports.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [options] - Transaction ownership.
+   * @returns {Promise<void>} - Resolves when the transaction starts.
+   */
+  async _startTransactionAction(options = {}) {
+    if (!this.args?.getConnection) {
+      if (!this._connection) throw new Error("SQLite web connection has not been initialized")
+
+      await this._connection.withTransactionStart(async () => {
+        await super._startTransactionAction(options)
+      })
+
+      return
+    }
+
+    await super._startTransactionAction(options)
+  }
+
+  /**
+   * Commits and persists bytes after the outermost SQL.js transaction closes.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [options] - Transaction ownership.
+   * @returns {Promise<void>} - Resolves when committed bytes are persisted.
+   */
+  async commitTransaction(options = {}) {
+    const outermostTransaction = this._transactionsCount === 1
+
+    await super.commitTransaction(options)
+
+    if (outermostTransaction && !this.args?.getConnection) {
+      if (!this._connection) throw new Error("SQLite web connection has not been initialized")
+
+      await this._connection.flushPendingDatabaseSave()
+    }
+  }
+
+  /**
+   * Rolls back and persists bytes after the outermost SQL.js transaction closes.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [options] - Transaction ownership.
+   * @returns {Promise<void>} - Resolves when rolled-back bytes are persisted.
+   */
+  async rollbackTransaction(options = {}) {
+    const outermostTransaction = this._transactionsCount === 1
+
+    await super.rollbackTransaction(options)
+
+    if (outermostTransaction && !this.args?.getConnection) {
+      if (!this._connection) throw new Error("SQLite web connection has not been initialized")
+
+      await this._connection.flushPendingDatabaseSave()
+    }
+  }
+
   /**
    * Runs get connection.
    * @returns {ConnectionSqlJs | SqliteWebConnection} - The connection.

package/build/database/drivers/sqlite/sql/alter-table.js

@@ -134,6 +134,16 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
 
     for (const currentForeignKey of currentTableData.getForeignKeys()) {
       const alterForeignKey = alterTableData.getForeignKeys().find((foreignKey) => foreignKey.getName() == currentForeignKey.getName())
+
+      if (alterForeignKey?.getDropForeignKey()) {
+        const targetColumnName = columnRenames.get(currentForeignKey.getColumnName()) || currentForeignKey.getColumnName()
+        const targetColumn = targetTableData.getColumns().find((column) => column.getActualName() == targetColumnName)
+
+        if (targetColumn) targetColumn.setForeignKey(undefined)
+
+        continue
+      }
+
       const finalForeignKey = this._renameForeignKeyColumn(alterForeignKey || currentForeignKey, columnRenames)
 
       seenForeignKeyNames.add(finalForeignKey.getName())
@@ -141,11 +151,14 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     }
 
     for (const alterForeignKey of alterTableData.getForeignKeys()) {
+      if (alterForeignKey.getDropForeignKey()) continue
       if (seenForeignKeyNames.has(alterForeignKey.getName())) continue
 
       targetTableData.addForeignKey(this._renameForeignKeyColumn(alterForeignKey, columnRenames))
     }
 
+    const targetColumnNames = new Set(targetTableData.getColumns().map((column) => column.getActualName()))
+
     for (const currentIndex of currentTableData.getIndexes()) {
       const renamedColumns = currentIndex.getColumns().map((columnName) => {
         if (typeof columnName != "string") return columnName
@@ -153,6 +166,10 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
         return columnRenames.get(columnName) || columnName
       })
 
+      const indexColumnNames = renamedColumns.map((column) => typeof column == "string" ? column : column.getName())
+
+      if (indexColumnNames.some((columnName) => !targetColumnNames.has(columnName))) continue
+
       targetTableData.addIndex(new TableIndex(renamedColumns, {
         name: currentIndex.getName(),
         unique: currentIndex.getUnique()
@@ -177,6 +194,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
 
     return new TableForeignKey({
       columnName: renamed,
+      dropForeignKey: foreignKey.getDropForeignKey(),
       isNewForeignKey: foreignKey.getIsNewForeignKey(),
       name: foreignKey.getName(),
       referencedColumnName: foreignKey.getReferencedColumnName(),

package/build/database/migration/index.js

@@ -270,6 +270,57 @@ export default class VelociousDatabaseMigration {
     )
   }
 
+  /**
+   * RemoveForeignKeyArgsType type.
+   * @typedef {object} RemoveForeignKeyArgsType
+   * @property {string} [columnName] - Override the derived foreign-key column name.
+   */
+  /**
+   * Runs remove foreign key.
+   * @param {string} tableName - Table the foreign key lives on.
+   * @param {string} referenceName - Singular reference name used to derive the FK column.
+   * @param {RemoveForeignKeyArgsType} [args] - Optional overrides.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async removeForeignKey(tableName, referenceName, args = {}) {
+    const {columnName, ...restArgs} = args
+
+    restArgsError(restArgs)
+
+    const resolvedColumnName = columnName || `${inflection.underscore(referenceName)}_id`
+    const driver = this.getDriver()
+    let maximumRemovals = 0
+    let previousMatchingCount = 0
+
+    for (let removalAttempt = 0; ; removalAttempt++) {
+      const table = await driver.getTableByName(tableName)
+
+      if (!table) throw new Error(`Table ${tableName} does not exist`)
+
+      const foreignKeys = await table.getForeignKeys()
+      const matchingForeignKeys = foreignKeys.filter((foreignKey) => foreignKey.getColumnName() == resolvedColumnName)
+
+      if (matchingForeignKeys.length === 0) {
+        if (removalAttempt === 0) throw new Error(`No foreign key on ${tableName}.${resolvedColumnName}`)
+
+        return
+      }
+
+      if (removalAttempt === 0) {
+        maximumRemovals = matchingForeignKeys.length
+      } else if (matchingForeignKeys.length >= previousMatchingCount) {
+        throw new Error(`Foreign key removal did not reduce matches on ${tableName}.${resolvedColumnName}`)
+      }
+
+      if (removalAttempt >= maximumRemovals) {
+        throw new Error(`Foreign key removal exceeded expected matches on ${tableName}.${resolvedColumnName}`)
+      }
+
+      previousMatchingCount = matchingForeignKeys.length
+      await driver.removeForeignKey(tableName, matchingForeignKeys[0])
+    }
+  }
+
   /**
    * Runs add reference.
    * @param {string} tableName - Table name.
@@ -298,16 +349,54 @@ export default class VelociousDatabaseMigration {
     }
   }
 
+  /**
+   * RemoveReferenceArgsType type.
+   * @typedef {object} RemoveReferenceArgsType
+   * @property {string} [columnName] - Override the derived reference column name.
+   * @property {string} [indexName] - Explicit generated index name to remove.
+   */
   /**
    * Runs remove reference.
    * @param {string} tableName - Table name.
    * @param {string} referenceName - Reference name.
+   * @param {RemoveReferenceArgsType} [args] - Optional overrides.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async removeReference(tableName, referenceName) {
-    const columnName = `${inflection.underscore(referenceName)}_id`
+  async removeReference(tableName, referenceName, args = {}) {
+    const {columnName, indexName, ...restArgs} = args
+
+    restArgsError(restArgs)
+
+    const resolvedColumnName = columnName || `${inflection.underscore(referenceName)}_id`
+    const driver = this.getDriver()
+    const table = await driver.getTableByName(tableName)
+
+    if (!table) throw new Error(`Table ${tableName} does not exist`)
+
+    const foreignKeys = await table.getForeignKeys()
+
+    for (const foreignKey of foreignKeys) {
+      if (foreignKey.getColumnName() != resolvedColumnName) continue
+
+      await driver.removeForeignKey(tableName, foreignKey)
+    }
+
+    const expectedIndexName = indexName || this._removeIndexName(tableName, [resolvedColumnName])
+    const indexes = await table.getIndexes()
+    const generatedIndex = indexes.find((index) => {
+      const indexColumnNames = index.getColumnNames()
+
+      return !index.isPrimaryKey() &&
+        index.getName() == expectedIndexName &&
+        indexColumnNames.length == 1 &&
+        indexColumnNames[0] == resolvedColumnName
+    })
+
+    if (generatedIndex) {
+      await this.removeIndex(tableName, generatedIndex.getName())
+    }
 
-    this.removeColumn(tableName, columnName)
+    await this.removeColumn(tableName, resolvedColumnName)
   }
 
   /**

package/build/database/operation-connection.js

@@ -0,0 +1,110 @@
+// @ts-check
+
+/**
+ * Explicit connection facade that tags operation-owned asynchronous work while
+ * forwarding the driver's synchronous SQL-builder and capability APIs.
+ */
+export default class VelociousDatabaseOperationConnection {
+  /**
+   * Runs constructor.
+   * @param {object} args - Connection ownership.
+   * @param {import("./drivers/base.js").default} args.connection - Pinned physical connection.
+   * @param {import("./operation.js").default} args.operation - Owning operation.
+   * @param {symbol} args.owner - Opaque lease owner token.
+   */
+  constructor({connection, operation, owner}) {
+    this._physicalConnection = connection
+    this._operation = operation
+    this._owner = owner
+
+    return new Proxy(this, {
+      get: (target, property, receiver) => {
+        if (Reflect.has(target, property)) {
+          const value = Reflect.get(target, property, receiver)
+
+          return typeof value === "function" ? value.bind(target) : value
+        }
+
+        const value = Reflect.get(connection, property, receiver)
+
+        return typeof value === "function" ? value.bind(receiver) : value
+      },
+      set: (target, property, value, receiver) => {
+        if (Reflect.has(target, property)) {
+          return Reflect.set(target, property, value, receiver)
+        }
+
+        return Reflect.set(connection, property, value, connection)
+      }
+    })
+  }
+
+  /**
+   * Runs a tagged SQL query on the pinned connection.
+   * @param {string} sql - SQL string.
+   * @param {import("./drivers/base.js").QueryOptions} [options] - Query options.
+   * @returns {Promise<import("./drivers/base.js").QueryResultType>} - Query result.
+   */
+  async query(sql, options = {}) {
+    this._operation.assertActive()
+
+    return await this._physicalConnection.query(sql, {...options, operationOwner: this._owner})
+  }
+
+  /**
+   * Streams an operation-owned SQL query.
+   * @param {string} sql - SQL string.
+   * @param {import("./drivers/base.js").QueryOptions} [options] - Query options.
+   * @yields {Record<string, unknown>} - Query rows.
+   */
+  async *queryStream(sql, options = {}) {
+    this._operation.assertActive()
+
+    yield* this._physicalConnection.queryStream(sql, {...options, operationOwner: this._owner})
+  }
+
+  /**
+   * Executes an operation-owned mutation and returns its affected row count.
+   * @param {string} sql - Mutation SQL string.
+   * @param {import("./drivers/base.js").QueryOptions} [options] - Query options.
+   * @returns {Promise<number>} - Affected row count.
+   */
+  async affectedRows(sql, options = {}) {
+    this._operation.assertActive()
+
+    return await this._physicalConnection.affectedRows(sql, {...options, operationOwner: this._owner})
+  }
+
+  /**
+   * Runs an operation-owned transaction or nested savepoint.
+   * @template T
+   * @param {() => Promise<T>} callback - Transaction callback.
+   * @returns {Promise<T>} - Callback result.
+   */
+  async transaction(callback) {
+    this._operation.assertActive()
+
+    return /** @type {Promise<T>} */ (this._physicalConnection.transaction(callback, {operationOwner: this._owner}))
+  }
+
+  /**
+   * Registers an operation-owned after-commit callback.
+   * @param {() => void | Promise<void>} callback - Callback.
+   * @returns {Promise<void>} - Resolves after registration or execution.
+   */
+  async afterCommit(callback) {
+    this._operation.assertActive()
+
+    await this._physicalConnection.afterCommit(callback, {operationOwner: this._owner})
+  }
+
+  /**
+   * Returns the last inserted identifier through the operation lease.
+   * @returns {Promise<number>} - Last inserted identifier.
+   */
+  async lastInsertID() {
+    this._operation.assertActive()
+
+    return await this._physicalConnection.lastInsertID({operationOwner: this._owner})
+  }
+}

package/build/database/operation-lease.js

@@ -0,0 +1,47 @@
+// @ts-check
+
+/**
+ * Exclusive lease installed on a shared physical connection while one
+ * operation-scoped transaction owns it.
+ */
+export default class VelociousDatabaseOperationLease {
+  /**
+   * Runs constructor.
+   * @param {symbol} owner - Opaque operation owner token.
+   */
+  constructor(owner) {
+    this.owner = owner
+    this.released = false
+    /**
+     * Resolves the lease waiters.
+     * @type {() => void} */
+    let release = () => {}
+
+    this.releasedPromise = new Promise((resolve) => {
+      release = () => resolve(undefined)
+    })
+    this.releasePromise = release
+  }
+
+  /**
+   * Waits until the lease is released unless `owner` owns it.
+   * @param {symbol | undefined} owner - Candidate operation owner.
+   * @returns {Promise<void>} - Resolves when access is allowed.
+   */
+  async wait(owner) {
+    if (owner === this.owner) return
+
+    await this.releasedPromise
+  }
+
+  /**
+   * Releases all waiters exactly once.
+   * @returns {void}
+   */
+  release() {
+    if (this.released) return
+
+    this.released = true
+    this.releasePromise()
+  }
+}

package/build/database/operation.js

@@ -0,0 +1,140 @@
+// @ts-check
+
+import OperationConnection from "./operation-connection.js"
+
+/**
+ * Explicit owner for model work performed on one pinned transactional
+ * connection.
+ */
+export default class VelociousDatabaseOperation {
+  /**
+   * Runs constructor.
+   * @param {object} args - Operation ownership.
+   * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+   * @param {string} args.configurationReuseKey - Physical database configuration key captured at checkout.
+   * @param {import("./drivers/base.js").default} args.connection - Pinned physical connection.
+   * @param {string} args.databaseIdentifier - Singular database identifier.
+   * @param {symbol} args.owner - Opaque pool lease owner.
+   */
+  constructor({configuration, configurationReuseKey, connection, databaseIdentifier, owner}) {
+    this._active = true
+    this._configuration = configuration
+    this._configurationReuseKey = configurationReuseKey
+    this._databaseIdentifier = databaseIdentifier
+    this._connection = new OperationConnection({
+      connection,
+      operation: this,
+      owner
+    })
+  }
+
+  /**
+   * Returns an operation-bound model query/create scope.
+   * @template {typeof import("./record/index.js").default} MC
+   * @param {MC} ModelClass - Model class to bind.
+   * @returns {import("./query/model-class-query.js").default<MC>} - Operation-bound scope.
+   */
+  forModel(ModelClass) {
+    this.assertActive()
+    this.assertModel(ModelClass)
+
+    return ModelClass._newQuery({
+      driver: this.connection(),
+      operation: this
+    })
+  }
+
+  /**
+   * Verifies that a model belongs to this operation's configuration and database.
+   * @param {typeof import("./record/index.js").default} ModelClass - Model class to verify.
+   * @returns {void}
+   */
+  assertModel(ModelClass) {
+    if (ModelClass._getConfiguration() !== this._configuration) {
+      throw new Error(`${ModelClass.getModelName()} belongs to another Velocious configuration`)
+    }
+
+    const modelDatabaseIdentifier = ModelClass.getDatabaseIdentifier()
+
+    if (modelDatabaseIdentifier !== this._databaseIdentifier) {
+      throw new Error(`${ModelClass.getModelName()} uses database ${JSON.stringify(modelDatabaseIdentifier)}, not operation database ${JSON.stringify(this._databaseIdentifier)}`)
+    }
+  }
+
+  /**
+   * Binds a loaded or built record to this operation.
+   * @template {import("./record/index.js").default} Model
+   * @param {Model} record - Record to bind.
+   * @returns {Model} - Bound record.
+   */
+  bindRecord(record) {
+    this.assertActive()
+    this.assertModel(record.getModelClass())
+    record.bindDatabaseOperation(this)
+
+    return record
+  }
+
+  /**
+   * Registers a callback owned by the current operation transaction frame.
+   * @param {() => void | Promise<void>} callback - Callback.
+   * @returns {Promise<void>} - Resolves after registration or execution.
+   */
+  async afterCommit(callback) {
+    this.assertActive()
+    await this.connection().afterCommit(callback)
+  }
+
+  /**
+   * Runs a nested operation transaction/savepoint.
+   * @template T
+   * @param {() => Promise<T>} callback - Callback.
+   * @returns {Promise<T>} - Callback result.
+   */
+  async transaction(callback) {
+    this.assertActive()
+
+    return await this.connection().transaction(callback)
+  }
+
+  /**
+   * Returns the deliberately exposed operation connection facade for raw SQL.
+   * @returns {import("./drivers/base.js").default} - Operation-bound connection.
+   */
+  connection() {
+    this.assertActive()
+
+    /**
+     * Narrows the Proxy facade to the complete driver surface that it forwards.
+     * @type {import("./drivers/base.js").default}
+     */
+    const connectionFacade = /** @type {?} */ (this._connection)
+
+    return connectionFacade
+  }
+
+  /**
+   * Raises when an operation handle has left its callback.
+   * @returns {void}
+   */
+  assertActive() {
+    if (!this._active) throw new Error("Database operation has completed")
+
+    const currentReuseKey = this
+      ._configuration
+      .getDatabasePool(this._databaseIdentifier)
+      .getConfigurationReuseKey()
+
+    if (currentReuseKey !== this._configurationReuseKey) {
+      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than the current tenant context`)
+    }
+  }
+
+  /**
+   * Expires the operation and all scopes/records bound to it.
+   * @returns {void}
+   */
+  complete() {
+    this._active = false
+  }
+}

package/build/database/pool/base.js

@@ -241,9 +241,21 @@ class VelociousDatabasePoolBase {
    * @returns {boolean} - Whether connection matches current resolved configuration.
    */
   connectionMatchesCurrentConfiguration(connection) {
+    return this.getConnectionConfigurationReuseKey(connection) === this.getConfigurationReuseKey()
+  }
+
+  /**
+   * Returns the resolved database configuration key stamped on a connection at checkout.
+   * @param {import("../drivers/base.js").default} connection - Checked-out connection.
+   * @returns {string} - Connection configuration reuse key.
+   */
+  getConnectionConfigurationReuseKey(connection) {
     const connectionWithPoolKey = /** @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
+    const reuseKey = connectionWithPoolKey[POOL_CONFIGURATION_KEY]
+
+    if (!reuseKey) throw new Error("Database connection is missing its configuration reuse key")
 
-    return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === this.getConfigurationReuseKey()
+    return reuseKey
   }
 
   /**
@@ -357,6 +369,19 @@ class VelociousDatabasePoolBase {
     throw new Error("'withConnection' not implemented")
   }
 
+  /**
+   * Runs an operation on a freshly checked-out connection.
+   * @template T
+   * @param {ConnectionCheckoutOptions} options - Checkout options.
+   * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Operation callback.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withOperationConnection(options, callback) {
+    const owner = Symbol("database-operation-owner")
+
+    return await this.withConnection(options, async (connection) => await callback(connection, owner))
+  }
+
   /**
    * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.
    * Default implementation just checks out a connection.

package/build/database/pool/single-multi-use.js

@@ -1,10 +1,12 @@
 // @ts-check
 
 import BasePool from "./base.js"
+import OperationLease from "../operation-lease.js"
 
 export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
   activeCheckoutCount = 0
   suppressedConnectionContextCount = 0
+  operationLeaseQueue = Promise.resolve()
 
   /**
    * Checkout names of the currently-active nested checkouts, innermost last. The
@@ -107,6 +109,53 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     }
   }
 
+  /**
+   * Runs an operation under an exclusive FIFO lease on the reusable physical connection.
+   * @template T
+   * @param {import("./base.js").ConnectionCheckoutOptions} options - Checkout options.
+   * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Operation callback.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withOperationConnection(options, callback) {
+    const previousLease = this.operationLeaseQueue
+    /**
+     * Resolves this FIFO queue turn.
+     * @type {() => void} */
+    let releaseQueue = () => {}
+    const queueTurn = new Promise((resolve) => {
+      releaseQueue = () => resolve(undefined)
+    })
+
+    this.operationLeaseQueue = previousLease.then(async () => await queueTurn)
+    await previousLease
+
+    const owner = Symbol("single-pool-operation-owner")
+    const operationLease = new OperationLease(owner)
+    /** @type {import("../drivers/base.js").default | undefined} */
+    let connection
+    let operationLeaseInstalled = false
+
+    try {
+      connection = await this.checkout(options)
+      await connection.setOperationLease(operationLease)
+      operationLeaseInstalled = true
+
+      return await callback(connection, owner)
+    } finally {
+      operationLease.release()
+
+      try {
+        if (connection && operationLeaseInstalled) connection.clearOperationLease(operationLease)
+      } finally {
+        try {
+          if (connection) await this.checkin(connection)
+        } finally {
+          releaseQueue()
+        }
+      }
+    }
+  }
+
   /**
    * Runs without current connection context.
    * @template T

package/build/database/query/alter-table-base.js

@@ -64,10 +64,16 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
     // SQLite's ALTER TABLE does not support adding constraints; the SQLite driver overrides
     // alterTableSQLs entirely (via TableRebuilder) so this base path is never invoked there.
     for (const foreignKey of tableData.getForeignKeys()) {
-      if (!foreignKey.getIsNewForeignKey()) continue
+      if (!foreignKey.getIsNewForeignKey() && !foreignKey.getDropForeignKey()) continue
 
       if (actionCount > 0) sql += ", "
 
+      if (foreignKey.getDropForeignKey()) {
+        sql += this.getDropForeignKeySQL(foreignKey)
+        actionCount++
+        continue
+      }
+
       sql += "ADD"
 
       if (foreignKey.getName()) {
@@ -101,4 +107,17 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
 
     return sqls
   }
+
+  /**
+   * Runs get drop foreign key sql.
+   * @param {import("../table-data/table-foreign-key.js").default} foreignKey - Foreign key to drop.
+   * @returns {string} - SQL fragment that removes the foreign key.
+   */
+  getDropForeignKeySQL(foreignKey) {
+    const name = foreignKey.getName()
+
+    if (!name) throw new Error(`Cannot remove unnamed foreign key on ${foreignKey.getTableName()}.${foreignKey.getColumnName()}`)
+
+    return `DROP CONSTRAINT ${this.getOptions().quoteIndexName(name)}`
+  }
 }