pure-orm 4.0.2 → 4.1.4

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.spec.ts

@@ -0,0 +1,444 @@
+/* eslint-disable max-len */
+import { createForPGP } from './pgp';
+import { createCore, IModel, ICollection } from '../core';
+import { entities as orderEntities } from '../../test-utils/order/entities';
+
+class SimpleModel implements IModel {
+  id: number;
+  constructor(props: any) {
+    this.id = props.id;
+  }
+}
+class SimpleCollection implements ICollection<SimpleModel> {
+  models: Array<SimpleModel>;
+  constructor({ models }: any) {
+    this.models = models;
+  }
+}
+
+const simpleEntities = [
+  {
+    tableName: 'widget',
+    columns: ['id'] as any,
+    Model: SimpleModel,
+    Collection: SimpleCollection
+  }
+];
+
+const makeRow = (id: number) => ({
+  'widget#id': id
+});
+
+const makeOrderRow = (id: number, email: string) => ({
+  '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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { many: jest.fn().mockResolvedValue([makeRow(1)]) };
+    const pgp = createForPGP({ core, db });
+
+    const result = await 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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { many: jest.fn().mockResolvedValue([]) };
+    const pgp = createForPGP({ core, db });
+
+    await expect(pgp.one('SELECT ...')).rejects.toThrow();
+  });
+
+  test('throws when result nests into more than one model', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      many: jest.fn().mockResolvedValue([makeRow(1), makeRow(2)])
+    };
+    const pgp = createForPGP({ core, db });
+
+    await expect(pgp.one('SELECT ...')).rejects.toThrow();
+  });
+
+  test('passes values to db.many', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { many: jest.fn().mockResolvedValue([makeRow(5)]) };
+    const pgp = createForPGP({ core, db });
+
+    await 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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { any: jest.fn().mockResolvedValue([makeRow(1)]) };
+    const pgp = createForPGP({ core, db });
+
+    const result = await pgp.oneOrNone('SELECT ...', { id: 1 });
+    expect(db.any).toHaveBeenCalledWith('SELECT ...', { id: 1 });
+    expect(result!.id).toEqual(1);
+  });
+
+  test('returns undefined when no results', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { any: jest.fn().mockResolvedValue([]) };
+    const pgp = createForPGP({ core, db });
+
+    const result = await pgp.oneOrNone('SELECT ...');
+    expect(result).toBeUndefined();
+  });
+
+  test('throws when more than one result', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      any: jest.fn().mockResolvedValue([makeRow(1), makeRow(2)])
+    };
+    const pgp = createForPGP({ core, db });
+
+    await expect(pgp.oneOrNone('SELECT ...')).rejects.toThrow();
+  });
+});
+
+/* -------------------------------------------------------------------------*/
+/* many --------------------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+
+describe('many', () => {
+  test('returns a collection with at least one model', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      any: jest.fn().mockResolvedValue([makeRow(1), makeRow(2)])
+    };
+    const pgp = createForPGP({ core, db });
+
+    const result: any = await 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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { any: jest.fn().mockResolvedValue([makeRow(42)]) };
+    const pgp = createForPGP({ core, db });
+
+    const result: any = await pgp.many('SELECT ...');
+    expect(result.models.length).toEqual(1);
+    expect(result.models[0].id).toEqual(42);
+  });
+
+  test('throws when no results', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { any: jest.fn().mockResolvedValue([]) };
+    const pgp = createForPGP({ core, db });
+
+    await expect(pgp.many('SELECT ...')).rejects.toThrow();
+  });
+
+  test('passes values to db.any', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { any: jest.fn().mockResolvedValue([makeRow(1)]) };
+    const pgp = createForPGP({ core, db });
+
+    await 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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      result: jest.fn().mockResolvedValue({
+        rows: [makeRow(1), makeRow(2)],
+        fields: [{ name: 'widget#id' }]
+      })
+    };
+    const pgp = createForPGP({ core, db });
+
+    const result: any = await pgp.any('SELECT ...');
+    expect(db.result).toHaveBeenCalledWith('SELECT ...', undefined);
+    expect(result.models.length).toEqual(2);
+  });
+
+  test('returns empty collection when no results', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      result: jest.fn().mockResolvedValue({
+        rows: [],
+        fields: [{ name: 'widget#id' }]
+      })
+    };
+    const pgp = createForPGP({ core, db });
+
+    const result: any = await pgp.any('SELECT ...');
+    expect(result.models).toBeDefined();
+    expect(result.models.length).toEqual(0);
+  });
+
+  test('extracts table name from first field name', async () => {
+    const core = createCore({ entities: orderEntities });
+    const db = {
+      result: jest.fn().mockResolvedValue({
+        rows: [makeOrderRow(1, 'a@b.com')],
+        fields: [{ name: 'order#id' }]
+      })
+    };
+    const pgp = createForPGP({ core, db });
+
+    const result: any = await pgp.any('SELECT ...');
+    expect(result.models.length).toEqual(1);
+    expect(result.models[0].id).toEqual(1);
+  });
+
+  test('passes values to db.result', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      result: jest.fn().mockResolvedValue({
+        rows: [],
+        fields: [{ name: 'widget#id' }]
+      })
+    };
+    const pgp = createForPGP({ core, db });
+
+    await 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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { none: jest.fn().mockResolvedValue(undefined) };
+    const pgp = createForPGP({ core, db });
+
+    const result = await pgp.none('DELETE ...');
+    expect(db.none).toHaveBeenCalledWith('DELETE ...', undefined);
+    expect(result).toBeNull();
+  });
+
+  test('passes values to db.none', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = { none: jest.fn().mockResolvedValue(undefined) };
+    const pgp = createForPGP({ core, db });
+
+    await 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', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('db error');
+    const db = { many: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db });
+
+    await expect(pgp.one('SELECT ...')).rejects.toThrow('db error');
+  });
+
+  test('defaultErrorHandler calls logError for non-QueryResultError', async () => {
+    const logError = jest.fn((err: Error) => {
+      throw err;
+    }) as any;
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('unexpected error');
+    const db = { many: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db, logError });
+
+    await expect(pgp.one('SELECT ...')).rejects.toThrow('unexpected error');
+    expect(logError).toHaveBeenCalledWith(err);
+  });
+
+  test('defaultErrorHandler does not call logError for QueryResultError', async () => {
+    const logError = jest.fn((err: Error) => {
+      throw err;
+    }) as any;
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('no data');
+    err.name = 'QueryResultError';
+    const db = { many: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db, logError });
+
+    await expect(pgp.one('SELECT ...')).rejects.toThrow('no data');
+    expect(logError).not.toHaveBeenCalled();
+  });
+
+  test('custom errorHandler overrides defaultErrorHandler', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('db failure');
+    const db = { many: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db });
+    const customHandler = jest.fn((_err: Error) => {
+      throw new Error('custom handled');
+    }) as any;
+
+    await expect(
+      pgp.one('SELECT ...', undefined, customHandler)
+    ).rejects.toThrow('custom handled');
+    expect(customHandler).toHaveBeenCalledWith(err);
+  });
+
+  test('custom errorHandler works for oneOrNone', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('fail');
+    const db = { any: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db });
+    const customHandler = jest.fn((_err: Error) => {
+      throw new Error('caught');
+    }) as any;
+
+    await expect(
+      pgp.oneOrNone('SELECT ...', undefined, customHandler)
+    ).rejects.toThrow('caught');
+    expect(customHandler).toHaveBeenCalledWith(err);
+  });
+
+  test('custom errorHandler works for many', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('fail');
+    const db = { any: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db });
+    const customHandler = jest.fn((_err: Error) => {
+      throw new Error('caught');
+    }) as any;
+
+    await expect(
+      pgp.many('SELECT ...', undefined, customHandler)
+    ).rejects.toThrow('caught');
+  });
+
+  test('custom errorHandler works for any', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('fail');
+    const db = { result: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db });
+    const customHandler = jest.fn((_err: Error) => {
+      throw new Error('caught');
+    }) as any;
+
+    await expect(
+      pgp.any('SELECT ...', undefined, customHandler)
+    ).rejects.toThrow('caught');
+  });
+
+  test('custom errorHandler works for none', async () => {
+    const core = createCore({ entities: simpleEntities });
+    const err = new Error('fail');
+    const db = { none: jest.fn().mockRejectedValue(err) };
+    const pgp = createForPGP({ core, db });
+    const customHandler = jest.fn((_err: Error) => {
+      throw new Error('caught');
+    }) as any;
+
+    await expect(
+      pgp.none('DELETE ...', undefined, customHandler)
+    ).rejects.toThrow('caught');
+  });
+});
+
+/* -------------------------------------------------------------------------*/
+/* Returned object structure -----------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+
+describe('createForPGP return structure', () => {
+  test('includes all core methods', () => {
+    const core = createCore({ entities: simpleEntities });
+    const db = {
+      many: jest.fn(),
+      any: jest.fn(),
+      result: jest.fn(),
+      none: jest.fn()
+    };
+    const pgp = 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 = createCore({ entities: simpleEntities });
+    const db = {
+      many: jest.fn(),
+      any: jest.fn(),
+      result: jest.fn(),
+      none: jest.fn()
+    };
+    const pgp = 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 = createCore({ entities: simpleEntities });
+    const db = {
+      many: jest.fn(),
+      any: jest.fn(),
+      result: jest.fn(),
+      none: jest.fn()
+    };
+    const pgp = createForPGP({ core, db });
+
+    expect(pgp.db).toBe(db);
+  });
+});

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)