@strapi/database 4.14.4 → 4.14.6

package/lib/schema/schema.js

@@ -1,202 +0,0 @@
-'use strict';
-
-const types = require('../types');
-
-const createColumn = (name, attribute) => {
-  const { type, args = [], ...opts } = getColumnType(attribute);
-
-  return {
-    name,
-    type,
-    args,
-    defaultTo: null,
-    notNullable: false,
-    unsigned: false,
-    ...opts,
-    ...(attribute.column || {}),
-  };
-};
-
-const createTable = (meta) => {
-  const table = {
-    name: meta.tableName,
-    indexes: meta.indexes || [],
-    foreignKeys: meta.foreignKeys || [],
-    columns: [],
-  };
-
-  for (const key of Object.keys(meta.attributes)) {
-    const attribute = meta.attributes[key];
-
-    if (types.isRelation(attribute.type)) {
-      if (attribute.morphColumn && attribute.owner) {
-        const { idColumn, typeColumn } = attribute.morphColumn;
-
-        table.columns.push(
-          createColumn(idColumn.name, {
-            type: 'integer',
-            column: {
-              unsigned: true,
-            },
-          })
-        );
-
-        table.columns.push(createColumn(typeColumn.name, { type: 'string' }));
-      } else if (attribute.joinColumn && attribute.owner) {
-        // NOTE: we could pass uniquness for oneToOne to avoid creating more than one to one
-
-        const { name: columnName, referencedColumn, referencedTable } = attribute.joinColumn;
-
-        const column = createColumn(columnName, {
-          type: 'integer',
-          column: {
-            unsigned: true,
-          },
-        });
-
-        table.columns.push(column);
-
-        table.foreignKeys.push({
-          name: `${table.name}_${columnName}_fk`,
-          columns: [columnName],
-          referencedTable,
-          referencedColumns: [referencedColumn],
-          // NOTE: could allow configuration
-          onDelete: 'SET NULL',
-        });
-
-        table.indexes.push({
-          name: `${table.name}_${columnName}_fk`,
-          columns: [columnName],
-        });
-      }
-    } else if (types.isScalar(attribute.type)) {
-      const column = createColumn(attribute.columnName || key, attribute);
-
-      if (column.unique) {
-        table.indexes.push({
-          type: 'unique',
-          name: `${table.name}_${column.name}_unique`,
-          columns: [column.name],
-        });
-      }
-
-      if (column.primary) {
-        table.indexes.push({
-          type: 'primary',
-          name: `${table.name}_${column.name}_primary`,
-          columns: [column.name],
-        });
-      }
-
-      table.columns.push(column);
-    }
-  }
-
-  return table;
-};
-
-const getColumnType = (attribute) => {
-  if (attribute.columnType) {
-    return attribute.columnType;
-  }
-
-  switch (attribute.type) {
-    case 'increments': {
-      return {
-        type: 'increments',
-        args: [{ primary: true, primaryKey: true }],
-        notNullable: true,
-      };
-    }
-
-    // We might want to convert email/password to string types before going into the orm with specific validators & transformers
-    case 'password':
-    case 'email':
-    case 'string':
-    case 'enumeration': {
-      return { type: 'string' };
-    }
-    case 'uid': {
-      return {
-        type: 'string',
-        unique: true,
-      };
-    }
-    case 'richtext':
-    case 'text': {
-      return {
-        type: 'text',
-        args: ['longtext'],
-      };
-    }
-    case 'blocks':
-    case 'json': {
-      return { type: 'jsonb' };
-    }
-    case 'integer': {
-      return { type: 'integer' };
-    }
-    case 'biginteger': {
-      return { type: 'bigInteger' };
-    }
-    case 'float': {
-      return { type: 'double' };
-    }
-    case 'decimal': {
-      return { type: 'decimal', args: [10, 2] };
-    }
-    case 'date': {
-      return { type: 'date' };
-    }
-    case 'time': {
-      return { type: 'time', args: [{ precision: 3 }] };
-    }
-    case 'datetime': {
-      return {
-        type: 'datetime',
-        args: [
-          {
-            useTz: false,
-            precision: 6,
-          },
-        ],
-      };
-    }
-    case 'timestamp': {
-      return {
-        type: 'timestamp',
-        args: [
-          {
-            useTz: false,
-            precision: 6,
-          },
-        ],
-      };
-    }
-    case 'boolean': {
-      return { type: 'boolean' };
-    }
-    default: {
-      throw new Error(`Unknown type ${attribute.type}`);
-    }
-  }
-};
-
-const metadataToSchema = (metadata) => {
-  const schema = {
-    tables: [],
-    addTable(table) {
-      this.tables.push(table);
-      return this;
-    },
-  };
-
-  metadata.forEach((metadata) => {
-    schema.addTable(createTable(metadata));
-  });
-
-  return schema;
-};
-
-module.exports = { metadataToSchema, createTable };

