@strapi/database 4.0.0-next.6 → 4.0.0

package/lib/dialects/sqlite/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const path = require('path');
+const fse = require('fs-extra');
+
+const errors = require('../../errors');
+const { Dialect } = require('../dialect');
+const SqliteSchmeaInspector = require('./schema-inspector');
+
+class SqliteDialect extends Dialect {
+  constructor(db) {
+    super(db);
+
+    this.schemaInspector = new SqliteSchmeaInspector(db);
+  }
+
+  configure() {
+    this.db.config.connection.connection.filename = path.resolve(
+      this.db.config.connection.connection.filename
+    );
+
+    const dbDir = path.dirname(this.db.config.connection.connection.filename);
+
+    fse.ensureDirSync(dbDir);
+  }
+
+  async initialize() {
+    await this.db.connection.raw('pragma foreign_keys = on');
+  }
+
+  canAlterConstraints() {
+    return false;
+  }
+
+  getSqlType(type) {
+    switch (type) {
+      // FIXME: enum must be dealt separately
+      case 'enum': {
+        return 'text';
+      }
+      case 'double':
+      case 'decimal': {
+        return 'float';
+      }
+      case 'timestamp': {
+        return 'datetime';
+      }
+      default: {
+        return type;
+      }
+    }
+  }
+
+  async startSchemaUpdate() {
+    await this.db.connection.raw(`pragma foreign_keys = off`);
+  }
+
+  async endSchemaUpdate() {
+    await this.db.connection.raw(`pragma foreign_keys = on`);
+  }
+
+  transformErrors(error) {
+    switch (error.errno) {
+      case 19: {
+        throw new errors.NotNullConstraint(); // TODO: extract column name
+      }
+      default: {
+        super.transformErrors(error);
+      }
+    }
+  }
+}
+
+module.exports = SqliteDialect;

package/lib/dialects/sqlite/schema-inspector.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const SQL_QUERIES = {
+  TABLE_LIST: `select name from sqlite_master where type = 'table' and name NOT LIKE 'sqlite%'`,
+  TABLE_INFO: `pragma table_info(??)`,
+  INDEX_LIST: 'pragma index_list(??)',
+  INDEX_INFO: 'pragma index_info(??)',
+  FOREIGN_KEY_LIST: 'pragma foreign_key_list(??)',
+};
+
+const toStrapiType = column => {
+  const { type } = column;
+
+  const rootType = type.toLowerCase().match(/[^(), ]+/)[0];
+
+  switch (rootType) {
+    case 'integer': {
+      if (column.pk) {
+        return { type: 'increments', args: [{ primary: true }] };
+      }
+
+      return { type: 'integer' };
+    }
+    case 'float': {
+      return { type: 'float', args: [10, 2] };
+    }
+    case 'bigint': {
+      return { type: 'bigInteger' };
+    }
+    case 'varchar': {
+      const length = type.slice(8, type.length - 1);
+
+      return { type: 'string', args: [Number(length)] };
+    }
+    case 'text': {
+      return { type: 'text', args: ['longtext'] };
+    }
+    case 'json': {
+      return { type: 'jsonb' };
+    }
+    case 'boolean': {
+      return { type: 'boolean' };
+    }
+    case 'datetime': {
+      return { type: 'datetime', args: [{ useTz: false, precision: 6 }] };
+    }
+    case 'date': {
+      return { type: 'date' };
+    }
+    case 'time': {
+      return { type: 'time', args: [{ precision: 3 }] };
+    }
+    default: {
+      return { type: 'specificType', args: [column.data_type] };
+    }
+  }
+};
+
+class SqliteSchemaInspector {
+  constructor(db) {
+    this.db = db;
+  }
+
+  async getSchema() {
+    const schema = { tables: [] };
+    const tables = await this.getTables();
+
+    for (const tableName of tables) {
+      const columns = await this.getColumns(tableName);
+      const indexes = await this.getIndexes(tableName);
+      const foreignKeys = await this.getForeignKeys(tableName);
+
+      schema.tables.push({
+        name: tableName,
+        columns,
+        indexes,
+        foreignKeys,
+      });
+    }
+
+    return schema;
+  }
+
+  async getTables() {
+    const rows = await this.db.connection.raw(SQL_QUERIES.TABLE_LIST);
+
+    return rows.map(row => row.name);
+  }
+
+  async getColumns(tableName) {
+    const rows = await this.db.connection.raw(SQL_QUERIES.TABLE_INFO, [tableName]);
+
+    return rows.map(row => {
+      const { type, args = [], ...rest } = toStrapiType(row);
+
+      return {
+        type,
+        args,
+        name: row.name,
+        defaultTo: row.dflt_value,
+        notNullable: row.notnull !== null ? Boolean(row.notnull) : null,
+        unsigned: false,
+        ...rest,
+      };
+    });
+  }
+
+  async getIndexes(tableName) {
+    const indexes = await this.db.connection.raw(SQL_QUERIES.INDEX_LIST, [tableName]);
+
+    const ret = [];
+
+    for (const index of indexes.filter(index => !index.name.startsWith('sqlite_'))) {
+      const res = await this.db.connection.raw(SQL_QUERIES.INDEX_INFO, [index.name]);
+
+      ret.push({
+        columns: res.map(row => row.name),
+        name: index.name,
+        type: index.unique ? 'unique' : null,
+      });
+    }
+
+    return ret;
+  }
+
+  async getForeignKeys(tableName) {
+    const fks = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_LIST, [tableName]);
+
+    const ret = {};
+
+    for (const fk of fks) {
+      if (!ret[fk.id]) {
+        ret[fk.id] = {
+          // TODO: name, //  find name
+          columns: [fk.from],
+          referencedColumns: [fk.to],
+          referencedTable: fk.table,
+          onUpdate: fk.on_update.toUpperCase(),
+          onDelete: fk.on_delete.toUpperCase(),
+        };
+      } else {
+        ret[fk.id].columns.push(fk.from);
+        ret[fk.id].referencedColumns.push(fk.to);
+      }
+    }
+
+    return Object.values(ret);
+  }
+}
+
+module.exports = SqliteSchemaInspector;

