knex 0.95.14 → 1.0.2

package/lib/dialects/sqlite3/schema/ddl.js

@@ -7,11 +7,13 @@
 const identity = require('lodash/identity');
 const { nanonum } = require('../../../util/nanoid');
 const {
-  createNewTable,
   copyData,
   dropOriginal,
   renameTable,
   getTableSql,
+  isForeignCheckEnabled,
+  setForeignCheck,
+  executeForeignCheck,
 } = require('./internal/sqlite-ddl-operations');
 const { parseCreateTable, parseCreateIndex } = require('./internal/parser');
 const {
@@ -43,365 +45,355 @@ class SQLite3_DDL {
   getTableSql() {
     const tableName = this.tableName();
 
-    this.trx.disableProcessing();
-    return this.trx.raw(getTableSql(tableName)).then((result) => {
-      this.trx.enableProcessing();
-      return {
-        createTable: result.filter((create) => create.type === 'table')[0].sql,
-        createIndices: result
-          .filter((create) => create.type === 'index')
-          .map((create) => create.sql),
-      };
-    });
+    return this.client.transaction(
+      async (trx) => {
+        trx.disableProcessing();
+        const result = await trx.raw(getTableSql(tableName));
+        trx.enableProcessing();
+
+        return {
+          createTable: result.filter((create) => create.type === 'table')[0]
+            .sql,
+          createIndices: result
+            .filter((create) => create.type === 'index')
+            .map((create) => create.sql),
+        };
+      },
+      { connection: this.connection }
+    );
   }
 
-  renameTable() {
-    return this.trx.raw(renameTable(this.alteredName, this.tableName()));
+  async isForeignCheckEnabled() {
+    const result = await this.client
+      .raw(isForeignCheckEnabled())
+      .connection(this.connection);
+
+    return result[0].foreign_keys === 1;
   }
 
-  dropOriginal() {
-    return this.trx.raw(dropOriginal(this.tableName()));
+  async setForeignCheck(enable) {
+    await this.client.raw(setForeignCheck(enable)).connection(this.connection);
   }
 
-  copyData(columns) {
-    return this.trx.raw(copyData(this.tableName(), this.alteredName, columns));
+  renameTable(trx) {
+    return trx.raw(renameTable(this.alteredName, this.tableName()));
   }
 
-  createNewTable(sql) {
-    return this.trx.raw(
-      createNewTable(sql, this.tableName(), this.alteredName)
-    );
+  dropOriginal(trx) {
+    return trx.raw(dropOriginal(this.tableName()));
   }
 
-  alterColumn(columns) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
+  copyData(trx, columns) {
+    return trx.raw(copyData(this.tableName(), this.alteredName, columns));
+  }
 
-        const { createTable, createIndices } = await this.getTableSql();
+  async alterColumn(columns) {
+    const { createTable, createIndices } = await this.getTableSql();
 
-        const parsedTable = parseCreateTable(createTable);
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
 
-        parsedTable.columns = parsedTable.columns.map((column) => {
-          const newColumnInfo = columns.find((c) =>
-            isEqualId(c.name, column.name)
-          );
+    parsedTable.columns = parsedTable.columns.map((column) => {
+      const newColumnInfo = columns.find((c) => isEqualId(c.name, column.name));
 
-          if (newColumnInfo) {
-            column.type = newColumnInfo.type;
-
-            column.constraints.default =
-              newColumnInfo.defaultTo !== null
-                ? {
-                    name: null,
-                    value: newColumnInfo.defaultTo,
-                    expression: false,
-                  }
-                : null;
-
-            column.constraints.notnull = newColumnInfo.notNull
-              ? { name: null, conflict: null }
-              : null;
-
-            column.constraints.null = newColumnInfo.notNull
-              ? null
-              : column.constraints.null;
-          }
+      if (newColumnInfo) {
+        column.type = newColumnInfo.type;
 
-          return column;
-        });
+        column.constraints.default =
+          newColumnInfo.defaultTo !== null
+            ? {
+                name: null,
+                value: newColumnInfo.defaultTo,
+                expression: false,
+              }
+            : null;
 
-        const newTable = compileCreateTable(parsedTable, this.wrap);
+        column.constraints.notnull = newColumnInfo.notNull
+          ? { name: null, conflict: null }
+          : null;
 
-        return this.alter(newTable, createIndices);
-      },
-      { connection: this.connection }
-    );
-  }
+        column.constraints.null = newColumnInfo.notNull
+          ? null
+          : column.constraints.null;
+      }
 
-  dropColumn(columns) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
+      return column;
+    });
 
-        const { createTable, createIndices } = await this.getTableSql();
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        const parsedTable = parseCreateTable(createTable);
+    return this.generateAlterCommands(newTable, createIndices);
+  }
 
-        parsedTable.columns = parsedTable.columns.filter(
-          (parsedColumn) =>
-            parsedColumn.expression || !includesId(columns, parsedColumn.name)
-        );
+  async dropColumn(columns) {
+    const { createTable, createIndices } = await this.getTableSql();
 
-        if (parsedTable.columns.length === 0) {
-          throw new Error('Unable to drop last column from table');
-        }
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
 
-        parsedTable.constraints = parsedTable.constraints.filter(
-          (constraint) => {
-            if (
-              constraint.type === 'PRIMARY KEY' ||
-              constraint.type === 'UNIQUE'
-            ) {
-              return constraint.columns.every(
-                (constraintColumn) =>
-                  constraintColumn.expression ||
-                  !includesId(columns, constraintColumn.name)
-              );
-            } else if (constraint.type === 'FOREIGN KEY') {
-              return (
-                constraint.columns.every(
-                  (constraintColumnName) =>
-                    !includesId(columns, constraintColumnName)
-                ) &&
-                (constraint.references.table !== parsedTable.table ||
-                  constraint.references.columns.every(
-                    (referenceColumnName) =>
-                      !includesId(columns, referenceColumnName)
-                  ))
-              );
-            } else {
-              return true;
-            }
-          }
+    parsedTable.columns = parsedTable.columns.filter(
+      (parsedColumn) =>
+        parsedColumn.expression || !includesId(columns, parsedColumn.name)
+    );
+
+    if (parsedTable.columns.length === 0) {
+      throw new Error('Unable to drop last column from table');
+    }
+
+    parsedTable.constraints = parsedTable.constraints.filter((constraint) => {
+      if (constraint.type === 'PRIMARY KEY' || constraint.type === 'UNIQUE') {
+        return constraint.columns.every(
+          (constraintColumn) =>
+            constraintColumn.expression ||
+            !includesId(columns, constraintColumn.name)
         );
+      } else if (constraint.type === 'FOREIGN KEY') {
+        return (
+          constraint.columns.every(
+            (constraintColumnName) => !includesId(columns, constraintColumnName)
+          ) &&
+          (constraint.references.table !== parsedTable.table ||
+            constraint.references.columns.every(
+              (referenceColumnName) => !includesId(columns, referenceColumnName)
+            ))
+        );
+      } else {
+        return true;
+      }
+    });
 
-        const newColumns = parsedTable.columns.map((column) => column.name);
+    const newColumns = parsedTable.columns.map((column) => column.name);
 
-        const newTable = compileCreateTable(parsedTable, this.wrap);
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        const newIndices = [];
-        for (const createIndex of createIndices) {
-          const parsedIndex = parseCreateIndex(createIndex);
+    const newIndices = [];
+    for (const createIndex of createIndices) {
+      const parsedIndex = parseCreateIndex(createIndex);
 
-          parsedIndex.columns = parsedIndex.columns.filter(
-            (parsedColumn) =>
-              parsedColumn.expression || !includesId(columns, parsedColumn.name)
-          );
+      parsedIndex.columns = parsedIndex.columns.filter(
+        (parsedColumn) =>
+          parsedColumn.expression || !includesId(columns, parsedColumn.name)
+      );
 
-          if (parsedIndex.columns.length > 0) {
-            newIndices.push(compileCreateIndex(parsedIndex, this.wrap));
-          }
-        }
+      if (parsedIndex.columns.length > 0) {
+        newIndices.push(compileCreateIndex(parsedIndex, this.wrap));
+      }
+    }
 
-        return this.alter(newTable, newIndices, newColumns);
-      },
-      { connection: this.connection }
-    );
+    return this.alter(newTable, newIndices, newColumns);
   }
 
-  dropForeign(columns, foreignKeyName) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
+  async dropForeign(columns, foreignKeyName) {
+    const { createTable, createIndices } = await this.getTableSql();
 
-        const { createTable, createIndices } = await this.getTableSql();
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
 
-        const parsedTable = parseCreateTable(createTable);
+    if (!foreignKeyName) {
+      parsedTable.columns = parsedTable.columns.map((column) => ({
+        ...column,
+        references: includesId(columns, column.name) ? null : column.references,
+      }));
+    }
 
-        if (!foreignKeyName) {
-          parsedTable.columns = parsedTable.columns.map((column) => ({
-            ...column,
-            references: includesId(columns, column.name)
-              ? null
-              : column.references,
-          }));
+    parsedTable.constraints = parsedTable.constraints.filter((constraint) => {
+      if (constraint.type === 'FOREIGN KEY') {
+        if (foreignKeyName) {
+          return (
+            !constraint.name || !isEqualId(constraint.name, foreignKeyName)
+          );
         }
 
-        parsedTable.constraints = parsedTable.constraints.filter(
-          (constraint) => {
-            if (constraint.type === 'FOREIGN KEY') {
-              if (foreignKeyName) {
-                return (
-                  !constraint.name ||
-                  !isEqualId(constraint.name, foreignKeyName)
-                );
-              }
-
-              return constraint.columns.every(
-                (constraintColumnName) =>
-                  !includesId(columns, constraintColumnName)
-              );
-            } else {
-              return true;
-            }
-          }
+        return constraint.columns.every(
+          (constraintColumnName) => !includesId(columns, constraintColumnName)
         );
+      } else {
+        return true;
+      }
+    });
 
-        const newTable = compileCreateTable(parsedTable, this.wrap);
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        return this.alter(newTable, createIndices);
-      },
-      { connection: this.connection }
-    );
+    return this.alter(newTable, createIndices);
   }
 
-  dropPrimary(constraintName) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
-
-        const { createTable, createIndices } = await this.getTableSql();
-
-        const parsedTable = parseCreateTable(createTable);
-
-        parsedTable.columns = parsedTable.columns.map((column) => ({
-          ...column,
-          primary: null,
-        }));
-
-        parsedTable.constraints = parsedTable.constraints.filter(
-          (constraint) => {
-            if (constraint.type === 'PRIMARY KEY') {
-              if (constraintName) {
-                return (
-                  !constraint.name ||
-                  !isEqualId(constraint.name, constraintName)
-                );
-              } else {
-                return false;
-              }
-            } else {
-              return true;
-            }
-          }
-        );
+  async dropPrimary(constraintName) {
+    const { createTable, createIndices } = await this.getTableSql();
 
-        const newTable = compileCreateTable(parsedTable, this.wrap);
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
 
-        return this.alter(newTable, createIndices);
-      },
-      { connection: this.connection }
-    );
-  }
+    parsedTable.columns = parsedTable.columns.map((column) => ({
+      ...column,
+      primary: null,
+    }));
 
