@strapi/database 4.2.0-beta.0 → 4.2.0-beta.3

package/lib/__tests__/lifecycles.test.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { createLifecyclesProvider } = require('../lifecycles');
+
+describe('LifecycleProvider', () => {
+  describe('run', () => {
+    /** @type {import("../lifecycles").LifecycleProvider} */
+    let provider;
+    let dbMetadataGetStub = jest.fn(uid => ({ uid, name: 'TestModel' }));
+
+    beforeEach(() => {
+      const db = {
+        metadata: {
+          get: dbMetadataGetStub,
+        },
+      };
+      provider = createLifecyclesProvider(db);
+      provider.clear();
+    });
+
+    it('store state', async () => {
+      const expectedState = new Date().toISOString();
+
+      const subscriber = {
+        async beforeEvent(event) {
+          event.state = expectedState;
+        },
+      };
+      provider.subscribe(subscriber);
+
+      const stateBefore = await provider.run('beforeEvent', 'test-model', { id: 'instance-id' });
+
+      expect(stateBefore.get(subscriber)).toEqual(expectedState);
+    });
+
+    it('use shared state', async () => {
+      const expectedState = { value: new Date().toISOString() };
+      let receivedState;
+
+      provider.subscribe({
+        async beforeEvent(event) {
+          event.state.value = expectedState.value;
+        },
+        async afterEvent(event) {
+          receivedState = event.state;
+        },
+      });
+
+      const stateBefore = await provider.run('beforeEvent', 'test-model', { id: 'instance-id' });
+      await provider.run('afterEvent', 'test-model', { id: 'instance-id' }, stateBefore);
+
+      expect(receivedState).toEqual(expectedState);
+    });
+  });
+});

package/lib/connection.js

@@ -0,0 +1,64 @@
+/* eslint-disable node/no-missing-require */
+/* eslint-disable node/no-extraneous-require */
+'use strict';
+
+const knex = require('knex');
+
+const SqliteClient = require('knex/lib/dialects/sqlite3/index');
+
+const trySqlitePackage = packageName => {
+  try {
+    require.resolve(packageName);
+    return packageName;
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      return false;
+    }
+    throw error;
+  }
+};
+class LegacySqliteClient extends SqliteClient {
+  _driver() {
+    return require('sqlite3');
+  }
+}
+
+const clientMap = {
+  'better-sqlite3': 'better-sqlite3',
+  '@vscode/sqlite3': 'sqlite',
+  sqlite3: LegacySqliteClient,
+};
+
+const getSqlitePackageName = () => {
+  // NOTE: allow forcing the package to use (mostly used for testing purposes)
+  if (typeof process.env.SQLITE_PKG !== 'undefined') {
+    return process.env.SQLITE_PKG;
+  }
+
+  // NOTE: this tries to find the best sqlite module possible to use
+  // while keeping retro compatibility
+  return (
+    trySqlitePackage('better-sqlite3') ||
+    trySqlitePackage('@vscode/sqlite3') ||
+    trySqlitePackage('sqlite3')
+  );
+};
+
+const createConnection = config => {
+  const knexConfig = { ...config };
+  if (knexConfig.client === 'sqlite') {
+    const sqlitePackageName = getSqlitePackageName();
+
+    knexConfig.client = clientMap[sqlitePackageName];
+  }
+
+  const knexInstance = knex(knexConfig);
+
+  return Object.assign(knexInstance, {
+    getSchemaName() {
+      return this.client.connectionSettings.schema;
+    },
+  });
+};
+
+module.exports = createConnection;

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

