@strapi/database 4.0.0-beta.3 → 4.0.0-beta.31

package/lib/dialects/mysql/schema-inspector.js

@@ -123,10 +123,6 @@ class MysqlSchemaInspector {
     return schema;
   }
 
-  getDatabaseSchema() {
-    return this.db.connection.client.connectionSettings.schema || 'public';
-  }
-
   async getTables() {
     const [rows] = await this.db.connection.raw(SQL_QUERIES.TABLE_LIST);
 

package/lib/dialects/postgresql/schema-inspector.js

@@ -4,36 +4,39 @@ const SQL_QUERIES = {
   TABLE_LIST: /* sql */ `
     SELECT *
     FROM information_schema.tables
-    WHERE table_schema = ? AND table_type = 'BASE TABLE';
+    WHERE
+      table_schema = ?
+      AND table_type = 'BASE TABLE'
+      AND table_name != 'geometry_columns'
+      AND table_name != 'spatial_ref_sys';
   `,
   LIST_COLUMNS: /* sql */ `
     SELECT data_type, column_name, character_maximum_length, column_default, is_nullable
     FROM information_schema.columns
-    WHERE table_schema = ?
-      AND table_name = ?;
+    WHERE table_schema = ? AND table_name = ?;
   `,
   INDEX_LIST: /* sql */ `
-    select
+    SELECT
       ix.indexrelid,
       i.relname as index_name,
       a.attname as column_name,
       ix.indisunique as is_unique,
       ix.indisprimary as is_primary
-    from
+    FROM
       pg_class t,
       pg_namespace s,
       pg_class i,
       pg_index ix,
       pg_attribute a
-    where
+    WHERE
       t.oid = ix.indrelid
-      and i.oid = ix.indexrelid
-      and a.attrelid = t.oid
-      and a.attnum = ANY(ix.indkey)
-      and t.relkind = 'r'
-      and t.relnamespace = s.oid
-      and s.nspname = ?
-      and t.relname = ?;
+      AND i.oid = ix.indexrelid
+      AND a.attrelid = t.oid
+      AND a.attnum = ANY(ix.indkey)
+      AND t.relkind = 'r'
+      AND t.relnamespace = s.oid
+      AND s.nspname = ?
+      AND t.relname = ?;
   `,
   FOREIGN_KEY_LIST: /* sql */ `
     SELECT
@@ -136,7 +139,7 @@ class PostgresqlSchemaInspector {
   }
 
   getDatabaseSchema() {
-    return this.db.connection.client.connectionSettings.schema || 'public';
+    return this.db.connection.getSchemaName() || 'public';
   }
 
   async getTables() {

package/lib/entity-manager.js

@@ -142,7 +142,7 @@ const createEntityManager = db => {
       await db.lifecycles.run('beforeCount', uid, { params });
 
       const res = await this.createQueryBuilder(uid)
-        .init(_.pick(['_q', 'where'], params))
+        .init(_.pick(['_q', 'where', 'filters'], params))
         .count()
         .first()
         .execute();
@@ -172,7 +172,7 @@ const createEntityManager = db => {
 
       await this.attachRelations(uid, id, data);
 
-      // TODO: in case there is not select or populate specified return the inserted data ?
+      // TODO: in case there is no select or populate specified return the inserted data ?
       // TODO: do not trigger the findOne lifecycles ?
       const result = await this.findOne(uid, {
         where: { id },
@@ -296,7 +296,7 @@ const createEntityManager = db => {
         throw new Error('Delete requires a where parameter');
       }
 
-      // TODO: avoid trigger the findOne lifecycles in the case ?
+      // TODO: do not trigger the findOne lifecycles ?
       const entity = await this.findOne(uid, {
         select: select && ['id'].concat(select),
         where,
@@ -469,7 +469,6 @@ const createEntityManager = db => {
           const { joinTable } = attribute;
           const { joinColumn, inverseJoinColumn } = joinTable;
 
-          // TODO: validate logic of delete
           if (isOneToAny(attribute) && isBidirectional(attribute)) {
             await this.createQueryBuilder(joinTable.name)
               .delete()

package/lib/errors.js

@@ -1,14 +1,56 @@
 'use strict';
 
-class NotNullConstraint extends Error {
+/* DatabaseError */
+class DatabaseError extends Error {
+  constructor(message, details = {}) {
+    super();
+    this.name = 'DatabaseError';
+    this.message = message || 'A database error occured';
+    this.details = details;
+  }
+}
+
+class NotNullConstraint extends DatabaseError {
   constructor({ column = '' } = {}) {
     super();
     this.name = 'NotNullConstraint';
-    this.message = `Not null constraint violation${column ? `on on column ${column}` : ''}.`;
+    this.message = `Not null constraint violation${column ? ` on column ${column}` : ''}.`;
+    this.details = { column };
     this.stack = '';
   }
 }
 
+class InvalidTimeError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidTimeFormat';
+    this.message = message || 'Invalid time format, expected HH:mm:ss.SSS';
+    this.details = {};
+  }
+}
+
+class InvalidDateError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidTimeFormat';
+    this.message = message || 'Invalid date format, expected YYYY-MM-DD';
+    this.details = {};
+  }
+}
+
+class InvalidDateTimeError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidTimeFormat';
+    this.message = message || 'Invalid datetime format, expected a timestamp or an ISO date';
+    this.details = {};
+  }
+}
+
 module.exports = {
+  DatabaseError,
   NotNullConstraint,
+  InvalidTimeError,
+  InvalidDateError,
+  InvalidDateTimeError,
 };

package/lib/fields.js

@@ -2,22 +2,13 @@
 
 const _ = require('lodash/fp');
 const dateFns = require('date-fns');
+const { InvalidTimeError, InvalidDateError, InvalidDateTimeError } = require('./errors');
 
 class Field {
   constructor(config) {
     this.config = config;
   }
 
-  // TODO: impl
-  validate() {
-    // // use config validators directly
-    // if (this.config.validators) {
-    //   this.config.validators.forEach(validator => {
-    //     validator(value)
-    //   })
-    // }
-  }
-
   toDB(value) {
     return value;
   }
@@ -112,12 +103,12 @@ const parseTime = value => {
   if (dateFns.isDate(value)) return dateFns.format(value, 'HH:mm:ss.SSS');
 
   if (typeof value !== 'string') {
-    throw new Error(`Expected a string, got a ${typeof value}`);
+    throw new InvalidTimeError(`Expected a string, got a ${typeof value}`);
   }
   const result = value.match(timeRegex);
 
   if (result === null) {
-    throw new Error('Invalid time format, expected HH:mm:ss.SSS');
+    throw new InvalidTimeError('Invalid time format, expected HH:mm:ss.SSS');
   }
 
   const [, hours, minutes, seconds, fraction = '.000'] = result;
@@ -133,9 +124,9 @@ const parseDate = value => {
 
     if (dateFns.isValid(date)) return dateFns.format(date, 'yyyy-MM-dd');
 
-    throw new Error(`Invalid format, expected an ISO compatible date`);
+    throw new InvalidDateError(`Invalid format, expected an ISO compatible date`);
   } catch (error) {
-    throw new Error(`Invalid format, expected an ISO compatible date`);
+    throw new InvalidDateError(`Invalid format, expected an ISO compatible date`);
   }
 };
 
@@ -148,9 +139,9 @@ const parseDateTimeOrTimestamp = value => {
     const milliUnixDate = dateFns.parse(value, 'T', new Date());
     if (dateFns.isValid(milliUnixDate)) return milliUnixDate;
 
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    throw new InvalidDateTimeError(`Invalid format, expected a timestamp or an ISO date`);
   } catch (error) {
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    throw new InvalidDateTimeError(`Invalid format, expected a timestamp or an ISO date`);
   }
 };
 

package/lib/index.js

@@ -8,20 +8,37 @@ const createMetadata = require('./metadata');
 const { createEntityManager } = require('./entity-manager');
 const { createMigrationsProvider } = require('./migrations');
 const { createLifecyclesProvider } = require('./lifecycles');
+const errors = require('./errors');
 
 // TODO: move back into strapi
 const { transformContentTypes } = require('./utils/content-types');
 
+const createConnection = config => {
+  const knexInstance = knex(config);
+
+  return Object.assign(knexInstance, {
+    getSchemaName() {
+      return this.client.connectionSettings.schema;
+    },
+  });
+};
+
 class Database {
   constructor(config) {
     this.metadata = createMetadata(config.models);
 
-    this.config = config;
+    this.config = {
+      connection: {},
+      settings: {
+        forceMigration: true,
+      },
+      ...config,
+    };
 
     this.dialect = getDialect(this);
     this.dialect.configure();
 
-    this.connection = knex(this.config.connection);
+    this.connection = createConnection(this.config.connection);
 
     this.dialect.initialize();
 
@@ -41,6 +58,17 @@ class Database {
     return this.entityManager.getRepository(uid);
   }
 
+  getConnection(tableName) {
+    const schema = this.connection.getSchemaName();
+    const connection = tableName ? this.connection(tableName) : this.connection;
+    return schema ? connection.withSchema(schema) : connection;
+  }
+
+  getSchemaConnection(trx = this.connection) {
+    const schema = this.connection.getSchemaName();
+    return schema ? trx.schema.withSchema(schema) : trx.schema;
+  }
+
   queryBuilder(uid) {
     return this.entityManager.createQueryBuilder(uid);
   }
@@ -57,4 +85,5 @@ Database.init = async config => new Database(config);
 
 module.exports = {
   Database,
+  errors,
 };

package/lib/migrations/index.js

@@ -27,7 +27,7 @@ const createUmzugProvider = db => {
 
   fse.ensureDirSync(migrationDir);
 
-  const wrapFn = fn => db => db.connection.transaction(trx => Promise.resolve(fn(trx)));
+  const wrapFn = fn => db => db.getConnection().transaction(trx => Promise.resolve(fn(trx)));
   const storage = createStorage({ db, tableName: 'strapi_migrations' });
 
   return new Umzug({

package/lib/migrations/storage.js

@@ -1,13 +1,12 @@
 'use strict';
 
 const createStorage = (opts = {}) => {
-  const tableName = opts.tableName || 'strapi_migrations';
-  const knex = opts.db.connection;
+  const { db, tableName = 'strapi_migrations' } = opts;
 
-  const hasMigrationTable = () => knex.schema.hasTable(tableName);
+  const hasMigrationTable = () => db.getSchemaConnection().hasTable(tableName);
 
   const createMigrationTable = () => {
-    return knex.schema.createTable(tableName, table => {
+    return db.getSchemaConnection().createTable(tableName, table => {
       table.increments('id');
       table.string('name');
       table.datetime('time', { useTz: false });
@@ -16,7 +15,8 @@ const createStorage = (opts = {}) => {
 
   return {
     async logMigration(migrationName) {
-      await knex
+      await db
+        .getConnection()
         .insert({
           name: migrationName,
           time: new Date(),
@@ -25,7 +25,8 @@ const createStorage = (opts = {}) => {
     },
 
     async unlogMigration(migrationName) {
-      await knex(tableName)
+      await db
+        .getConnection(tableName)
         .del()
         .where({ name: migrationName });
     },
@@ -36,7 +37,8 @@ const createStorage = (opts = {}) => {
         return [];
       }
 
-      const logs = await knex
+      const logs = await db
+        .getConnection(tableName)
         .select()
         .from(tableName)
         .orderBy('time');

package/lib/query/helpers/join.js

@@ -67,7 +67,7 @@ const applyJoin = (qb, join) => {
     orderBy,
   } = join;
 
-  qb[method]({ [alias]: referencedTable }, inner => {
+  qb[method](`${referencedTable} as ${alias}`, inner => {
     inner.on(`${rootTable}.${rootColumn}`, `${alias}.${referencedColumn}`);
 
     if (on) {

package/lib/query/helpers/populate.js

@@ -103,6 +103,7 @@ const pickPopulateParams = _.pick([
   'orderBy',
   'limit',
   'offset',
+  'filters',
 ]);
 
 // TODO: cleanup code
@@ -122,7 +123,11 @@ const applyPopulate = async (results, populate, ctx) => {
     const attribute = meta.attributes[key];
     const targetMeta = db.metadata.get(attribute.target);
 
-    const populateValue = pickPopulateParams(populate[key]);
+    const populateValue = {
+      filters: qb.state.filters,
+      ...pickPopulateParams(populate[key]),
+    };
+
     const isCount = populateValue.count === true;
 
     const fromTargetRow = rowOrRows => fromRow(targetMeta, rowOrRows);

package/lib/query/helpers/where.js

@@ -3,6 +3,7 @@
 const _ = require('lodash/fp');
 
 const types = require('../../types');
+const { createField } = require('../../fields');
 const { createJoin } = require('./join');
 const { toColumnName } = require('./transform');
 
@@ -28,10 +29,65 @@ const OPERATORS = [
   '$notContainsi',
 ];
 
+const CAST_OPERATORS = [
+  '$not',
+  '$in',
+  '$notIn',
+  '$eq',
+  '$ne',
+  '$gt',
+  '$gte',
+  '$lt',
+  '$lte',
+  '$between',
+];
+
 const ARRAY_OPERATORS = ['$in', '$notIn', '$between'];
 
 const isOperator = key => OPERATORS.includes(key);
 
+const castValue = (value, attribute) => {
+  if (!attribute) {
+    return value;
+  }
+
+  if (types.isScalar(attribute.type)) {
+    const field = createField(attribute);
+
+    return value === null ? null : field.toDB(value);
+  }
+
+  return value;
+};
+
+const processAttributeWhere = (attribute, where, operator = '$eq') => {
+  if (_.isArray(where)) {
+    return where.map(sub => processAttributeWhere(attribute, sub, operator));
+  }
+
+  if (!_.isPlainObject(where)) {
+    if (CAST_OPERATORS.includes(operator)) {
+      return castValue(where, attribute);
+    }
+
+    return where;
+  }
+
+  const filters = {};
+
+  for (const key in where) {
+    const value = where[key];
+
+    if (!isOperator(key)) {
+      throw new Error(`Undefined attribute level operator ${key}`);
+    }
+
+    filters[key] = processAttributeWhere(attribute, value, key);
+  }
+
+  return filters;
+};
+
 /**
  * Process where parameter
  * @param {Object} where
@@ -39,7 +95,7 @@ const isOperator = key => OPERATORS.includes(key);
  * @param {number} depth
  * @returns {Object}
  */
-const processWhere = (where, ctx, depth = 0) => {
+const processWhere = (where, ctx) => {
   if (!_.isArray(where) && !_.isPlainObject(where)) {
     throw new Error('Where must be an array or an object');
   }
@@ -53,7 +109,7 @@ const processWhere = (where, ctx, depth = 0) => {
       return where;
     }
 
-    return processWhere(where, ctx, depth + 1);
+    return processWhere(where, ctx);
   };
 
   const { db, uid, qb, alias } = ctx;
@@ -64,7 +120,6 @@ const processWhere = (where, ctx, depth = 0) => {
   // for each key in where
   for (const key in where) {
     const value = where[key];
-    const attribute = meta.attributes[key];
 
     // if operator $and $or then loop over them
     if (GROUP_OPERATORS.includes(key)) {
@@ -78,28 +133,17 @@ const processWhere = (where, ctx, depth = 0) => {
     }
 
     if (isOperator(key)) {
-      if (depth == 0) {
-        throw new Error(
-          `Only $and, $or and $not can by used as root level operators. Found ${key}.`
-        );
-      }
-
-      filters[key] = processNested(value, ctx);
-      continue;
+      throw new Error(`Only $and, $or and $not can by used as root level operators. Found ${key}.`);
     }
 
-    if (!attribute) {
-      filters[qb.aliasColumn(key, alias)] = processNested(value, ctx);
+    const attribute = meta.attributes[key];
 
+    if (!attribute) {
+      filters[qb.aliasColumn(key, alias)] = processAttributeWhere(null, value);
       continue;
-
-      // throw new Error(`Attribute ${key} not found on model ${uid}`);
     }
 
-    // move to if else to check for scalar / relation / components & throw for other types
-    if (attribute.type === 'relation') {
-      // TODO: pass down some filters (e.g published at)
-
+    if (types.isRelation(attribute.type)) {
       // attribute
       const subAlias = createJoin(ctx, {
         alias: alias || qb.alias,
@@ -127,9 +171,10 @@ const processWhere = (where, ctx, depth = 0) => {
 
     if (types.isScalar(attribute.type)) {
       const columnName = toColumnName(meta, key);
+      const aliasedColumnName = qb.aliasColumn(columnName, alias);
+
+      filters[aliasedColumnName] = processAttributeWhere(attribute, value);
 
-      // TODO: cast to DB type
-      filters[qb.aliasColumn(columnName, alias)] = processNested(value, ctx);
       continue;
     }
 
@@ -139,6 +184,7 @@ const processWhere = (where, ctx, depth = 0) => {
   return filters;
 };
 
+// TODO: add type casting per operator at some point
 const applyOperator = (qb, column, operator, value) => {
   if (Array.isArray(value) && !ARRAY_OPERATORS.includes(operator)) {
     return qb.where(subQB => {
@@ -201,7 +247,6 @@ const applyOperator = (qb, column, operator, value) => {
       break;
     }
     case '$null': {
-      // TODO: make this better
       if (value) {
         qb.whereNull(column);
       }
@@ -211,15 +256,12 @@ const applyOperator = (qb, column, operator, value) => {
       if (value) {
         qb.whereNotNull(column);
       }
-
       break;
     }
     case '$between': {
       qb.whereBetween(column, value);
       break;
     }
-
-    // TODO: add casting logic
     case '$startsWith': {
       qb.where(column, 'like', `${value}%`);
       break;
@@ -253,7 +295,7 @@ const applyOperator = (qb, column, operator, value) => {
     // TODO: relational operators every/some/exists/size ...
 
     default: {
-      throw new Error(`Undefined operator ${operator}`);
+      throw new Error(`Undefined attribute level operator ${operator}`);
     }
   }
 };
@@ -267,7 +309,6 @@ const applyWhereToColumn = (qb, column, columnWhere) => {
     return qb.where(column, columnWhere);
   }
 
-  // TODO: handle casing
   Object.keys(columnWhere).forEach(operator => {
     const value = columnWhere[operator];
 

package/lib/query/query-builder.js

@@ -29,6 +29,7 @@ const createQueryBuilder = (uid, db) => {
   return {
     alias: getAlias(),
     getAlias,
+    state,
 
     select(args) {
       state.type = 'select';
@@ -115,7 +116,7 @@ const createQueryBuilder = (uid, db) => {
     },
 
     init(params = {}) {
-      const { _q, where, select, limit, offset, orderBy, groupBy, populate } = params;
+      const { _q, filters, where, select, limit, offset, orderBy, groupBy, populate } = params;
 
       if (!_.isNil(where)) {
         this.where(where);
@@ -151,9 +152,17 @@ const createQueryBuilder = (uid, db) => {
         this.populate(populate);
       }
 
+      if (!_.isNil(filters)) {
+        this.filters(filters);
+      }
+
       return this;
     },
 
+    filters(filters) {
+      state.filters = filters;
+    },
+
     first() {
       state.first = true;
       return this;
@@ -196,16 +205,32 @@ const createQueryBuilder = (uid, db) => {
       this.select('id');
       const subQB = this.getKnexQuery();
 
-      const nestedSubQuery = db.connection.select('id').from(subQB.as('subQuery'));
+      const nestedSubQuery = db
+        .getConnection()
+        .select('id')
+        .from(subQB.as('subQuery'));
 
       return db
-        .connection(tableName)
+        .getConnection(tableName)
         [state.type]()
         .whereIn('id', nestedSubQuery);
     },
 
     processState() {
       state.orderBy = helpers.processOrderBy(state.orderBy, { qb: this, uid, db });
+
+      if (!_.isNil(state.filters)) {
+        if (_.isFunction(state.filters)) {
+          const filters = state.filters({ qb: this, uid, meta, db });
+
+          if (!_.isNil(filters)) {
+            state.where.push(filters);
+          }
+        } else {
+          state.where.push(state.filters);
+        }
+      }
+
       state.where = helpers.processWhere(state.where, { qb: this, uid, db });
       state.populate = helpers.processPopulate(state.populate, { qb: this, uid, db });
       state.data = helpers.toRow(meta, state.data);
@@ -235,9 +260,9 @@ const createQueryBuilder = (uid, db) => {
         this.select('*');
       }
 
-      const aliasedTableName = this.mustUseAlias() ? { [this.alias]: tableName } : tableName;
+      const aliasedTableName = this.mustUseAlias() ? `${tableName} as ${this.alias}` : tableName;
 
-      const qb = db.connection(aliasedTableName);
+      const qb = db.getConnection(aliasedTableName);
 
       if (this.shouldUseSubQuery()) {
         return this.runSubQuery();

package/lib/schema/builder.js

@@ -11,8 +11,8 @@ module.exports = db => {
      * Returns a knex schema builder instance
      * @param {string} table - table name
      */
-    getSchemaBuilder(table, trx = db.connection) {
-      return table.schema ? trx.schema.withSchema(table.schema) : trx.schema;
+    getSchemaBuilder(trx) {
+      return db.getSchemaConnection(trx);
     },
 
     /**
@@ -20,10 +20,7 @@ module.exports = db => {
      * @param {Schema} schema - database schema
      */
     async createSchema(schema) {
-      // TODO: ensure database exists;
-
       await db.connection.transaction(async trx => {
-        // create tables without FKs first do avoid ordering issues
         await this.createTables(schema.tables, trx);
       });
     },
@@ -36,14 +33,14 @@ module.exports = db => {
     async createTables(tables, trx) {
       for (const table of tables) {
         debug(`Creating table: ${table.name}`);
-        const schemaBuilder = this.getSchemaBuilder(table, trx);
+        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(table, trx);
+        const schemaBuilder = this.getSchemaBuilder(trx);
         await helpers.createTableForeignKeys(schemaBuilder, table);
       }
     },
@@ -61,7 +58,7 @@ module.exports = db => {
 
       await db.connection.transaction(async trx => {
         for (const table of schema.tables.reverse()) {
-          const schemaBuilder = this.getSchemaBuilder(table, trx);
+          const schemaBuilder = this.getSchemaBuilder(trx);
           await helpers.dropTable(schemaBuilder, table);
         }
       });
@@ -73,29 +70,33 @@ module.exports = db => {
      */
     // 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);
 
-        // drop all delete table foreign keys then delete the tables
-        for (const table of schemaDiff.tables.removed) {
-          debug(`Removing table foreign keys: ${table.name}`);
+        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(table, trx);
-          await helpers.dropTableForeignKeys(schemaBuilder, table);
-        }
+            const schemaBuilder = this.getSchemaBuilder(trx);
+            await helpers.dropTableForeignKeys(schemaBuilder, table);
+          }
 
-        for (const table of schemaDiff.tables.removed) {
-          debug(`Removing table: ${table.name}`);
+          for (const table of schemaDiff.tables.removed) {
+            debug(`Removing table: ${table.name}`);
 
-          const schemaBuilder = this.getSchemaBuilder(table, trx);
-          await helpers.dropTable(schemaBuilder, table);
+            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(table, trx);
+          const schemaBuilder = this.getSchemaBuilder(trx);
 
           await helpers.alterTable(schemaBuilder, table);
         }
@@ -118,7 +119,11 @@ const createHelpers = db => {
     const constraint = tableBuilder
       .foreign(columns, name)
       .references(referencedColumns)
-      .inTable(referencedTable);
+      .inTable(
+        db.connection.getSchemaName()
+          ? `${db.connection.getSchemaName()}.${referencedTable}`
+          : referencedTable
+      );
 
     if (onDelete) {
       constraint.onDelete(onDelete);
@@ -167,6 +172,10 @@ const createHelpers = db => {
    * @param {Index} index
    */
   const dropIndex = (tableBuilder, index) => {
+    if (!db.config.settings.forceMigration) {
+      return;
+    }
+
     const { type, columns, name } = index;
 
     switch (type) {
@@ -221,7 +230,11 @@ const createHelpers = db => {
    * @param {Column} column
    */
   const dropColumn = (tableBuilder, column) => {
-    tableBuilder.dropColumn(column.name);
+    if (!db.config.settings.forceMigration) {
+      return;
+    }
+
+    return tableBuilder.dropColumn(column.name);
   };
 
   /**
@@ -316,7 +329,13 @@ const createHelpers = db => {
    * @param {Knex.SchemaBuilder} schemaBuilder
    * @param {Table} table
    */
-  const dropTable = (schemaBuilder, table) => schemaBuilder.dropTableIfExists(table.name);
+  const dropTable = (schemaBuilder, table) => {
+    if (!db.config.settings.forceMigration) {
+      return;
+    }
+
+    return schemaBuilder.dropTableIfExists(table.name);
+  };
 
   /**
    * Creates a table foreign keys constraints
@@ -336,6 +355,10 @@ const createHelpers = db => {
    * @param {Table} table
    */
   const dropTableForeignKeys = async (schemaBuilder, table) => {
+    if (!db.config.settings.forceMigration) {
+      return;
+    }
+
     // foreign keys
     await schemaBuilder.table(table.name, tableBuilder => {
       (table.foreignKeys || []).forEach(foreignKey => dropForeignKey(tableBuilder, foreignKey));

package/lib/schema/storage.js

@@ -5,10 +5,10 @@ const crypto = require('crypto');
 const TABLE_NAME = 'strapi_database_schema';
 
 module.exports = db => {
-  const hasSchemaTable = () => db.connection.schema.hasTable(TABLE_NAME);
+  const hasSchemaTable = () => db.getSchemaConnection().hasTable(TABLE_NAME);
 
   const createSchemaTable = () => {
-    return db.connection.schema.createTable(TABLE_NAME, t => {
+    return db.getSchemaConnection().createTable(TABLE_NAME, t => {
       t.increments('id');
       t.json('schema');
       t.datetime('time', { useTz: false });
@@ -26,7 +26,8 @@ module.exports = db => {
     async read() {
       await checkTableExists();
 
-      const res = await db.connection
+      const res = await db
+        .getConnection()
         .select('*')
         .from(TABLE_NAME)
         .orderBy('time', 'DESC')
@@ -55,21 +56,24 @@ module.exports = db => {
       await checkTableExists();
 
       // NOTE: we can remove this to add history
-      await db.connection(TABLE_NAME).delete();
+      await db.getConnection(TABLE_NAME).delete();
 
       const time = new Date();
 
-      await db.connection(TABLE_NAME).insert({
-        schema: JSON.stringify(schema),
-        hash: this.hashSchema(schema),
-        time,
-      });
+      await db
+        .getConnection()
+        .insert({
+          schema: JSON.stringify(schema),
+          hash: this.hashSchema(schema),
+          time,
+        })
+        .into(TABLE_NAME);
     },
 
     async clear() {
       await checkTableExists();
 
-      await db.connection(TABLE_NAME).truncate();
+      await db.getConnection(TABLE_NAME).truncate();
     },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.0.0-beta.3",
+  "version": "4.0.0-beta.31",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "main": "./lib/index.js",
@@ -35,5 +35,5 @@
     "lodash": "4.17.21",
     "umzug": "2.3.0"
   },
-  "gitHead": "5501518e6c4290f6b285f7fd065953381a61b08a"
+  "gitHead": "965d27fa02fd6908db602a25069795f304167f2c"
 }