@strapi/database 4.0.0-next.9 → 4.0.0

package/lib/dialects/dialect.js

@@ -0,0 +1,45 @@
+'use strict';
+
+class Dialect {
+  constructor(db) {
+    this.db = db;
+  }
+
+  configure() {}
+  initialize() {}
+
+  getSqlType(type) {
+    return type;
+  }
+
+  canAlterConstraints() {
+    return true;
+  }
+
+  usesForeignKeys() {
+    return false;
+  }
+
+  useReturning() {
+    return false;
+  }
+
+  supportsUnsigned() {
+    return false;
+  }
+
+  async startSchemaUpdate() {}
+  async endSchemaUpdate() {}
+
+  transformErrors(error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error(error.message);
+  }
+}
+
+module.exports = {
+  Dialect,
+};

package/lib/dialects/index.js

@@ -1,120 +1,13 @@
 'use strict';
 
-const path = require('path');
-const fse = require('fs-extra');
-
-const errors = require('../errors');
-
-class Dialect {
-  constructor(db) {
-    this.db = db;
-  }
-
-  usesForeignKeys() {
-    return false;
-  }
-
-  useReturning() {
-    return false;
-  }
-
-  // TODO: pass query info to display some more metadata
-  transformErrors(error) {
-    if (error instanceof Error) {
-      throw error;
-    }
-
-    throw new Error(error.message);
-  }
-}
-class PostgresDialect extends Dialect {
-  useReturning() {
-    return true;
-  }
-
-  initialize() {
-    // FIXME:
-    // this.db.connection.context.client.types.setTypeParser(1700, 'text', parseFloat);
-  }
-
-  usesForeignKeys() {
-    return false;
-  }
-
-  transformErrors(error) {
-    switch (error.code) {
-      case '23502': {
-        throw new errors.NotNullConstraint({ column: error.column });
-      }
-      default: {
-        super.transformErrors(error);
-      }
-    }
-  }
-}
-
-class MysqlDialect extends Dialect {
-  initialize() {
-    this.db.config.connection.connection.supportBigNumbers = true;
-    this.db.config.connection.connection.bigNumberStrings = true;
-    this.db.config.connection.connection.typeCast = (field, next) => {
-      if (field.type == 'DECIMAL' || field.type === 'NEWDECIMAL') {
-        var value = field.string();
-        return value === null ? null : Number(value);
-      }
-
-      if (field.type == 'TINY' && field.length == 1) {
-        let value = field.string();
-        return value ? value == '1' : null;
-      }
-      return next();
-    };
-  }
-
-  usesForeignKeys() {
-    return false;
-  }
-
-  transformErrors(error) {
-    super.transformErrors(error);
-  }
-}
-
-class SqliteDialect extends Dialect {
-  async initialize() {
-    // Create the directory if it does not exist.
-
-    // TODO: get strapi.dir from somewhere else
-
-    this.db.config.connection.connection.filename = path.resolve(
-      this.db.config.connection.connection.filename
-    );
-
-    const dbDir = path.dirname(this.db.config.connection.connection.filename);
-
-    await fse.ensureDir(dbDir);
-  }
-
-  transformErrors(error) {
-    switch (error.errno) {
-      case 19: {
-        throw new errors.NotNullConstraint(); // TODO: extract column name
-      }
-      default: {
-        super.transformErrors(error);
-      }
-    }
-  }
-}
-
-const createDialect = (db, client) => {
+const getDialectClass = client => {
   switch (client) {
     case 'postgres':
-      return new PostgresDialect(db);
+      return require('./postgresql');
     case 'mysql':
-      return new MysqlDialect(db);
+      return require('./mysql');
     case 'sqlite':
-      return new SqliteDialect(db);
+      return require('./sqlite');
     default:
       throw new Error(`Unknow dialect ${client}`);
   }
@@ -123,7 +16,8 @@ const createDialect = (db, client) => {
 const getDialect = db => {
   const { client } = db.config.connection;
 
-  const dialect = createDialect(db, client);
+  const constructor = getDialectClass(client);
+  const dialect = new constructor(db);
   dialect.client = client;
 
   return dialect;

package/lib/dialects/mysql/index.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { Dialect } = require('../dialect');
+const MysqlSchemaInspector = require('./schema-inspector');
+
+class MysqlDialect extends Dialect {
+  constructor(db) {
+    super(db);
+
+    this.schemaInspector = new MysqlSchemaInspector(db);
+  }
+
+  configure() {
+    this.db.config.connection.connection.supportBigNumbers = true;
+    this.db.config.connection.connection.bigNumberStrings = true;
+    this.db.config.connection.connection.typeCast = (field, next) => {
+      if (field.type == 'DECIMAL' || field.type === 'NEWDECIMAL') {
+        var value = field.string();
+        return value === null ? null : Number(value);
+      }
+
+      if (field.type == 'TINY' && field.length == 1) {
+        let value = field.string();
+        return value ? value == '1' : null;
+      }
+      return next();
+    };
+  }
+
+  async startSchemaUpdate() {
+    await this.db.connection.raw(`set foreign_key_checks = 0;`);
+  }
+
+  async endSchemaUpdate() {
+    await this.db.connection.raw(`set foreign_key_checks = 1;`);
+  }
+
+  supportsUnsigned() {
+    return true;
+  }
+
+  usesForeignKeys() {
+    return true;
+  }
+
+  transformErrors(error) {
+    super.transformErrors(error);
+  }
+}
+
+module.exports = MysqlDialect;

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

@@ -0,0 +1,199 @@
+'use strict';
+
+const SQL_QUERIES = {
+  TABLE_LIST: /* sql */ `
+    SELECT
+      t.table_name as table_name
+    FROM information_schema.tables t
+    WHERE table_type = 'BASE TABLE'
+    AND table_schema = schema();
+  `,
+  LIST_COLUMNS: /* sql */ `
+    SELECT
+      c.data_type as data_type,
+      c.column_name as column_name,
+      c.character_maximum_length as character_maximum_length,
+      c.column_default as column_default,
+      c.is_nullable as is_nullable,
+      c.column_type as column_type,
+      c.column_key as column_key
+    FROM information_schema.columns c
+    WHERE table_schema = database()
+    AND table_name = ?;
+  `,
+  INDEX_LIST: /* sql */ `
+    show index from ??;
+  `,
+  FOREIGN_KEY_LIST: /* sql */ `
+    SELECT
+      tc.constraint_name as constraint_name,
+      kcu.column_name as column_name,
+      kcu.referenced_table_name as referenced_table_name,
+      kcu.referenced_column_name as referenced_column_name,
+      rc.update_rule as on_update,
+      rc.delete_rule as on_delete
+    FROM information_schema.table_constraints tc
+    INNER JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name
+    INNER JOIN information_schema.referential_constraints AS rc ON kcu.constraint_name = rc.constraint_name
+    WHERE constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema = database()
+    AND tc.table_name = ?;
+
+  `,
+};
+
+const toStrapiType = column => {
+  const rootType = column.data_type.toLowerCase().match(/[^(), ]+/)[0];
+
+  switch (rootType) {
+    case 'int': {
+      if (column.column_key === 'PRI') {
+        return { type: 'increments', args: [{ primary: true }], unsigned: false };
+      }
+
+      return { type: 'integer' };
+    }
+    case 'decimal': {
+      return { type: 'decimal', args: [10, 2] };
+    }
+    case 'double': {
+      return { type: 'double' };
+    }
+    case 'bigint': {
+      return { type: 'bigInteger' };
+    }
+    case 'enum': {
+      return { type: 'enum' };
+    }
+    case 'tinyint': {
+      return { type: 'boolean' };
+    }
+    case 'longtext': {
+      return { type: 'text', args: ['longtext'] };
+    }
+    case 'varchar': {
+      return { type: 'string', args: [column.character_maximum_length] };
+    }
+    case 'datetime': {
+      return { type: 'datetime', args: [{ useTz: false, precision: 6 }] };
+    }
+    case 'date': {
+      return { type: 'date' };
+    }
+    case 'time': {
+      return { type: 'time', args: [{ precision: 3 }] };
+    }
+    case 'timestamp': {
+      return { type: 'timestamp', args: [{ useTz: false, precision: 6 }] };
+    }
+    case 'json': {
+      return { type: 'jsonb' };
+    }
+    default: {
+      return { type: 'specificType', args: [column.data_type] };
+    }
+  }
+};
+
+class MysqlSchemaInspector {
+  constructor(db) {
+    this.db = db;
+  }
+
+  async getSchema() {
+    const schema = { tables: [] };
+
+    const tables = await this.getTables();
+
+    schema.tables = await Promise.all(
+      tables.map(async tableName => {
+        const columns = await this.getColumns(tableName);
+        const indexes = await this.getIndexes(tableName);
+        const foreignKeys = await this.getForeignKeys(tableName);
+
+        return {
+          name: tableName,
+          columns,
+          indexes,
+          foreignKeys,
+        };
+      })
+    );
+
+    return schema;
+  }
+
+  async getTables() {
+    const [rows] = await this.db.connection.raw(SQL_QUERIES.TABLE_LIST);
+
+    return rows.map(row => row.table_name);
+  }
+
+  async getColumns(tableName) {
+    const [rows] = await this.db.connection.raw(SQL_QUERIES.LIST_COLUMNS, [tableName]);
+
+    return rows.map(row => {
+      const { type, args = [], ...rest } = toStrapiType(row);
+
+      return {
+        type,
+        args,
+        defaultTo: row.column_default,
+        name: row.column_name,
+        notNullable: row.is_nullable === 'NO',
+        unsigned: row.column_type.endsWith(' unsigned'),
+        ...rest,
+      };
+    });
+  }
+
+  async getIndexes(tableName) {
+    const [rows] = await this.db.connection.raw(SQL_QUERIES.INDEX_LIST, [tableName]);
+
+    const ret = {};
+
+    for (const index of rows) {
+      if (index.Column_name === 'id') {
+        continue;
+      }
+
+      if (!ret[index.Key_name]) {
+        ret[index.Key_name] = {
+          columns: [index.Column_name],
+          name: index.Key_name,
+          type: !index.Non_unique ? 'unique' : null,
+        };
+      } else {
+        ret[index.Key_name].columns.push(index.Column_name);
+      }
+    }
+
+    return Object.values(ret);
+  }
+
+  async getForeignKeys(tableName) {
+    const [rows] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_LIST, [tableName]);
+
+    const ret = {};
+
+    for (const fk of rows) {
+      if (!ret[fk.constraint_name]) {
+        ret[fk.constraint_name] = {
+          name: fk.constraint_name,
+          columns: [fk.column_name],
+          referencedColumns: [fk.referenced_column_name],
+          referencedTable: fk.referenced_table_name,
+          onUpdate: fk.on_update.toUpperCase(),
+          onDelete: fk.on_delete.toUpperCase(),
+        };
+      } else {
+        ret[fk.constraint_name].columns.push(fk.column_name);
+        ret[fk.constraint_name].referencedColumns.push(fk.referenced_column_name);
+      }
+    }
+
+    return Object.values(ret);
+  }
+}
+
+module.exports = MysqlSchemaInspector;

package/lib/dialects/postgresql/index.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const errors = require('../../errors');
+const { Dialect } = require('../dialect');
+const PostgresqlSchemaInspector = require('./schema-inspector');
+
+class PostgresDialect extends Dialect {
+  constructor(db) {
+    super(db);
+
+    this.schemaInspector = new PostgresqlSchemaInspector(db);
+  }
+
+  useReturning() {
+    return true;
+  }
+
+  initialize() {
+    this.db.connection.client.driver.types.setTypeParser(1700, 'text', parseFloat);
+  }
+
+  usesForeignKeys() {
+    return true;
+  }
+
+  getSqlType(type) {
+    switch (type) {
+      case 'timestamp': {
+        return 'datetime';
+      }
+      default: {
+        return type;
+      }
+    }
+  }
+
+  transformErrors(error) {
+    switch (error.code) {
+      case '23502': {
+        throw new errors.NotNullConstraint({ column: error.column });
+      }
+      default: {
+        super.transformErrors(error);
+      }
+    }
+  }
+}
+
+module.exports = PostgresDialect;

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

@@ -0,0 +1,232 @@
+'use strict';
+
+const SQL_QUERIES = {
+  TABLE_LIST: /* sql */ `
+    SELECT *
+    FROM information_schema.tables
+    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 = ?;
+  `,
+  INDEX_LIST: /* sql */ `
+    SELECT
+      ix.indexrelid,
+      i.relname as index_name,
+      a.attname as column_name,
+      ix.indisunique as is_unique,
+      ix.indisprimary as is_primary
+    FROM
+      pg_class t,
+      pg_namespace s,
+      pg_class i,
+      pg_index ix,
+      pg_attribute a
+    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 = ?;
+  `,
+  FOREIGN_KEY_LIST: /* sql */ `
+    SELECT
+      tco."constraint_name" as constraint_name,
+      kcu."column_name" as column_name,
+      rel_kcu."table_name" as foreign_table,
+      rel_kcu."column_name" as fk_column_name,
+      rco.update_rule as on_update,
+      rco.delete_rule as on_delete
+    FROM information_schema.table_constraints tco
+    JOIN information_schema.key_column_usage kcu
+      ON tco.constraint_schema = kcu.constraint_schema
+      AND tco.constraint_name = kcu.constraint_name
+    JOIN information_schema.referential_constraints rco
+      ON tco.constraint_schema = rco.constraint_schema
+      AND tco.constraint_name = rco.constraint_name
+    JOIN information_schema.key_column_usage rel_kcu
+      ON rco.unique_constraint_schema = rel_kcu.constraint_schema
+      AND rco.unique_constraint_name = rel_kcu.constraint_name
+      AND kcu.ordinal_position = rel_kcu.ordinal_position
+    WHERE
+      tco.constraint_type = 'FOREIGN KEY'
+      AND tco.constraint_schema = ?
+      AND tco.table_name = ?
+    ORDER BY kcu.table_schema, kcu.table_name, kcu.ordinal_position, kcu.constraint_name;
+  `,
+};
+
+const toStrapiType = column => {
+  const rootType = column.data_type.toLowerCase().match(/[^(), ]+/)[0];
+
+  switch (rootType) {
+    case 'integer': {
+      // find a way to figure out the increments
+      return { type: 'integer' };
+    }
+    case 'text': {
+      return { type: 'text', args: ['longtext'] };
+    }
+    case 'boolean': {
+      return { type: 'boolean' };
+    }
+    case 'character': {
+      return { type: 'string', args: [column.character_maximum_length] };
+    }
+    case 'timestamp': {
+      return { type: 'datetime', args: [{ useTz: false, precision: 6 }] };
+    }
+    case 'date': {
+      return { type: 'date' };
+    }
+    case 'time': {
+      return { type: 'time', args: [{ precision: 3 }] };
+    }
+    case 'numeric': {
+      return { type: 'decimal', args: [10, 2] };
+    }
+    case 'real':
+    case 'double': {
+      return { type: 'double' };
+    }
+    case 'bigint': {
+      return { type: 'bigInteger' };
+    }
+    case 'jsonb': {
+      return { type: 'jsonb' };
+    }
+    default: {
+      return { type: 'specificType', args: [column.data_type] };
+    }
+  }
+};
+
+class PostgresqlSchemaInspector {
+  constructor(db) {
+    this.db = db;
+  }
+
+  async getSchema() {
+    const schema = { tables: [] };
+
+    const tables = await this.getTables();
+
+    schema.tables = await Promise.all(
+      tables.map(async tableName => {
+        const columns = await this.getColumns(tableName);
+        const indexes = await this.getIndexes(tableName);
+        const foreignKeys = await this.getForeignKeys(tableName);
+
+        return {
+          name: tableName,
+          columns,
+          indexes,
+          foreignKeys,
+        };
+      })
+    );
+
+    return schema;
+  }
+
+  getDatabaseSchema() {
+    return this.db.connection.getSchemaName() || 'public';
+  }
+
+  async getTables() {
+    const { rows } = await this.db.connection.raw(SQL_QUERIES.TABLE_LIST, [
+      this.getDatabaseSchema(),
+    ]);
+
+    return rows.map(row => row.table_name);
+  }
+
+  async getColumns(tableName) {
+    const { rows } = await this.db.connection.raw(SQL_QUERIES.LIST_COLUMNS, [
+      this.getDatabaseSchema(),
+      tableName,
+    ]);
+
+    return rows.map(row => {
+      const { type, args = [], ...rest } = toStrapiType(row);
+
+      const defaultTo =
+        row.column_default && row.column_default.includes('nextval(') ? null : row.column_default;
+
+      return {
+        type,
+        args,
+        defaultTo,
+        name: row.column_name,
+        notNullable: row.is_nullable === 'NO',
+        unsigned: false,
+        ...rest,
+      };
+    });
+  }
+
+  async getIndexes(tableName) {
+    const { rows } = await this.db.connection.raw(SQL_QUERIES.INDEX_LIST, [
+      this.getDatabaseSchema(),
+      tableName,
+    ]);
+
+    const ret = {};
+
+    for (const index of rows) {
+      if (index.column_name === 'id') {
+        continue;
+      }
+
+      if (!ret[index.indexrelid]) {
+        ret[index.indexrelid] = {
+          columns: [index.column_name],
+          name: index.index_name,
+          type: index.is_primary ? 'primary' : index.is_unique ? 'unique' : null,
+        };
+      } else {
+        ret[index.indexrelid].columns.push(index.column_name);
+      }
+    }
+
+    return Object.values(ret);
+  }
+
+  async getForeignKeys(tableName) {
+    const { rows } = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_LIST, [
+      this.getDatabaseSchema(),
+      tableName,
+    ]);
+
+    const ret = {};
+
+    for (const fk of rows) {
+      if (!ret[fk.constraint_name]) {
+        ret[fk.constraint_name] = {
+          name: fk.constraint_name,
+          columns: [fk.column_name],
+          referencedColumns: [fk.fk_column_name],
+          referencedTable: fk.foreign_table,
+          onUpdate: fk.on_update.toUpperCase(),
+          onDelete: fk.on_delete.toUpperCase(),
+        };
+      } else {
+        ret[fk.constraint_name].columns.push(fk.column_name);
+        ret[fk.constraint_name].referencedColumns.push(fk.fk_column_name);
+      }
+    }
+
+    return Object.values(ret);
+  }
+}
+
+module.exports = PostgresqlSchemaInspector;