@@ -48,7 +48,7 @@ const toStrapiType = column => {
   switch (rootType) {
     case 'int': {
       if (column.column_key === 'PRI') {
-        return { type: 'increments', args: [{ primary: true }], unsigned: false };
+        return { type: 'increments', args: [{ primary: true, primaryKey: true }], unsigned: false };
       }
 
       return { type: 'integer' };

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

@@ -16,7 +16,7 @@ const toStrapiType = column => {
   switch (rootType) {
     case 'integer': {
       if (column.pk) {
-        return { type: 'increments', args: [{ primary: true }] };
+        return { type: 'increments', args: [{ primary: true, primaryKey: true }] };
       }
 
       return { type: 'integer' };

package/lib/entity-manager.js

@@ -113,33 +113,33 @@ const createEntityManager = db => {
 
   return {
     async findOne(uid, params) {
-      await db.lifecycles.run('beforeFindOne', uid, { params });
+      const states = await db.lifecycles.run('beforeFindOne', uid, { params });
 
       const result = await this.createQueryBuilder(uid)
         .init(params)
         .first()
         .execute();
 
-      await db.lifecycles.run('afterFindOne', uid, { params, result });
+      await db.lifecycles.run('afterFindOne', uid, { params, result }, states);
 
       return result;
     },
 
     // should we name it findOne because people are used to it ?
     async findMany(uid, params) {
-      await db.lifecycles.run('beforeFindMany', uid, { params });
+      const states = await db.lifecycles.run('beforeFindMany', uid, { params });
 
       const result = await this.createQueryBuilder(uid)
         .init(params)
         .execute();
 
-      await db.lifecycles.run('afterFindMany', uid, { params, result });
+      await db.lifecycles.run('afterFindMany', uid, { params, result }, states);
 
       return result;
     },
 
-    async count(uid, params = {}) {
-      await db.lifecycles.run('beforeCount', uid, { params });
+    async count(uid, params) {
+      const states = await db.lifecycles.run('beforeCount', uid, { params });
 
       const res = await this.createQueryBuilder(uid)
         .init(_.pick(['_q', 'where', 'filters'], params))
@@ -149,13 +149,13 @@ const createEntityManager = db => {
 
       const result = Number(res.count);
 
-      await db.lifecycles.run('afterCount', uid, { params, result });
+      await db.lifecycles.run('afterCount', uid, { params, result }, states);
 
       return result;
     },
 
     async create(uid, params = {}) {
-      await db.lifecycles.run('beforeCreate', uid, { params });
+      const states = await db.lifecycles.run('beforeCreate', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { data } = params;
@@ -166,10 +166,12 @@ const createEntityManager = db => {
 
       const dataToInsert = processData(metadata, data, { withDefaults: true });
 
-      const [id] = await this.createQueryBuilder(uid)
+      const res = await this.createQueryBuilder(uid)
         .insert(dataToInsert)
         .execute();
 
+      const id = res[0].id || res[0];
+
       await this.attachRelations(uid, id, data);
 
       // TODO: in case there is no select or populate specified return the inserted data ?
@@ -180,14 +182,14 @@ const createEntityManager = db => {
         populate: params.populate,
       });
 
-      await db.lifecycles.run('afterCreate', uid, { params, result });
+      await db.lifecycles.run('afterCreate', uid, { params, result }, states);
 
       return result;
     },
 
     // TODO: where do we handle relation processing for many queries ?
     async createMany(uid, params = {}) {
-      await db.lifecycles.run('beforeCreateMany', uid, { params });
+      const states = await db.lifecycles.run('beforeCreateMany', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { data } = params;
@@ -208,13 +210,13 @@ const createEntityManager = db => {
 
       const result = { count: data.length };
 
-      await db.lifecycles.run('afterCreateMany', uid, { params, result });
+      await db.lifecycles.run('afterCreateMany', uid, { params, result }, states);
 
       return result;
     },
 
     async update(uid, params = {}) {
-      await db.lifecycles.run('beforeUpdate', uid, { params });
+      const states = await db.lifecycles.run('beforeUpdate', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { where, data } = params;
@@ -257,14 +259,14 @@ const createEntityManager = db => {
         populate: params.populate,
       });
 
-      await db.lifecycles.run('afterUpdate', uid, { params, result });
+      await db.lifecycles.run('afterUpdate', uid, { params, result }, states);
 
       return result;
     },
 
     // TODO: where do we handle relation processing for many queries ?
     async updateMany(uid, params = {}) {
-      await db.lifecycles.run('beforeUpdateMany', uid, { params });
+      const states = await db.lifecycles.run('beforeUpdateMany', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { where, data } = params;
@@ -282,13 +284,13 @@ const createEntityManager = db => {
 
       const result = { count: updatedRows };
 
-      await db.lifecycles.run('afterUpdateMany', uid, { params, result });
+      await db.lifecycles.run('afterUpdateMany', uid, { params, result }, states);
 
       return result;
     },
 
     async delete(uid, params = {}) {
-      await db.lifecycles.run('beforeDelete', uid, { params });
+      const states = await db.lifecycles.run('beforeDelete', uid, { params });
 
       const { where, select, populate } = params;
 
@@ -316,14 +318,14 @@ const createEntityManager = db => {
 
       await this.deleteRelations(uid, id);
 
-      await db.lifecycles.run('afterDelete', uid, { params, result: entity });
+      await db.lifecycles.run('afterDelete', uid, { params, result: entity }, states);
 
       return entity;
     },
 
     // TODO: where do we handle relation processing for many queries ?
     async deleteMany(uid, params = {}) {
-      await db.lifecycles.run('beforeDeleteMany', uid, { params });
+      const states = await db.lifecycles.run('beforeDeleteMany', uid, { params });
 
       const { where } = params;
 
@@ -334,7 +336,7 @@ const createEntityManager = db => {
 
       const result = { count: deletedRows };
 
-      await db.lifecycles.run('afterDelete', uid, { params, result });
+      await db.lifecycles.run('afterDeleteMany', uid, { params, result }, states);
 
       return result;
     },

package/lib/index.d.ts

@@ -2,16 +2,37 @@ import { LifecycleProvider } from './lifecycles';
 import { MigrationProvider } from './migrations';
 import { SchemaProvideer } from './schema';
 
-type BooleanWhere<T> = {
+type LogicOperators<T> = {
   $and?: WhereParams<T>[];
   $or?: WhereParams<T>[];
   $not?: WhereParams<T>;
-};
+}
+
+type AttributeOperators<T, K extends keyof T> = {
+  $eq?: T[K];
+  $ne?: 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>;
+}
 
-type WhereParams<T> = {
-  [K in keyof T]?: T[K];
+export type WhereParams<T> = {
+  [K in keyof T]?: T[K] | T[K][] | AttributeOperators<T, K>;
 } &
-  BooleanWhere<T>;
+  LogicOperators<T>;
 
 type Sortables<T> = {
   // check sortable

package/lib/index.js

@@ -1,28 +1,17 @@
 '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');
+const createConnection = require('./connection');
 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);

package/lib/lifecycles/index.d.ts

@@ -43,7 +43,8 @@ export interface Event {
 export interface LifecycleProvider {
   subscribe(subscriber: Subscriber): () => void;
   clear(): void;
-  run(action: Action, uid: string, properties: any): Promise<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;
 }
 

package/lib/lifecycles/index.js

@@ -30,21 +30,39 @@ const createLifecyclesProvider = db => {
       subscribers = [];
     },
 
-    createEvent(action, uid, properties) {
+    /**
+     * @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,
       };
     },
 
-    async run(action, uid, properties) {
-      for (const subscriber of subscribers) {
+    /**
+     * @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++) {
+        const subscriber = subscribers[i];
         if (typeof subscriber === 'function') {
-          const event = this.createEvent(action, uid, properties);
+          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;
         }
 
@@ -52,11 +70,17 @@ const createLifecyclesProvider = db => {
         const hasModel = !subscriber.models || subscriber.models.includes(uid);
 
         if (hasAction && hasModel) {
-          const event = this.createEvent(action, uid, properties);
+          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;
     },
   };
 };

package/lib/migrations/index.js

@@ -2,24 +2,35 @@
 
 const path = require('path');
 const fse = require('fs-extra');
-const Umzug = require('umzug');
+const { Umzug } = require('umzug');
 
 const createStorage = require('./storage');
 
+const wrapTransaction = db => fn => () =>
+  db.getConnection().transaction(trx => Promise.resolve(fn(trx)));
+
 // TODO: check multiple commands in one sql statement
-const migrationResolver = path => {
+const migrationResolver = ({ name, path, context }) => {
+  const { db } = context;
+
   // if sql file run with knex raw
   if (path.match(/\.sql$/)) {
     const sql = fse.readFileSync(path, 'utf8');
 
     return {
-      up: knex => knex.raw(sql),
+      name,
+      up: wrapTransaction(db)(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 migration = require(path);
+  return {
+    name,
+    up: wrapTransaction(db)(migration.up),
+    down: wrapTransaction(db)(migration.down),
+  };
 };
 
 const createUmzugProvider = db => {
@@ -27,17 +38,12 @@ const createUmzugProvider = db => {
 
   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,
+    storage: createStorage({ db, tableName: 'strapi_migrations' }),
+    context: { db },
     migrations: {
-      path: migrationDir,
-      pattern: /\.(js|sql)$/,
-      params: [db],
-      wrap: wrapFn,
-      customResolver: migrationResolver,
+      glob: ['*.{js,sql}', { cwd: migrationDir }],
+      resolve: migrationResolver,
     },
   });
 };

package/lib/migrations/storage.js

@@ -14,21 +14,21 @@ const createStorage = (opts = {}) => {
   };
 
   return {
-    async logMigration(migrationName) {
+    async logMigration({ name }) {
       await db
         .getConnection()
         .insert({
-          name: migrationName,
+          name,
           time: new Date(),
         })
         .into(tableName);
     },
 
-    async unlogMigration(migrationName) {
+    async unlogMigration({ name }) {
       await db
         .getConnection(tableName)
         .del()
-        .where({ name: migrationName });
+        .where({ name });
     },
 
     async executed() {

package/lib/schema/schema.js

@@ -105,7 +105,7 @@ const getColumnType = attribute => {
     case 'increments': {
       return {
         type: 'increments',
-        args: [{ primary: true }],
+        args: [{ primary: true, primaryKey: true }],
         notNullable: true,
       };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.2.0-beta.0",
+  "version": "4.2.0-beta.3",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -34,13 +34,13 @@
     "date-fns": "2.22.1",
     "debug": "4.3.1",
     "fs-extra": "10.0.0",
-    "knex": "0.95.6",
+    "knex": "1.0.4",
     "lodash": "4.17.21",
-    "umzug": "2.3.0"
+    "umzug": "3.1.1"
   },
   "engines": {
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "db70f0de7cc73fb469c8a076b89530729cf14142"
+  "gitHead": "c4addbad6ecbc8ef7633bbba3806f3b0a2ae5f49"
 }

package/examples/connections.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const postgres = {
-  client: 'postgres',
-  connection: {
-    database: 'strapi',
-    user: 'strapi',
-    password: 'strapi',
-  },
-  // debug: true,
-};
-
-const mysql = {
-  client: 'mysql',
-  connection: {
-    database: 'strapi',
-    user: 'strapi',
-    password: 'strapi',
-  },
-  // debug: true,
-};
-
-const sqlite = {
-  client: 'sqlite',
-  connection: {
-    filename: 'data.sqlite',
-  },
-  useNullAsDefault: true,
-  // debug: true,
-};
-
-module.exports = {
-  sqlite,
-  postgres,
-  mysql,
-};

package/examples/docker-compose.yml

@@ -1,29 +0,0 @@
-version: '3'
-
-services:
-  postgres:
-    image: postgres
-    restart: always
-    volumes:
-      - ./data/postgresql:/var/lib/postgresql/data
-    environment:
-      POSTGRES_USER: strapi
-      POSTGRES_PASSWORD: strapi
-      POSTGRES_DB: strapi
-    ports:
-      - '5432:5432'
-
-  mysql:
-    image: mysql
-    restart: always
-    command: --default-authentication-plugin=mysql_native_password
-    environment:
-      MYSQL_DATABASE: strapi
-      MYSQL_USER: strapi
-      MYSQL_PASSWORD: strapi
-      MYSQL_ROOT_HOST: '%'
-      MYSQL_ROOT_PASSWORD: strapi
-    volumes:
-      - ./data/mysql:/var/lib/mysql
-    ports:
-      - '3306:3306'

package/examples/index.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const util = require('util');
-
-const { Database } = require('../lib/index');
-const models = require('./models');
-const connections = require('./connections');
-
-async function main(connection) {
-  const orm = await Database.init({
-    connection,
-    models: Database.transformContentTypes(models),
-  });
-
-  try {
-    // await orm.schema.drop();
-    // await orm.schema.create();
-
-    await orm.schema.reset();
-
-    let res;
-
-    const c1 = await orm.query('comment').create({
-      data: {
-        title: 'coucou',
-      },
-    });
-
-    const c2 = await orm.query('video-comment').create({
-      data: {
-        title: 'coucou',
-      },
-    });
-
-    res = await orm.query('article').create({
-      data: {
-        dz: [
-          {
-            __type: 'comment',
-            id: c1.id,
-          },
-          {
-            __type: 'video-comment',
-            id: c2.id,
-          },
-        ],
-      },
-      populate: {
-        dz: true,
-      },
-    });
-
-    log(res);
-
-    res = await orm.query('article').findMany({
-      populate: {
-        dz: true,
-      },
-    });
-
-    log(res);
-
-    // await tests(orm);
-  } finally {
-    orm.destroy();
-  }
-}
-
-function log(res) {
-  console.log(util.inspect(res, null, null, true));
-}
-
-main(connections.sqlite);

package/examples/models.js

@@ -1,341 +0,0 @@
-'use strict';
-
-const category = {
-  modelName: 'category',
-  uid: 'category',
-  collectionName: 'categories',
-  attributes: {
-    title: {
-      type: 'string',
-    },
-    price: {
-      type: 'integer',
-      required: true,
-      default: 12,
-
-      column: {
-        unique: true,
-        nonNullable: true,
-        unsigned: true,
-        defaultTo: 12,
-      },
-    },
-    articles: {
-      type: 'relation',
-      relation: 'oneToMany',
-      target: 'article',
-      mappedBy: 'category',
-    },
-    compo: {
-      type: 'component',
-      component: 'compo',
-    },
-  },
-};
-
-const article = {
-  modelName: 'article',
-  uid: 'article',
-  collectionName: 'articles',
-  attributes: {
-    title: {
-      type: 'string',
-    },
-    category: {
-      type: 'relation',
-      relation: 'manyToOne',
-      target: 'category',
-      inversedBy: 'articles',
-      // useJoinTable: false,
-    },
-    // tags: {
-    //   type: 'relation',
-    //   relation: 'manyToMany',
-    //   target: 'tag',
-    //   inversedBy: 'articles',
-    // },
-    // compo: {
-    //   type: 'component',
-    //   component: 'compo',
-    //   // repeatable: true,
-    // },
-    // cover: {
-    //   type: 'media',
-    //   single: true,
-    // },
-    // gallery: {
-    //   type: 'media',
-    //   multiple: true,
-    // },
-  },
-};
-
-const tags = {
-  modelName: 'tag',
-  uid: 'tag',
-  collectionName: 'tags',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    articles: {
-      type: 'relation',
-      relation: 'manyToMany',
-      target: 'article',
-      mappedBy: 'tag',
-    },
-  },
-};
-
-const compo = {
-  modelName: 'compo',
-  uid: 'compo',
-  collectionName: 'compos',
-  attributes: {
-    key: {
-      type: 'string',
-    },
-    value: {
-      type: 'string',
-    },
-  },
-};
-
-const user = {
-  modelName: 'user',
-  uid: 'user',
-  collectionName: 'users',
-  attributes: {
-    address: {
-      type: 'relation',
-      relation: 'oneToOne',
-      target: 'address',
-      inversedBy: 'user',
-      // useJoinTable: false,
-    },
-  },
-};
-
-const address = {
-  modelName: 'address',
-  uid: 'address',
-  collectionName: 'addresses',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    user: {
-      type: 'relation',
-      relation: 'oneToOne',
-      target: 'user',
-      mappedBy: 'address',
-    },
-  },
-};
-
-const file = {
-  modelName: 'file',
-  uid: 'file',
-  collectionName: 'files',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    alternativeText: {
-      type: 'string',
-    },
-    caption: {
-      type: 'string',
-    },
-    width: {
-      type: 'integer',
-    },
-    height: {
-      type: 'integer',
-    },
-    formats: {
-      type: 'json',
-    },
-    hash: {
-      type: 'string',
-    },
-    ext: {
-      type: 'string',
-    },
-    mime: {
-      type: 'string',
-    },
-    size: {
-      type: 'decimal',
-    },
-    url: {
-      type: 'string',
-    },
-    previewUrl: {
-      type: 'string',
-    },
-    provider: {
-      type: 'string',
-    },
-    provider_metadata: {
-      type: 'json',
-    },
-    // related: {
-    //   type: 'relation',
-    //   relation: 'oneToMany',
-    //   target: 'file_morph',
-    //   mappedBy: 'file',
-    // },
-    // related: {
-    //   type: 'relation',
-    //   realtion: 'morphTo',
-    // },
-  },
-};
-
-const fileMorph = {
-  modelName: 'file-morph',
-  uid: 'file-morph',
-  collectionName: 'file_morphs',
-  attributes: {
-    // file: {
-    //   type: 'relation',
-    //   relation: 'manyToOne',
-    //   target: 'file',
-    //   inversedBy: 'related',
-    //   useJoinTable: false,
-    // },
-  },
-};
-
-const blogPost = {
-  modelName: 'blogPost',
-  uid: 'blogPost',
-  collectionName: 'blog_posts',
-  attributes: {
-    passwordField: {
-      type: 'password',
-    },
-    emailField: {
-      type: 'email',
-    },
-    stringField: {
-      type: 'string',
-    },
-    uidField: {
-      type: 'uid',
-    },
-    richtextField: {
-      type: 'richtext',
-    },
-    textField: {
-      type: 'text',
-    },
-    enumerationField: {
-      type: 'enumeration',
-      enum: ['A', 'B'],
-    },
-    jsonField: {
-      type: 'json',
-    },
-    bigintegerField: {
-      type: 'biginteger',
-    },
-    integerField: {
-      type: 'integer',
-    },
-    floatField: {
-      type: 'float',
-    },
-    decimalField: {
-      type: 'decimal',
-    },
-    dateField: {
-      type: 'date',
-    },
-    timeField: {
-      type: 'time',
-    },
-    datetimeField: {
-      type: 'datetime',
-    },
-    timestampField: {
-      type: 'timestamp',
-    },
-    booleanField: {
-      type: 'boolean',
-    },
-  },
-};
-
-module.exports = [category, article, tags, compo, user, address, file, fileMorph, blogPost];
-
-// const article = {
-//   modelName: 'article',
-//   uid: 'article',
-//   collectionName: 'articles',
-//   attributes: {
-//     commentable: {
-//       type: 'relation',
-//       relation: 'morphToOne',
-//     },
-//     reportables: {
-//       type: 'relation',
-//       relation: 'morphToMany',
-//     },
-//     dz: {
-//       type: 'dynamiczone',
-//       components: ['comment', 'video-comment'],
-//     },
-//   },
-// };
-
-// const comment = {
-//   modelName: 'comment',
-//   uid: 'comment',
-//   collectionName: 'comments',
-//   attributes: {
-//     article: {
-//       type: 'relation',
-//       relation: 'morphOne',
-//       target: 'article',
-//       morphBy: 'commentable',
-//     },
-//     title: {
-//       type: 'string',
-//     },
-//   },
-// };
-
-// const videoComment = {
-//   modelName: 'video-comment',
-//   uid: 'video-comment',
-//   collectionName: 'video_comments',
-//   attributes: {
-//     articles: {
-//       type: 'relation',
-//       relation: 'morphMany',
-//       target: 'article',
-//       morphBy: 'commentable',
-//     },
-//     title: {
-//       type: 'string',
-//     },
-//   },
-// };
-
-// const folder = {
-//   modelName: 'folder',
-//   uid: 'folder',
-//   collectionName: 'folders',
-//   attributes: {
-//     articles: {
-//       type: 'relation',
-//       relation: 'morphMany',
-//       target: 'article',
-//       morphBy: 'reportables',
-//     },
-//   },
-// };
-
-// module.exports = [article, comment, videoComment, folder];

package/examples/typings.ts

@@ -1,17 +0,0 @@
-type ID = number | string;
-
-interface Category {
-  id: ID;
-  title: string;
-}
-
-interface Article {
-  id: ID;
-  title: string;
-  category: Category | ID;
-}
-
-interface AllTypes {
-  article: Article;
-  category: Category;
-}