pure-orm 4.0.2 → 4.1.4

package/dist/src/core.spec.js

@@ -12,6 +12,9 @@ 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 order_1 = require("../test-utils/order/models/order");
+const utm_source_1 = require("../test-utils/order/models/utm-source");
+const feature_switch_1 = require("../test-utils/nine/models/feature-switch");
 const two = require('../test-utils/two/results');
 const three = require('../test-utils/three/results');
 const one = require('../test-utils/one/results.json');
@@ -680,3 +683,413 @@ test('tables', () => {
     expect(core.tables.productVariant.columns).toEqual('"product_variant".id as "product_variant#id", "product_variant".product_id as "product_variant#product_id", "product_variant".actual_product_variant_id as "product_variant#actual_product_variant_id", "product_variant".color_id as "product_variant#color_id", "product_variant".gender_id as "product_variant#gender_id", "product_variant".size_id as "product_variant#size_id", "product_variant".barcode as "product_variant#barcode", "product_variant".price as "product_variant#price", "product_variant".compare_at_price as "product_variant#compare_at_price", "product_variant".created_date as "product_variant#created_date", "product_variant".updated_date as "product_variant#updated_date", "product_variant".grams as "product_variant#grams", "product_variant".requires_shipping as "product_variant#requires_shipping"');
     expect(core.tables.product.columns).toEqual('"product".id as "product#id", "product".vendor_id as "product#vendor_id", "product".value as "product#value", "product".label as "product#label", "product".product_type as "product#product_type", "product".created_date as "product#created_date", "product".updated_date as "product#updated_date", "product".published_date as "product#published_date", "product".category as "product#category"');
 });
