pure-orm 4.0.1 → 4.0.3

package/dist/example/data-access/person.d.ts

@@ -1,2 +1,2 @@
 import { Person } from '../models/person';
-export declare const getPerson: (id: number) => Person;
+export declare const getPerson: (id: number) => Promise<Person>;

package/dist/src/core.d.ts

@@ -4,20 +4,20 @@ export interface IColumnData {
     references?: IModelClass;
     primaryKey?: boolean;
 }
-export declare type IColumn = IColumnData | string;
-export declare type IColumns = Array<IColumn> | (() => Array<IColumn>);
+export type IColumn = IColumnData | string;
+export type IColumns = Array<IColumn> | (() => Array<IColumn>);
 export interface IColumnInternalData {
     column: string;
     property: string;
     references?: IModelClass;
     primaryKey: boolean;
 }
-export declare type IColumnInternal = IColumnInternalData;
-export declare type IColumnsInternal = Array<IColumnInternal>;
+export type IColumnInternal = IColumnInternalData;
+export type IColumnsInternal = Array<IColumnInternal>;
 export interface IModel {
     [key: string]: any;
 }
-export declare type IModelClass = new (props: any) => IModel;
+export type IModelClass = new (props: any) => IModel;
 export interface ICollection<T extends IModel> {
     models: Array<T>;
 }
@@ -29,7 +29,7 @@ export interface IEntity<T extends IModel> {
     Model: new (props: any) => T;
     Collection: new ({ models }: any) => ICollection<T>;
 }
