@strapi/database 4.0.0-next.9 → 4.0.3

package/lib/metadata/index.js

@@ -1,8 +1,3 @@
-/**
- * @module metadata
- *
- */
-
 'use strict';
 
 const _ = require('lodash/fp');
@@ -16,43 +11,13 @@ class Metadata extends Map {
   }
 }
 
+// TODO: check if there isn't an attribute with an id already
 /**
  * Create Metadata from models configurations
- *
- * timestamps => not optional anymore but auto added. Auto added on the content type or in the db layer ?
- *
- * options => options are handled on the layer above. Options convert to fields on the CT
- *
- * filters => not in v1
- *
- * attributes
- *
- * - type
- * - mapping field name - column name
- * - mapping field type - column type
- * - formatter / parser => coming from field type so no
- * - indexes / checks / contstraints
- * - relations => reference to the target model (function or string to avoid circular deps ?)
- *   - name of the LEFT/RIGHT side foreign keys
- *   - name of join table
- *
- * - compo/dz => reference to the components
- * - validators
- * - hooks
- * - default value
- * - required -> should add a not null option instead of the API required
- * - unique -> should add a DB unique option instead of the unique in the API (Unique by locale or something else for example)
- *
- * lifecycles
- *
- * private fields ? => handled on a different layer
  * @param {object[]} models
  * @returns {Metadata}
  */
 const createMetadata = (models = []) => {
-  // TODO: reorder to make sure we can create everything or delete everything in the right order
-  // TODO: allow passing the join config in the attribute
-  // TODO: allow passing column config in the attribute
   const metadata = new Metadata();
 
   // init pass
@@ -62,7 +27,6 @@ const createMetadata = (models = []) => {
       uid: model.uid,
       tableName: model.tableName,
       attributes: {
-        // TODO: check if there isn't an attribute with an id already
         id: {
           type: 'increments',
         },
@@ -83,67 +47,12 @@ const createMetadata = (models = []) => {
     for (const [attributeName, attribute] of Object.entries(meta.attributes)) {
       try {
         if (types.isComponent(attribute.type)) {
-          // convert component to relation
-
-          Object.assign(attribute, {
-            type: 'relation',
-            relation: attribute.repeatable === true ? 'oneToMany' : 'oneToOne',
-            target: attribute.component,
-            joinTable: {
-              name: meta.componentLink.tableName,
-              joinColumn: {
-                name: 'entity_id',
-                referencedColumn: 'id',
-              },
-              inverseJoinColumn: {
-                name: 'component_id',
-                referencedColumn: 'id',
-              },
-              on: {
-                field: attributeName,
-              },
-              orderBy: {
-                order: 'asc',
-              },
-            },
-          });
-
+          createComponent(attributeName, attribute, meta, metadata);
           continue;
         }
 
         if (types.isDynamicZone(attribute.type)) {
-          //
-
-          Object.assign(attribute, {
-            type: 'relation',
-            relation: 'morphToMany',
-            // TODO: handle restrictions at some point
-            // target: attribute.components,
-            joinTable: {
-              name: meta.componentLink.tableName,
-              joinColumn: {
-                name: 'entity_id',
-                referencedColumn: 'id',
-              },
-              morphColumn: {
-                idColumn: {
-                  name: 'component_id',
-                  referencedColumn: 'id',
-                },
-                typeColumn: {
-                  name: 'component_type',
-                },
-                typeField: '__component',
-              },
-              on: {
-                field: attributeName,
-              },
-              orderBy: {
-                order: 'asc',
-              },
-            },
-          });
-
+          createDynamicZone(attributeName, attribute, meta, metadata);
           continue;
         }
 
@@ -151,7 +60,10 @@ const createMetadata = (models = []) => {
           createRelation(attributeName, attribute, meta, metadata);
           continue;
         }
+
+        createAttribute(attributeName, attribute, meta, metadata);
       } catch (error) {
+        console.log(error);
         throw new Error(
           `Error on attribute ${attributeName} in model ${meta.singularName}(${meta.uid}): ${error.message}`
         );
@@ -159,6 +71,15 @@ const createMetadata = (models = []) => {
     }
   }
 
+  for (const meta of metadata.values()) {
+    const columnToAttribute = Object.keys(meta.attributes).reduce((acc, key) => {
+      const attribute = meta.attributes[key];
+      return Object.assign(acc, { [attribute.columnName || key]: key });
+    }, {});
+
+    meta.columnToAttribute = columnToAttribute;
+  }
+
   return metadata;
 };
 
@@ -201,7 +122,7 @@ const createCompoLinkModelMeta = baseModelMeta => {
         type: 'integer',
         column: {
           unsigned: true,
-          defaultTo: [0],
+          defaultTo: 0,
         },
       },
     },
@@ -209,10 +130,16 @@ const createCompoLinkModelMeta = baseModelMeta => {
       {
         name: `${baseModelMeta.tableName}_field_index`,
         columns: ['field'],
+        type: null,
       },
       {
         name: `${baseModelMeta.tableName}_component_type_index`,
         columns: ['component_type'],
+        type: null,
+      },
+      {
+        name: `${baseModelMeta.tableName}_entity_fk`,
+        columns: ['entity_id'],
       },
     ],
     foreignKeys: [
@@ -227,4 +154,66 @@ const createCompoLinkModelMeta = baseModelMeta => {
   };
 };
 
+const createDynamicZone = (attributeName, attribute, meta) => {
+  Object.assign(attribute, {
+    type: 'relation',
+    relation: 'morphToMany',
+    // TODO: handle restrictions at some point
+    // target: attribute.components,
+    joinTable: {
+      name: meta.componentLink.tableName,
+      joinColumn: {
+        name: 'entity_id',
+        referencedColumn: 'id',
+      },
+      morphColumn: {
+        idColumn: {
+          name: 'component_id',
+          referencedColumn: 'id',
+        },
+        typeColumn: {
+          name: 'component_type',
+        },
+        typeField: '__component',
+      },
+      on: {
+        field: attributeName,
+      },
+      orderBy: {
+        order: 'asc',
+      },
+    },
+  });
+};
+
+const createComponent = (attributeName, attribute, meta) => {
+  Object.assign(attribute, {
+    type: 'relation',
+    relation: attribute.repeatable === true ? 'oneToMany' : 'oneToOne',
+    target: attribute.component,
+    joinTable: {
+      name: meta.componentLink.tableName,
+      joinColumn: {
+        name: 'entity_id',
+        referencedColumn: 'id',
+      },
+      inverseJoinColumn: {
+        name: 'component_id',
+        referencedColumn: 'id',
+      },
+      on: {
+        field: attributeName,
+      },
+      orderBy: {
+        order: 'asc',
+      },
+    },
+  });
+};
+
+const createAttribute = (attributeName, attribute) => {
+  const columnName = _.snakeCase(attributeName);
+  Object.assign(attribute, { columnName });
+};
+
 module.exports = createMetadata;

package/lib/metadata/relations.js

@@ -235,6 +235,12 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
         },
       },
     },
