pure-orm 4.0.2 → 4.1.4

package/dist/src/driver-integrations/pgp.spec.js

@@ -0,0 +1,376 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const pgp_1 = require("./pgp");
+const core_1 = require("../core");
+const entities_1 = require("../../test-utils/order/entities");
+class SimpleModel {
+    constructor(props) {
+        this.id = props.id;
+    }
+}
+class SimpleCollection {
+    constructor({ models }) {
+        this.models = models;
+    }
+}
+const simpleEntities = [
+    {
+        tableName: 'widget',
+        columns: ['id'],
+        Model: SimpleModel,
+        Collection: SimpleCollection
+    }
+];
+const makeRow = (id) => ({
+    'widget#id': id
+});
+const makeOrderRow = (id, email) => ({
+    'order#id': id,
+    'order#email': email,
+    'order#browser_ip': null,
+    'order#browser_user_agent': null,
+    'order#kujo_imported_date': null,
+    'order#created_date': null,
+    'order#cancel_reason': null,
+    'order#cancelled_date': null,
+    'order#closed_date': null,
+    'order#processed_date': null,
+    'order#updated_date': null,
+    'order#note': null,
+    'order#subtotal_price': null,
+    'order#taxes_included': null,
+    'order#total_discounts': null,
+    'order#total_price': null,
+    'order#total_tax': null,
+    'order#total_weight': null,
+    'order#order_status_url': null,
+    'order#utm_source_id': null,
+    'order#utm_medium_id': null,
+    'order#utm_campaign': null,
+    'order#utm_content': null,
+    'order#utm_term': null
+});
+/* -------------------------------------------------------------------------*/
+/* one ---------------------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('one', () => {
+    test('calls db.many and returns a single model', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { many: jest.fn().mockResolvedValue([makeRow(1)]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.one('SELECT ...', { id: 1 });
+        expect(db.many).toHaveBeenCalledWith('SELECT ...', { id: 1 });
+        expect(result.id).toEqual(1);
+    }));
+    test('throws when db.many returns empty array', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { many: jest.fn().mockResolvedValue([]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield expect(pgp.one('SELECT ...')).rejects.toThrow();
+    }));
+    test('throws when result nests into more than one model', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            many: jest.fn().mockResolvedValue([makeRow(1), makeRow(2)])
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield expect(pgp.one('SELECT ...')).rejects.toThrow();
+    }));
+    test('passes values to db.many', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { many: jest.fn().mockResolvedValue([makeRow(5)]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield pgp.one('SELECT ... WHERE id = $1', [5]);
+        expect(db.many).toHaveBeenCalledWith('SELECT ... WHERE id = $1', [5]);
+    }));
+});
+/* -------------------------------------------------------------------------*/
+/* oneOrNone ---------------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('oneOrNone', () => {
+    test('returns a model when one result exists', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { any: jest.fn().mockResolvedValue([makeRow(1)]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.oneOrNone('SELECT ...', { id: 1 });
+        expect(db.any).toHaveBeenCalledWith('SELECT ...', { id: 1 });
+        expect(result.id).toEqual(1);
+    }));
+    test('returns undefined when no results', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { any: jest.fn().mockResolvedValue([]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.oneOrNone('SELECT ...');
+        expect(result).toBeUndefined();
+    }));
+    test('throws when more than one result', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            any: jest.fn().mockResolvedValue([makeRow(1), makeRow(2)])
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield expect(pgp.oneOrNone('SELECT ...')).rejects.toThrow();
+    }));
+});
+/* -------------------------------------------------------------------------*/
+/* many --------------------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('many', () => {
+    test('returns a collection with at least one model', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            any: jest.fn().mockResolvedValue([makeRow(1), makeRow(2)])
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.many('SELECT ...');
+        expect(db.any).toHaveBeenCalledWith('SELECT ...', undefined);
+        expect(result.models.length).toEqual(2);
+        expect(result.models[0].id).toEqual(1);
+        expect(result.models[1].id).toEqual(2);
+    }));
+    test('works with a single result row', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { any: jest.fn().mockResolvedValue([makeRow(42)]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.many('SELECT ...');
+        expect(result.models.length).toEqual(1);
+        expect(result.models[0].id).toEqual(42);
+    }));
+    test('throws when no results', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { any: jest.fn().mockResolvedValue([]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield expect(pgp.many('SELECT ...')).rejects.toThrow();
+    }));
+    test('passes values to db.any', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { any: jest.fn().mockResolvedValue([makeRow(1)]) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield pgp.many('SELECT ... WHERE x = $1', [10]);
+        expect(db.any).toHaveBeenCalledWith('SELECT ... WHERE x = $1', [10]);
+    }));
+});
+/* -------------------------------------------------------------------------*/
+/* any ---------------------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('any', () => {
+    test('returns a collection when results exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            result: jest.fn().mockResolvedValue({
+                rows: [makeRow(1), makeRow(2)],
+                fields: [{ name: 'widget#id' }]
+            })
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.any('SELECT ...');
+        expect(db.result).toHaveBeenCalledWith('SELECT ...', undefined);
+        expect(result.models.length).toEqual(2);
+    }));
+    test('returns empty collection when no results', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            result: jest.fn().mockResolvedValue({
+                rows: [],
+                fields: [{ name: 'widget#id' }]
+            })
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.any('SELECT ...');
+        expect(result.models).toBeDefined();
+        expect(result.models.length).toEqual(0);
+    }));
+    test('extracts table name from first field name', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const db = {
+            result: jest.fn().mockResolvedValue({
+                rows: [makeOrderRow(1, 'a@b.com')],
+                fields: [{ name: 'order#id' }]
+            })
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.any('SELECT ...');
+        expect(result.models.length).toEqual(1);
+        expect(result.models[0].id).toEqual(1);
+    }));
+    test('passes values to db.result', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            result: jest.fn().mockResolvedValue({
+                rows: [],
+                fields: [{ name: 'widget#id' }]
+            })
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield pgp.any('SELECT ... WHERE x = $1', [5]);
+        expect(db.result).toHaveBeenCalledWith('SELECT ... WHERE x = $1', [5]);
+    }));
+});
+/* -------------------------------------------------------------------------*/
+/* none --------------------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('none', () => {
+    test('calls db.none and resolves to null', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { none: jest.fn().mockResolvedValue(undefined) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const result = yield pgp.none('DELETE ...');
+        expect(db.none).toHaveBeenCalledWith('DELETE ...', undefined);
+        expect(result).toBeNull();
+    }));
+    test('passes values to db.none', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = { none: jest.fn().mockResolvedValue(undefined) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield pgp.none('DELETE ... WHERE id = $(id)', { id: 7 });
+        expect(db.none).toHaveBeenCalledWith('DELETE ... WHERE id = $(id)', {
+            id: 7
+        });
+    }));
+});
+/* -------------------------------------------------------------------------*/
+/* Error handling ----------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('error handling', () => {
+    test('defaultErrorHandler rethrows the error', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('db error');
+        const db = { many: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        yield expect(pgp.one('SELECT ...')).rejects.toThrow('db error');
+    }));
+    test('defaultErrorHandler calls logError for non-QueryResultError', () => __awaiter(void 0, void 0, void 0, function* () {
+        const logError = jest.fn((err) => {
+            throw err;
+        });
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('unexpected error');
+        const db = { many: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db, logError });
+        yield expect(pgp.one('SELECT ...')).rejects.toThrow('unexpected error');
+        expect(logError).toHaveBeenCalledWith(err);
+    }));
+    test('defaultErrorHandler does not call logError for QueryResultError', () => __awaiter(void 0, void 0, void 0, function* () {
+        const logError = jest.fn((err) => {
+            throw err;
+        });
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('no data');
+        err.name = 'QueryResultError';
+        const db = { many: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db, logError });
+        yield expect(pgp.one('SELECT ...')).rejects.toThrow('no data');
+        expect(logError).not.toHaveBeenCalled();
+    }));
+    test('custom errorHandler overrides defaultErrorHandler', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('db failure');
+        const db = { many: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const customHandler = jest.fn((_err) => {
+            throw new Error('custom handled');
+        });
+        yield expect(pgp.one('SELECT ...', undefined, customHandler)).rejects.toThrow('custom handled');
+        expect(customHandler).toHaveBeenCalledWith(err);
+    }));
+    test('custom errorHandler works for oneOrNone', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('fail');
+        const db = { any: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const customHandler = jest.fn((_err) => {
+            throw new Error('caught');
+        });
+        yield expect(pgp.oneOrNone('SELECT ...', undefined, customHandler)).rejects.toThrow('caught');
+        expect(customHandler).toHaveBeenCalledWith(err);
+    }));
+    test('custom errorHandler works for many', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('fail');
+        const db = { any: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const customHandler = jest.fn((_err) => {
+            throw new Error('caught');
+        });
+        yield expect(pgp.many('SELECT ...', undefined, customHandler)).rejects.toThrow('caught');
+    }));
+    test('custom errorHandler works for any', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('fail');
+        const db = { result: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const customHandler = jest.fn((_err) => {
+            throw new Error('caught');
+        });
+        yield expect(pgp.any('SELECT ...', undefined, customHandler)).rejects.toThrow('caught');
+    }));
+    test('custom errorHandler works for none', () => __awaiter(void 0, void 0, void 0, function* () {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const err = new Error('fail');
+        const db = { none: jest.fn().mockRejectedValue(err) };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        const customHandler = jest.fn((_err) => {
+            throw new Error('caught');
+        });
+        yield expect(pgp.none('DELETE ...', undefined, customHandler)).rejects.toThrow('caught');
+    }));
+});
+/* -------------------------------------------------------------------------*/
+/* Returned object structure -----------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('createForPGP return structure', () => {
+    test('includes all core methods', () => {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            many: jest.fn(),
+            any: jest.fn(),
+            result: jest.fn(),
+            none: jest.fn()
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        expect(typeof pgp.createFromDatabase).toBe('function');
+        expect(typeof pgp.createOneFromDatabase).toBe('function');
+        expect(typeof pgp.createOneOrNoneFromDatabase).toBe('function');
+        expect(typeof pgp.createManyFromDatabase).toBe('function');
+        expect(typeof pgp.createAnyFromDatabase).toBe('function');
+        expect(typeof pgp.getEntityByModel).toBe('function');
+        expect(typeof pgp.getEntityByTableName).toBe('function');
+        expect(pgp.tables).toBeDefined();
+    });
+    test('includes all query methods', () => {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            many: jest.fn(),
+            any: jest.fn(),
+            result: jest.fn(),
+            none: jest.fn()
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        expect(typeof pgp.one).toBe('function');
+        expect(typeof pgp.oneOrNone).toBe('function');
+        expect(typeof pgp.many).toBe('function');
+        expect(typeof pgp.any).toBe('function');
+        expect(typeof pgp.none).toBe('function');
+    });
+    test('exposes db reference', () => {
+        const core = (0, core_1.createCore)({ entities: simpleEntities });
+        const db = {
+            many: jest.fn(),
+            any: jest.fn(),
+            result: jest.fn(),
+            none: jest.fn()
+        };
+        const pgp = (0, pgp_1.createForPGP)({ core, db });
+        expect(pgp.db).toBe(db);
+    });
+});

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;
-    update: <T extends IModel>(model: T, options: {
+    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>;