@strapi/database 4.0.0-beta.0

package/lib/entity-repository.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const withDefaultPagination = params => {
+  const { page = 1, pageSize = 10, ...rest } = params;
+
+  return {
+    page: Number(page),
+    pageSize: Number(pageSize),
+    ...rest,
+  };
+};
+
+const createRepository = (uid, db) => {
+  return {
+    findOne(params) {
+      return db.entityManager.findOne(uid, params);
+    },
+
+    findMany(params) {
+      return db.entityManager.findMany(uid, params);
+    },
+
+    findWithCount(params) {
+      return Promise.all([
+        db.entityManager.findMany(uid, params),
+        db.entityManager.count(uid, params),
+      ]);
+    },
+
+    async findPage(params) {
+      const { page, pageSize, ...rest } = withDefaultPagination(params);
+
+      const offset = Math.max(page - 1, 0) * pageSize;
+      const limit = pageSize;
+
+      const query = {
+        ...rest,
+        limit,
+        offset,
+      };
+
+      const [results, total] = await Promise.all([
+        db.entityManager.findMany(uid, query),
+        db.entityManager.count(uid, query),
+      ]);
+
+      return {
+        results,
+        pagination: {
+          page,
+          pageSize,
+          pageCount: Math.ceil(total / pageSize),
+          total,
+        },
+      };
+    },
+
+    create(params) {
+      return db.entityManager.create(uid, params);
+    },
+
+    createMany(params) {
+      return db.entityManager.createMany(uid, params);
+    },
+
+    update(params) {
+      return db.entityManager.update(uid, params);
+    },
+
+    updateMany(params) {
+      return db.entityManager.updateMany(uid, params);
+    },
+
+    delete(params) {
+      return db.entityManager.delete(uid, params);
+    },
+
+    deleteMany(params) {
+      return db.entityManager.deleteMany(uid, params);
+    },
+
+    count(params) {
+      return db.entityManager.count(uid, params);
+    },
+
+    attachRelations(id, data) {
+      return db.entityManager.attachRelations(uid, id, data);
+    },
+
+    updateRelations(id, data) {
+      return db.entityManager.updateRelations(uid, id, data);
+    },
+
+    deleteRelations(id) {
+      return db.entityManager.deleteRelations(uid, id);
+    },
+
+    populate(entity, populate) {
+      return db.entityManager.populate(uid, entity, populate);
+    },
+
+    load(entity, field, params) {
+      return db.entityManager.load(uid, entity, field, params);
+    },
+  };
+};
+
+module.exports = {
+  createRepository,
+};

package/lib/errors.js

@@ -0,0 +1,14 @@
+'use strict';
+
+class NotNullConstraint extends Error {
+  constructor({ column = '' } = {}) {
+    super();
+    this.name = 'NotNullConstraint';
+    this.message = `Not null constraint violation${column ? `on on column ${column}` : ''}.`;
+    this.stack = '';
+  }
+}
+
+module.exports = {
+  NotNullConstraint,
+};

package/lib/fields.d.ts

@@ -0,0 +1,9 @@
+import { Attribute } from './schema';
+
+interface Field {
+  config: {};
+  toDB(value: any): any;
+  fromDB(value: any): any;
+}
+
+export function createField(attribute: Attribute): Field;