+    indexes: [
+      {
+        name: `${joinTableName}_fk`,
+        columns: [joinColumnName],
+      },
+    ],
     foreignKeys: [
       {
         name: `${joinTableName}_fk`,
@@ -384,7 +390,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   const targetMeta = metadata.get(attribute.target);
 
   if (!targetMeta) {
-    throw new Error(`Unknow target ${attribute.target}`);
+    throw new Error(`Unknown target ${attribute.target}`);
   }
 
   const joinTableName = _.snakeCase(`${meta.tableName}_${attributeName}_links`);
@@ -415,6 +421,16 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       },
       // TODO: add extra pivot attributes -> user should use an intermediate entity
     },
+    indexes: [
+      {
+        name: `${joinTableName}_fk`,
+        columns: [joinColumnName],
+      },
+      {
+        name: `${joinTableName}_inv_fk`,
+        columns: [inverseJoinColumnName],
+      },
+    ],
     foreignKeys: [
       {
         name: `${joinTableName}_fk`,

package/lib/migrations/index.d.ts

@@ -0,0 +1,9 @@
+import { Database } from '../';
+
+export interface MigrationProvider {
+  shouldRun(): Promise<boolean>;
+  up(): Promise<void>;
+  down(): Promise<void>;
+}
+
+export function createMigrationsProvider(db: Database): MigrationProvider;

package/lib/migrations/index.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const path = require('path');
+const fse = require('fs-extra');
+const Umzug = require('umzug');
+
+const createStorage = require('./storage');
+
+// TODO: check multiple commands in one sql statement
+const migrationResolver = path => {
+  // if sql file run with knex raw
+  if (path.match(/\.sql$/)) {
+    const sql = fse.readFileSync(path, 'utf8');
+
+    return {
+      up: knex => knex.raw(sql),
+      down() {},
+    };
+  }
+
+  // NOTE: we can add some ts register if we want to handle ts migration files at some point
+  return require(path);
+};
+
+const createUmzugProvider = db => {
+  const migrationDir = path.join(strapi.dirs.root, 'database/migrations');
+
+  fse.ensureDirSync(migrationDir);
+
+  const wrapFn = fn => db => db.getConnection().transaction(trx => Promise.resolve(fn(trx)));
+  const storage = createStorage({ db, tableName: 'strapi_migrations' });
+
+  return new Umzug({
+    storage,
+    migrations: {
+      path: migrationDir,
+      pattern: /\.(js|sql)$/,
+      params: [db],
+      wrap: wrapFn,
+      customResolver: migrationResolver,
+    },
+  });
+};
+
+// NOTE: when needed => add internal migrations for core & plugins. How do we overlap them with users migrations ?
+
+/**
+ * Creates migrations provider
+ * @type {import('.').createMigrationsProvider}
+ */
+const createMigrationsProvider = db => {
+  const migrations = createUmzugProvider(db);
+
+  return {
+    async shouldRun() {
+      const pending = await migrations.pending();
+
+      return pending.length > 0;
+    },
+    async up() {
+      await migrations.up();
+    },
+    async down() {
+      await migrations.down();
+    },
+  };
+};
+
+module.exports = { createMigrationsProvider };

package/lib/migrations/storage.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const createStorage = (opts = {}) => {
+  const { db, tableName = 'strapi_migrations' } = opts;
+
+  const hasMigrationTable = () => db.getSchemaConnection().hasTable(tableName);
+
+  const createMigrationTable = () => {
+    return db.getSchemaConnection().createTable(tableName, table => {
+      table.increments('id');
+      table.string('name');
+      table.datetime('time', { useTz: false });
+    });
+  };
+
+  return {
+    async logMigration(migrationName) {
+      await db
+        .getConnection()
+        .insert({
+          name: migrationName,
+          time: new Date(),
+        })
+        .into(tableName);
+    },
+
+    async unlogMigration(migrationName) {
+      await db
+        .getConnection(tableName)
+        .del()
+        .where({ name: migrationName });
+    },
+
+    async executed() {
+      if (!(await hasMigrationTable())) {
+        await createMigrationTable();
+        return [];
+      }
+
+      const logs = await db
+        .getConnection(tableName)
+        .select()
+        .from(tableName)
+        .orderBy('time');
+
+      return logs.map(log => log.name);
+    },
+  };
+};
+
+module.exports = createStorage;

package/lib/query/helpers/join.js

@@ -51,12 +51,10 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
     return createPivotJoin(qb, joinTable, alias, tragetMeta);
   }
 
-  // TODO: polymorphic relations
-
   return alias;
 };
 
