@strapi/database 4.0.0-beta.0

package/lib/schema/schema.js

@@ -0,0 +1,209 @@
+'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 in 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 }],
+        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': {
+      return { type: 'string' };
+    }
+    case 'uid': {
+      return {
+        type: 'string',
+        unique: true,
+      };
+    }
+    case 'richtext':
+    case 'text': {
+      return {
+        type: 'text',
+        args: ['longtext'],
+      };
+    }
+    case 'json': {
+      return { type: 'jsonb' };
+    }
+    case 'enumeration': {
+      return {
+        type: 'enum',
+        args: [
+          attribute.enum,
+          /*,{ useNative: true, existingType: true, enumName: 'foo_type', schemaName: 'public' }*/
+        ],
+      };
+    }
+    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(`Unknow 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

@@ -0,0 +1,75 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const TABLE_NAME = 'strapi_database_schema';
+
+module.exports = db => {
+  const hasSchemaTable = () => db.connection.schema.hasTable(TABLE_NAME);
+
+  const createSchemaTable = () => {
+    return db.connection.schema.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.connection
+        .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.connection(TABLE_NAME).delete();
+
+      const time = new Date();
+
+      await db.connection(TABLE_NAME).insert({
+        schema: JSON.stringify(schema),
+        hash: this.hashSchema(schema),
+        time,
+      });
+    },
+
+    async clear() {
+      await checkTableExists();
+
+      await db.connection(TABLE_NAME).truncate();
+    },
+  };
+};

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,34 @@
+'use strict';
+
+const SCALAR_TYPES = [
+  'increments',
+  'password',
+  'email',
+  'string',
+  'uid',
+  'richtext',
+  'text',
+  'json',
+  'enumeration',
+  'integer',
+  'biginteger',
+  'float',
+  'decimal',
+  'date',
+  'time',
+  'datetime',
+  'timestamp',
+  'boolean',
+];
+
+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

@@ -0,0 +1,41 @@
+'use strict';
+
+const transformAttribute = attribute => {
+  switch (attribute.type) {
+    case 'media': {
+      // TODO: handle a filter on field
+      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/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@strapi/database",
+  "version": "4.0.0-beta.0",
+  "description": "Strapi's database layer",
+  "homepage": "https://strapi.io",
+  "main": "./lib/index.js",
+  "scripts": {
+    "test": "echo \"no tests yet\""
+  },
+  "directories": {
+    "lib": "./lib"
+  },
+  "author": {
+    "name": "Strapi team",
+    "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"
+  },
+  "engines": {
+    "node": ">=12.x.x <=16.x.x",
+    "npm": ">=6.0.0"
+  },
+  "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",
+    "umzug": "2.3.0"
+  },
+  "gitHead": "9807c78cb7ab6373b7abb46da5ecc4980a9ea56c"
+}