-  primary(columns, constraintName) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
+    parsedTable.constraints = parsedTable.constraints.filter((constraint) => {
+      if (constraint.type === 'PRIMARY KEY') {
+        if (constraintName) {
+          return (
+            !constraint.name || !isEqualId(constraint.name, constraintName)
+          );
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    });
 
-        const { createTable, createIndices } = await this.getTableSql();
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        const parsedTable = parseCreateTable(createTable);
+    return this.alter(newTable, createIndices);
+  }
 
-        parsedTable.columns = parsedTable.columns.map((column) => ({
-          ...column,
-          primary: null,
-        }));
+  async primary(columns, constraintName) {
+    const { createTable, createIndices } = await this.getTableSql();
 
-        parsedTable.constraints = parsedTable.constraints.filter(
-          (constraint) => constraint.type !== 'PRIMARY KEY'
-        );
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
 
-        parsedTable.constraints.push({
-          type: 'PRIMARY KEY',
-          name: constraintName || null,
-          columns: columns.map((column) => ({
-            name: column,
-            expression: false,
-            collation: null,
-            order: null,
-          })),
-          conflict: null,
-        });
-
-        const newTable = compileCreateTable(parsedTable, this.wrap);
-
-        return this.alter(newTable, createIndices);
-      },
-      { connection: this.connection }
+    parsedTable.columns = parsedTable.columns.map((column) => ({
+      ...column,
+      primary: null,
+    }));
+
+    parsedTable.constraints = parsedTable.constraints.filter(
+      (constraint) => constraint.type !== 'PRIMARY KEY'
     );
-  }
 
