@strapi/database 0.0.0-fd8e4c6bfa → 0.0.0-ffd0a215143bcafd0354d791533a57a084e53ffb

package/lib/__tests__/index.test.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { Database } = require('../index');
+
+jest.mock('../connection', () =>
+  jest.fn(() => {
+    const trx = {
+      commit: jest.fn(),
+      rollback: jest.fn(),
+    };
+    return {
+      ...trx,
+      transaction: jest.fn(async () => trx),
+    };
+  })
+);
+
+jest.mock('../dialects', () => ({
+  getDialect: jest.fn(() => ({
+    configure: jest.fn(),
+    initialize: jest.fn(),
+  })),
+}));
+
+jest.mock('../migrations', () => ({
+  createMigrationsProvider: jest.fn(),
+}));
+
+const config = {
+  models: [
+    {
+      tableName: 'strapi_core_store_settings',
+    },
+  ],
+  connection: {
+    client: 'postgres',
+    connection: {
+      database: 'strapi',
+      user: 'strapi',
+      password: 'strapi',
+      port: 5432,
+      host: 'localhost',
+    },
+  },
+};
+
+describe('Database', () => {
+  describe('constructor', () => {
+    it('should throw an error if no config is provided', async () => {
+      expect(async () => Database.init()).rejects.toThrowError();
+    });
+
+    it('it should intialize if config is provided', async () => {
+      expect(() => Database.init(config)).toBeDefined();
+    });
+  });
+
+  describe('Transaction', () => {
+    it('transaction should be defined', async () => {
+      const db = await Database.init(config);
+      expect(db.transaction).toBeDefined();
+    });
+
+    it('should return value if transaction is complete', async () => {
+      const db = await Database.init(config);
+      const result = await db.transaction(async () => 'test');
+      expect(result).toBe('test');
+      expect(db.connection.commit).toHaveBeenCalledTimes(1);
+    });
+
+    it('rollback is called incase of error', async () => {
+      const db = await Database.init(config);
+      try {
+        await db.transaction(async () => {
+          throw new Error('test');
+        });
+      } catch {
+        /* ignore */
+      }
+      expect(db.connection.rollback).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw error', async () => {
+      const db = await Database.init(config);
+
+      expect(async () => {
+        await db.transaction(async () => {
+          throw new Error('test');
+        });
+      }).rejects.toThrowError('test');
+    });
+  });
+});

package/lib/dialects/dialect.js

@@ -29,6 +29,10 @@ class Dialect {
     return false;
   }
 
+  supportsWindowFunctions() {
+    return true;
+  }
+
   async startSchemaUpdate() {
     // noop
   }
@@ -44,6 +48,10 @@ class Dialect {
 
     throw new Error(error.message);
   }
+
+  canAddIncrements() {
+    return true;
+  }
 }
 
 module.exports = {

package/lib/dialects/mysql/constants.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  MYSQL: 'MYSQL',
+  MARIADB: 'MARIADB',
+};

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

@@ -0,0 +1,37 @@
+'use strict';
+
+const { MARIADB, MYSQL } = require('./constants');
+
+const SQL_QUERIES = {
+  VERSION: `SELECT version() as version`,
+};
+
+class MysqlDatabaseInspector {
+  constructor(db) {
+    this.db = db;
+  }
+
+  async getInformation() {
+    let database;
+    let versionNumber;
+    try {
+      const [results] = await this.db.connection.raw(SQL_QUERIES.VERSION);
+      const versionSplit = results[0].version.split('-');
+      const databaseName = versionSplit[1];
+      versionNumber = versionSplit[0];
+      database = databaseName && databaseName.toLowerCase() === 'mariadb' ? MARIADB : MYSQL;
+    } catch (e) {
+      return {
+        database: null,
+        version: null,
+      };
+    }
+
+    return {
+      database,
+      version: versionNumber,
+    };
+  }
+}
+
+module.exports = MysqlDatabaseInspector;

