@strapi/database 4.14.3 → 4.14.5

package/lib/connection.js

@@ -1,64 +0,0 @@
-/* eslint-disable import/no-extraneous-dependencies */
-
-'use strict';
-
-const knex = require('knex');
-
-const SqliteClient = require('knex/lib/dialects/sqlite3/index');
-
-const trySqlitePackage = (packageName) => {
-  try {
-    require.resolve(packageName);
-    return packageName;
-  } catch (error) {
-    if (error.code === 'MODULE_NOT_FOUND') {
-      return false;
-    }
-    throw error;
-  }
-};
-class LegacySqliteClient extends SqliteClient {
-  _driver() {
-    return require('sqlite3');
-  }
-}
-
-const clientMap = {
-  'better-sqlite3': 'better-sqlite3',
-  '@vscode/sqlite3': 'sqlite',
-  sqlite3: LegacySqliteClient,
-};
-
-const getSqlitePackageName = () => {
-  // NOTE: allow forcing the package to use (mostly used for testing purposes)
-  if (typeof process.env.SQLITE_PKG !== 'undefined') {
-    return process.env.SQLITE_PKG;
-  }
-
-  // NOTE: this tries to find the best sqlite module possible to use
-  // while keeping retro compatibility
-  return (
-    trySqlitePackage('better-sqlite3') ||
-    trySqlitePackage('@vscode/sqlite3') ||
-    trySqlitePackage('sqlite3')
-  );
-};
-
-const createConnection = (config) => {
-  const knexConfig = { ...config };
-  if (knexConfig.client === 'sqlite') {
-    const sqlitePackageName = getSqlitePackageName();
-
-    knexConfig.client = clientMap[sqlitePackageName];
-  }
-
-  const knexInstance = knex(knexConfig);
-
-  return Object.assign(knexInstance, {
-    getSchemaName() {
-      return this.client.connectionSettings.schema;
-    },
-  });
-};
-
-module.exports = createConnection;

package/lib/dialects/dialect.js

@@ -1,63 +0,0 @@
-'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;
-  }
-
-  supportsWindowFunctions() {
-    return true;
-  }
-
-  supportsOperator() {
-    return true;
-  }
-
-  async startSchemaUpdate() {
-    // noop
-  }
-
-  async endSchemaUpdate() {
-    // noop
-  }
-
-  transformErrors(error) {
-    if (error instanceof Error) {
-      throw error;
-    }
-
-    throw new Error(error.message);
-  }
-
-  canAddIncrements() {
-    return true;
-  }
-}
-
-module.exports = {
-  Dialect,
-};

package/lib/dialects/index.js

@@ -1,53 +0,0 @@
-'use strict';
-
-/**
- * Require our dialect-specific code
- */
-const getDialectClass = (client) => {
-  switch (client) {
-    case 'postgres':
-      return require('./postgresql');
-    case 'mysql':
-      return require('./mysql');
-    case 'sqlite':
-      return require('./sqlite');
-    default:
-      throw new Error(`Unknown dialect ${client}`);
-  }
-};
-
-/**
- * Get the dialect of a database client
- *
- * @param {string} The client value from a project database configuration
- * @returns {string} The dialect of that client
- */
-const getDialectName = (client) => {
-  switch (client) {
-    case 'postgres':
-      return 'postgres';
-    case 'mysql':
-    case 'mysql2':
-      return 'mysql';
-    case 'sqlite':
-    case 'sqlite-legacy':
-      return 'sqlite';
-    default:
-      throw new Error(`Unknown dialect ${client}`);
-  }
-};
-
-const getDialect = (db) => {
-  const { client } = db.config.connection;
-  const dialectName = getDialectName(client);
-
-  const constructor = getDialectClass(dialectName);
-  const dialect = new constructor(db);
-  dialect.client = dialectName;
-
-  return dialect;
-};
-
-module.exports = {
-  getDialect,
-};

package/lib/dialects/mysql/constants.js

@@ -1,6 +0,0 @@
-'use strict';
-
-module.exports = {
-  MYSQL: 'MYSQL',
-  MARIADB: 'MARIADB',
-};

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

@@ -1,37 +0,0 @@
-'use strict';
-
-const { MARIADB, MYSQL } = require('./constants');
-
-const SQL_QUERIES = {
-  VERSION: `SELECT version() as version`,
-};
-
-class MysqlDatabaseInspector {
-  constructor(db) {
-    this.db = db;
-  }
-
-  async getInformation() {
-    let database;
-    let versionNumber;
-    try {
-      const [results] = await this.db.connection.raw(SQL_QUERIES.VERSION);
-      const versionSplit = results[0].version.split('-');
-      const databaseName = versionSplit[1];
-      versionNumber = versionSplit[0];
-      database = databaseName && databaseName.toLowerCase() === 'mariadb' ? MARIADB : MYSQL;
-    } catch (e) {
-      return {
-        database: null,
-        version: null,
-      };
-    }
-
-    return {
-      database,
-      version: versionNumber,
-    };
-  }
-}
-
-module.exports = MysqlDatabaseInspector;

package/lib/dialects/mysql/index.js