-  foreign(foreignInfo) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
+    parsedTable.constraints.push({
+      type: 'PRIMARY KEY',
+      name: constraintName || null,
+      columns: columns.map((column) => ({
+        name: column,
+        expression: false,
+        collation: null,
+        order: null,
+      })),
+      conflict: null,
+    });
 
-        const { createTable, createIndices } = await this.getTableSql();
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        const parsedTable = parseCreateTable(createTable);
+    return this.alter(newTable, createIndices);
+  }
 
-        parsedTable.constraints.push({
-          type: 'FOREIGN KEY',
-          name: foreignInfo.keyName || null,
-          columns: foreignInfo.column,
-          references: {
-            table: foreignInfo.inTable,
-            columns: foreignInfo.references,
-            delete: foreignInfo.onDelete || null,
-            update: foreignInfo.onUpdate || null,
-            match: null,
-            deferrable: null,
-          },
-        });
+  async foreign(foreignInfo) {
+    const { createTable, createIndices } = await this.getTableSql();
+
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
+
+    parsedTable.constraints.push({
+      type: 'FOREIGN KEY',
+      name: foreignInfo.keyName || null,
+      columns: foreignInfo.column,
+      references: {
+        table: foreignInfo.inTable,
+        columns: foreignInfo.references,
+        delete: foreignInfo.onDelete || null,
+        update: foreignInfo.onUpdate || null,
+        match: null,
+        deferrable: null,
+      },
+    });
 
-        const newTable = compileCreateTable(parsedTable, this.wrap);
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        return this.generateAlterCommands(newTable, createIndices);
-      },
-      { connection: this.connection }
-    );
+    return this.generateAlterCommands(newTable, createIndices);
   }
 
