@strapi/database 4.0.0-next.8 → 4.0.2

package/lib/schema/storage.js

@@ -0,0 +1,79 @@
+'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/utils/content-types.js

@@ -3,7 +3,6 @@
 const transformAttribute = attribute => {
   switch (attribute.type) {
     case 'media': {
-      // TODO: handle a filter on field
       return {
         type: 'relation',
         relation: attribute.multiple === true ? 'morphMany' : 'morphOne',

package/package.json

@@ -1,41 +1,46 @@
 {
   "name": "@strapi/database",
-  "version": "4.0.0-next.8",
+  "version": "4.0.2",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
-  "main": "./lib/index.js",
-  "scripts": {
-    "test": "echo \"no tests yet\""
+  "bugs": {
+    "url": "https://github.com/strapi/strapi/issues"
   },
-  "directories": {
-    "lib": "./lib"
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/strapi/strapi.git"
   },
+  "license": "SEE LICENSE IN LICENSE",
   "author": {
-    "name": "Strapi team",
+    "name": "Strapi Solutions SAS",
     "email": "hi@strapi.io",
     "url": "https://strapi.io"
   },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/strapi/strapi.git"
-  },
-  "bugs": {
-    "url": "https://github.com/strapi/strapi/issues"
+  "maintainers": [
+    {
+      "name": "Strapi Solutions SAS",
+      "email": "hi@strapi.io",
+      "url": "https://strapi.io"
+    }
+  ],
+  "main": "./lib/index.js",
+  "directories": {
+    "lib": "./lib"
   },
-  "engines": {
-    "node": ">=12.x.x <=16.x.x",
-    "npm": ">=6.0.0"
+  "scripts": {
+    "test:unit": "jest --verbose"
   },
-  "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
     "date-fns": "2.22.1",
     "debug": "4.3.1",
     "fs-extra": "10.0.0",
     "knex": "0.95.6",
-    "lodash": "4.17.21"
+    "lodash": "4.17.21",
+    "umzug": "2.3.0"
   },
-  "devDependencies": {
-    "sqlite3": "5.0.2"
+  "engines": {
+    "node": ">=12.x.x <=16.x.x",
+    "npm": ">=6.0.0"
   },
-  "gitHead": "e3452f6662a45a4ba96e96861e076e313b297666"
+  "gitHead": "fd656a47698e0a33aae42abd4330410c8cba1d08"
 }

package/lib/configuration.js

@@ -1,49 +0,0 @@
-'use strict';
-const { prop, defaultsDeep } = require('lodash/fp');
-
-/*
-config/database.js
-
-{
-  connector: '',
-  connection: {},
-  migration: {},
-  seed: {},
-  schema: {
-    autoSync: true,
-    forceSync: true
-  }
-}
-
-*/
-
-class Configuration {
-  constructor(config) {
-    this.config = config;
-  }
-
-  static from(config) {
-    if (config instanceof Configuration) {
-      return config;
-    }
-
-    return new Configuration(defaultsDeep(config, Configuration.defaults));
-  }
-
-  get(path) {
-    return prop(path, this.config);
-  }
-}
-
-Configuration.defaults = {
-  connector: '@strapi/connector-sql',
-  migration: {
-    //
-  },
-  seed: {
-    //
-  },
-  models: [],
-};
-
-module.exports = Configuration;

package/lib/schema/schema-diff.js

@@ -1,337 +0,0 @@
-'use strict';
-
-const _ = require('lodash/fp');
-
-const statuses = {
-  CHANGED: 'CHANGED',
-  UNCHANGED: 'UNCHANGED',
-};
-
-// NOTE:We could move the schema to use maps of tables & columns instead of arrays to make it easier to diff
-// => this will make the creation a bit more complicated (ordering, Object.values(tables | columns)) -> not a big pbl
-
-const helpers = {
-  hasTable(schema, tableName) {
-    return schema.tables.findIndex(table => table.name === tableName) !== -1;
-  },
-  findTable(schema, tableName) {
-    return schema.tables.find(table => table.name === tableName);
-  },
-
-  hasColumn(table, columnName) {
-    return table.columns.findIndex(column => column.name === columnName) !== -1;
-  },
-  findColumn(table, columnName) {
-    return table.columns.find(column => column.name === columnName);
-  },
-
-  hasIndex(table, columnName) {
-    return table.indexes.findIndex(column => column.name === columnName) !== -1;
-  },
-  findIndex(table, columnName) {
-    return table.indexes.find(column => column.name === columnName);
-  },
-
-  hasForeignKey(table, columnName) {
-    return table.foreignKeys.findIndex(column => column.name === columnName) !== -1;
-  },
-  findForeignKey(table, columnName) {
-    return table.foreignKeys.find(column => column.name === columnName);
-  },
-};
-
-const diffProperties = (srcObject, destObject) => {
-  const addedProperties = [];
-  const updatedProperties = [];
-  const unchangedProperties = [];
-  const removedProperties = [];
-
-  for (const key in destObject) {
-    const value = destObject[key];
-
-    if (_.has(key, srcObject)) {
-      const srcValue = srcObject[key];
-
-      if (!_.isEqual(srcValue, value)) {
-        updatedProperties.push({ key, oldValue: srcValue, value });
-      } else {
-        unchangedProperties.push({ key, value });
-      }
-    } else {
-      addedProperties.push({ key, value });
-    }
-  }
-
-  for (const key in srcObject) {
-    const value = srcObject[key];
-
-    if (!_.has(key, destObject)) {
-      removedProperties.push({ key, oldValue: value });
-    }
-  }
-
-  const hasChanged = [addedProperties, updatedProperties, removedProperties].some(
-    arr => arr.length > 0
-  );
-
-  return {
-    status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-    diff: {
-      name: destObject.name,
-      object: destObject,
-      // NOTE: maybe put into properties: {}
-      added: addedProperties,
-      updated: updatedProperties,
-      unchanged: unchangedProperties,
-      removed: removedProperties,
-    },
-  };
-};
-
-const diffTableColumns = (srcTable, destTable) => {
-  /*
-  for each column in dest table
-    if exists in src table
-      diff the two columns
-        check properties
-      if diff has changes push to changed
-      else push to unchanged
-    else push to added
-
-  for each column in src table
-    if not exists in dest table push to removed
-
-  */
-
-  const addedColumns = [];
-  const updatedColumns = [];
-  const unchangedColumns = [];
-  const removedColumns = [];
-
-  for (const destColumn of destTable.columns) {
-    if (helpers.hasColumn(srcTable, destColumn.name)) {
-      const srcColumn = helpers.findColumn(srcTable, destColumn.name);
-      const { status, diff } = diffProperties(srcColumn, destColumn);
-
-      if (status === statuses.CHANGED) {
-        updatedColumns.push(diff);
-      } else {
-        unchangedColumns.push(srcColumn);
-      }
-    } else {
-      addedColumns.push(destColumn);
-    }
-  }
-
-  for (const srcColumn of srcTable.columns) {
-    if (!helpers.hasColumn(destTable, srcColumn.name)) {
-      removedColumns.push(srcColumn);
-    }
-  }
-
-  const hasChanged = [addedColumns, updatedColumns, removedColumns].some(arr => arr.length > 0);
-
-  return {
-    status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-    diff: {
-      added: addedColumns,
-      updated: updatedColumns,
-      unchanged: unchangedColumns,
-      removed: removedColumns,
-    },
-  };
-};
-
-const diffTableIndexes = (srcTable, destTable) => {
-  /*
-  for each indexes in dest table
-    if exists in src table
-      diff the two indexes
-        check properties
-      if diff has changes push to changed
-      else push to unchanged
-    else push to added
-
-  for each indexes in src table
-    if not exists in dest table push to removed
-    */
-
-  const addedIndexes = [];
-  const updatedIndexes = [];
-  const unchangedIndexes = [];
-  const removedIndexes = [];
-
-  for (const destIndex of destTable.indexes) {
-    if (helpers.hasIndex(srcTable, destIndex.name)) {
-      const srcIndex = helpers.findIndex(srcTable, destIndex.name);
-      const { status, diff } = diffProperties(srcIndex, destIndex);
-
-      if (status === statuses.CHANGED) {
-        updatedIndexes.push(diff);
-      } else {
-        unchangedIndexes.push(srcIndex);
-      }
-    } else {
-      addedIndexes.push(destIndex);
-    }
-  }
-
-  for (const srcIndex of srcTable.indexes) {
-    if (!helpers.hasIndex(destTable, srcIndex.name)) {
-      removedIndexes.push(srcIndex);
-    }
-  }
-
-  const hasChanged = [addedIndexes, updatedIndexes, removedIndexes].some(arr => arr.length > 0);
-
-  return {
-    status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-    diff: {
-      added: addedIndexes,
-      updated: updatedIndexes,
-      unchanged: unchangedIndexes,
-      removed: removedIndexes,
-    },
-  };
-};
-
-const diffTableForeignKeys = (srcTable, destTable) => {
-  /*
-  for each foreginKeys in dest table
-    if exists in src table
-      diff the two foreginKeys
-        check properties
-      if diff has changes push to changed
-      else push to unchanged
-    else push to added
-
-  for each foreginKeys in src table
-    if not exists in dest table push to removed
-  */
-
-  const addedForeignKeys = [];
-  const updatedForeignKeys = [];
-  const unchangedForeignKeys = [];
-  const removedForeignKeys = [];
-
-  for (const destForeignKey of destTable.foreignKeys) {
-    if (helpers.hasForeignKey(srcTable, destForeignKey.name)) {
-      const srcForeignKey = helpers.findForeignKey(srcTable, destForeignKey.name);
-      const { status, diff } = diffProperties(srcForeignKey, destForeignKey);
-
-      if (status === statuses.CHANGED) {
-        updatedForeignKeys.push(diff);
-      } else {
-        unchangedForeignKeys.push(srcForeignKey);
-      }
-    } else {
-      addedForeignKeys.push(destForeignKey);
-    }
-  }
-
-  for (const srcForeignKey of srcTable.foreignKeys) {
-    if (!helpers.hasForeignKey(destTable, srcForeignKey.name)) {
-      removedForeignKeys.push(srcForeignKey);
-    }
-  }
-
-  const hasChanged = [addedForeignKeys, updatedForeignKeys, removedForeignKeys].some(
-    arr => arr.length > 0
-  );
-
-  return {
-    status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-    diff: {
-      added: addedForeignKeys,
-      updated: updatedForeignKeys,
-      unchanged: unchangedForeignKeys,
-      removed: removedForeignKeys,
-    },
-  };
-};
-
-const hasChangedStatus = diff => diff.status === statuses.CHANGED;
-
-const diffTables = (srcTable, destTable) => {
-  const columnsDiff = diffTableColumns(srcTable, destTable);
-  const indexesDiff = diffTableIndexes(srcTable, destTable);
-  const foreignKeysDiff = diffTableForeignKeys(srcTable, destTable);
-
-  const hasChanged = [columnsDiff, indexesDiff, foreignKeysDiff].some(hasChangedStatus);
-
-  return {
-    status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-    diff: {
-      name: srcTable.name,
-      indexes: indexesDiff.diff,
-      foreignKeys: foreignKeysDiff.diff,
-      columns: columnsDiff.diff,
-    },
-  };
-};
-
-const diffSchemas = (srcSchema, destSchema) => {
-  // NOTE: We could eventually try to detect renames in tables & columns or hint them when making changes
-  // TODO: let's try to see how we can avoid restarts completely by applying these dynamically in dev mode
-
-  /*
-  for each table in dest
-    if exists in src then
-
-      diff two tables
-
-      if diff has changes push to changed
-      else push to unchanged
-    else push to added
-
-  for each table in src check if it still exists
-    if table not in dest push to removed
-
-  */
-
-  const addedTables = [];
-  const updatedTables = [];
-  const unchangedTables = [];
-  const removedTables = [];
-
-  for (const destTable of destSchema.tables) {
-    if (helpers.hasTable(srcSchema, destTable.name)) {
-      // either changed or unchanged
-      const srcTable = helpers.findTable(srcSchema, destTable.name);
-
-      const { status, diff } = diffTables(srcTable, destTable);
-
-      if (status === statuses.CHANGED) {
-        updatedTables.push(diff);
-      } else {
-        unchangedTables.push(srcTable);
-      }
-    } else {
-      addedTables.push(destTable);
-    }
-  }
-
-  for (const srcTable of srcSchema.tables) {
-    if (!helpers.hasTable(destSchema, srcTable.name)) {
-      removedTables.push(srcTable);
-    }
-  }
-
-  const hasChanged = [addedTables, updatedTables, removedTables].some(arr => arr.length > 0);
-
-  return {
-    status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-    diff: {
-      tables: {
-        added: addedTables,
-        updated: updatedTables,
-        unchanged: unchangedTables,
-        removed: removedTables,
-      },
-    },
-  };
-};
-
-module.exports = {
-  diffSchemas,
-};

package/lib/schema/schema-storage.js

@@ -1,44 +0,0 @@
-'use strict';
-
-module.exports = db => ({
-  async read() {
-    /*
-        NOTE:
-        1- read the tables structure etc
-        2- select from a specific table
-      */
-
-    if (await db.connection.schema.hasTable('strapi_database_schema')) {
-      // NOTE: We could store and history of database schemas to fix / rollback etc ?
-      const res = await db.connection
-        .select('*')
-        .from('strapi_database_schema')
-        .orderBy('id', 'DESC')
-        .first();
-
-      if (!res) {
-        return null;
-      }
-
-      return typeof res.schema === 'object' ? res.schema : JSON.parse(res.schema);
-    }
-
-    return null;
-  },
-
-  async update(schema) {
-    await db.connection('strapi_database_schema').update({
-      schema: JSON.stringify(schema),
-    });
-  },
-
-  async create(schema) {
-    await db.connection('strapi_database_schema').insert({
-      schema: JSON.stringify(schema),
-    });
-  },
-
-  async clear() {
-    await db.connection('strapi_database_schema').del();
-  },
-});