@strapi/database 4.0.0-next.6 → 4.0.0

package/lib/index.js

@@ -6,41 +6,48 @@ const { getDialect } = require('./dialects');
 const createSchemaProvider = require('./schema');
 const createMetadata = require('./metadata');
 const { createEntityManager } = require('./entity-manager');
-const { createLifecyclesManager } = require('./lifecycles');
+const { createMigrationsProvider } = require('./migrations');
+const { createLifecyclesProvider } = require('./lifecycles');
+const errors = require('./errors');
 
 // TODO: move back into strapi
 const { transformContentTypes } = require('./utils/content-types');
 
+const createConnection = config => {
+  const knexInstance = knex(config);
+
+  return Object.assign(knexInstance, {
+    getSchemaName() {
+      return this.client.connectionSettings.schema;
+    },
+  });
+};
+
 class Database {
   constructor(config) {
     this.metadata = createMetadata(config.models);
 
-    // TODO: validate meta
-    // this.metadata.validate();
+    this.config = {
+      connection: {},
+      settings: {
+        forceMigration: true,
+      },
+      ...config,
+    };
 
-    this.config = config;
     this.dialect = getDialect(this);
+    this.dialect.configure();
 
-    // TODO: migrations -> allow running them through cli before startup
-    this.schema = createSchemaProvider(this);
+    this.connection = createConnection(this.config.connection);
 
-    this.lifecycles = createLifecyclesManager(this);
+    this.dialect.initialize();
 
-    this.entityManager = createEntityManager(this);
-  }
-
-  async initialize() {
-    await this.dialect.initialize();
+    this.schema = createSchemaProvider(this);
 
-    this.connection = knex(this.config.connection);
+    this.migrations = createMigrationsProvider(this);
+    this.lifecycles = createLifecyclesProvider(this);
 
-    // register module lifeycles subscriber
-    this.lifecycles.subscribe(async event => {
-      const { model } = event;
-      if (event.action in model.lifecycles) {
-        await model.lifecycles[event.action](event);
-      }
-    });
+    this.entityManager = createEntityManager(this);
   }
 
   query(uid) {
@@ -51,6 +58,21 @@ class Database {
     return this.entityManager.getRepository(uid);
   }
 
+  getConnection(tableName) {
+    const schema = this.connection.getSchemaName();
+    const connection = tableName ? this.connection(tableName) : this.connection;
+    return schema ? connection.withSchema(schema) : connection;
+  }
+
+  getSchemaConnection(trx = this.connection) {
+    const schema = this.connection.getSchemaName();
+    return schema ? trx.schema.withSchema(schema) : trx.schema;
+  }
+
+  queryBuilder(uid) {
+    return this.entityManager.createQueryBuilder(uid);
+  }
+
   async destroy() {
     await this.lifecycles.clear();
     await this.connection.destroy();
@@ -59,14 +81,9 @@ class Database {
 
 // TODO: move into strapi
 Database.transformContentTypes = transformContentTypes;
-Database.init = async config => {
-  const db = new Database(config);
-
-  await db.initialize();
-
-  return db;
-};
+Database.init = async config => new Database(config);
 
 module.exports = {
   Database,
+  errors,
 };

package/lib/lifecycles/index.d.ts

@@ -0,0 +1,50 @@
+import { Database } from '../';
+import { Model } from '../schema';
+import { Subscriber } from './subscribers';
+
+export type Action =
+  | 'beforeCreate'
+  | 'afterCreate'
+  | 'beforeFindOne'
+  | 'afterFindOne'
+  | 'beforeFindMany'
+  | 'afterFindMany'
+  | 'beforeCount'
+  | 'afterCount'
+  | 'beforeCreateMany'
+  | 'afterCreateMany'
+  | 'beforeUpdate'
+  | 'afterUpdate'
+  | 'beforeUpdateMany'
+  | 'afterUpdateMany'
+  | 'beforeDelete'
+  | 'afterDelete'
+  | 'beforeDeleteMany'
+  | 'afterDeleteMany';
+
+export interface Params {
+  select?: any;
+  where?: any;
+  _q?: any;
+  orderBy?: any;
+  groupBy?: any;
+  offset?: any;
+  limit?: any;
+  populate?: any;
+  data?: any;
+}
+
+export interface Event {
+  action: Action;
+  model: Model;
+  params: Params;
+}
+
+export interface LifecycleProvider {
+  subscribe(subscriber: Subscriber): () => void;
+  clear(): void;
+  run(action: Action, uid: string, properties: any): Promise<void>;
+  createEvent(action: Action, uid: string, properties: any): Event;
+}
+
+export function createLifecyclesProvider(db: Database): LifecycleProvider;

package/lib/{lifecycles.js → lifecycles/index.js}

@@ -1,16 +1,33 @@
 'use strict';
 
-const createLifecyclesManager = db => {
-  let subscribers = [];
+const assert = require('assert').strict;
 
-  const lifecycleManager = {
+const timestampsLifecyclesSubscriber = require('./subscribers/timestamps');
+const modelLifecyclesSubscriber = require('./subscribers/models-lifecycles');
+
+const isValidSubscriber = subscriber => {
+  return (
+    typeof subscriber === 'function' || (typeof subscriber === 'object' && subscriber !== null)
+  );
+};
+
+/**
+ * @type {import('.').createLifecyclesProvider}
+ */
+const createLifecyclesProvider = db => {
+  let subscribers = [timestampsLifecyclesSubscriber, modelLifecyclesSubscriber];
+
+  return {
     subscribe(subscriber) {
-      // TODO: verify subscriber
+      assert(isValidSubscriber(subscriber), 'Invalid subscriber. Expected function or object');
+
       subscribers.push(subscriber);
 
-      return () => {
-        subscribers.splice(subscribers.indexOf(subscriber), 1);
-      };
+      return () => subscribers.splice(subscribers.indexOf(subscriber), 1);
+    },
+
+    clear() {
+      subscribers = [];
     },
 
     createEvent(action, uid, properties) {
@@ -41,15 +58,9 @@ const createLifecyclesManager = db => {
         }
       }
     },
-
-    clear() {
-      subscribers = [];
-    },
   };
-
-  return lifecycleManager;
 };
 
 module.exports = {
-  createLifecyclesManager,
+  createLifecyclesProvider,
 };

package/lib/lifecycles/subscribers/index.d.ts

@@ -0,0 +1,9 @@
+import { Event, Action } from '../';
+
+type SubscriberFn = (event: Event) => Promise<void> | void;
+
+type SubscriberMap = {
+  [k in Action]: SubscriberFn;
+};
+
+export type Subscriber = SubscriberFn | SubscriberMap;

package/lib/lifecycles/subscribers/models-lifecycles.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * @typedef {import(".").Subscriber } Subscriber
+ */
+
+/**
+ * For each model try to run it's lifecycles function if any is defined
+ * @type {Subscriber}
+ */
+const modelsLifecyclesSubscriber = async event => {
+  const { model } = event;
+
+  if (event.action in model.lifecycles) {
+    await model.lifecycles[event.action](event);
+  }
+};
+
+module.exports = modelsLifecyclesSubscriber;

package/lib/lifecycles/subscribers/timestamps.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * @typedef {import(".").Subscriber } Subscriber
+ * @typedef { import("../").Event } Event
+ */
+
+// NOTE: we could add onCreate & onUpdate on field level to do this instead
+
+/**
+ * @type {Subscriber}
+ */
+const timestampsLifecyclesSubscriber = {
+  /**
+   * Init createdAt & updatedAt before create
+   * @param {Event} event
+   */
+  beforeCreate(event) {
+    const { data } = event.params;
+
+    const now = new Date();
+    _.defaults(data, { createdAt: now, updatedAt: now });
+  },
+
+  /**
+   * Init createdAt & updatedAt before create
+   * @param {Event} event
+   */
+  beforeCreateMany(event) {
+    const { data } = event.params;
+
+    const now = new Date();
+    if (_.isArray(data)) {
+      data.forEach(data => _.defaults(data, { createdAt: now, updatedAt: now }));
+    }
+  },
+
+  /**
+   * Update updatedAt before update
+   * @param {Event} event
+   */
+  beforeUpdate(event) {
+    const { data } = event.params;
+
+    const now = new Date();
+    _.assign(data, { updatedAt: now });
+  },
+
+  /**
+   * Update updatedAt before update
+   * @param {Event} event
+   */
+  beforeUpdateMany(event) {
+    const { data } = event.params;
+
+    const now = new Date();
+    if (_.isArray(data)) {
+      data.forEach(data => _.assign(data, { updatedAt: now }));
+    }
+  },
+};
+
+module.exports = timestampsLifecyclesSubscriber;

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`,
@@ -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 };