package/lib/dialects/mysql/index.js

@@ -1,13 +1,19 @@
 'use strict';
 
+const semver = require('semver');
+
 const { Dialect } = require('../dialect');
 const MysqlSchemaInspector = require('./schema-inspector');
+const MysqlDatabaseInspector = require('./database-inspector');
+const { MYSQL } = require('./constants');
 
 class MysqlDialect extends Dialect {
   constructor(db) {
     super(db);
 
     this.schemaInspector = new MysqlSchemaInspector(db);
+    this.databaseInspector = new MysqlDatabaseInspector(db);
+    this.info = null;
   }
 
   configure() {
@@ -38,6 +44,8 @@ class MysqlDialect extends Dialect {
     } catch (err) {
       // Ignore error due to lack of session permissions
     }
+
+    this.info = await this.databaseInspector.getInformation();
   }
 
   async startSchemaUpdate() {
@@ -57,6 +65,17 @@ class MysqlDialect extends Dialect {
     return true;
   }
 
+  supportsWindowFunctions() {
+    const isMysqlDB = !this.info.database || this.info.database === MYSQL;
+    const isBeforeV8 = !semver.valid(this.info.version) || semver.lt(this.info.version, '8.0.0');
+
+    if (isMysqlDB && isBeforeV8) {
+      return false;
+    }
+
+    return true;
+  }
+
   usesForeignKeys() {
     return true;
   }

package/lib/dialects/postgresql/index.js

@@ -15,9 +15,24 @@ class PostgresDialect extends Dialect {
     return true;
   }
 
-  initialize() {
-    this.db.connection.client.driver.types.setTypeParser(1082, 'text', (v) => v); // Don't cast DATE string to Date()
-    this.db.connection.client.driver.types.setTypeParser(1700, 'text', parseFloat);
+  async initialize() {
+    // Don't cast DATE string to Date()
+    this.db.connection.client.driver.types.setTypeParser(
+      this.db.connection.client.driver.types.builtins.DATE,
+      'text',
+      (v) => v
+    );
+    // Don't parse JSONB automatically
+    this.db.connection.client.driver.types.setTypeParser(
+      this.db.connection.client.driver.types.builtins.JSONB,
+      'text',
+      (v) => v
+    );
+    this.db.connection.client.driver.types.setTypeParser(
+      this.db.connection.client.driver.types.builtins.NUMERIC,
+      'text',
+      parseFloat
+    );
   }
 
   usesForeignKeys() {

package/lib/dialects/sqlite/index.js

@@ -5,13 +5,13 @@ const fse = require('fs-extra');
 
 const errors = require('../../errors');
 const { Dialect } = require('../dialect');
-const SqliteSchmeaInspector = require('./schema-inspector');
+const SqliteSchemaInspector = require('./schema-inspector');
 
 class SqliteDialect extends Dialect {
   constructor(db) {
     super(db);
 
-    this.schemaInspector = new SqliteSchmeaInspector(db);
+    this.schemaInspector = new SqliteSchemaInspector(db);
   }
 
   configure() {
@@ -24,6 +24,10 @@ class SqliteDialect extends Dialect {
     fse.ensureDirSync(dbDir);
   }
 
+  useReturning() {
+    return true;
+  }
+
   async initialize() {
     await this.db.connection.raw('pragma foreign_keys = on');
   }
@@ -68,6 +72,10 @@ class SqliteDialect extends Dialect {
       }
     }
   }
+
+  canAddIncrements() {
+    return false;
+  }
 }
 
 module.exports = SqliteDialect;

package/lib/entity-manager/__tests__/relations-orderer.test.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const { relationsOrderer } = require('../relations-orderer');
+
+describe('Given I have some relations in the database', () => {
+  describe('When I connect a relation at the end', () => {
+    test('Then it is placed at the end with the correct order', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: 4 },
+          { id: 3, order: 10 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([{ id: 4, position: { end: true } }, { id: 5 }]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 2, order: 4 },
+        { id: 3, order: 10 },
+        { id: 4, order: 10.5 },
+        { id: 5, order: 10.5 },
+      ]);
+    });
+  });
+
+  describe('When I connect a relation at the start', () => {
+    test('Then it is placed at the start with the correct order', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: 4 },
+          { id: 3, order: 10 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([{ id: 4, position: { start: true } }]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 4, order: 0.5 },
+        { id: 2, order: 4 },
+        { id: 3, order: 10 },
+      ]);
+    });
+  });
+
+  describe('When I connect multiple relations using before', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: 4 },
+          { id: 3, order: 10 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([
+        { id: 4, position: { before: 3 } },
+        { id: 5, position: { before: 4 } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 2, order: 4 },
+        { id: 5, order: 9.5 },
+        { id: 4, order: 9.5 },
+        { id: 3, order: 10 },
+      ]);
+    });
+  });
+
+  describe('When you connect multiple disordered relations', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 1, order: 1 },
+          { id: 2, order: 2 },
+          { id: 3, order: 3 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([
+        { id: 5, position: { before: 1 } },
+        { id: 1, position: { before: 2 } },
+        { id: 2, position: { end: true } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 5, order: 0.5 },
+        { id: 1, order: 1.5 },
+        { id: 3, order: 3 },
+        { id: 2, order: 3.5 },
+      ]);
+    });
+  });
+
+  describe('When you connect a relation before a non-existing relation in non-strict mode', () => {
+    test('Then it is placed at the end', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 1, order: 1 },
+          { id: 2, order: 2 },
+          { id: 3, order: 3 },
+        ],
+        'id',
+        'order',
+        false
+      );
+
+      orderer.connect([{ id: 4, position: { before: 5 } }]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 1, order: 1 },
+        { id: 2, order: 2 },
+        { id: 3, order: 3 },
+        { id: 4, order: 3.5 },
+      ]);
+    });
+  });
+});
+
+describe('Given there are no relations in the database', () => {
+  describe('When you connect multiple new relations', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer([], 'id', 'order');
+
+      orderer.connect([
+        { id: 1, position: { start: true } },
+        { id: 2, position: { start: true } },
+        { id: 3, position: { after: 1 } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 2, order: 0.5 },
+        { id: 1, order: 0.5 },
+        { id: 3, order: 0.5 },
+      ]);
+    });
+  });
+
+  describe('When you connect multiple disordered relations', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer([], 'id', 'order');
+
+      orderer.connect([
+        { id: 5, position: { before: 1 } },
+        { id: 1, position: { before: 2 } },
+        { id: 2, position: { end: true } },
+        { id: 3, position: { after: 1 } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 5, order: 0.5 },
+        { id: 1, order: 0.5 },
+        { id: 3, order: 0.5 },
+        { id: 2, order: 0.5 },
+      ]);
+    });
+  });
+});