package/lib/schema/storage.js

@@ -1,76 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-
-const TABLE_NAME = 'strapi_database_schema';
-
-module.exports = (db) => {
-  const hasSchemaTable = () => db.getSchemaConnection().hasTable(TABLE_NAME);
-
-  const createSchemaTable = () => {
-    return db.getSchemaConnection().createTable(TABLE_NAME, (t) => {
-      t.increments('id');
-      t.json('schema');
-      t.datetime('time', { useTz: false });
-      t.string('hash');
-    });
-  };
-
-  const checkTableExists = async () => {
-    if (!(await hasSchemaTable())) {
-      await createSchemaTable();
-    }
-  };
-
-  return {
-    async read() {
-      await checkTableExists();
-
-      const res = await db
-        .getConnection()
-        .select('*')
-        .from(TABLE_NAME)
-        .orderBy('time', 'DESC')
-        .first();
-
-      if (!res) {
-        return null;
-      }
-
-      const parsedSchema = typeof res.schema === 'object' ? res.schema : JSON.parse(res.schema);
-
-      return {
-        ...res,
-        schema: parsedSchema,
-      };
-    },
-
-    hashSchema(schema) {
-      return crypto.createHash('md5').update(JSON.stringify(schema)).digest('hex');
-    },
-
-    async add(schema) {
-      await checkTableExists();
-
-      // NOTE: we can remove this to add history
-      await db.getConnection(TABLE_NAME).delete();
-
-      const time = new Date();
-
-      await db
-        .getConnection()
-        .insert({
-          schema: JSON.stringify(schema),
-          hash: this.hashSchema(schema),
-          time,
-        })
-        .into(TABLE_NAME);
-    },
-
-    async clear() {
-      await checkTableExists();
-
-      await db.getConnection(TABLE_NAME).truncate();
-    },
-  };
-};

package/lib/transaction-context.js

@@ -1,68 +0,0 @@
-'use strict';
-
-const { AsyncLocalStorage } = require('async_hooks');
-
-const storage = new AsyncLocalStorage();
-
-const transactionCtx = {
-  async run(store, cb) {
-    return storage.run({ trx: store, commitCallbacks: [], rollbackCallbacks: [] }, cb);
-  },
-
-  get() {
-    const store = storage.getStore();
-    return store?.trx;
-  },
-
-  async commit(trx) {
-    const store = storage.getStore();
-
-    // Clear transaction from store
-    if (store?.trx) {
-      store.trx = null;
-    }
-
-    // Commit transaction
-    await trx.commit();
-
-    if (!store?.commitCallbacks.length) return;
-
-    // Run callbacks
-    store.commitCallbacks.forEach((cb) => cb());
-    store.commitCallbacks = [];
-  },
-
-  async rollback(trx) {
-    const store = storage.getStore();
-
-    // Clear transaction from store
-    if (store?.trx) {
-      store.trx = null;
-    }
-
-    // Rollback transaction
-    await trx.rollback();
-
-    if (!store?.rollbackCallbacks.length) return;
-
-    // Run callbacks
-    store.rollbackCallbacks.forEach((cb) => cb());
-    store.rollbackCallbacks = [];
-  },
-
-  onCommit(cb) {
-    const store = storage.getStore();
-    if (store?.commitCallbacks) {
-      store.commitCallbacks.push(cb);
-    }
-  },
-
-  onRollback(cb) {
-    const store = storage.getStore();
-    if (store?.rollbackCallbacks) {
-      store.rollbackCallbacks.push(cb);
-    }
-  },
-};
-
-module.exports = transactionCtx;