package/lib/entity-manager.js

@@ -29,8 +29,7 @@ const toAssocs = data => {
     });
 };
 
-// TODO: handle programmatic defaults
-const toRow = (metadata, data = {}, { withDefaults = false } = {}) => {
+const processData = (metadata, data = {}, { withDefaults = false } = {}) => {
   const { attributes } = metadata;
 
   const obj = {};
@@ -38,7 +37,6 @@ const toRow = (metadata, data = {}, { withDefaults = false } = {}) => {
   for (const attributeName in attributes) {
     const attribute = attributes[attributeName];
 
-    // TODO:  convert to column name
     if (types.isScalar(attribute.type)) {
       const field = createField(attribute);
 
@@ -65,7 +63,6 @@ const toRow = (metadata, data = {}, { withDefaults = false } = {}) => {
     if (types.isRelation(attribute.type)) {
       // oneToOne & manyToOne
       if (attribute.joinColumn && attribute.owner) {
-        // TODO: ensure joinColumn name respect convention ?
         const joinColumnName = attribute.joinColumn.name;
 
         // allow setting to null
@@ -145,7 +142,7 @@ const createEntityManager = db => {
       await db.lifecycles.run('beforeCount', uid, { params });
 
       const res = await this.createQueryBuilder(uid)
-        .init(_.pick(['_q', 'where'], params))
+        .init(_.pick(['_q', 'where', 'filters'], params))
         .count()
         .first()
         .execute();
@@ -167,7 +164,7 @@ const createEntityManager = db => {
         throw new Error('Create expects a data object');
       }
 
-      const dataToInsert = toRow(metadata, data, { withDefaults: true });
+      const dataToInsert = processData(metadata, data, { withDefaults: true });
 
       const [id] = await this.createQueryBuilder(uid)
         .insert(dataToInsert)
@@ -175,7 +172,7 @@ const createEntityManager = db => {
 
       await this.attachRelations(uid, id, data);
 
-      // TODO: in case there is not select or populate specified return the inserted data ?
+      // TODO: in case there is no select or populate specified return the inserted data ?
       // TODO: do not trigger the findOne lifecycles ?
       const result = await this.findOne(uid, {
         where: { id },
@@ -199,7 +196,7 @@ const createEntityManager = db => {
         throw new Error('CreateMany expects data to be an array');
       }
 
-      const dataToInsert = data.map(datum => toRow(metadata, datum, { withDefaults: true }));
+      const dataToInsert = data.map(datum => processData(metadata, datum, { withDefaults: true }));
 
       if (_.isEmpty(dataToInsert)) {
         throw new Error('Nothing to insert');
@@ -242,7 +239,7 @@ const createEntityManager = db => {
 
       const { id } = entity;
 
-      const dataToUpdate = toRow(metadata, data);
+      const dataToUpdate = processData(metadata, data);
 
       if (!_.isEmpty(dataToUpdate)) {
         await this.createQueryBuilder(uid)
@@ -272,7 +269,7 @@ const createEntityManager = db => {
       const metadata = db.metadata.get(uid);
       const { where, data } = params;
 
-      const dataToUpdate = toRow(metadata, data);
+      const dataToUpdate = processData(metadata, data);
 
       if (_.isEmpty(dataToUpdate)) {
         throw new Error('Update requires data');
@@ -299,7 +296,7 @@ const createEntityManager = db => {
         throw new Error('Delete requires a where parameter');
       }
 
-      // TODO: avoid trigger the findOne lifecycles in the case ?
+      // TODO: do not trigger the findOne lifecycles ?
       const entity = await this.findOne(uid, {
         select: select && ['id'].concat(select),
         where,
@@ -472,7 +469,6 @@ const createEntityManager = db => {
           const { joinTable } = attribute;
           const { joinColumn, inverseJoinColumn } = joinTable;
 
-          // TODO: validate logic of delete
           if (isOneToAny(attribute) && isBidirectional(attribute)) {
             await this.createQueryBuilder(joinTable.name)
               .delete()
@@ -654,7 +650,10 @@ const createEntityManager = db => {
             .where(joinTable.on || {})
             .execute();
 
-          if (['oneToOne', 'oneToMany'].includes(attribute.relation)) {
+          if (
+            isBidirectional(attribute) &&
+            ['oneToOne', 'oneToMany'].includes(attribute.relation)
+          ) {
             await this.createQueryBuilder(joinTable.name)
               .delete()
               .where({ [inverseJoinColumn.name]: toIds(data[attributeName]) })
@@ -772,6 +771,7 @@ const createEntityManager = db => {
           continue;
         }
 
+        // do not need to delete links when using foreign keys
         if (db.dialect.usesForeignKeys()) {
           return;
         }
@@ -812,7 +812,7 @@ const createEntityManager = db => {
       const entry = await this.findOne(uid, {
         select: ['id'],
         where: { id: entity.id },
-        populate: populate,
+        populate,
       });
 
       return Object.assign({}, entity, entry);
@@ -837,6 +837,10 @@ const createEntityManager = db => {
         },
       });
 
+      if (!entry) {
+        return null;
+      }
+
       return entry[field];
     },
 

package/lib/entity-repository.js

@@ -95,9 +95,8 @@ const createRepository = (uid, db) => {
       return db.entityManager.deleteRelations(uid, id);
     },
 
-    // TODO: add relation API
-    populate(entity, field, params) {
-      return db.entityManager.populate(uid, entity, field, params);
+    populate(entity, populate) {
+      return db.entityManager.populate(uid, entity, populate);
     },
 
     load(entity, field, params) {

package/lib/errors.js

@@ -1,14 +1,56 @@
 'use strict';
 
-class NotNullConstraint extends Error {
+/* DatabaseError */
+class DatabaseError extends Error {
+  constructor(message, details = {}) {
+    super();
+    this.name = 'DatabaseError';
+    this.message = message || 'A database error occured';
+    this.details = details;
+  }
+}
+
+class NotNullConstraint extends DatabaseError {
   constructor({ column = '' } = {}) {
     super();
     this.name = 'NotNullConstraint';
-    this.message = `Not null constraint violation${column ? `on on column ${column}` : ''}.`;
-    this.stack = null;
+    this.message = `Not null constraint violation${column ? ` on column ${column}` : ''}.`;
+    this.details = { column };
+    this.stack = '';
+  }
+}
+
+class InvalidTimeError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidTimeFormat';
+    this.message = message || 'Invalid time format, expected HH:mm:ss.SSS';
+    this.details = {};
+  }
+}
+
+class InvalidDateError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidTimeFormat';
+    this.message = message || 'Invalid date format, expected YYYY-MM-DD';
+    this.details = {};
+  }
+}
+
+class InvalidDateTimeError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidTimeFormat';
+    this.message = message || 'Invalid datetime format, expected a timestamp or an ISO date';
+    this.details = {};
   }
 }
 
 module.exports = {
+  DatabaseError,
   NotNullConstraint,
+  InvalidTimeError,
+  InvalidDateError,
+  InvalidDateTimeError,
 };

package/lib/fields.d.ts

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

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>;
 }