-  setNullable(column, isNullable) {
-    return this.client.transaction(
-      async (trx) => {
-        this.trx = trx;
+  async setNullable(column, isNullable) {
+    const { createTable, createIndices } = await this.getTableSql();
 
-        const { createTable, createIndices } = await this.getTableSql();
+    const parsedTable = parseCreateTable(createTable);
+    parsedTable.table = this.alteredName;
 
-        const parsedTable = parseCreateTable(createTable);
-        const parsedColumn = parsedTable.columns.find((c) =>
-          isEqualId(column, c.name)
-        );
+    const parsedColumn = parsedTable.columns.find((c) =>
+      isEqualId(column, c.name)
+    );
 
-        if (!parsedColumn) {
-          throw new Error(
-            `.setNullable: Column ${column} does not exist in table ${this.tableName()}.`
-          );
-        }
+    if (!parsedColumn) {
+      throw new Error(
+        `.setNullable: Column ${column} does not exist in table ${this.tableName()}.`
+      );
+    }
 
-        parsedColumn.constraints.notnull = isNullable
-          ? null
-          : { name: null, conflict: null };
+    parsedColumn.constraints.notnull = isNullable
+      ? null
+      : { name: null, conflict: null };
 
-        parsedColumn.constraints.null = isNullable
-          ? parsedColumn.constraints.null
-          : null;
+    parsedColumn.constraints.null = isNullable
+      ? parsedColumn.constraints.null
+      : null;
 
-        const newTable = compileCreateTable(parsedTable, this.wrap);
+    const newTable = compileCreateTable(parsedTable, this.wrap);
 
-        return this.generateAlterCommands(newTable, createIndices);
-      },
-      { connection: this.connection }
-    );
+    return this.generateAlterCommands(newTable, createIndices);
   }
 
   async alter(newSql, createIndices, columns) {
-    await this.createNewTable(newSql);
-    await this.copyData(columns);
-    await this.dropOriginal();
-    await this.renameTable();
+    const wasForeignCheckEnabled = await this.isForeignCheckEnabled();
 
-    for (const createIndex of createIndices) {
-      await this.trx.raw(createIndex);
+    if (wasForeignCheckEnabled) {
+      await this.setForeignCheck(false);
+    }
+
+    try {
+      await this.client.transaction(
+        async (trx) => {
+          await trx.raw(newSql);
+          await this.copyData(trx, columns);
+          await this.dropOriginal(trx);
+          await this.renameTable(trx);
+
+          for (const createIndex of createIndices) {
+            await trx.raw(createIndex);
+          }
+
+          if (wasForeignCheckEnabled) {
+            const foreignViolations = await trx.raw(executeForeignCheck());
+
+            if (foreignViolations.length > 0) {
+              throw new Error('FOREIGN KEY constraint failed');
+            }
+          }
+        },
+        { connection: this.connection }
+      );
+    } finally {
+      if (wasForeignCheckEnabled) {
+        await this.setForeignCheck(true);
+      }
     }
   }
 
-  generateAlterCommands(newSql, createIndices, columns) {
-    const result = [];
+  async generateAlterCommands(newSql, createIndices, columns) {
+    const sql = [];
+    const pre = [];
+    const post = [];
+    let check = null;
 
-    result.push(createNewTable(newSql, this.tableName(), this.alteredName));
-    result.push(copyData(this.tableName(), this.alteredName, columns));
-    result.push(dropOriginal(this.tableName()));
-    result.push(renameTable(this.alteredName, this.tableName()));
+    sql.push(newSql);
+    sql.push(copyData(this.tableName(), this.alteredName, columns));
+    sql.push(dropOriginal(this.tableName()));
+    sql.push(renameTable(this.alteredName, this.tableName()));
 
     for (const createIndex of createIndices) {
-      result.push(createIndex);
+      sql.push(createIndex);
+    }
+
+    const isForeignCheckEnabled = await this.isForeignCheckEnabled();
+
+    if (isForeignCheckEnabled) {
+      pre.push(setForeignCheck(false));
+      post.push(setForeignCheck(true));
+
+      check = executeForeignCheck();
     }
 
-    return result;
+    return { pre, sql, check, post };
   }
 }