@strapi/database 4.0.0-next.8 → 4.0.2

package/lib/schema/builder.js

@@ -1,344 +1,375 @@
 'use strict';
 
-const { isUndefined } = require('lodash/fp');
-const debug = require('debug')('@strapi/database');
+const { isNil, prop, omit, castArray } = require('lodash/fp');
+const debug = require('debug')('strapi::database');
+
+module.exports = db => {
+  const helpers = createHelpers(db);
+
+  return {
+    /**
+     * Returns a knex schema builder instance
+     * @param {string} table - table name
+     */
+    getSchemaBuilder(trx) {
+      return db.getSchemaConnection(trx);
+    },
+
+    /**
+     * Creates schema in DB
+     * @param {Schema} schema - database schema
+     */
+    async createSchema(schema) {
+      await db.connection.transaction(async trx => {
+        await this.createTables(schema.tables, trx);
+      });
+    },
+
+    /**
+     * Creates a list of tables in a schema
+     * @param {KnexInstance} trx
+     * @param {Table[]} tables
+     */
+    async createTables(tables, trx) {
+      for (const table of tables) {
+        debug(`Creating table: ${table.name}`);
+        const schemaBuilder = this.getSchemaBuilder(trx);
+        await helpers.createTable(schemaBuilder, table);
+      }
+
+      // create FKs once all the tables exist
+      for (const table of tables) {
+        debug(`Creating table foreign keys: ${table.name}`);
+        const schemaBuilder = this.getSchemaBuilder(trx);
+        await helpers.createTableForeignKeys(schemaBuilder, table);
+      }
+    },
+    /**
+     * Drops schema from DB
+     * @param {Schema} schema - database schema
+     * @param {object} opts
+     * @param {boolean} opts.dropDatabase - weather to drop the entire database or simply drop the tables
+     */
+    async dropSchema(schema, { dropDatabase = false } = {}) {
+      if (dropDatabase) {
+        // TODO: drop database & return as it will drop everything
+        return;
+      }
+
+      await db.connection.transaction(async trx => {
+        for (const table of schema.tables.reverse()) {
+          const schemaBuilder = this.getSchemaBuilder(trx);
+          await helpers.dropTable(schemaBuilder, table);
+        }
+      });
+    },
+
+    /**
+     * Applies a schema diff update in the DB
+     * @param {*} schemaDiff
+     */
+    // TODO: implement force option to disable removal in DB
+    async updateSchema(schemaDiff) {
+      const { forceMigration } = db.config.settings;
+
+      await db.dialect.startSchemaUpdate();
+      await db.connection.transaction(async trx => {
+        await this.createTables(schemaDiff.tables.added, trx);
+
+        if (forceMigration) {
+          // drop all delete table foreign keys then delete the tables
+          for (const table of schemaDiff.tables.removed) {
+            debug(`Removing table foreign keys: ${table.name}`);
+
+            const schemaBuilder = this.getSchemaBuilder(trx);
+            await helpers.dropTableForeignKeys(schemaBuilder, table);
+          }
+
+          for (const table of schemaDiff.tables.removed) {
+            debug(`Removing table: ${table.name}`);
+
+            const schemaBuilder = this.getSchemaBuilder(trx);
+            await helpers.dropTable(schemaBuilder, table);
+          }
+        }
+
+        for (const table of schemaDiff.tables.updated) {
+          debug(`Updating table: ${table.name}`);
+          // alter table
+          const schemaBuilder = this.getSchemaBuilder(trx);
+
+          await helpers.alterTable(schemaBuilder, table);
+        }
+      });
+
+      await db.dialect.endSchemaUpdate();
+    },
+  };
+};
 