-// TODO: allow for more conditions
+// TODO: toColumnName for orderBy & on
 const applyJoin = (qb, join) => {
   const {
     method = 'leftJoin',
@@ -64,12 +62,12 @@ const applyJoin = (qb, join) => {
     referencedTable,
     referencedColumn,
     rootColumn,
-    rootTable = this.alias,
+    rootTable = qb.alias,
     on,
     orderBy,
   } = join;
 
-  qb[method]({ [alias]: referencedTable }, inner => {
+  qb[method](`${referencedTable} as ${alias}`, inner => {
     inner.on(`${rootTable}.${rootColumn}`, `${alias}.${referencedColumn}`);
 
     if (on) {

package/lib/query/helpers/order-by.js

@@ -4,19 +4,23 @@ const _ = require('lodash/fp');
 
 const types = require('../../types');
 const { createJoin } = require('./join');
+const { toColumnName } = require('./transform');
 
-// TODO: convert field names to columns names
 const processOrderBy = (orderBy, ctx) => {
-  const { db, uid, qb, alias = qb.alias } = ctx;
+  const { db, uid, qb, alias } = ctx;
+  const meta = db.metadata.get(uid);
+  const { attributes } = meta;
 
   if (typeof orderBy === 'string') {
-    const attribute = db.metadata.get(uid).attributes[orderBy];
+    const attribute = attributes[orderBy];
 
     if (!attribute) {
       throw new Error(`Attribute ${orderBy} not found on model ${uid}`);
     }
 
-    return [{ column: `${alias}.${orderBy}` }];
+    const columnName = toColumnName(meta, orderBy);
+
+    return [{ column: qb.aliasColumn(columnName, alias) }];
   }
 
   if (Array.isArray(orderBy)) {
@@ -26,15 +30,25 @@ const processOrderBy = (orderBy, ctx) => {
   if (_.isPlainObject(orderBy)) {
     return Object.entries(orderBy).flatMap(([key, direction]) => {
       const value = orderBy[key];
-      const attribute = db.metadata.get(uid).attributes[key];
+      const attribute = attributes[key];
 
       if (!attribute) {
         throw new Error(`Attribute ${key} not found on model ${uid}`);
       }
 
+      if (types.isScalar(attribute.type)) {
+        const columnName = toColumnName(meta, key);
+
+        return { column: qb.aliasColumn(columnName, alias), order: direction };
+      }
+
       if (attribute.type === 'relation') {
-        // TODO: pass down some filters (e.g published at)
-        const subAlias = createJoin(ctx, { alias, uid, attributeName: key, attribute });
+        const subAlias = createJoin(ctx, {
+          alias: alias || qb.alias,
+          uid,
+          attributeName: key,
+          attribute,
+        });
 
         return processOrderBy(value, {
           db,
@@ -44,10 +58,6 @@ const processOrderBy = (orderBy, ctx) => {
         });
       }
 
-      if (types.isScalar(attribute.type)) {
-        return { column: `${alias}.${key}`, order: direction };
-      }
-
       throw new Error(`You cannot order on ${attribute.type} types`);
     });
   }

package/lib/query/helpers/populate.js

@@ -33,7 +33,7 @@ const processPopulate = (populate, ctx) => {
 
   let populateMap = {};
 
-  if (populate === false) {
+  if (populate === false || _.isNil(populate)) {
     return null;
   }
 
@@ -94,8 +94,17 @@ const processPopulate = (populate, ctx) => {
   return finalPopulate;
 };
 
-//  Omit limit & offset to avoid needing a query per result to avoid making too many queries
-const pickPopulateParams = _.pick(['select', 'count', 'where', 'populate', 'orderBy']);
+//  TODO: Omit limit & offset to avoid needing a query per result to avoid making too many queries
+const pickPopulateParams = _.pick([
+  'select',
+  'count',
+  'where',
+  'populate',
+  'orderBy',
+  'limit',
+  'offset',
+  'filters',
+]);
 
 // TODO: cleanup code
 // TODO: create aliases for pivot columns
@@ -114,7 +123,11 @@ const applyPopulate = async (results, populate, ctx) => {
     const attribute = meta.attributes[key];
     const targetMeta = db.metadata.get(attribute.target);
 
-    const populateValue = pickPopulateParams(populate[key]);
+    const populateValue = {
+      filters: qb.state.filters,
+      ...pickPopulateParams(populate[key]),
+    };
+
     const isCount = populateValue.count === true;
 
     const fromTargetRow = rowOrRows => fromRow(targetMeta, rowOrRows);
@@ -181,7 +194,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinTable.inverseJoinColumn.name,
             rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -265,7 +278,7 @@ const applyPopulate = async (results, populate, ctx) => {
           const rows = await qb
             .init(populateValue)
             .join({
-              alias: alias,
+              alias,
               referencedTable: joinTable.name,
               referencedColumn: joinTable.inverseJoinColumn.name,
               rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -299,7 +312,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinTable.inverseJoinColumn.name,
             rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -344,7 +357,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinTable.inverseJoinColumn.name,
             rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -378,7 +391,7 @@ const applyPopulate = async (results, populate, ctx) => {
       const rows = await qb
         .init(populateValue)
         .join({
-          alias: alias,
+          alias,
           referencedTable: joinTable.name,
           referencedColumn: joinTable.inverseJoinColumn.name,
           rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -461,7 +474,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinColumn.name,
             rootColumn: joinColumn.referencedColumn,
@@ -538,6 +551,12 @@ const applyPopulate = async (results, populate, ctx) => {
       for (const type in idsByType) {
         const ids = idsByType[type];
 
+        // type was removed but still in morph relation
+        if (!db.metadata.get(type)) {
+          map[type] = {};
+          continue;
+        }
+
         const qb = db.entityManager.createQueryBuilder(type);
 
         const rows = await qb
@@ -596,6 +615,12 @@ const applyPopulate = async (results, populate, ctx) => {
       for (const type in idsByType) {
         const ids = idsByType[type];
 
+        // type was removed but still in morph relation
+        if (!db.metadata.get(type)) {
+          map[type] = {};
+          continue;
+        }
+
         const qb = db.entityManager.createQueryBuilder(type);
 
         const rows = await qb

package/lib/query/helpers/search.js

@@ -3,11 +3,13 @@
 const _ = require('lodash/fp');
 
 const types = require('../../types');
+const { toColumnName } = require('./transform');
 
-const applySearch = (qb, query, ctx) => {
-  const { alias, uid, db } = ctx;
+const applySearch = (knex, query, ctx) => {
+  const { qb, uid, db } = ctx;
+  const meta = db.metadata.get(uid);
 
-  const { attributes } = db.metadata.get(uid);
+  const { attributes } = meta;
 
   const searchColumns = ['id'];
 
@@ -29,22 +31,34 @@ const applySearch = (qb, query, ctx) => {
 
   switch (db.dialect.client) {
     case 'postgres': {
-      searchColumns.forEach(attr =>
-        qb.orWhereRaw(`"${alias}"."${attr}"::text ILIKE ?`, `%${escapeQuery(query, '*%\\')}%`)
-      );
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`??::text ILIKE ?`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
 
       break;
     }
     case 'sqlite': {
-      searchColumns.forEach(attr =>
-        qb.orWhereRaw(`"${alias}"."${attr}" LIKE ? ESCAPE '\\'`, `%${escapeQuery(query, '*%\\')}%`)
-      );
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`?? LIKE ? ESCAPE '\\'`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
       break;
     }
     case 'mysql': {
-      searchColumns.forEach(attr =>
-        qb.orWhereRaw(`\`${alias}\`.\`${attr}\` LIKE ?`, `%${escapeQuery(query, '*%\\')}%`)
-      );
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`?? LIKE ?`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
       break;
     }
     default: {