package/lib/types/index.d.ts

@@ -1,6 +0,0 @@
-export function isScalar(type: string): boolean;
-export function isNumber(type: string): boolean;
-export function isString(type: string): boolean;
-export function isComponent(type: string): boolean;
-export function isDynamicZone(type: string): boolean;
-export function isRelation(type: string): boolean;

package/lib/types/index.js

@@ -1,35 +0,0 @@
-'use strict';
-
-const SCALAR_TYPES = [
-  'increments',
-  'password',
-  'email',
-  'string',
-  'uid',
-  'richtext',
-  'text',
-  'json',
-  'enumeration',
-  'integer',
-  'biginteger',
-  'float',
-  'decimal',
-  'date',
-  'time',
-  'datetime',
-  'timestamp',
-  'boolean',
-  'blocks',
-];
-
-const STRING_TYPES = ['string', 'text', 'uid', 'email', 'enumeration', 'richtext'];
-const NUMBER_TYPES = ['biginteger', 'integer', 'decimal', 'float'];
-
-module.exports = {
-  isString: (type) => STRING_TYPES.includes(type),
-  isNumber: (type) => NUMBER_TYPES.includes(type),
-  isScalar: (type) => SCALAR_TYPES.includes(type),
-  isComponent: (type) => type === 'component',
-  isDynamicZone: (type) => type === 'dynamiczone',
-  isRelation: (type) => type === 'relation',
-};

package/lib/utils/content-types.js

@@ -1,40 +0,0 @@
-'use strict';
-
-const transformAttribute = (attribute) => {
-  switch (attribute.type) {
-    case 'media': {
-      return {
-        type: 'relation',
-        relation: attribute.multiple === true ? 'morphMany' : 'morphOne',
-        target: 'plugin::upload.file',
-        morphBy: 'related',
-      };
-    }
-    default: {
-      return attribute;
-    }
-  }
-};
-
-// TODO: model logic outside DB
-const transformContentTypes = (contentTypes) => {
-  return contentTypes.map((contentType) => {
-    const model = {
-      ...contentType,
-      // reuse new model def
-      singularName: contentType.modelName,
-      tableName: contentType.collectionName,
-      attributes: {
-        ...Object.keys(contentType.attributes || {}).reduce((attrs, attrName) => {
-          return Object.assign(attrs, {
-            [attrName]: transformAttribute(contentType.attributes[attrName]),
-          });
-        }, {}),
-      },
-    };
-
-    return model;
-  });
-};
-
-module.exports = { transformContentTypes };

package/lib/utils/knex.js

@@ -1,22 +0,0 @@
-'use strict';
-
-const KnexBuilder = require('knex/lib/query/querybuilder');
-const KnexRaw = require('knex/lib/raw');
-
-const isKnexQuery = (value) => {
-  return value instanceof KnexBuilder || value instanceof KnexRaw;
-};
-
-/**
- * Adds the name of the schema to the table name if the schema was defined by the user.
- * Users can set the db schema only for Postgres in strapi database config.
- */
-const addSchema = (tableName) => {
-  const schemaName = strapi.db.connection.getSchemaName();
-  return schemaName ? `${schemaName}.${tableName}` : tableName;
-};
-
-module.exports = {
-  isKnexQuery,
-  addSchema,
-};

package/lib/validations/index.js

@@ -1,20 +0,0 @@
-'use strict';
-
-const { validateRelations } = require('./relations');
-
-/**
- * Validate if the database is in a valid state before starting the server.
- *
- * @param {*} db - Database instance
- */
-async function validateDatabase(db) {
-  const relationErrors = await validateRelations(db);
-  const errorList = [...relationErrors];
-
-  if (errorList.length > 0) {
-    errorList.forEach((error) => strapi.log.error(error));
-    throw new Error('There are errors in some of your models. Please check the logs above.');
-  }
-}
-
-module.exports = { validateDatabase };

