@strapi/database 4.15.0-alpha.0 → 4.15.1

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

@@ -1,283 +0,0 @@
-'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
-    FROM information_schema.table_constraints tco
-    WHERE
-      tco.constraint_type = 'FOREIGN KEY'
-      AND tco.constraint_schema = ?
-      AND tco.table_name = ?
-  `,
-  FOREIGN_KEY_REFERENCES: /* sql */ `
-    SELECT
-      kcu."constraint_name" as constraint_name,
-      kcu."column_name" as column_name
-
-    FROM information_schema.key_column_usage kcu
-    WHERE kcu.constraint_name=ANY(?)
-    AND kcu.table_schema = ?
-    AND kcu.table_name = ?;
-  `,
-
-  FOREIGN_KEY_REFERENCES_CONSTRAIN: /* sql */ `
-  SELECT
-  rco.update_rule as on_update,
-  rco.delete_rule as on_delete,
-  rco."unique_constraint_name" as unique_constraint_name
-  FROM information_schema.referential_constraints rco
-  WHERE rco.constraint_name=ANY(?)
-  AND rco.constraint_schema = ?
-`,
-  FOREIGN_KEY_REFERENCES_CONSTRAIN_RFERENCE: /* sql */ `
-  SELECT
-  rel_kcu."table_name" as foreign_table,
-  rel_kcu."column_name" as fk_column_name
-    FROM information_schema.key_column_usage rel_kcu
-    WHERE rel_kcu.constraint_name=?
-    AND rel_kcu.table_schema = ?
-`,
-};
-
-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] };
-    }
-  }
-};
-
-const getIndexType = (index) => {
-  if (index.is_primary) {
-    return 'primary';
-  }
-
-  if (index.is_unique) {
-    return 'unique';
-  }
-
-  return null;
-};
-
-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: getIndexType(index),
-        };
-      } 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) {
-      ret[fk.constraint_name] = {
-        name: fk.constraint_name,
-        columns: [],
-        referencedColumns: [],
-        referencedTable: null,
-        onUpdate: null,
-        onDelete: null,
-      };
-    }
-    const constraintNames = Object.keys(ret);
-    const dbSchema = this.getDatabaseSchema();
-    if (constraintNames.length > 0) {
-      const { rows: fkReferences } = await this.db.connection.raw(
-        SQL_QUERIES.FOREIGN_KEY_REFERENCES,
-        [[constraintNames], dbSchema, tableName]
-      );
-
-      for (const fkReference of fkReferences) {
-        ret[fkReference.constraint_name].columns.push(fkReference.column_name);
-
-        const { rows: fkReferencesConstraint } = await this.db.connection.raw(
-          SQL_QUERIES.FOREIGN_KEY_REFERENCES_CONSTRAIN,
-          [[fkReference.constraint_name], dbSchema]
-        );
-
-        for (const fkReferenceC of fkReferencesConstraint) {
-          const { rows: fkReferencesConstraintReferece } = await this.db.connection.raw(
-            SQL_QUERIES.FOREIGN_KEY_REFERENCES_CONSTRAIN_RFERENCE,
-            [fkReferenceC.unique_constraint_name, dbSchema]
-          );
-          for (const fkReferenceConst of fkReferencesConstraintReferece) {
-            ret[fkReference.constraint_name].referencedTable = fkReferenceConst.foreign_table;
-            ret[fkReference.constraint_name].referencedColumns.push(
-              fkReferenceConst.fk_column_name
-            );
-          }
-          ret[fkReference.constraint_name].onUpdate = fkReferenceC.on_update.toUpperCase();
-          ret[fkReference.constraint_name].onDelete = fkReferenceC.on_delete.toUpperCase();
-        }
-      }
-    }
-
-    return Object.values(ret);
-  }
-}
-
-module.exports = PostgresqlSchemaInspector;

package/lib/dialects/sqlite/index.js

@@ -1,87 +0,0 @@
-'use strict';
-
-const path = require('path');
-const fse = require('fs-extra');
-
-const errors = require('../../errors');
-const { Dialect } = require('../dialect');
-const SqliteSchemaInspector = require('./schema-inspector');
-
-const UNSUPPORTED_OPERATORS = ['$jsonSupersetOf'];
-
-class SqliteDialect extends Dialect {
-  constructor(db) {
-    super(db);
-
-    this.schemaInspector = new SqliteSchemaInspector(db);
-  }
-
-  configure() {
-    this.db.config.connection.connection.filename = path.resolve(
-      this.db.config.connection.connection.filename
-    );
-
-    const dbDir = path.dirname(this.db.config.connection.connection.filename);
-
-    fse.ensureDirSync(dbDir);
-  }
-
-  useReturning() {
-    return true;
-  }
-
-  async initialize() {
-    await this.db.connection.raw('pragma foreign_keys = on');
-  }
-
-  canAlterConstraints() {
-    return false;
-  }
-
-  getSqlType(type) {
-    switch (type) {
-      case 'enum': {
-        return 'text';
-      }
-      case 'double':
-      case 'decimal': {
-        return 'float';
-      }
-      case 'timestamp': {
-        return 'datetime';
-      }
-      default: {
-        return type;
-      }
-    }
-  }
-
-  supportsOperator(operator) {
-    return !UNSUPPORTED_OPERATORS.includes(operator);
-  }
-
-  async startSchemaUpdate() {
-    await this.db.connection.raw(`pragma foreign_keys = off`);
-  }
-
-  async endSchemaUpdate() {
-    await this.db.connection.raw(`pragma foreign_keys = on`);
-  }
-
-  transformErrors(error) {
-    switch (error.errno) {
-      case 19: {
-        throw new errors.NotNullError(); // TODO: extract column name
-      }
-      default: {
-        super.transformErrors(error);
-      }
-    }
-  }
-
-  canAddIncrements() {
-    return false;
-  }
-}
-
-module.exports = SqliteDialect;

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

@@ -1,151 +0,0 @@
-'use strict';
-
-const SQL_QUERIES = {
-  TABLE_LIST: `select name from sqlite_master where type = 'table' and name NOT LIKE 'sqlite%'`,
-  TABLE_INFO: `pragma table_info(??)`,
-  INDEX_LIST: 'pragma index_list(??)',
-  INDEX_INFO: 'pragma index_info(??)',
-  FOREIGN_KEY_LIST: 'pragma foreign_key_list(??)',
-};
-
-const toStrapiType = (column) => {
-  const { type } = column;
-
-  const rootType = type.toLowerCase().match(/[^(), ]+/)[0];
-
-  switch (rootType) {
-    case 'integer': {
-      if (column.pk) {
-        return { type: 'increments', args: [{ primary: true, primaryKey: true }] };
-      }
-
-      return { type: 'integer' };
-    }
-    case 'float': {
-      return { type: 'float', args: [10, 2] };
-    }
-    case 'bigint': {
-      return { type: 'bigInteger' };
-    }
-    case 'varchar': {
-      const length = type.slice(8, type.length - 1);
-
-      return { type: 'string', args: [Number(length)] };
-    }
-    case 'text': {
-      return { type: 'text', args: ['longtext'] };
-    }
-    case 'json': {
-      return { type: 'jsonb' };
-    }
-    case 'boolean': {
-      return { type: 'boolean' };
-    }
-    case 'datetime': {
-      return { type: 'datetime', args: [{ useTz: false, precision: 6 }] };
-    }
-    case 'date': {
-      return { type: 'date' };
-    }
-    case 'time': {
-      return { type: 'time', args: [{ precision: 3 }] };
-    }
-    default: {
-      return { type: 'specificType', args: [column.data_type] };
-    }
-  }
-};
-
-class SqliteSchemaInspector {
-  constructor(db) {
-    this.db = db;
-  }
-
-  async getSchema() {
-    const schema = { tables: [] };
-    const tables = await this.getTables();
-
-    for (const tableName of tables) {
-      const columns = await this.getColumns(tableName);
-      const indexes = await this.getIndexes(tableName);
-      const foreignKeys = await this.getForeignKeys(tableName);
-
-      schema.tables.push({
-        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.name);
-  }
-
-  async getColumns(tableName) {
-    const rows = await this.db.connection.raw(SQL_QUERIES.TABLE_INFO, [tableName]);
-
-    return rows.map((row) => {
-      const { type, args = [], ...rest } = toStrapiType(row);
-
-      return {
-        type,
-        args,
-        name: row.name,
-        defaultTo: row.dflt_value,
-        notNullable: row.notnull !== null ? Boolean(row.notnull) : null,
-        unsigned: false,
-        ...rest,
-      };
-    });
-  }
-
-  async getIndexes(tableName) {
-    const indexes = await this.db.connection.raw(SQL_QUERIES.INDEX_LIST, [tableName]);
-
-    const ret = [];
-
-    for (const index of indexes.filter((index) => !index.name.startsWith('sqlite_'))) {
-      const res = await this.db.connection.raw(SQL_QUERIES.INDEX_INFO, [index.name]);
-
-      ret.push({
-        columns: res.map((row) => row.name),
-        name: index.name,
-        type: index.unique ? 'unique' : null,
-      });
-    }
-
-    return ret;
-  }
-
-  async getForeignKeys(tableName) {
-    const fks = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_LIST, [tableName]);
-
-    const ret = {};
-
-    for (const fk of fks) {
-      if (!ret[fk.id]) {
-        ret[fk.id] = {
-          // TODO: name, //  find name
-          columns: [fk.from],
-          referencedColumns: [fk.to],
-          referencedTable: fk.table,
-          onUpdate: fk.on_update.toUpperCase(),
-          onDelete: fk.on_delete.toUpperCase(),
-        };
-      } else {
-        ret[fk.id].columns.push(fk.from);
-        ret[fk.id].referencedColumns.push(fk.to);
-      }
-    }
-
-    return Object.values(ret);
-  }
-}
-
-module.exports = SqliteSchemaInspector;

package/lib/entity-manager/__tests__/relations-orderer.test.js

@@ -1,186 +0,0 @@
-'use strict';
-
-const { relationsOrderer } = require('../relations-orderer');
-
-describe('Given I have some relations in the database', () => {
-  describe('When I connect a relation at the end', () => {
-    test('Then it is placed at the end with the correct order', () => {
-      const orderer = relationsOrderer(
-        [
-          { id: 2, order: 4 },
-          { id: 3, order: 10 },
-        ],
-        'id',
-        'order'
-      );
-
-      orderer.connect([{ id: 4, position: { end: true } }, { id: 5 }]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 2, order: 4 },
-        { id: 3, order: 10 },
-        { id: 4, order: 10.5 },
-        { id: 5, order: 10.5 },
-      ]);
-    });
-  });
-
-  describe('When I connect a relation at the start', () => {
-    test('Then it is placed at the start with the correct order', () => {
-      const orderer = relationsOrderer(
-        [
-          { id: 2, order: 4 },
-          { id: 3, order: 10 },
-        ],
-        'id',
-        'order'
-      );
-
-      orderer.connect([{ id: 4, position: { start: true } }]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 4, order: 0.5 },
-        { id: 2, order: 4 },
-        { id: 3, order: 10 },
-      ]);
-    });
-  });
-
-  describe('When I connect multiple relations using before', () => {
-    test('Then they are correctly ordered', () => {
-      const orderer = relationsOrderer(
-        [
-          { id: 2, order: 4 },
-          { id: 3, order: 10 },
-        ],
-        'id',
-        'order'
-      );
-
-      orderer.connect([
-        { id: 4, position: { before: 3 } },
-        { id: 5, position: { before: 4 } },
-      ]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 2, order: 4 },
-        { id: 5, order: 9.5 },
-        { id: 4, order: 9.5 },
-        { id: 3, order: 10 },
-      ]);
-    });
-  });
-
-  describe('When you connect multiple disordered relations', () => {
-    test('Then they are correctly ordered', () => {
-      const orderer = relationsOrderer(
-        [
-          { id: 1, order: 1 },
-          { id: 2, order: 2 },
-          { id: 3, order: 3 },
-        ],
-        'id',
-        'order'
-      );
-
-      orderer.connect([
-        { id: 5, position: { before: 1 } },
-        { id: 1, position: { before: 2 } },
-        { id: 2, position: { end: true } },
-      ]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 5, order: 0.5 },
-        { id: 1, order: 1.5 },
-        { id: 3, order: 3 },
-        { id: 2, order: 3.5 },
-      ]);
-    });
-  });
-
-  describe('When you connect a relation before a non-existing relation in non-strict mode', () => {
-    test('Then it is placed at the end', () => {
-      const orderer = relationsOrderer(
-        [
-          { id: 1, order: 1 },
-          { id: 2, order: 2 },
-          { id: 3, order: 3 },
-        ],
-        'id',
-        'order',
-        false
-      );
-
-      orderer.connect([{ id: 4, position: { before: 5 } }]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 1, order: 1 },
-        { id: 2, order: 2 },
-        { id: 3, order: 3 },
-        { id: 4, order: 3.5 },
-      ]);
-    });
-  });
-
-  describe('When you connect a relation before one with null order', () => {
-    test('Then it replaces null order values to 1 and properly reorders relations', () => {
-      const orderer = relationsOrderer(
-        [
-          { id: 2, order: null },
-          { id: 3, order: null },
-        ],
-        'id',
-        'order'
-      );
-
-      orderer.connect([{ id: 4, position: { before: 3 } }, { id: 5 }]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 2, order: 1 },
-        { id: 4, order: 0.5 },
-        { id: 3, order: 1 },
-        { id: 5, order: 1.5 },
-      ]);
-    });
-  });
-});
-
-describe('Given there are no relations in the database', () => {
-  describe('When you connect multiple new relations', () => {
-    test('Then they are correctly ordered', () => {
-      const orderer = relationsOrderer([], 'id', 'order');
-
-      orderer.connect([
-        { id: 1, position: { start: true } },
-        { id: 2, position: { start: true } },
-        { id: 3, position: { after: 1 } },
-      ]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 2, order: 0.5 },
-        { id: 1, order: 0.5 },
-        { id: 3, order: 0.5 },
-      ]);
-    });
-  });
-
-  describe('When you connect multiple disordered relations', () => {
-    test('Then they are correctly ordered', () => {
-      const orderer = relationsOrderer([], 'id', 'order');
-
-      orderer.connect([
-        { id: 5, position: { before: 1 } },
-        { id: 1, position: { before: 2 } },
-        { id: 2, position: { end: true } },
-        { id: 3, position: { after: 1 } },
-      ]);
-
-      expect(orderer.get()).toMatchObject([
-        { id: 5, order: 0.5 },
-        { id: 1, order: 0.5 },
-        { id: 3, order: 0.5 },
-        { id: 2, order: 0.5 },
-      ]);
-    });
-  });
-});