-module.exports = db => ({
+const createHelpers = db => {
   /**
-   * Returns a knex schema builder instance
-   * @param {string} table - table name
+   *  Creates a foreign key on a table
+   * @param {Knex.TableBuilder} tableBuilder
+   * @param {ForeignKey} foreignKey
    */
-  getSchemaBuilder(table, trx = db.connection) {
-    return table.schema ? trx.schema.withSchema(table.schema) : trx.schema;
-  },
+  const createForeignKey = (tableBuilder, foreignKey) => {
+    const { name, columns, referencedColumns, referencedTable, onDelete, onUpdate } = foreignKey;
+
+    const constraint = tableBuilder
+      .foreign(columns, name)
+      .references(referencedColumns)
+      .inTable(
+        db.connection.getSchemaName()
+          ? `${db.connection.getSchemaName()}.${referencedTable}`
+          : referencedTable
+      );
+
+    if (onDelete) {
+      constraint.onDelete(onDelete);
+    }
+
+    if (onUpdate) {
+      constraint.onUpdate(onUpdate);
+    }
+  };
 
   /**
-   * Creates schema in DB
-   * @param {Schema} schema - database schema
+   * Drops a foreign key from a table
+   * @param {Knex.TableBuilder} tableBuilder
+   * @param {ForeignKey} foreignKey
    */
-  async createSchema(schema) {
-    // TODO: ensure database exists;
+  const dropForeignKey = (tableBuilder, foreignKey) => {
+    const { name, columns } = foreignKey;
 
-    await db.connection.transaction(async trx => {
-      // create tables without FKs first do avoid ordering issues
-      await this.createTables(schema.tables, trx);
-    });
-  },
+    tableBuilder.dropForeign(columns, name);
+  };
 
   /**
-   * Creates a list of tables in a schema
-   * @param {KnexInstance} trx
-   * @param {Table[]} tables
+   * Creates an index on a table
+   * @param {Knex.TableBuilder} tableBuilder
+   * @param {Index} index
    */
-  async createTables(tables, trx) {
-    for (const table of tables) {
-      debug(`Creating table: ${table.name}`);
-      const schemaBuilder = this.getSchemaBuilder(table, trx);
-      await createTable(schemaBuilder, table);
-    }
+  const createIndex = (tableBuilder, index) => {
+    const { type, columns, name } = index;
 
-    // create FKs once all the tables exist
-    for (const table of tables) {
-      debug(`Creating table foreign keys: ${table.name}`);
-      const schemaBuilder = this.getSchemaBuilder(table, trx);
-      await createTableForeignKeys(schemaBuilder, table);
+    switch (type) {
+      case 'primary': {
+        return tableBuilder.primary(columns, name);
+      }
+      case 'unique': {
+        return tableBuilder.unique(columns, name);
+      }
+      default: {
+        return tableBuilder.index(columns, name, type);
+      }
     }
-  },
+  };
+
   /**
-   * Drops schema from DB
-   * @param {Schema} schema - database schema
-   * @param {object} opts
-   * @param {boolean} opts.dropDatabase - weather to drop the entire database or simply drop the tables
+   * Drops an index from table
+   * @param {Knex.TableBuilder} tableBuilder
+   * @param {Index} index
    */
-  async dropSchema(schema, { dropDatabase = false } = {}) {
-    if (dropDatabase) {
-      // TODO: drop database & return as it will drop everything
+  const dropIndex = (tableBuilder, index) => {
+    if (!db.config.settings.forceMigration) {
       return;
     }
 
-    await db.connection.transaction(async trx => {
-      for (const table of schema.tables.reverse()) {
-        const schemaBuilder = this.getSchemaBuilder(table, trx);
-        await dropTable(schemaBuilder, table);
+    const { type, columns, name } = index;
+
+    switch (type) {
+      case 'primary': {
+        return tableBuilder.dropPrimary(name);
       }
-    });
-  },
+      case 'unique': {
+        return tableBuilder.dropUnique(columns, name);
+      }
+      default: {
+        return tableBuilder.dropIndex(columns, name);
+      }
+    }
+  };
 
   /**
-   * Applies a schema diff update in the DB
-   * @param {*} schemaDiff
+   * Creates a column in a table
+   * @param {Knex.TableBuilder} tableBuilder
+   * @param {Column} column
    */
-  // TODO: implement force option to disable removal in DB
-  async updateSchema(schemaDiff) {
-    await db.connection.transaction(async trx => {
-      await this.createTables(schemaDiff.tables.added, trx);
+  const createColumn = (tableBuilder, column) => {
+    const { type, name, args = [], defaultTo, unsigned, notNullable } = column;
 
-      // drop all delete table foreign keys then delete the tables
-      for (const table of schemaDiff.tables.removed) {
-        debug(`Removing table foreign keys: ${table.name}`);
+    const col = tableBuilder[type](name, ...args);
 
-        const schemaBuilder = this.getSchemaBuilder(table, trx);
-        await dropTableForeignKeys(schemaBuilder, table);
-      }
-
-      for (const table of schemaDiff.tables.removed) {
-        debug(`Removing table: ${table.name}`);
-
-        const schemaBuilder = this.getSchemaBuilder(table, trx);
-        await dropTable(schemaBuilder, table);
-      }
+    if (unsigned === true) {
+      col.unsigned();
+    }
 
-      for (const table of schemaDiff.tables.updated) {
-        debug(`Updating table: ${table.name}`);
-        // alter table
-        const schemaBuilder = this.getSchemaBuilder(table, trx);
+    if (!isNil(defaultTo)) {
+      const [value, opts] = castArray(defaultTo);
 
-        await alterTable(schemaBuilder, table);
+      if (prop('isRaw', opts)) {
+        col.defaultTo(db.connection.raw(value), omit('isRaw', opts));
+      } else {
+        col.defaultTo(value, opts);
       }
-    });
-  },
-});
-
-/**
- *  Creates a foreign key on a table
- * @param {Knex.TableBuilder} tableBuilder
- * @param {ForeignKey} foreignKey
- */
-const createForeignKey = (tableBuilder, foreignKey) => {
-  const { name, columns, referencedColumns, referencedTable, onDelete, onUpdate } = foreignKey;
-
-  const constraint = tableBuilder
-    .foreign(columns, name)
-    .references(referencedColumns)
-    .inTable(referencedTable);
-
-  if (onDelete) {
-    constraint.onDelete(onDelete);
-  }
-
-  if (onUpdate) {
-    constraint.onUpdate(onUpdate);
-  }
-};
-
-/**
- * Drops a foreign key from a table
- * @param {Knex.TableBuilder} tableBuilder
- * @param {ForeignKey} foreignKey
- */
-const dropForeignKey = (tableBuilder, foreignKey) => {
-  const { name, columns } = foreignKey;
-
-  tableBuilder.dropForeign(columns, name);
-};
-
-/**
- * Creates an index on a table
- * @param {Knex.TableBuilder} tableBuilder
- * @param {Index} index
- */
-const createIndex = (tableBuilder, index) => {
-  const { type, columns, name } = index;
-
-  switch (type) {
-    case 'primary': {
-      return tableBuilder.primary(columns, name);
     }
-    case 'unique': {
-      return tableBuilder.unique(columns, name);
-    }
-    default: {
-      return tableBuilder.index(columns, name, type);
-    }
-  }
-};
 
-/**
- * Drops an index from table
- * @param {Knex.TableBuilder} tableBuilder
- * @param {Index} index
- */
-const dropIndex = (tableBuilder, index) => {
-  const { type, columns, name } = index;
-
-  switch (type) {
-    case 'primary': {
-      return tableBuilder.dropPrimary(name);
+    if (notNullable === true) {
+      col.notNullable();
+    } else {
+      col.nullable();
     }
-    case 'unique': {
-      return tableBuilder.dropUnique(columns, name);
-    }
-    default: {
-      return tableBuilder.dropIndex(columns, name);
+
+    return col;
+  };
+
+  /**
+   * Drops a column from a table
+   * @param {Knex.TableBuilder} tableBuilder
+   * @param {Column} column
+   */
+  const dropColumn = (tableBuilder, column) => {
+    if (!db.config.settings.forceMigration) {
+      return;
     }
-  }
-};
 
-/**
- * Creates a column in a table
- * @param {Knex.TableBuilder} tableBuilder
- * @param {Column} column
- */
-const createColumn = (tableBuilder, column) => {
-  const { type, name, args = [], defaultTo, unsigned, notNullable } = column;
+    return tableBuilder.dropColumn(column.name);
+  };
 
-  const col = tableBuilder[type](name, ...args);
+  /**
+   * Creates a table in a database
+   * @param {SchemaBuilder} schemaBuilder
+   * @param {Table} table
+   */
+  const createTable = async (schemaBuilder, table) => {
+    await schemaBuilder.createTable(table.name, tableBuilder => {
+      // columns
+      (table.columns || []).forEach(column => createColumn(tableBuilder, column));
 
-  if (unsigned) {
-    col.unsigned();
-  }
+      // indexes
+      (table.indexes || []).forEach(index => createIndex(tableBuilder, index));
 
-  if (!isUndefined(defaultTo)) {
-    // TODO: allow some raw default values
-    col.defaultTo(...[].concat(defaultTo));
-  }
+      // foreign keys
 
-  if (notNullable) {
-    col.notNullable();
-  } else {
-    col.nullable();
-  }
+      if (!db.dialect.canAlterConstraints()) {
+        (table.foreignKeys || []).forEach(foreignKey => createForeignKey(tableBuilder, foreignKey));
+      }
+    });
+  };
 
-  return col;
-};
+  const alterTable = async (schemaBuilder, table) => {
+    await schemaBuilder.alterTable(table.name, tableBuilder => {
+      // Delete indexes / fks / columns
 
-/**
- * Drops a column from a table
- * @param {Knex.TableBuilder} tableBuilder
- * @param {Column} column
- */
-const dropColumn = (tableBuilder, column) => {
-  tableBuilder.dropColumn(column.name);
-};
+      for (const removedIndex of table.indexes.removed) {
+        debug(`Dropping index ${removedIndex.name}`);
+        dropIndex(tableBuilder, removedIndex);
+      }
 
-/**
- * Creates a table in a database
- * @param {SchemaBuilder} schemaBuilder
- * @param {Table} table
- */
-const createTable = async (schemaBuilder, table) => {
-  if (await schemaBuilder.hasTable(table.name)) {
-    debug(`Table ${table.name} already exists trying to alter it`);
-
-    // TODO: implement a DB sync at some point
-    return;
-  }
-
-  await schemaBuilder.createTable(table.name, tableBuilder => {
-    // columns
-    (table.columns || []).forEach(column => createColumn(tableBuilder, column));
-
-    // indexes
-    (table.indexes || []).forEach(index => createIndex(tableBuilder, index));
-  });
-};
+      for (const updateddIndex of table.indexes.updated) {
+        debug(`Dropping updated index ${updateddIndex.name}`);
+        dropIndex(tableBuilder, updateddIndex.object);
+      }
 
-const alterTable = async (schemaBuilder, table) => {
-  await schemaBuilder.alterTable(table.name, tableBuilder => {
-    // Delete indexes / fks / columns
+      for (const removedForeignKey of table.foreignKeys.removed) {
+        debug(`Dropping foreign key ${removedForeignKey.name}`);
+        dropForeignKey(tableBuilder, removedForeignKey);
+      }
 
-    for (const removedIndex of table.indexes.removed) {
-      debug(`Dropping index ${removedIndex.name}`);
-      dropIndex(tableBuilder, removedIndex);
-    }
+      for (const updatedForeignKey of table.foreignKeys.updated) {
+        debug(`Dropping updated foreign key ${updatedForeignKey.name}`);
+        dropForeignKey(tableBuilder, updatedForeignKey.object);
+      }
 
-    for (const updateddIndex of table.indexes.updated) {
-      debug(`Dropping updated index ${updateddIndex.name}`);
-      dropIndex(tableBuilder, updateddIndex);
-    }
+      for (const removedColumn of table.columns.removed) {
+        debug(`Dropping column ${removedColumn.name}`);
+        dropColumn(tableBuilder, removedColumn);
+      }
 
-    for (const removedForeignKey of table.foreignKeys.removed) {
-      debug(`Dropping foreign key ${removedForeignKey.name}`);
-      dropForeignKey(tableBuilder, removedForeignKey);
-    }
+      // Update existing columns / foreign keys / indexes
 
-    for (const updatedForeignKey of table.foreignKeys.updated) {
-      debug(`Dropping updated foreign key ${updatedForeignKey.name}`);
-      dropForeignKey(tableBuilder, updatedForeignKey);
-    }
+      for (const updatedColumn of table.columns.updated) {
+        debug(`Updating column ${updatedColumn.name}`);
 
-    for (const removedColumn of table.columns.removed) {
-      debug(`Dropping column ${removedColumn.name}`);
-      dropColumn(tableBuilder, removedColumn);
-    }
+        const { object } = updatedColumn;
 
-    // Update existing columns / foreign keys / indexes
+        createColumn(tableBuilder, object).alter();
+      }
 
-    for (const updatedColumn of table.columns.updated) {
-      debug(`Updating column ${updatedColumn.name}`);
+      for (const updatedForeignKey of table.foreignKeys.updated) {
+        debug(`Recreating updated foreign key ${updatedForeignKey.name}`);
+        createForeignKey(tableBuilder, updatedForeignKey.object);
+      }
 
-      // TODO: cleanup diffs for columns
-      const { object } = updatedColumn;
+      for (const updatedIndex of table.indexes.updated) {
+        debug(`Recreating updated index ${updatedIndex.name}`);
+        createIndex(tableBuilder, updatedIndex.object);
+      }
 
-      /*
-        type -> recreate the type
-        args -> recreate the type
-        unsigned
-          if changed then recreate the type
-          if removed then check if old value was true -> recreate the type else do nothing
-        defaultTo
-          reapply the default to previous data
-        notNullable
-          if null to not null we need a default value to migrate the data
-      */
+      for (const addedColumn of table.columns.added) {
+        debug(`Creating column ${addedColumn.name}`);
+        createColumn(tableBuilder, addedColumn);
+      }
 
-      createColumn(tableBuilder, object).alter();
-    }
+      for (const addedForeignKey of table.foreignKeys.added) {
+        debug(`Creating foreign keys ${addedForeignKey.name}`);
+        createForeignKey(tableBuilder, addedForeignKey);
+      }
 
-    for (const updatedForeignKey of table.foreignKeys.updated) {
-      debug(`Recreating updated foreign key ${updatedForeignKey.name}`);
-      createForeignKey(tableBuilder, updatedForeignKey);
-    }
+      for (const addedIndex of table.indexes.added) {
+        debug(`Creating index ${addedIndex.name}`);
+        createIndex(tableBuilder, addedIndex);
+      }
+    });
+  };
 
-    for (const updatedIndex of table.indexes.updated) {
-      debug(`Recreating updated index ${updatedIndex.name}`);
-      createIndex(tableBuilder, updatedIndex);
+  /**
+   * Drops a table from a database
+   * @param {Knex.SchemaBuilder} schemaBuilder
+   * @param {Table} table
+   */
+  const dropTable = (schemaBuilder, table) => {
+    if (!db.config.settings.forceMigration) {
+      return;
     }
 
-    for (const addedColumn of table.columns.added) {
-      debug(`Creating column ${addedColumn.name}`);
-      createColumn(tableBuilder, addedColumn);
-    }
+    return schemaBuilder.dropTableIfExists(table.name);
+  };
 
-    for (const addedForeignKey of table.foreignKeys.added) {
-      debug(`Creating foreign keys ${addedForeignKey.name}`);
-      createForeignKey(tableBuilder, addedForeignKey);
-    }
+  /**
+   * Creates a table foreign keys constraints
+   * @param {SchemaBuilder} schemaBuilder
+   * @param {Table} table
+   */
+  const createTableForeignKeys = async (schemaBuilder, table) => {
+    // foreign keys
+    await schemaBuilder.table(table.name, tableBuilder => {
+      (table.foreignKeys || []).forEach(foreignKey => createForeignKey(tableBuilder, foreignKey));
+    });
+  };
 
-    for (const addedIndex of table.indexes.added) {
-      debug(`Creating index ${addedIndex.name}`);
-      createIndex(tableBuilder, addedIndex);
+  /**
+   * Drops a table foreign keys constraints
+   * @param {SchemaBuilder} schemaBuilder
+   * @param {Table} table
+   */
+  const dropTableForeignKeys = async (schemaBuilder, table) => {
+    if (!db.config.settings.forceMigration) {
+      return;
     }
-  });
-};
 
-/**
- * Drops a table from a database
- * @param {Knex.SchemaBuilder} schemaBuilder
- * @param {Table} table
- */
-const dropTable = (schemaBuilder, table) => schemaBuilder.dropTableIfExists(table.name);
-
-/**
- * Creates a table foreign keys constraints
- * @param {SchemaBuilder} schemaBuilder
- * @param {Table} table
- */
-const createTableForeignKeys = async (schemaBuilder, table) => {
-  // foreign keys
-  await schemaBuilder.table(table.name, tableBuilder => {
-    (table.foreignKeys || []).forEach(foreignKey => createForeignKey(tableBuilder, foreignKey));
-  });
-};
-
-/**
- * Drops a table foreign keys constraints
- * @param {SchemaBuilder} schemaBuilder
- * @param {Table} table
- */
-const dropTableForeignKeys = async (schemaBuilder, table) => {
-  // foreign keys
-  await schemaBuilder.table(table.name, tableBuilder => {
-    (table.foreignKeys || []).forEach(foreignKey => dropForeignKey(tableBuilder, foreignKey));
-  });
+    // foreign keys
+    await schemaBuilder.table(table.name, tableBuilder => {
+      (table.foreignKeys || []).forEach(foreignKey => dropForeignKey(tableBuilder, foreignKey));
+    });
+  };
+
+  return {
+    createTable,
+    alterTable,
+    dropTable,
+    createTableForeignKeys,
+    dropTableForeignKeys,
+  };
 };