@strapi/database 4.0.0-next.8 → 4.0.2

package/lib/fields.js

@@ -2,22 +2,13 @@
 
 const _ = require('lodash/fp');
 const dateFns = require('date-fns');
+const { InvalidTimeError, InvalidDateError, InvalidDateTimeError } = require('./errors');
 
 class Field {
   constructor(config) {
     this.config = config;
   }
 
-  // TODO: impl
-  validate() {
-    // // use config validators directly
-    // if (this.config.validators) {
-    //   this.config.validators.forEach(validator => {
-    //     validator(value)
-    //   })
-    // }
-  }
-
   toDB(value) {
     return value;
   }
@@ -112,12 +103,12 @@ const parseTime = value => {
   if (dateFns.isDate(value)) return dateFns.format(value, 'HH:mm:ss.SSS');
 
   if (typeof value !== 'string') {
-    throw new Error(`Expected a string, got a ${typeof value}`);
+    throw new InvalidTimeError(`Expected a string, got a ${typeof value}`);
   }
   const result = value.match(timeRegex);
 
   if (result === null) {
-    throw new Error('Invalid time format, expected HH:mm:ss.SSS');
+    throw new InvalidTimeError('Invalid time format, expected HH:mm:ss.SSS');
   }
 
   const [, hours, minutes, seconds, fraction = '.000'] = result;
@@ -133,9 +124,9 @@ const parseDate = value => {
 
     if (dateFns.isValid(date)) return dateFns.format(date, 'yyyy-MM-dd');
 
-    throw new Error(`Invalid format, expected an ISO compatible date`);
+    throw new InvalidDateError(`Invalid format, expected an ISO compatible date`);
   } catch (error) {
-    throw new Error(`Invalid format, expected an ISO compatible date`);
+    throw new InvalidDateError(`Invalid format, expected an ISO compatible date`);
   }
 };
 
@@ -148,9 +139,9 @@ const parseDateTimeOrTimestamp = value => {
     const milliUnixDate = dateFns.parse(value, 'T', new Date());
     if (dateFns.isValid(milliUnixDate)) return milliUnixDate;
 
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    throw new InvalidDateTimeError(`Invalid format, expected a timestamp or an ISO date`);
   } catch (error) {
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    throw new InvalidDateTimeError(`Invalid format, expected a timestamp or an ISO date`);
   }
 };
 

package/lib/index.d.ts

@@ -1,3 +1,7 @@
+import { LifecycleProvider } from './lifecycles';
+import { MigrationProvider } from './migrations';
+import { SchemaProvideer } from './schema';
+
 type BooleanWhere<T> = {
   $and?: WhereParams<T>[];
   $or?: WhereParams<T>[];
@@ -50,26 +54,71 @@ interface Pagination {
   total: number;
 }
 
+interface PopulateParams {}
+interface EntityManager {
+  findOne<K extends keyof AllTypes>(uid: K, params: FindParams<AllTypes[K]>): Promise<any>;
+  findMany<K extends keyof AllTypes>(uid: K, params: FindParams<AllTypes[K]>): Promise<any[]>;
+
+  create<K extends keyof AllTypes>(uid: K, params: CreateParams<AllTypes[K]>): Promise<any>;
+  createMany<K extends keyof AllTypes>(
+    uid: K,
+    params: CreateManyParams<AllTypes[K]>
+  ): Promise<{ count: number }>;
+
+  update<K extends keyof AllTypes>(uid: K, params: any): Promise<any>;
+  updateMany<K extends keyof AllTypes>(uid: K, params: any): Promise<{ count: number }>;
+
+  delete<K extends keyof AllTypes>(uid: K, params: any): Promise<any>;
+  deleteMany<K extends keyof AllTypes>(uid: K, params: any): Promise<{ count: number }>;
+
+  count<K extends keyof AllTypes>(uid: K, params: any): Promise<number>;
+
+  attachRelations<K extends keyof AllTypes>(uid: K, id: ID, data: any): Promise<any>;
+  updateRelations<K extends keyof AllTypes>(uid: K, id: ID, data: any): Promise<any>;
+  deleteRelations<K extends keyof AllTypes>(uid: K, id: ID): Promise<any>;
+
+  populate<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    entity: T,
+    populate: PopulateParams
+  ): Promise<T>;
+
+  load<K extends keyof AllTypes, T extends AllTypes[K], SK extends keyof T>(
+    uid: K,
+    entity: T,
+    field: SK,
+    populate: PopulateParams
+  ): Promise<T[SK]>;
+}
+
 interface QueryFromContentType<T extends keyof AllTypes> {
-  findOne(params: FindParams<AllTypes[T]>): any;
-  findMany(params: FindParams<AllTypes[T]>): any[];
-  findWithCount(params: FindParams<AllTypes[T]>): [any[], number];
-  findPage(params: FindParams<AllTypes[T]>): { results: any[]; pagination: Pagination };
+  findOne(params: FindParams<AllTypes[T]>): Promise<any>;
+  findMany(params: FindParams<AllTypes[T]>): Promise<any[]>;
+  findWithCount(params: FindParams<AllTypes[T]>): Promise<[any[], number]>;
+  findPage(params: FindParams<AllTypes[T]>): Promise<{ results: any[]; pagination: Pagination }>;
+
+  create(params: CreateParams<AllTypes[T]>): Promise<any>;
+  createMany(params: CreateManyParams<AllTypes[T]>): Promise<{ count: number }>;
 
-  create(params: CreateParams<AllTypes[T]>): any;
-  createMany(params: CreateManyParams<AllTypes[T]>): { count: number };
+  update(params: any): Promise<any>;
+  updateMany(params: any): Promise<{ count: number }>;
 
-  update(params: any): any;
-  updateMany(params: any): { count: number };
+  delete(params: any): Promise<any>;
+  deleteMany(params: any): Promise<{ count: number }>;
 
-  delete(params: any): any;
-  deleteMany(params: any): { count: number };
+  count(params: any): Promise<number>;
 
-  count(params: any): number;
+  attachRelations(id: ID, data: any): Promise<any>;
+  updateRelations(id: ID, data: any): Promise<any>;
+  deleteRelations(id: ID): Promise<any>;
 
-  attachRelations(id: ID, data: any): any;
-  updateRelations(id: ID, data: any): any;
-  deleteRelations(id: ID): any;
+  populate<S extends AllTypes[T]>(entity: S, populate: PopulateParams): Promise<S>;
+
+  load<S extends AllTypes[T], K extends keyof S>(
+    entity: S,
+    field: K,
+    populate: PopulateParams
+  ): Promise<S[K]>;
 }
 
 interface ModelConfig {
@@ -83,15 +132,11 @@ interface DatabaseConfig {
   connection: ConnectionConfig;
   models: ModelConfig[];
 }
-
-interface DatabaseSchema {
-  sync(): Promise<void>;
-  reset(): Promise<void>;
-  create(): Promise<void>;
-  drop(): Promise<void>;
-}
 export interface Database {
-  schema: DatabaseSchema;
+  schema: SchemaProvideer;
+  lifecycles: LifecycleProvider;
+  migrations: MigrationProvider;
+  entityManager: EntityManager;
 
   query<T extends keyof AllTypes>(uid: T): QueryFromContentType<T>;
 }

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;