pure-orm 4.0.0 → 4.0.2

package/src/core.ts

@@ -74,7 +74,7 @@ export interface ICore {
   createFromDatabase: <T extends ICollection<IModel>>(rows: any) => T;
   createAnyFromDatabase: <T extends ICollection<IModel>>(
     rows: any,
-    rootKey: string | IModel
+    rootKey: string | IModelClass
   ) => T;
   createOneFromDatabase: <T extends IModel>(rows: any) => T;
   createOneOrNoneFromDatabase: <T extends IModel>(rows: any) => T | void;
@@ -209,14 +209,20 @@ export const createCore = ({
     new Map()
   );
 
-  const getEntityByModel = (model: IModel): IEntityInternal<IModel> => {
-    const entity = modelToEntityMap.get(model.constructor);
+  const getEntityByModelClass = (
+    Model: IModelClass
+  ): IEntityInternal<IModel> => {
+    const entity = modelToEntityMap.get(Model);
     if (!entity) {
-      throw new Error(`Could not find entity for class ${model.constructor}`);
+      throw new Error(`Could not find entity for class ${Model}`);
     }
     return entity;
   };
 
+  const getEntityByModel = (model: IModel): IEntityInternal<IModel> => {
+    return getEntityByModelClass(model.constructor as IModelClass);
+  };
+
   /*
    * In:
    *  [
@@ -286,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) {
@@ -447,13 +460,13 @@ export const createCore = ({
 
   const createAnyFromDatabase = <T extends ICollection<IModel>>(
     rows: any,
-    rootKey: string | IModel
+    rootKey: string | IModelClass
   ): T => {
     if (!rows || !rows.length) {
       const Collection =
         typeof rootKey === 'string'
           ? getEntityByTableName(rootKey).Collection
-          : getEntityByModel(rootKey).Collection;
+          : getEntityByModelClass(rootKey).Collection;
       return new Collection({ models: [] }) as T;
     }
     return <T>createFromDatabase<T>(rows);

package/src/driver-integrations/index.ts

@@ -7,6 +7,8 @@ export interface ICreateForDriverOptions {
 }
 
 export interface ICoreIntegratedDriver extends ICore {
+  db: any;
+
   /* ------------------------------------------------------------------------*/
   /* Query methods ----------------------------------------------------------*/
   /* ------------------------------------------------------------------------*/

package/src/orm.spec.ts

@@ -0,0 +1,113 @@
+/* eslint-disable max-len */
+import { create } from './index';
+import { entities as orderEntities } from '../test-utils/order/entities';
+
+test('getSqlInsertParts', () => {
+  const orm = create({
+    entities: orderEntities,
+    db: { $config: { pgp: true } }
+  });
+  const order = new orderEntities[0].Model({
+    id: 1,
+    email: 'test@test.com',
+    subtotalPrice: 100,
+    utmSourceId: 10
+  });
+  expect(orm.getSqlInsertParts(order)).toEqual({
+    columns: '"id", "email", "subtotal_price", "utm_source_id"',
+    values: [1, 'test@test.com', 100, 10],
+    valuesVar: ['$1', '$2', '$3', '$4']
+  });
+});
+
+test('getSqlUpdateParts', () => {
+  const orm = create({
+    entities: orderEntities,
+    db: { $config: { pgp: true } }
+  });
+  const order = new orderEntities[0].Model({
+    id: 1,
+    email: 'test@test.com',
+    subtotalPrice: 100,
+    utmSourceId: 10
+  });
+  expect(orm.getSqlUpdateParts(order)).toEqual({
+    clause:
+      '"id" = $1, "email" = $2, "subtotal_price" = $3, "utm_source_id" = $4',
+    idVar: '$5',
+    values: [1, 'test@test.com', 100, 10, 1]
+  });
+});
+
+test('getMatchingParts', () => {
+  const orm = create({
+    entities: orderEntities,
+    db: { $config: { pgp: true } }
+  });
+  const order = new orderEntities[0].Model({
+    id: 1,
+    email: 'test@test.com',
+    subtotalPrice: 100,
+    utmSourceId: 10
+  });
+  expect(orm.getMatchingParts(order)).toEqual({
+    values: [1, 'test@test.com', 100, 10],
+    whereClause:
+      '"order"."id" = $1 AND "order"."email" = $2 AND "order"."subtotal_price" = $3 AND "order"."utm_source_id" = $4'
+  });
+});
+
+test('getMatchingPartsObject', () => {
+  const orm = create({
+    entities: orderEntities,
+    db: { $config: { pgp: true } }
+  });
+  const order = new orderEntities[0].Model({
+    id: 1,
+    email: 'test@test.com',
+    subtotalPrice: 100,
+    utmSourceId: 10
+  });
+  expect(orm.getMatchingPartsObject(order)).toEqual({
+    values: {
+      1: 1,
+      2: 'test@test.com',
+      3: 100,
+      4: 10
+    },
+    whereClause:
+      '"order"."id" = $(1) AND "order"."email" = $(2) AND "order"."subtotal_price" = $(3) AND "order"."utm_source_id" = $(4)'
+  });
+});
+
+test('getValueBySqlColumn', () => {
+  const orm = create({
+    entities: orderEntities,
+    db: { $config: { pgp: true } }
+  });
+  const order = new orderEntities[0].Model({
+    id: 1,
+    email: 'test@test.com',
+    subtotalPrice: 100,
+    utmSourceId: 10
+  });
+  expect(orm.getValueBySqlColumn(order, 'id')).toEqual(1);
+  expect(orm.getValueBySqlColumn(order, 'email')).toEqual('test@test.com');
+  expect(orm.getValueBySqlColumn(order, 'subtotal_price')).toEqual(100);
+  expect(orm.getValueBySqlColumn(order, 'utm_source_id')).toEqual(10);
+});
+
+test('getSqlColumnForPropertyName', () => {
+  const orm = create({
+    entities: orderEntities,
+    db: { $config: { pgp: true } }
+  });
+  const order = new orderEntities[0].Model({ id: 1 });
+  expect(orm.getSqlColumnForPropertyName(order, 'id')).toEqual('id');
+  expect(orm.getSqlColumnForPropertyName(order, 'utmSourceId')).toEqual(
+    'utm_source_id'
+  );
+  expect(orm.getSqlColumnForPropertyName(order, 'browserIP')).toEqual(
+    'browser_ip'
+  );
+});

package/src/orm.ts

@@ -28,6 +28,31 @@ export interface IPureORM extends ICoreIntegratedDriver {
   update: <T extends IModel>(model: T, options: { on: string }) => T;
   delete: <T extends IModel>(model: T) => void;
   deleteMatching: <T extends IModel>(model: T) => void;
+
+  /* ------------------------------------------------------------------------*/
+  /* Helper Utility Functions -----------------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  getSqlInsertParts: (model: IModel) => {
+    columns: string;
+    values: Array<string>;
+    valuesVar: Array<string>;
+  };
+  getSqlUpdateParts: (
+    model: IModel,
+    on?: string
+  ) => { clause: string; idVar: string; values: Array<string> };
+  getMatchingParts: (model: IModel) => {
+    whereClause: string;
+    values: Array<string>;
+  };
+  getMatchingPartsObject: (model: IModel) => {
+    whereClause: string;
+    values: Array<string>;
+  };
+  getNewWith: (model: IModel, sqlColumns: any, values: any) => IModel;
+  getValueBySqlColumn: (model: IModel, sqlColumn: string) => string;
+  getSqlColumnForPropertyName: (model: IModel, propertyName: string) => string;
 }
 
 export const create = ({
@@ -50,7 +75,9 @@ export const create = ({
   /* Helper Utilities for CRUD functions ------------------------------------*/
   /* ------------------------------------------------------------------------*/
 
-  const getSqlInsertParts = (model: IModel) => {
+  const getSqlInsertParts = (
+    model: IModel
+  ): { columns: string; values: Array<string>; valuesVar: Array<string> } => {
     const columns = orm
       .getEntityByModel(model)
       .columnNames.filter(
@@ -75,7 +102,10 @@ export const create = ({
     return { columns, values, valuesVar };
   };
 
-  const getSqlUpdateParts = (model: IModel, on = 'id') => {
+  const getSqlUpdateParts = (
+    model: IModel,
+    on = 'id'
+  ): { clause: string; idVar: string; values: Array<string> } => {
     const clauseArray = orm
       .getEntityByModel(model)
       .columnNames.filter(
@@ -101,7 +131,9 @@ export const create = ({
     return { clause, idVar, values };
   };
 
-  const getMatchingParts = (model: IModel) => {
+  const getMatchingParts = (
+    model: IModel
+  ): { whereClause: string; values: Array<string> } => {
     const whereClause = orm
       .getEntityByModel(model)
       .propertyNames.map((property: string, index: number) =>
@@ -127,7 +159,9 @@ export const create = ({
 
   // This one returns an object, which allows it to be more versatile.
   // To-do: make this one even better and use it instead of the one above.
-  const getMatchingPartsObject = (model: IModel) => {
+  const getMatchingPartsObject = (
+    model: IModel
+  ): { whereClause: string; values: Array<string> } => {
     const whereClause = orm
       .getEntityByModel(model)
       .propertyNames.map((property: string, index: number) =>
@@ -156,7 +190,7 @@ export const create = ({
     return { whereClause, values };
   };
 
-  const getNewWith = (model: IModel, sqlColumns: any, values: any) => {
+  const getNewWith = (model: IModel, sqlColumns: any, values: any): IModel => {
     const Constructor = model.constructor as any;
     const modelKeys = sqlColumns.map(
       (key: string) =>
@@ -174,7 +208,7 @@ export const create = ({
     return new Constructor(modelData);
   };
 
-  const getValueBySqlColumn = (model: IModel, sqlColumn: string) => {
+  const getValueBySqlColumn = (model: IModel, sqlColumn: string): string => {
     return model[
       orm.getEntityByModel(model).propertyNames[
         orm.getEntityByModel(model).columnNames.indexOf(sqlColumn)
@@ -182,6 +216,15 @@ export const create = ({
     ];
   };
 
+  const getSqlColumnForPropertyName = (
+    model: IModel,
+    propertyName: string
+  ): string => {
+    return orm.getEntityByModel(model).columnNames[
+      orm.getEntityByModel(model).propertyNames.indexOf(propertyName)
+    ];
+  };
+
   /* ------------------------------------------------------------------------*/
   /* Built-in basic CRUD functions ------------------------------------------*/
   /* ------------------------------------------------------------------------*/
@@ -203,7 +246,9 @@ export const create = ({
     const query = `
       UPDATE "${orm.getEntityByModel(model).tableName}"
       SET ${clause}
-      WHERE "${orm.getEntityByModel(model).tableName}".${on} = ${idVar}
+      WHERE "${
+        orm.getEntityByModel(model).tableName
+      }".${getSqlColumnForPropertyName(model, on)} = ${idVar}
       RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
     `;
     return orm.one<T>(query, values);
@@ -286,6 +331,7 @@ export const create = ({
     getMatchingParts,
     getMatchingPartsObject,
     getNewWith,
-    getValueBySqlColumn
+    getValueBySqlColumn,
+    getSqlColumnForPropertyName
   });
 };

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];

package/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/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/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/test-utils/order/entities.ts

@@ -1,12 +1,12 @@
-import { utmSourceEntity } from './models/utm-source';
 import { orderEntity } from './models/order';
+import { utmSourceEntity } from './models/utm-source';
 import { lineItemEntity } from './models/line-item';
 import { productVariantEntity } from './models/product-variant';
 import { productEntity } from './models/product';
 
 export const entities = [
-  utmSourceEntity,
   orderEntity,
+  utmSourceEntity,
   lineItemEntity,
   productVariantEntity,
   productEntity

package/test-utils/order/models/order.ts

@@ -6,7 +6,7 @@ export const tableName: string = 'order';
 export const columns: IColumns = [
   'id',
   'email',
-  'browser_ip',
+  { column: 'browser_ip', property: 'browserIP' },
   'browser_user_agent',
   'kujo_imported_date',
   'created_date',