-export declare type IEntities<T extends IModel> = Array<IEntity<T>>;
+export type IEntities<T extends IModel> = Array<IEntity<T>>;
 export interface IEntityInternal<T extends IModel> {
     tableName: string;
     displayName: string;
@@ -45,7 +45,7 @@ export interface IEntityInternal<T extends IModel> {
     selectColumnsClause: string;
     getPkId: (model: IModel) => string;
 }
-export declare type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
+export type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
 export interface ICreateCoreOptions {
     entities: IEntities<IModel>;
 }

package/dist/src/core.js

@@ -138,12 +138,19 @@ const createCore = ({ entities: externalEntities }) => {
                     ...nodes.slice(0, indexOfOldestParent + 1).reverse()
                 ];
                 const nodeItPointsTo = parentHeirarchy.find((parent) => {
-                    const index = Object.values(getEntityByModel(model).references).indexOf(parent.constructor);
-                    if (index === -1) {
+                    const indexes = Object.values(getEntityByModel(model).references)
+                        .map((x, i) => x === parent.constructor ? i : null)
+                        .filter((x, i) => x != null);
+                    if (!indexes.length) {
                         return false;
                     }
-                    const property = Object.keys(getEntityByModel(model).references)[index];
-                    return model[property] === parent.id;
+                    for (const index of indexes) {
+                        const property = Object.keys(getEntityByModel(model).references)[index];
+                        if (model[property] === parent.id) {
+                            return true;
+                        }
+                    }
+                    return false;
                 });
                 if (isNodeAlreadySeen) {
                     if (nodeItPointsTo && !nodePointingToIt) {

package/dist/src/core.spec.js

@@ -10,6 +10,7 @@ const entities_5 = require("../test-utils/five/entities");
 const entities_6 = require("../test-utils/six/entities");
 const entities_7 = require("../test-utils/twelve/entities");
 const entities_8 = require("../test-utils/thirteen/entities");
+const entities_9 = require("../test-utils/fourteen/entities");
 const article_1 = require("../test-utils/blog/models/article");
 const two = require('../test-utils/two/results');
 const three = require('../test-utils/three/results');
@@ -24,6 +25,7 @@ const ten = require('../test-utils/ten/results.json');
 const eleven = require('../test-utils/eleven/results.json');
 const twelve = require('../test-utils/twelve/results.json');
 const thirteen = require('../test-utils/thirteen/results.json');
+const fourteen = require('../test-utils/fourteen/results.json');
 describe('createFromDatabase', () => {
     test('multiple rows reduce to one nested object (with all one-to-one or one-to-many tables)', () => {
         const core = (0, core_1.createCore)({ entities: entities_1.entities });
@@ -575,6 +577,19 @@ describe('createFromDatabase', () => {
         expect(member === null || member === void 0 ? void 0 : member.recommendations.models[3].category.id).toEqual(4);
         expect(member === null || member === void 0 ? void 0 : member.recommendations.models[3].recommendationAudiences.models[0].audience.id).toEqual(1);
     });
+    // Issue occcurs in nestClump
+    // Problem when a table has two columns which reference the same other table
+    test('14', () => {
+        var _a;
+        const core = (0, core_1.createCore)({ entities: entities_9.entities });
+        const persons = core.createFromDatabase(fourteen);
+        expect(persons === null || persons === void 0 ? void 0 : persons.models.length).toEqual(1);
+        expect(persons.models[0].id).toEqual(67);
+        // Known issue: A reference always uses the model's name,
+        // instead of some version of the column's name
+        expect((_a = persons.models[0].customers) === null || _a === void 0 ? void 0 : _a.models.length).toEqual(1);
+        expect(persons.models[0].customers.models[0].id).toEqual(4);
+    });
 });
 describe('createOneFromDatabase', () => {
     test('reduces to one', () => {

package/dist/src/driver-integrations/index.d.ts

@@ -6,9 +6,9 @@ export interface ICreateForDriverOptions {
 }
 export interface ICoreIntegratedDriver extends ICore {
     db: any;
-    one: <T extends IModel>(query: string, values?: object, errorHandler?: (err: Error) => never) => T;
-    oneOrNone: <T extends IModel>(query: string, values?: object, errorHandler?: (err: Error) => never) => T | void;
-    many: <T extends ICollection<IModel>>(query: string, values?: object, errorHandler?: (err: Error) => never) => T;
-    any: <T extends ICollection<IModel>>(query: string, values?: object, errorHandler?: (err: Error) => never) => T | void;
-    none: (query: string, values?: object, errorHandler?: (err: Error) => never) => void;
+    one: <T extends IModel>(query: string, values?: object, errorHandler?: (err: Error) => never) => Promise<T>;
+    oneOrNone: <T extends IModel>(query: string, values?: object, errorHandler?: (err: Error) => never) => Promise<T | void>;
+    many: <T extends ICollection<IModel>>(query: string, values?: object, errorHandler?: (err: Error) => never) => Promise<T>;
+    any: <T extends ICollection<IModel>>(query: string, values?: object, errorHandler?: (err: Error) => never) => Promise<T | void>;
+    none: (query: string, values?: object, errorHandler?: (err: Error) => never) => Promise<void>;
 }

package/dist/src/orm.d.ts

@@ -6,16 +6,16 @@ export interface ICreateOptions {
     logError?: (err: Error) => never;
 }
 export interface IPureORM extends ICoreIntegratedDriver {
-    getMatching: <T extends IModel>(model: T) => T;
-    getOneOrNoneMatching: <T extends IModel>(model: T) => T | void;
-    getAnyMatching: <T extends ICollection<IModel>>(model: IModel) => T | void;
-    getAllMatching: <T extends ICollection<IModel>>(model: IModel) => T;
-    create: <T extends IModel>(model: T) => T;
+    getMatching: <T extends IModel>(model: T) => Promise<T>;
+    getOneOrNoneMatching: <T extends IModel>(model: T) => Promise<T | void>;
+    getAnyMatching: <T extends ICollection<IModel>>(model: IModel) => Promise<T | void>;
+    getAllMatching: <T extends ICollection<IModel>>(model: IModel) => Promise<T>;
+    create: <T extends IModel>(model: T) => Promise<T>;
     update: <T extends IModel>(model: T, options: {
         on: string;
-    }) => T;
-    delete: <T extends IModel>(model: T) => void;
-    deleteMatching: <T extends IModel>(model: T) => void;
+    }) => Promise<T>;
+    delete: <T extends IModel>(model: T) => Promise<void>;
+    deleteMatching: <T extends IModel>(model: T) => Promise<void>;
     getSqlInsertParts: (model: IModel) => {
         columns: string;
         values: Array<string>;

package/dist/test-utils/fourteen/entities.d.ts

@@ -0,0 +1,6 @@
+export declare const entities: {
+    tableName: string;
+    columns: import("../../src/core").IColumn[];
+    Model: typeof import("./models/person").Person;
+    Collection: typeof import("./models/person").Persons;
+}[];

package/dist/test-utils/fourteen/entities.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entities = void 0;
+const person_1 = require("./models/person");
+const customer_1 = require("./models/customer");
+exports.entities = [person_1.personEntity, customer_1.customerEntity];

package/dist/test-utils/fourteen/entities.ts

@@ -0,0 +1,3 @@
+import { personEntity } from './models/person';
+import { customerEntity } from './models/customer';
+export const entities = [personEntity, customerEntity];

package/dist/test-utils/fourteen/models/customer.d.ts

@@ -0,0 +1,19 @@
+import { IModel, ICollection, IColumns } from '../../../src/index';
+export declare const tableName: string;
+export declare const columns: IColumns;
+export declare class Customer implements IModel {
+    id: number;
+    lockedToAffiliateId: number;
+    lockedToSalespersonId: number;
+    constructor(props: any);
+}
+export declare class Customers implements ICollection<Customer> {
+    models: Array<Customer>;
+    constructor({ models }: any);
+}
+export declare const customerEntity: {
+    tableName: string;
+    columns: import("../../../src/core").IColumn[];
+    Model: typeof Customer;
+    Collection: typeof Customers;
+};

package/dist/test-utils/fourteen/models/customer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerEntity = exports.Customers = exports.Customer = exports.columns = exports.tableName = void 0;
+const person_1 = require("./person");
+exports.tableName = 'customer';
+exports.columns = [
+    'id',
+    { column: 'locked_to_affiliate_id', references: person_1.Person },
+    { column: 'locked_to_salesperson_id', references: person_1.Person }
+];
+class Customer {
+    constructor(props) {
+        this.id = props.id;
+        this.lockedToAffiliateId = props.lockedToAffiliateId;
+        this.lockedToSalespersonId = props.lockedToSalespersonId;
+    }
+}
+exports.Customer = Customer;
+class Customers {
+    constructor({ models }) {
+        this.models = models;
+    }
+}
+exports.Customers = Customers;
+exports.customerEntity = {
+    tableName: exports.tableName,
+    columns: exports.columns,
+    Model: Customer,
+    Collection: Customers
+};

package/dist/test-utils/fourteen/models/customer.ts

@@ -0,0 +1,36 @@
+import { IModel, ICollection, IColumns } from '../../../src/index';
+import { Person } from './person';
+
+export const tableName: string = 'customer';
+
+export const columns: IColumns = [
+  'id',
+  { column: 'locked_to_affiliate_id', references: Person },
+  { column: 'locked_to_salesperson_id', references: Person }
+];
+
+export class Customer implements IModel {
+  id: number;
+  lockedToAffiliateId: number;
+  lockedToSalespersonId: number;
+
+  constructor(props: any) {
+    this.id = props.id;
+    this.lockedToAffiliateId = props.lockedToAffiliateId;
+    this.lockedToSalespersonId = props.lockedToSalespersonId;
+  }
+}
+
+export class Customers implements ICollection<Customer> {
+  models: Array<Customer>;
+  constructor({ models }: any) {
+    this.models = models;
+  }
+}
+
+export const customerEntity = {
+  tableName,
+  columns,
+  Model: Customer,
+  Collection: Customers
+};

package/dist/test-utils/fourteen/models/person.d.ts

@@ -0,0 +1,17 @@
+import { IModel, ICollection, IColumns } from '../../../src/index';
+export declare const tableName: string;
+export declare const columns: IColumns;
+export declare class Person implements IModel {
+    id: number;
+    constructor(props: any);
+}
+export declare class Persons implements ICollection<Person> {
+    models: Array<Person>;
+    constructor({ models }: any);
+}
+export declare const personEntity: {
+    tableName: string;
+    columns: import("../../../src/core").IColumn[];
+    Model: typeof Person;
+    Collection: typeof Persons;
+};

package/dist/test-utils/fourteen/models/person.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.personEntity = exports.Persons = exports.Person = exports.columns = exports.tableName = void 0;
+exports.tableName = 'person';
+exports.columns = ['id'];
+class Person {
+    constructor(props) {
+        this.id = props.id;
+    }
+}
+exports.Person = Person;
+class Persons {
+    constructor({ models }) {
+        this.models = models;
+    }
+}
+exports.Persons = Persons;
+exports.personEntity = {
+    tableName: exports.tableName,
+    columns: exports.columns,
+    Model: Person,
+    Collection: Persons
+};

package/dist/test-utils/fourteen/models/person.ts

@@ -0,0 +1,27 @@
+import { IModel, ICollection, IColumns } from '../../../src/index';
+
+export const tableName: string = 'person';
+
+export const columns: IColumns = ['id'];
+
+export class Person implements IModel {
+  id: number;
+
+  constructor(props: any) {
+    this.id = props.id;
+  }
+}
+
+export class Persons implements ICollection<Person> {
+  models: Array<Person>;
+  constructor({ models }: any) {
+    this.models = models;
+  }
+}
+
+export const personEntity = {
+  tableName,
+  columns,
+  Model: Person,
+  Collection: Persons
+};

package/dist/test-utils/fourteen/results.json

@@ -0,0 +1,8 @@
+[
+  {
+    "person#id": 67,
+    "customer#id": 4,
+    "customer#locked_to_affiliate_id": null,
+    "customer#locked_to_salesperson_id": 67
+  }
+]

package/example/data-access/person.ts

@@ -1,7 +1,7 @@
 import orm from '../factories/orm';
 import { Person } from '../models/person';
 
-export const getPerson = (id: number): Person => {
+export const getPerson = (id: number): Promise<Person> => {
   const query = `
     SELECT
       ${orm.tables.person.columns},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pure-orm",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "engines": {
@@ -28,13 +28,14 @@
   },
   "devDependencies": {
     "@types/express": "^4.17.13",
-    "eslint": "^2.8.0",
+    "eslint": "^8.38.0",
+    "@babel/eslint-parser": "^7.21.3",
     "express": "^4.18.1",
     "jest": "^24.8.0",
-    "np": "^5.0.1",
+    "np": "^10.2.0",
     "pg-promise": "^10.11.1",
     "prettier": "^2.6.2",
-    "typescript": "^4.6.3"
+    "typescript": "^5.8.3"
   },
   "jest": {
     "coverageDirectory": "./coverage/",

package/src/core.spec.ts

@@ -8,6 +8,7 @@ import { entities as fiveEntities } from '../test-utils/five/entities';
 import { entities as sixEntities } from '../test-utils/six/entities';
 import { entities as twelveEntities } from '../test-utils/twelve/entities';
 import { entities as thirteenEntities } from '../test-utils/thirteen/entities';
+import { entities as fourteenEntities } from '../test-utils/fourteen/entities';
 import { Articles } from '../test-utils/blog/models/article';
 const two = require('../test-utils/two/results');
 const three = require('../test-utils/three/results');
@@ -22,6 +23,7 @@ const ten = require('../test-utils/ten/results.json');
 const eleven = require('../test-utils/eleven/results.json');
 const twelve = require('../test-utils/twelve/results.json');
 const thirteen = require('../test-utils/thirteen/results.json');
+const fourteen = require('../test-utils/fourteen/results.json');
 
 describe('createFromDatabase', () => {
   test('multiple rows reduce to one nested object (with all one-to-one or one-to-many tables)', () => {
@@ -1066,6 +1068,19 @@ describe('createFromDatabase', () => {
         .audience.id
     ).toEqual(1);
   });
+
+  // Issue occcurs in nestClump
+  // Problem when a table has two columns which reference the same other table
+  test('14', () => {
+    const core = createCore({ entities: fourteenEntities });
+    const persons = core.createFromDatabase(fourteen);
+    expect(persons?.models.length).toEqual(1);
+    expect(persons.models[0].id).toEqual(67);
+    // Known issue: A reference always uses the model's name,
+    // instead of some version of the column's name
+    expect(persons.models[0].customers?.models.length).toEqual(1);
+    expect(persons.models[0].customers.models[0].id).toEqual(4);
+  });
 });
 
 describe('createOneFromDatabase', () => {

package/src/core.ts

@@ -292,16 +292,23 @@ export const createCore = ({
           ...nodes.slice(0, indexOfOldestParent + 1).reverse()
         ];
         const nodeItPointsTo = parentHeirarchy.find((parent) => {
-          const index = Object.values(
-            getEntityByModel(model).references
-          ).indexOf(parent.constructor);
-          if (index === -1) {
+          const indexes = Object.values(getEntityByModel(model).references)
+            .map((x: IModelClass, i: number) =>
+              x === parent.constructor ? i : null
+            )
+            .filter((x: number | null, i) => x != null) as Array<number>;
+          if (!indexes.length) {
             return false;
           }
-          const property = Object.keys(getEntityByModel(model).references)[
-            index
-          ];
-          return model[property as keyof typeof model] === parent.id;
+          for (const index of indexes) {
+            const property = Object.keys(getEntityByModel(model).references)[
+              index
+            ];
+            if (model[property] === parent.id) {
+              return true;
+            }
+          }
+          return false;
         });
         if (isNodeAlreadySeen) {
           if (nodeItPointsTo && !nodePointingToIt) {

package/src/driver-integrations/index.ts

@@ -26,33 +26,33 @@ export interface ICoreIntegratedDriver extends ICore {
     query: string,
     values?: object,
     errorHandler?: (err: Error) => never
-  ) => T;
+  ) => Promise<T>;
 
   // Execute a query returning either single model or undefined, or throws.
   oneOrNone: <T extends IModel>(
     query: string,
     values?: object,
     errorHandler?: (err: Error) => never
-  ) => T | void;
+  ) => Promise<T | void>;
 
   // Execute a query returning a Collection with at least one model, or throws.
   many: <T extends ICollection<IModel>>(
     query: string,
     values?: object,
     errorHandler?: (err: Error) => never
-  ) => T;
+  ) => Promise<T>;
 
   // Execute a query returning a Collection.
   any: <T extends ICollection<IModel>>(
     query: string,
     values?: object,
     errorHandler?: (err: Error) => never
-  ) => T | void;
+  ) => Promise<T | void>;
 
   // Execute a query returning null.
   none: (
     query: string,
     values?: object,
     errorHandler?: (err: Error) => never
-  ) => void;
+  ) => Promise<void>;
 }

package/src/driver-integrations/pgp.ts

@@ -23,7 +23,7 @@ export const createForPGP = ({
     query: string,
     values?: object,
     errorHandler = defaultErrorHandler
-  ): T => {
+  ): Promise<T> => {
     return db
       .many(query, values)
       .then((rows: any) => core.createOneFromDatabase(rows))
@@ -34,7 +34,7 @@ export const createForPGP = ({
     query: string,
     values?: object,
     errorHandler = defaultErrorHandler
-  ): T | void => {
+  ): Promise<T | void> => {
     return db
       .any(query, values)
       .then((rows: any) => core.createOneOrNoneFromDatabase(rows))
@@ -45,7 +45,7 @@ export const createForPGP = ({
     query: string,
     values?: object,
     errorHandler = defaultErrorHandler
-  ): T => {
+  ): Promise<T> => {
     return db
       .any(query, values)
       .then((rows: any) => core.createManyFromDatabase(rows))
@@ -56,7 +56,7 @@ export const createForPGP = ({
     query: string,
     values?: object,
     errorHandler = defaultErrorHandler
-  ): T | void => {
+  ): Promise<T | void> => {
     return db
       .result(query, values)
       .then((result: any) =>
@@ -72,7 +72,7 @@ export const createForPGP = ({
     query: string,
     values?: object,
     errorHandler = defaultErrorHandler
-  ): void => {
+  ): Promise<void> => {
     return db
       .none(query, values)
       .then(() => null)

package/src/orm.ts

@@ -20,14 +20,16 @@ export interface IPureORM extends ICoreIntegratedDriver {
    * if you want to write these in your data access layer yourself.
    */
 
-  getMatching: <T extends IModel>(model: T) => T;
-  getOneOrNoneMatching: <T extends IModel>(model: T) => T | void;
-  getAnyMatching: <T extends ICollection<IModel>>(model: IModel) => T | void;
-  getAllMatching: <T extends ICollection<IModel>>(model: IModel) => T;
-  create: <T extends IModel>(model: T) => T;
-  update: <T extends IModel>(model: T, options: { on: string }) => T;
-  delete: <T extends IModel>(model: T) => void;
-  deleteMatching: <T extends IModel>(model: T) => void;
+  getMatching: <T extends IModel>(model: T) => Promise<T>;
+  getOneOrNoneMatching: <T extends IModel>(model: T) => Promise<T | void>;
+  getAnyMatching: <T extends ICollection<IModel>>(
+    model: IModel
+  ) => Promise<T | void>;
+  getAllMatching: <T extends ICollection<IModel>>(model: IModel) => Promise<T>;
+  create: <T extends IModel>(model: T) => Promise<T>;
+  update: <T extends IModel>(model: T, options: { on: string }) => Promise<T>;
+  delete: <T extends IModel>(model: T) => Promise<void>;
+  deleteMatching: <T extends IModel>(model: T) => Promise<void>;
 
   /* ------------------------------------------------------------------------*/
   /* Helper Utility Functions -----------------------------------------------*/
@@ -230,7 +232,7 @@ export const create = ({
   /* ------------------------------------------------------------------------*/
 
   // Standard create
-  const create = <T extends IModel>(model: T): T => {
+  const create = <T extends IModel>(model: T): Promise<T> => {
     const { columns, values, valuesVar } = getSqlInsertParts(model);
     const query = `
       INSERT INTO "${orm.getEntityByModel(model).tableName}" ( ${columns} )
@@ -241,7 +243,10 @@ export const create = ({
   };
 
   // Standard update
-  const update = <T extends IModel>(model: T, { on = 'id' } = {}): T => {
+  const update = <T extends IModel>(
+    model: T,
+    { on = 'id' } = {}
+  ): Promise<T> => {
     const { clause, idVar, values } = getSqlUpdateParts(model, on);
     const query = `
       UPDATE "${orm.getEntityByModel(model).tableName}"
@@ -255,7 +260,7 @@ export const create = ({
   };
 
   // Standard delete
-  const _delete = <T extends IModel>(model: T): void => {
+  const _delete = <T extends IModel>(model: T): Promise<void> => {
     const id = (model as any).id;
     const query = `
       DELETE FROM "${orm.getEntityByModel(model).tableName}"
@@ -264,7 +269,7 @@ export const create = ({
     return orm.none(query, { id });
   };
 
-  const deleteMatching = <T extends IModel>(model: T) => {
+  const deleteMatching = <T extends IModel>(model: T): Promise<void> => {
     const { whereClause, values } = getMatchingParts(model);
     const query = `
       DELETE FROM "${orm.getEntityByModel(model).tableName}"
@@ -273,7 +278,7 @@ export const create = ({
     return orm.none(query, values);
   };
 
-  const getMatching = <T extends IModel>(model: T): T => {
+  const getMatching = <T extends IModel>(model: T): Promise<T> => {
     const { whereClause, values } = getMatchingParts(model);
     const query = `
       SELECT ${orm.getEntityByModel(model).selectColumnsClause}
@@ -283,7 +288,9 @@ export const create = ({
     return orm.one<T>(query, values);
   };
 
-  const getOneOrNoneMatching = <T extends IModel>(model: T): T | void => {
+  const getOneOrNoneMatching = <T extends IModel>(
+    model: T
+  ): Promise<T | void> => {
     const { whereClause, values } = getMatchingParts(model);
     const query = `
       SELECT ${orm.getEntityByModel(model).selectColumnsClause}
@@ -295,7 +302,7 @@ export const create = ({
 
   const getAnyMatching = <T extends ICollection<IModel>>(
     model: IModel
-  ): T | void => {
+  ): Promise<T | void> => {
     const { whereClause, values } = getMatchingParts(model);
     const query = `
       SELECT ${orm.getEntityByModel(model).selectColumnsClause}
@@ -305,7 +312,9 @@ export const create = ({
     return orm.any<T>(query, values);
   };
 
-  const getAllMatching = <T extends ICollection<IModel>>(model: IModel): T => {
+  const getAllMatching = <T extends ICollection<IModel>>(
+    model: IModel
+  ): Promise<T> => {
     const { whereClause, values } = getMatchingParts(model);
     const query = `
       SELECT ${orm.getEntityByModel(model).selectColumnsClause}

package/test-utils/fourteen/entities.ts

@@ -0,0 +1,3 @@
+import { personEntity } from './models/person';
+import { customerEntity } from './models/customer';
+export const entities = [personEntity, customerEntity];