@@ -1,92 +0,0 @@
-'use strict';
-
-const semver = require('semver');
-
-const { Dialect } = require('../dialect');
-const MysqlSchemaInspector = require('./schema-inspector');
-const MysqlDatabaseInspector = require('./database-inspector');
-const { MYSQL } = require('./constants');
-
-class MysqlDialect extends Dialect {
-  constructor(db) {
-    super(db);
-
-    this.schemaInspector = new MysqlSchemaInspector(db);
-    this.databaseInspector = new MysqlDatabaseInspector(db);
-    this.info = null;
-  }
-
-  configure() {
-    this.db.config.connection.connection.supportBigNumbers = true;
-    // Only allow bigNumberStrings option set to be true if no connection option passed
-    // Otherwise bigNumberStrings option should be allowed to used from DB config
-    if (this.db.config.connection.connection.bigNumberStrings === undefined) {
-      this.db.config.connection.connection.bigNumberStrings = true;
-    }
-    this.db.config.connection.connection.typeCast = (field, next) => {
-      if (field.type === 'DECIMAL' || field.type === 'NEWDECIMAL') {
-        const value = field.string();
-        return value === null ? null : Number(value);
-      }
-
-      if (field.type === 'TINY' && field.length === 1) {
-        const value = field.string();
-        return value ? value === '1' : null;
-      }
-
-      if (field.type === 'DATE') {
-        return field.string();
-      }
-
-      return next();
-    };
-  }
-
-  async initialize() {
-    try {
-      await this.db.connection.raw(`set session sql_require_primary_key = 0;`);
-    } catch (err) {
-      // Ignore error due to lack of session permissions
-    }
-
-    this.info = await this.databaseInspector.getInformation();
-  }
-
-  async startSchemaUpdate() {
-    try {
-      await this.db.connection.raw(`set foreign_key_checks = 0;`);
-      await this.db.connection.raw(`set session sql_require_primary_key = 0;`);
-    } catch (err) {
-      // Ignore error due to lack of session permissions
-    }
-  }
-
-  async endSchemaUpdate() {
-    await this.db.connection.raw(`set foreign_key_checks = 1;`);
-  }
-
-  supportsUnsigned() {
-    return true;
-  }
-
-  supportsWindowFunctions() {
-    const isMysqlDB = !this.info.database || this.info.database === MYSQL;
-    const isBeforeV8 = !semver.valid(this.info.version) || semver.lt(this.info.version, '8.0.0');
-
-    if (isMysqlDB && isBeforeV8) {
-      return false;
-    }
-
-    return true;
-  }
-
-  usesForeignKeys() {
-    return true;
-  }
-
-  transformErrors(error) {
-    super.transformErrors(error);
-  }
-}
-
-module.exports = MysqlDialect;

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

@@ -1,234 +0,0 @@
-'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
-    FROM information_schema.table_constraints tc
-    WHERE tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_schema = database()
-    AND tc.table_name = ?;
-  `,
-  FOREIGN_KEY_REFERENCES: /* sql */ `
-    SELECT
-      kcu.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
-    FROM information_schema.key_column_usage kcu
-    WHERE kcu.constraint_name in (?)
-    AND kcu.table_schema = database()
-    AND kcu.table_name = ?;
-  `,
-  FOREIGN_KEY_REFERENTIALS_CONSTRAINTS: /* sql */ `
-    SELECT
-      rc.constraint_name as constraint_name,
-      rc.update_rule as on_update,
-      rc.delete_rule as on_delete
-    FROM information_schema.referential_constraints AS rc
-    WHERE rc.constraint_name in (?)
-    AND rc.constraint_schema = database()
-    AND rc.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, primaryKey: 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: 'string' };
-    }
-    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) {
-      ret[fk.constraint_name] = {
-        name: fk.constraint_name,
-        columns: [],
-        referencedColumns: [],
-        referencedTable: null,
-        onUpdate: null,
-        onDelete: null,
-      };
-    }
-
-    const contraintNames = Object.keys(ret);
-
-    if (contraintNames.length > 0) {
-      const [fkReferences] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES, [
-        contraintNames,
-        tableName,
-      ]);
-
-      for (const fkReference of fkReferences) {
-        ret[fkReference.constraint_name].referencedTable = fkReference.referenced_table_name;
-        ret[fkReference.constraint_name].columns.push(fkReference.column_name);
-        ret[fkReference.constraint_name].referencedColumns.push(fkReference.referenced_column_name);
-      }
-
-      const [fkReferentialConstraints] = await this.db.connection.raw(
-        SQL_QUERIES.FOREIGN_KEY_REFERENTIALS_CONSTRAINTS,
-        [contraintNames, tableName]
-      );
-
-      for (const fkReferentialConstraint of fkReferentialConstraints) {
-        ret[fkReferentialConstraint.constraint_name].onUpdate =
-          fkReferentialConstraint.on_update.toUpperCase();
-        ret[fkReferentialConstraint.constraint_name].onDelete =
-          fkReferentialConstraint.on_delete.toUpperCase();
-      }
-    }
-
-    return Object.values(ret);
-  }
-}
-
-module.exports = MysqlSchemaInspector;

package/lib/dialects/postgresql/index.js

@@ -1,65 +0,0 @@
-'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;
-  }
-
-  async initialize() {
-    // Don't cast DATE string to Date()
-    this.db.connection.client.driver.types.setTypeParser(
-      this.db.connection.client.driver.types.builtins.DATE,
-      'text',
-      (v) => v
-    );
-    // Don't parse JSONB automatically
-    this.db.connection.client.driver.types.setTypeParser(
-      this.db.connection.client.driver.types.builtins.JSONB,
-      'text',
-      (v) => v
-    );
-    this.db.connection.client.driver.types.setTypeParser(
-      this.db.connection.client.driver.types.builtins.NUMERIC,
-      '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.NotNullError({ column: error.column });
-      }
-      default: {
-        super.transformErrors(error);
-      }
-    }
-  }
-}
-
-module.exports = PostgresDialect;