+/* -------------------------------------------------------------------------*/
+/* getEntityByModel --------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('getEntityByModel', () => {
+    test('returns entity for a model instance', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const order = new order_1.Order({ id: 1, email: 'x@x.com' });
+        const entity = core.getEntityByModel(order);
+        expect(entity.tableName).toEqual('order');
+        expect(entity.displayName).toEqual('order');
+        expect(entity.Model).toBe(order_1.Order);
+        expect(entity.Collection).toBe(order_1.Orders);
+    });
+    test('returns correct entity among multiple registered entities', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const utm = new utm_source_1.UtmSource({
+            id: 1,
+            value: 'google',
+            label: 'Google',
+            internal: 'false'
+        });
+        const entity = core.getEntityByModel(utm);
+        expect(entity.tableName).toEqual('utm_source');
+        expect(entity.displayName).toEqual('utmSource');
+    });
+    test('throws for an unregistered model class', () => {
+        const core = (0, core_1.createCore)({ entities: entities_4.entities });
+        const order = new order_1.Order({ id: 1 });
+        expect(() => core.getEntityByModel(order)).toThrow('Could not find entity for class');
+    });
+    test('entity has correct propertyNames derived from columns', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const order = new order_1.Order({ id: 1 });
+        const entity = core.getEntityByModel(order);
+        expect(entity.propertyNames).toContain('id');
+        expect(entity.propertyNames).toContain('email');
+        expect(entity.propertyNames).toContain('browserIP');
+        expect(entity.propertyNames).toContain('utmSourceId');
+    });
+    test('entity has correct columnNames derived from columns', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const order = new order_1.Order({ id: 1 });
+        const entity = core.getEntityByModel(order);
+        expect(entity.columnNames).toContain('id');
+        expect(entity.columnNames).toContain('email');
+        expect(entity.columnNames).toContain('browser_ip');
+        expect(entity.columnNames).toContain('utm_source_id');
+    });
+    test('entity has correct prefixedColumnNames', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const order = new order_1.Order({ id: 1 });
+        const entity = core.getEntityByModel(order);
+        expect(entity.prefixedColumnNames).toContain('order#id');
+        expect(entity.prefixedColumnNames).toContain('order#email');
+        expect(entity.prefixedColumnNames).toContain('order#browser_ip');
+    });
+    test('entity has correct references', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const order = new order_1.Order({ id: 1 });
+        const entity = core.getEntityByModel(order);
+        expect(entity.references).toEqual({ utmSourceId: utm_source_1.UtmSource });
+    });
+    test('entity defaults primaryKeys to [id] when none specified', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const order = new order_1.Order({ id: 1 });
+        const entity = core.getEntityByModel(order);
+        expect(entity.primaryKeys).toEqual(['id']);
+    });
+    test('entity selectColumnsClause is correctly formed', () => {
+        const core = (0, core_1.createCore)({ entities: entities_4.entities });
+        const fs = new feature_switch_1.FeatureSwitch({ id: 'x', label: 'x', on: true });
+        const entity = core.getEntityByModel(fs);
+        expect(entity.selectColumnsClause).toEqual('"feature_switch".id as "feature_switch#id", "feature_switch".label as "feature_switch#label", "feature_switch".on as "feature_switch#on"');
+    });
+});
+/* -------------------------------------------------------------------------*/
+/* getEntityByTableName ----------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('getEntityByTableName', () => {
+    test('returns entity for a valid table name', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const entity = core.getEntityByTableName('order');
+        expect(entity.tableName).toEqual('order');
+        expect(entity.Model).toBe(order_1.Order);
+    });
+    test('returns correct entity among multiple registered entities', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const entity = core.getEntityByTableName('utm_source');
+        expect(entity.tableName).toEqual('utm_source');
+        expect(entity.displayName).toEqual('utmSource');
+        expect(entity.Model).toBe(utm_source_1.UtmSource);
+    });
+    test('throws for a non-existent table name', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        expect(() => core.getEntityByTableName('nonexistent')).toThrow('Could not find entity for table nonexistent');
+    });
+});
+/* -------------------------------------------------------------------------*/
+/* Entity configuration edge cases -----------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('entity configuration', () => {
+    test('custom displayName is used instead of camelCase tableName', () => {
+        class Widget {
+            constructor(props) {
+                this.id = props.id;
+            }
+        }
+        class Widgets {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'widget_thing',
+                    displayName: 'myWidget',
+                    columns: ['id'],
+                    Model: Widget,
+                    Collection: Widgets
+                }
+            ]
+        });
+        expect(core.tables.myWidget).toBeDefined();
+        expect(core.tables.myWidget.columns).toEqual('"widget_thing".id as "widget_thing#id"');
+    });
+    test('custom collectionDisplayName is used', () => {
+        class Goose {
+            constructor(props) {
+                this.id = props.id;
+            }
+        }
+        class Geese {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'goose',
+                    collectionDisplayName: 'geese',
+                    columns: ['id'],
+                    Model: Goose,
+                    Collection: Geese
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('goose');
+        expect(entity.collectionDisplayName).toEqual('geese');
+    });
+    test('default collectionDisplayName appends "s" to displayName', () => {
+        const core = (0, core_1.createCore)({ entities: entities_1.entities });
+        const entity = core.getEntityByTableName('order');
+        expect(entity.collectionDisplayName).toEqual('orders');
+    });
+    test('function-based columns are resolved', () => {
+        class Item {
+            constructor(props) {
+                this.id = props.id;
+                this.name = props.name;
+            }
+        }
+        class Items {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const columnsFn = () => ['id', 'name'];
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'item',
+                    columns: columnsFn,
+                    Model: Item,
+                    Collection: Items
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('item');
+        expect(entity.columnNames).toEqual(['id', 'name']);
+        expect(entity.propertyNames).toEqual(['id', 'name']);
+    });
+    test('custom primary key is used', () => {
+        class Tenant {
+            constructor(props) {
+                this.slug = props.slug;
+                this.name = props.name;
+            }
+        }
+        class Tenants {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'tenant',
+                    columns: [{ column: 'slug', primaryKey: true }, 'name'],
+                    Model: Tenant,
+                    Collection: Tenants
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('tenant');
+        expect(entity.primaryKeys).toEqual(['slug']);
+    });
+    test('composite primary keys', () => {
+        class Mapping {
+            constructor(props) {
+                this.aId = props.aId;
+                this.bId = props.bId;
+            }
+        }
+        class Mappings {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'mapping',
+                    columns: [
+                        { column: 'a_id', primaryKey: true },
+                        { column: 'b_id', primaryKey: true }
+                    ],
+                    Model: Mapping,
+                    Collection: Mappings
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('mapping');
+        expect(entity.primaryKeys).toEqual(['a_id', 'b_id']);
+    });
+    test('column with explicit property name overrides camelCase', () => {
+        class Thing {
+            constructor(props) {
+                this.myIP = props.myIP;
+            }
+        }
+        class Things {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'thing',
+                    columns: [{ column: 'ip_address', property: 'myIP' }],
+                    Model: Thing,
+                    Collection: Things
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('thing');
+        expect(entity.propertyNames).toEqual(['myIP']);
+        expect(entity.columnNames).toEqual(['ip_address']);
+    });
+    test('getPkId returns concatenated primary key values', () => {
+        class Mapping {
+            constructor(props) {
+                this.a_id = props.aId;
+                this.b_id = props.bId;
+            }
+        }
+        class Mappings {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'mapping',
+                    columns: [
+                        { column: 'a_id', primaryKey: true },
+                        { column: 'b_id', primaryKey: true }
+                    ],
+                    Model: Mapping,
+                    Collection: Mappings
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('mapping');
+        const m = new Mapping({ aId: 5, bId: 10 });
+        expect(entity.getPkId(m)).toEqual('510');
+    });
+    test('entity with no columns other than id', () => {
+        class Simple {
+            constructor(props) {
+                this.id = props.id;
+            }
+        }
+        class Simples {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'simple',
+                    columns: ['id'],
+                    Model: Simple,
+                    Collection: Simples
+                }
+            ]
+        });
+        const entity = core.getEntityByTableName('simple');
+        expect(entity.columnNames).toEqual(['id']);
+        expect(entity.propertyNames).toEqual(['id']);
+        expect(entity.primaryKeys).toEqual(['id']);
+        expect(entity.references).toEqual({});
+    });
+});
+/* -------------------------------------------------------------------------*/
+/* createFromDatabase error/edge cases -------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('createFromDatabase edge cases', () => {
+    test('handles a single row (not an array)', () => {
+        const core = (0, core_1.createCore)({ entities: entities_4.entities });
+        const row = {
+            'feature_switch#id': 'test_switch',
+            'feature_switch#label': 'Test',
+            'feature_switch#on': true
+        };
+        const result = core.createFromDatabase(row);
+        expect(result.models.length).toEqual(1);
+        expect(result.models[0].id).toEqual('test_switch');
+    });
+    test('throws when column names are not namespaced', () => {
+        const core = (0, core_1.createCore)({ entities: entities_4.entities });
+        expect(() => core.createFromDatabase([{ id: 1, label: 'test', on: true }])).toThrow('Column names must be namespaced to table');
+    });
+    test('handles meta_ prefixed columns', () => {
+        class Widget {
+            constructor(props) {
+                this.id = props.id;
+                Object.assign(this, props);
+            }
+        }
+        class Widgets {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'widget',
+                    columns: ['id'],
+                    Model: Widget,
+                    Collection: Widgets
+                }
+            ]
+        });
+        const result = core.createFromDatabase([
+            { 'widget#id': 1, 'widget#meta_count': 42 }
+        ]);
+        expect(result.models[0].id).toEqual(1);
+        expect(result.models[0].metaCount).toEqual(42);
+    });
+    test('throws for non-meta unrecognized columns', () => {
+        class Widget {
+            constructor(props) {
+                this.id = props.id;
+            }
+        }
+        class Widgets {
+            constructor({ models }) {
+                this.models = models;
+            }
+        }
+        const core = (0, core_1.createCore)({
+            entities: [
+                {
+                    tableName: 'widget',
+                    columns: ['id'],
+                    Model: Widget,
+                    Collection: Widgets
+                }
+            ]
+        });
+        expect(() => core.createFromDatabase([{ 'widget#id': 1, 'widget#unknown_col': 'x' }])).toThrow('No property name for "unknown_col"');
+    });
+});
+/* -------------------------------------------------------------------------*/
+/* tables property ---------------------------------------------------------*/
+/* -------------------------------------------------------------------------*/
+describe('tables property', () => {
+    test('uses displayName as key', () => {
+        const core = (0, core_1.createCore)({ entities: entities_2.entities });
+        expect(core.tables.article).toBeDefined();
+        expect(core.tables.person).toBeDefined();
+        expect(core.tables.articleTag).toBeDefined();
+        expect(core.tables.tag).toBeDefined();
+    });
+    test('each table entry has a columns string', () => {
+        const core = (0, core_1.createCore)({ entities: entities_4.entities });
+        expect(typeof core.tables.featureSwitch.columns).toBe('string');
+        expect(core.tables.featureSwitch.columns).toContain('feature_switch');
+    });
+    test('single entity produces single table entry', () => {
+        const core = (0, core_1.createCore)({ entities: entities_4.entities });
+        expect(Object.keys(core.tables).length).toEqual(1);
+    });
+});

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/driver-integrations/pgp.spec.d.ts

@@ -0,0 +1 @@
+export {};