pure-orm 4.0.0 → 4.0.1

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:
    *  [
@@ -447,13 +453,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/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',