@strapi/database 4.14.4 → 4.14.6

package/lib/index.d.ts

@@ -1,198 +0,0 @@
-import { Knex } from 'knex';
-import { LifecycleProvider } from './lifecycles';
-import { MigrationProvider } from './migrations';
-import { SchemaProvider } from './schema';
-export * as errors from './errors';
-
-type ID = number | string;
-
-type LogicalOperators<T> = {
-  $and?: WhereParams<T>[];
-  $or?: WhereParams<T>[];
-  $not?: WhereParams<T>;
-};
-
-type AttributeOperators<T, K extends keyof T> = {
-  $eq?: T[K] | Array<T[K]>;
-  $ne?: T[K] | Array<T[K]>;
-  $nei?: T[K] | Array<T[K]>;
-  $in?: T[K][];
-  $notIn?: T[K][];
-  $lt?: T[K];
-  $lte?: T[K];
-  $gt?: T[K];
-  $gte?: T[K];
-  $between?: [T[K], T[K]];
-  $contains?: T[K];
-  $notContains?: T[K];
-  $containsi?: T[K];
-  $notContainsi?: T[K];
-  $startsWith?: T[K];
-  $endsWith?: T[K];
-  $null?: boolean;
-  $notNull?: boolean;
-  $not?: WhereParams<T> | AttributeOperators<T, K>;
-};
-
-export type WhereParams<T> = {
-  [K in keyof T]?: T[K] | T[K][] | AttributeOperators<T, K>;
-} & LogicalOperators<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][];
-}
-
-export 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; ids: ID[] }>;
-
-  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]>;
-}
-
-export interface QueryFromContentType<T extends keyof AllTypes> {
-  findOne(params?: any): Promise<any>;
-  findMany(params?: any): Promise<any[]>;
-  findWithCount(params?: any): Promise<[any[], number]>;
-  findPage(params?: any): Promise<{ results: any[]; pagination: Pagination }>;
-
-  create(params?: any): Promise<any>;
-  createMany(params?: any): Promise<{ count: number; ids: ID[] }>;
-
-  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>;
-  clone<S extends AllTypes[T]>(cloneId: ID, params?: Params<S>): Promise<S>;
-  load<S extends AllTypes[T], K extends string>(
-    entity: S,
-    field: K | K[],
-    populate?: PopulateParams
-  ): Promise<S[K]>;
-  loadPages<S extends AllTypes[T], K extends string>(
-    entity: S,
-    field: K | 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: SchemaProvider;
-  lifecycles: LifecycleProvider;
-  migrations: MigrationProvider;
-  entityManager: EntityManager;
-  queryBuilder: any;
-  metadata: any;
-  connection: Knex;
-  dialect: {
-    client: string;
-  };
-
-  destroy(): Promise<void>;
-
-  getSchemaConnection: () => Knex.SchemaBuilder;
-
-  query: <T extends keyof AllTypes>(uid: T) => QueryFromContentType<T>;
-  transaction(
-    cb?: (params: {
-      trx: Knex.Transaction;
-      rollback: () => Promise<void>;
-      commit: () => Promise<void>;
-      onCommit: (cb) => void;
-      onRollback: (cb) => void;
-    }) => Promise<unknown>
-  ):
-    | Promise<unknown>
-    | { get: () => Knex.Transaction; rollback: () => Promise<void>; commit: () => Promise<void> };
-  inTransaction: () => boolean;
-}
-export class Database implements Database {
-  static transformContentTypes(contentTypes: any[]): ModelConfig[];
-  static init(config: DatabaseConfig): Promise<Database>;
-}

package/lib/index.js

@@ -1,129 +0,0 @@
-'use strict';
-
-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');
-const createConnection = require('./connection');
-const errors = require('./errors');
-const transactionCtx = require('./transaction-context');
-
-// TODO: move back into strapi
-const { transformContentTypes } = require('./utils/content-types');
-const { validateDatabase } = require('./validations');
-
-class Database {
-  constructor(config) {
-    this.metadata = createMetadata(config.models);
-
-    this.config = {
-      connection: {},
-      settings: {
-        forceMigration: true,
-        runMigrations: true,
-        ...config.settings,
-      },
-      ...config,
-    };
-
-    this.dialect = getDialect(this);
-    this.dialect.configure();
-
-    this.connection = createConnection(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);
-  }
-
-  inTransaction() {
-    return !!transactionCtx.get();
-  }
-
-  async transaction(cb) {
-    const notNestedTransaction = !transactionCtx.get();
-    const trx = notNestedTransaction ? await this.connection.transaction() : transactionCtx.get();
-
-    async function commit() {
-      if (notNestedTransaction) {
-        await transactionCtx.commit(trx);
-      }
-    }
-
-    async function rollback() {
-      if (notNestedTransaction) {
-        await transactionCtx.rollback(trx);
-      }
-    }
-
-    if (!cb) {
-      return { commit, rollback, get: () => trx };
-    }
-
-    return transactionCtx.run(trx, async () => {
-      try {
-        const callbackParams = {
-          trx,
-          commit,
-          rollback,
-          onCommit: transactionCtx.onCommit,
-          onRollback: transactionCtx.onRollback,
-        };
-        const res = await cb(callbackParams);
-        await commit();
-        return res;
-      } catch (error) {
-        await rollback();
-        throw error;
-      }
-    });
-  }
-
-  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();
-  }
-}
-
-// TODO: move into strapi
-Database.transformContentTypes = transformContentTypes;
-Database.init = async (config) => {
-  const db = new Database(config);
-  await validateDatabase(db);
-  return db;
-};
-
-module.exports = {
-  Database,
-  errors,
-};

package/lib/lifecycles/index.d.ts

@@ -1,51 +0,0 @@
-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<Map<any, any>>;
-  run(action: Action, uid: string, properties: any, states: Map<any, any>): Promise<Map<any, any>>;
-  createEvent(action: Action, uid: string, properties: any): Event;
-}
-
-export function createLifecyclesProvider(db: Database): LifecycleProvider;

package/lib/lifecycles/index.js

@@ -1,90 +0,0 @@
-'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 = [];
-    },
-
-    /**
-     * @param {string} action
-     * @param {string} uid
-     * @param {{ params?: any, result?: any }} properties
-     * @param {Map<any, any>} state
-     */
-    createEvent(action, uid, properties, state) {
-      const model = db.metadata.get(uid);
-
-      return {
-        action,
-        model,
-        state,
-        ...properties,
-      };
-    },
-
-    /**
-     * @param {string} action
-     * @param {string} uid
-     * @param {{ params?: any, result?: any }} properties
-     * @param {Map<any, any>} states
-     */
-    async run(action, uid, properties, states = new Map()) {
-      for (let i = 0; i < subscribers.length; i += 1) {
-        const subscriber = subscribers[i];
-        if (typeof subscriber === 'function') {
-          const state = states.get(subscriber) || {};
-          const event = this.createEvent(action, uid, properties, state);
-          await subscriber(event);
-          if (event.state) {
-            states.set(subscriber, event.state || state);
-          }
-          continue;
-        }
-
-        const hasAction = action in subscriber;
-        const hasModel = !subscriber.models || subscriber.models.includes(uid);
-
-        if (hasAction && hasModel) {
-          const state = states.get(subscriber) || {};
-          const event = this.createEvent(action, uid, properties, state);
-
-          await subscriber[action](event);
-          if (event.state) {
-            states.set(subscriber, event.state);
-          }
-        }
-      }
-
-      return states;
-    },
-  };
-};
-
-module.exports = {
-  createLifecyclesProvider,
-};

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

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

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

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

@@ -1,65 +0,0 @@
-'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;