package/lib/validations/relations/bidirectional.js

@@ -1,89 +0,0 @@
-'use strict';
-
-const types = require('../../types');
-const { getJoinTableName } = require('../../metadata/relations');
-
-const getLinksWithoutMappedBy = (db) => {
-  const relationsToUpdate = {};
-
-  db.metadata.forEach((contentType) => {
-    const attributes = contentType.attributes;
-
-    // For each relation attribute, add the joinTable name to tablesToUpdate
-    Object.values(attributes).forEach((attribute) => {
-      if (!types.isRelation(attribute.type)) return;
-
-      if (attribute.inversedBy) {
-        const invRelation = db.metadata.get(attribute.target).attributes[attribute.inversedBy];
-
-        // Both relations use inversedBy.
-        if (invRelation.inversedBy) {
-          relationsToUpdate[attribute.joinTable.name] = {
-            relation: attribute,
-            invRelation,
-          };
-        }
-      }
-    });
-  });
-
-  return Object.values(relationsToUpdate);
-};
-
-const isLinkTableEmpty = async (db, linkTableName) => {
-  // If the table doesn't exist, it's empty
-  const exists = await db.getSchemaConnection().hasTable(linkTableName);
-  if (!exists) return true;
-
-  const result = await db.getConnection().count('* as count').from(linkTableName);
-  return Number(result[0].count) === 0;
-};
-
-/**
- * Validates bidirectional relations before starting the server.
- * - If both sides use inversedBy, one of the sides must switch to mappedBy.
- *    When this happens, two join tables exist in the database.
- *    This makes sure you switch the side which does not delete any data.
- *
- * @param {*} db
- * @return {*}
- */
-const validateBidirectionalRelations = async (db) => {
-  const invalidLinks = getLinksWithoutMappedBy(db);
-  const errorList = [];
-
-  for (const { relation, invRelation } of invalidLinks) {
-    const contentType = db.metadata.get(invRelation.target);
-    const invContentType = db.metadata.get(relation.target);
-
-    // Generate the join table name based on the relation target table and attribute name.
-    const joinTableName = getJoinTableName(contentType.tableName, invRelation.inversedBy);
-    const inverseJoinTableName = getJoinTableName(invContentType.tableName, relation.inversedBy);
-
-    const joinTableEmpty = await isLinkTableEmpty(db, joinTableName);
-    const inverseJoinTableEmpty = await isLinkTableEmpty(db, inverseJoinTableName);
-
-    if (joinTableEmpty) {
-      process.emitWarning(
-        `Error on attribute "${invRelation.inversedBy}" in model "${contentType.singularName}" (${contentType.uid}).` +
-          ` Please modify your ${contentType.singularName} schema by renaming the key "inversedBy" to "mappedBy".` +
-          ` Ex: { "inversedBy": "${relation.inversedBy}" } -> { "mappedBy": "${relation.inversedBy}" }`
-      );
-    } else if (inverseJoinTableEmpty) {
-      // Its safe to delete the inverse join table
-      process.emitWarning(
-        `Error on attribute "${relation.inversedBy}" in model "${invContentType.singularName}" (${invContentType.uid}).` +
-          ` Please modify your ${invContentType.singularName} schema by renaming the key "inversedBy" to "mappedBy".` +
-          ` Ex: { "inversedBy": "${invRelation.inversedBy}" } -> { "mappedBy": "${invRelation.inversedBy}" }`
-      );
-    } else {
-      // Both sides have data in the join table
-    }
-  }
-
-  return errorList;
-};
-
-module.exports = {
-  validateBidirectionalRelations,
-};

package/lib/validations/relations/index.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const { validateBidirectionalRelations } = require('./bidirectional');
-
-/**
- * Validates if relations data and tables are in a valid state before
- * starting the server.
- */
-const validateRelations = async (db) => {
-  const bidirectionalRelationsErrors = await validateBidirectionalRelations(db);
-  return [...bidirectionalRelationsErrors];
-};
-
-module.exports = { validateRelations };