package/lib/entity-manager/__tests__/sort-connect-array.test.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { sortConnectArray } = require('../relations-orderer');
+
+describe('sortConnectArray', () => {
+  test('sorts connect array', () => {
+    const sortConnect = sortConnectArray([
+      { id: 5, position: { before: 1 } },
+      { id: 1, position: { before: 2 } },
+      { id: 2, position: { end: true } },
+      { id: 3, position: { after: 1 } },
+    ]);
+
+    expect(sortConnect).toMatchObject([
+      { id: 2, position: { end: true } },
+      { id: 1, position: { before: 2 } },
+      { id: 5, position: { before: 1 } },
+      { id: 3, position: { after: 1 } },
+    ]);
+  });
+
+  test('sorts connect array with initial relations', () => {
+    const sortConnect = sortConnectArray(
+      [
+        { id: 5, position: { before: 1 } },
+        { id: 1, position: { before: 2 } },
+        { id: 2, position: { end: true } },
+        { id: 3, position: { after: 1 } },
+      ],
+      [{ id: 1 }]
+    );
+
+    expect(sortConnect).toMatchObject([
+      { id: 5, position: { before: 1 } },
+      { id: 2, position: { end: true } },
+      { id: 1, position: { before: 2 } },
+      { id: 3, position: { after: 1 } },
+    ]);
+  });
+
+  test("error if position doesn't exist", () => {
+    const sortConnect = () => sortConnectArray([{ id: 1, position: { after: 2 } }]);
+
+    expect(sortConnect).toThrowError(
+      'There was a problem connecting relation with id 1 at position {"after":2}. The relation with id 2 needs to be connected first.'
+    );
+  });
+
+  test('error with circular references', () => {
+    const sortConnect = () =>
+      sortConnectArray(
+        [
+          { id: 2, position: { after: 1 } },
+          { id: 3, position: { after: 1 } },
+          { id: 1, position: { after: 3 } },
+        ],
+        []
+      );
+
+    expect(sortConnect).toThrowError(
+      'A circular reference was found in the connect array. One relation is trying to connect before/after another one that is trying to connect before/after it'
+    );
+  });
+
+  test('error when connecting same relation twice', () => {
+    const sortConnect = () =>
+      sortConnectArray(
+        [
+          { id: 1, position: { after: 2 } },
+          { id: 1, position: { after: 3 } },
+        ],
+        []
+      );
+
+    expect(sortConnect).toThrowError(
+      'The relation with id 1 is already connected. You cannot connect the same relation twice.'
+    );
+  });
+});