package/lib/fields.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const _ = require('lodash/fp');
+const dateFns = require('date-fns');
+
+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;
+  }
+
+  fromDB(value) {
+    return value;
+  }
+}
+
+class StringField extends Field {
+  toDB(value) {
+    return _.toString(value);
+  }
+
+  fromDB(value) {
+    return _.toString(value);
+  }
+}
+
+class JSONField extends Field {
+  toDB(value) {
+    return JSON.stringify(value);
+  }
+
+  fromDB(value) {
+    if (typeof value === 'string') return JSON.parse(value);
+    return value;
+  }
+}
+
+class BooleanField extends Field {
+  toDB(value) {
+    if (typeof value === 'boolean') return value;
+
+    if (['true', 't', '1', 1].includes(value)) {
+      return true;
+    }
+
+    if (['false', 'f', '0', 0].includes(value)) {
+      return false;
+    }
+
+    return Boolean(value);
+  }
+
+  fromDB(value) {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    const strVal = _.toString(value);
+
+    if (strVal === '1') {
+      return true;
+    } else if (strVal === '0') {
+      return false;
+    } else {
+      return null;
+    }
+  }
+}
+
+class NumberField extends Field {
+  toDB(value) {
+    const numberValue = _.toNumber(value);
+
+    if (Number.isNaN(numberValue)) {
+      throw new Error(`Expected a valid Number, got ${value}`);
+    }
+
+    return numberValue;
+  }
+
+  fromDB(value) {
+    return _.toNumber(value);
+  }
+}
+
+class BigIntegerField extends NumberField {
+  toDB(value) {
+    return _.toString(value);
+  }
+
+  fromDB(value) {
+    return _.toString(value);
+  }
+}
+
+const timeRegex = new RegExp('^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$');
+
+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}`);
+  }
+  const result = value.match(timeRegex);
+
+  if (result === null) {
+    throw new Error('Invalid time format, expected HH:mm:ss.SSS');
+  }
+
+  const [, hours, minutes, seconds, fraction = '.000'] = result;
+  const fractionPart = _.padCharsEnd('0', 3, fraction.slice(1));
+
+  return `${hours}:${minutes}:${seconds}.${fractionPart}`;
+};
+
+const parseDate = value => {
+  if (dateFns.isDate(value)) return dateFns.format(value, 'yyyy-MM-dd');
+  try {
+    let date = dateFns.parseISO(value);
+
+    if (dateFns.isValid(date)) return dateFns.format(date, 'yyyy-MM-dd');
+
+    throw new Error(`Invalid format, expected an ISO compatible date`);
+  } catch (error) {
+    throw new Error(`Invalid format, expected an ISO compatible date`);
+  }
+};
+
+const parseDateTimeOrTimestamp = value => {
+  if (dateFns.isDate(value)) return value;
+  try {
+    const date = dateFns.parseISO(value);
+    if (dateFns.isValid(date)) return date;
+
+    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`);
+  } catch (error) {
+    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+  }
+};
+
+class DateField extends Field {
+  toDB(value) {
+    return parseDate(value);
+  }
+
+  fromDB(value) {
+    const cast = new Date(value);
+    return dateFns.isValid(cast) ? dateFns.formatISO(cast, { representation: 'date' }) : null;
+  }
+}
+class DatetimeField extends Field {
+  toDB(value) {
+    return parseDateTimeOrTimestamp(value);
+  }
+
+  fromDB(value) {
+    const cast = new Date(value);
+    return dateFns.isValid(cast) ? cast.toISOString() : null;
+  }
+}
+
+class TimeField extends Field {
+  toDB(value) {
+    return parseTime(value);
+  }
+
+  fromDB(value) {
+    // make sure that's a string with valid format ?
+    return value;
+  }
+}
+class TimestampField extends Field {
+  toDB(value) {
+    return parseDateTimeOrTimestamp(value);
+  }
+
+  fromDB(value) {
+    const cast = new Date(value);
+    return dateFns.isValid(cast) ? dateFns.format(cast, 'T') : null;
+  }
+}
+
+const typeToFieldMap = {
+  increments: Field,
+  password: StringField,
+  email: StringField,
+  string: StringField,
+  uid: StringField,
+  richtext: StringField,
+  text: StringField,
+  enumeration: StringField,
+  json: JSONField,
+  biginteger: BigIntegerField,
+  integer: NumberField,
+  float: NumberField,
+  decimal: NumberField,
+  date: DateField,
+  time: TimeField,
+  datetime: DatetimeField,
+  timestamp: TimestampField,
+  boolean: BooleanField,
+};
+
+const createField = attribute => {
+  const { type } = attribute;
+
+  if (_.has(type, typeToFieldMap)) {
+    return new typeToFieldMap[type]({});
+  }
+
+  throw new Error(`Undefined field for type ${type}`);
+};
+
+module.exports = {
+  createField,
+};

package/lib/index.d.ts

