@strapi/database 4.14.4 → 4.14.5

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

@@ -1,79 +0,0 @@
-'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-manager/entity-repository.js

@@ -1,164 +0,0 @@
-'use strict';
-
-const { isString } = require('lodash/fp');
-const { isAnyToMany } = require('../metadata/relations');
-
-const withDefaultPagination = (params) => {
-  const { page = 1, pageSize = 10, ...rest } = params;
-
-  return {
-    page: Number(page),
-    pageSize: Number(pageSize),
-    ...rest,
-  };
-};
-
-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) {
-      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 [query, { page, pageSize }] = withOffsetLimit(params);
-
-      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);
-    },
-
-    clone(id, params) {
-      return db.entityManager.clone(uid, id, 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);
-    },
-
-    async updateRelations(id, data) {
-      const trx = await db.transaction();
-      try {
-        await db.entityManager.updateRelations(uid, id, data, { transaction: trx.get() });
-        return trx.commit();
-      } catch (e) {
-        await trx.rollback();
-        throw e;
-      }
-    },
-
-    deleteRelations(id) {
-      return db.entityManager.deleteRelations(uid, id);
-    },
-
-    cloneRelations(targetId, sourceId, params) {
-      return db.entityManager.cloneRelations(uid, targetId, sourceId, params);
-    },
-
-    populate(entity, populate) {
-      return db.entityManager.populate(uid, entity, populate);
-    },
-
-    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,
-        },
-      };
-    },
-  };
-};
-
-module.exports = {
-  createRepository,
-};