package/lib/{entity-repository.js → entity-manager/entity-repository.js}

@@ -1,5 +1,8 @@
 'use strict';
 
+const { isString } = require('lodash/fp');
+const { isAnyToMany } = require('../metadata/relations');
+
 const withDefaultPagination = (params) => {
   const { page = 1, pageSize = 10, ...rest } = params;
 
@@ -10,6 +13,21 @@ const withDefaultPagination = (params) => {
   };
 };
 
+const withOffsetLimit = (params) => {
+  const { page, pageSize, ...rest } = withDefaultPagination(params);
+
+  const offset = Math.max(page - 1, 0) * pageSize;
+  const limit = pageSize;
+
+  const query = {
+    ...rest,
+    limit,
+    offset,
+  };
+
+  return [query, { page, pageSize }];
+};
+
 const createRepository = (uid, db) => {
   return {
     findOne(params) {
@@ -28,16 +46,7 @@ const createRepository = (uid, db) => {
     },
 
     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 [query, { page, pageSize }] = withOffsetLimit(params);
 
       const [results, total] = await Promise.all([
         db.entityManager.findMany(uid, query),
@@ -99,8 +108,38 @@ const createRepository = (uid, db) => {
       return db.entityManager.populate(uid, entity, populate);
     },
 
-    load(entity, field, params) {
-      return db.entityManager.load(uid, entity, field, params);
+    load(entity, fields, params) {
+      return db.entityManager.load(uid, entity, fields, params);
+    },
+
+    async loadPages(entity, field, params) {
+      if (!isString(field)) {
+        throw new Error(`Invalid load. Expected ${field} to be a string`);
+      }
+
+      const { attributes } = db.metadata.get(uid);
+      const attribute = attributes[field];
+
+      if (!attribute || attribute.type !== 'relation' || !isAnyToMany(attribute)) {
+        throw new Error(`Invalid load. Expected ${field} to be an anyToMany relational attribute`);
+      }
+
+      const [query, { page, pageSize }] = withOffsetLimit(params);
+
+      const [results, { count: total }] = await Promise.all([
+        db.entityManager.load(uid, entity, field, query),
+        db.entityManager.load(uid, entity, field, { ...query, count: true }),
+      ]);
+
+      return {
+        results,
+        pagination: {
+          page,
+          pageSize,
+          pageCount: Math.ceil(total / pageSize),
+          total,
+        },
+      };
     },
   };
 };