@@ -0,0 +1,146 @@
+import { LifecycleProvider } from './lifecycles';
+import { MigrationProvider } from './migrations';
+import { SchemaProvideer } from './schema';
+
+type BooleanWhere<T> = {
+  $and?: WhereParams<T>[];
+  $or?: WhereParams<T>[];
+  $not?: WhereParams<T>;
+};
+
+type WhereParams<T> = {
+  [K in keyof T]?: T[K];
+} &
+  BooleanWhere<T>;
+
+type Sortables<T> = {
+  // check sortable
+  [P in keyof T]: P;
+}[keyof T];
+
+type Direction = 'asc' | 'ASC' | 'DESC' | 'desc';
+
+interface FindParams<T> {
+  select?: (keyof T)[];
+  // TODO: add nested operators & relations
+  where?: WhereParams<T>;
+  limit?: number;
+  offset?: number;
+  orderBy?: // TODO: add relations
+  | Sortables<T>
+    | Sortables<T>[]
+    | { [K in Sortables<T>]?: Direction }
+    | { [K in Sortables<T>]?: Direction }[];
+  // TODO: define nested obj
+  populate?: (keyof T)[];
+}
+
+interface CreateParams<T> {
+  select?: (keyof T)[];
+  populate?: (keyof T)[];
+  data: T[keyof T];
+}
+
+interface CreateManyParams<T> {
+  select?: (keyof T)[];
+  populate?: (keyof T)[];
+  data: T[keyof T][];
+}
+
+interface Pagination {
+  page: number;
+  pageSize: number;
+  pageCount: number;
+  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]>): 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 }>;
+
+  update(params: any): Promise<any>;
+  updateMany(params: any): Promise<{ count: number }>;
+
+  delete(params: any): Promise<any>;
+  deleteMany(params: any): Promise<{ count: number }>;
+
+  count(params: any): Promise<number>;
+
+  attachRelations(id: ID, data: any): Promise<any>;
+  updateRelations(id: ID, data: any): Promise<any>;
+  deleteRelations(id: ID): Promise<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 {
+  tableName: string;
+  [k: string]: any;
+}
+
+interface ConnectionConfig {}
+
+interface DatabaseConfig {
+  connection: ConnectionConfig;
+  models: ModelConfig[];
+}
+export interface Database {
+  schema: SchemaProvideer;
+  lifecycles: LifecycleProvider;
+  migrations: MigrationProvider;
+  entityManager: EntityManager;
+
+  query<T extends keyof AllTypes>(uid: T): QueryFromContentType<T>;
+}
+export class Database implements Database {
+  static transformContentTypes(contentTypes: any[]): ModelConfig[];
+  static init(config: DatabaseConfig): Promise<Database>;
+}

package/lib/index.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const knex = require('knex');
+
+const { getDialect } = require('./dialects');
+const createSchemaProvider = require('./schema');
+const createMetadata = require('./metadata');
+const { createEntityManager } = require('./entity-manager');
+const { createMigrationsProvider } = require('./migrations');
+const { createLifecyclesProvider } = require('./lifecycles');
+
+// TODO: move back into strapi
+const { transformContentTypes } = require('./utils/content-types');
+
+class Database {
+  constructor(config) {
+    this.metadata = createMetadata(config.models);
+
+    this.config = config;
+
+    this.dialect = getDialect(this);
+    this.dialect.configure();
+
+    this.connection = knex(this.config.connection);
+
+    this.dialect.initialize();
+
+    this.schema = createSchemaProvider(this);
+
+    this.migrations = createMigrationsProvider(this);
+    this.lifecycles = createLifecyclesProvider(this);
+
+    this.entityManager = createEntityManager(this);
+  }
+
+  query(uid) {
+    if (!this.metadata.has(uid)) {
+      throw new Error(`Model ${uid} not found`);
+    }
+
+    return this.entityManager.getRepository(uid);
+  }
+
+  queryBuilder(uid) {
+    return this.entityManager.createQueryBuilder(uid);
+  }
+
+  async destroy() {
+    await this.lifecycles.clear();
+    await this.connection.destroy();
+  }
+}
+
+// TODO: move into strapi
+Database.transformContentTypes = transformContentTypes;
+Database.init = async config => new Database(config);
+
+module.exports = {
+  Database,
+};

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/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const assert = require('assert').strict;
+
+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) {
+      assert(isValidSubscriber(subscriber), 'Invalid subscriber. Expected function or object');
+
+      subscribers.push(subscriber);
+
+      return () => subscribers.splice(subscribers.indexOf(subscriber), 1);
+    },
+
+    clear() {
+      subscribers = [];
+    },
+
+    createEvent(action, uid, properties) {
+      const model = db.metadata.get(uid);
+
+      return {
+        action,
+        model,
+        ...properties,
+      };
+    },
+
+    async run(action, uid, properties) {
+      for (const subscriber of subscribers) {
+        if (typeof subscriber === 'function') {
+          const event = this.createEvent(action, uid, properties);
+          await subscriber(event);
+          continue;
+        }
+
+        const hasAction = action in subscriber;
+        const hasModel = !subscriber.models || subscriber.models.includes(uid);
+
+        if (hasAction && hasModel) {
+          const event = this.createEvent(action, uid, properties);
+
+          await subscriber[action](event);
+        }
+      }
+    },
+  };
+};
+
+module.exports = {
+  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;