pure-orm 4.0.2 → 4.1.4

package/src/orm.ts

@@ -20,14 +20,16 @@ export interface IPureORM extends ICoreIntegratedDriver {
    * if you want to write these in your data access layer yourself.
    */
 
-  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: { on: string }) => T;
-  delete: <T extends IModel>(model: T) => void;
-  deleteMatching: <T extends IModel>(model: T) => void;
+  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 }) => Promise<T>;
+  delete: <T extends IModel>(model: T) => Promise<void>;
+  deleteMatching: <T extends IModel>(model: T) => Promise<void>;
 
   /* ------------------------------------------------------------------------*/
   /* Helper Utility Functions -----------------------------------------------*/
@@ -75,30 +77,61 @@ export const create = ({
   /* Helper Utilities for CRUD functions ------------------------------------*/
   /* ------------------------------------------------------------------------*/
 
+  interface IOrmHelperPlan {
+    quotedColumns: Array<string>;
+    updateClausePrefixes: Array<string>;
+    wherePositionalPrefixes: Array<string>;
+    whereNamedPrefixes: Array<string>;
+  }
+
+  const helperPlanByEntity = new Map<any, IOrmHelperPlan>();
+  const getHelperPlan = (entity: any): IOrmHelperPlan => {
+    let plan = helperPlanByEntity.get(entity);
+    if (!plan) {
+      const quotedColumns = new Array(entity.columnNames.length);
+      const updateClausePrefixes = new Array(entity.columnNames.length);
+      const wherePositionalPrefixes = new Array(entity.columnNames.length);
+      const whereNamedPrefixes = new Array(entity.columnNames.length);
+      for (let i = 0; i < entity.columnNames.length; i++) {
+        const column = entity.columnNames[i];
+        quotedColumns[i] = `"${column}"`;
+        updateClausePrefixes[i] = `"${column}" = $`;
+        wherePositionalPrefixes[i] = `"${entity.tableName}"."${column}" = $`;
+        whereNamedPrefixes[i] = `"${entity.tableName}"."${column}" = $(`;
+      }
+      plan = {
+        quotedColumns,
+        updateClausePrefixes,
+        wherePositionalPrefixes,
+        whereNamedPrefixes
+      };
+      helperPlanByEntity.set(entity, plan);
+    }
+    return plan;
+  };
+
   const getSqlInsertParts = (
     model: IModel
   ): { columns: string; values: Array<string>; valuesVar: Array<string> } => {
-    const columns = orm
-      .getEntityByModel(model)
-      .columnNames.filter(
-        (column: string, index: number) =>
-          model[
-            orm.getEntityByModel(model).propertyNames[
-              index
-            ] as keyof typeof model
-          ] !== void 0
-      )
-      .map((col: string) => `"${col}"`)
-      .join(', ');
-    const values = orm
-      .getEntityByModel(model)
-      .propertyNames.map(
-        (property: string) => model[property as keyof typeof model]
-      )
-      .filter((value: any) => value !== void 0);
-    const valuesVar = values.map(
-      (value: any, index: number) => `$${index + 1}`
-    );
+    const entity = orm.getEntityByModel(model);
+    const { columnNames, propertyNames } = entity;
+    const helperPlan = getHelperPlan(entity);
+    let columns = '';
+    const values: Array<any> = [];
+    const valuesVar: Array<string> = [];
+    let paramIndex = 1;
+    for (let i = 0; i < columnNames.length; i++) {
+      const val = model[propertyNames[i] as keyof typeof model];
+      if (val !== void 0) {
+        if (columns) {
+          columns += ', ';
+        }
+        columns += helperPlan.quotedColumns[i];
+        values.push(val);
+        valuesVar.push(`$${paramIndex}`);
+        paramIndex++;
+      }
+    }
     return { columns, values, valuesVar };
   };
 
@@ -106,54 +139,48 @@ export const create = ({
     model: IModel,
     on = 'id'
   ): { clause: string; idVar: string; values: Array<string> } => {
-    const clauseArray = orm
-      .getEntityByModel(model)
-      .columnNames.filter(
-        (sqlColumn: string, index: number) =>
-          model[
-            orm.getEntityByModel(model).propertyNames[
-              index
-            ] as keyof typeof model
-          ] !== void 0
-      )
-      .map(
-        (sqlColumn: string, index: number) => `"${sqlColumn}" = $${index + 1}`
-      );
-    const clause = clauseArray.join(', ');
-    const idVar = `$${clauseArray.length + 1}`;
-    const _values = orm
-      .getEntityByModel(model)
-      .propertyNames.map(
-        (property: string) => model[property as keyof typeof model]
-      )
-      .filter((value: any) => value !== void 0);
-    const values = [..._values, model[on as keyof typeof model]];
+    const entity = orm.getEntityByModel(model);
+    const { columnNames, propertyNames } = entity;
+    const helperPlan = getHelperPlan(entity);
+    let clause = '';
+    const values: Array<any> = [];
+    let paramIndex = 1;
+    for (let i = 0; i < columnNames.length; i++) {
+      const val = model[propertyNames[i] as keyof typeof model];
+      if (val !== void 0) {
+        if (clause) {
+          clause += ', ';
+        }
+        clause += helperPlan.updateClausePrefixes[i] + paramIndex;
+        values.push(val);
+        paramIndex++;
+      }
+    }
+    const idVar = `$${paramIndex}`;
+    values.push(model[on as keyof typeof model]);
     return { clause, idVar, values };
   };
 
   const getMatchingParts = (
     model: IModel
   ): { whereClause: string; values: Array<string> } => {
-    const whereClause = orm
-      .getEntityByModel(model)
-      .propertyNames.map((property: string, index: number) =>
-        model[property as keyof typeof model] != null
-          ? `"${orm.getEntityByModel(model).tableName}"."${
-              orm.getEntityByModel(model).columnNames[index]
-            }"`
-          : null
-      )
-      .filter((x: string | null) => x != null)
-      .map((x: string | null, i: number) => `${x} = $${i + 1}`)
-      .join(' AND ');
-    const values = orm
-      .getEntityByModel(model)
-      .propertyNames.map((property: string) =>
-        model[property as keyof typeof model] != null
-          ? model[property as keyof typeof model]
-          : null
-      )
-      .filter((x: any) => x != null);
+    const entity = orm.getEntityByModel(model);
+    const { propertyNames, columnNames } = entity;
+    const helperPlan = getHelperPlan(entity);
+    const values: Array<any> = [];
+    let paramIndex = 1;
+    let whereClause = '';
+    for (let i = 0; i < propertyNames.length; i++) {
+      const val = model[propertyNames[i] as keyof typeof model];
+      if (val != null) {
+        if (whereClause) {
+          whereClause += ' AND ';
+        }
+        whereClause += helperPlan.wherePositionalPrefixes[i] + paramIndex;
+        values.push(val);
+        paramIndex++;
+      }
+    }
     return { whereClause, values };
   };
 
@@ -162,67 +189,54 @@ export const create = ({
   const getMatchingPartsObject = (
     model: IModel
   ): { whereClause: string; values: Array<string> } => {
-    const whereClause = orm
-      .getEntityByModel(model)
-      .propertyNames.map((property: string, index: number) =>
-        model[property as keyof typeof model] != null
-          ? `"${orm.getEntityByModel(model).tableName}"."${
-              orm.getEntityByModel(model).columnNames[index]
-            }"`
-          : null
-      )
-      .filter((x: string | null) => x != null)
-      .map((x: string | null, i: number) => `${x} = $(${i + 1})`)
-      .join(' AND ');
-    const values = orm
-      .getEntityByModel(model)
-      .propertyNames.map((property: string) =>
-        model[property as keyof typeof model] != null
-          ? model[property as keyof typeof model]
-          : null
-      )
-      .filter((x: any) => x != null)
-      .reduce(
-        (accum: any, val: any, index: number) =>
-          Object.assign({}, accum, { [index + 1]: val }),
-        {}
-      );
+    const entity = orm.getEntityByModel(model);
+    const { propertyNames, columnNames } = entity;
+    const helperPlan = getHelperPlan(entity);
+    const values: any = {};
+    let paramIndex = 1;
+    let whereClause = '';
+    for (let i = 0; i < propertyNames.length; i++) {
+      const val = model[propertyNames[i] as keyof typeof model];
+      if (val != null) {
+        if (whereClause) {
+          whereClause += ' AND ';
+        }
+        whereClause += helperPlan.whereNamedPrefixes[i] + paramIndex + ')';
+        values[paramIndex] = val;
+        paramIndex++;
+      }
+    }
     return { whereClause, values };
   };
 
   const getNewWith = (model: IModel, sqlColumns: any, values: any): IModel => {
     const Constructor = model.constructor as any;
-    const modelKeys = sqlColumns.map(
-      (key: string) =>
-        orm.getEntityByModel(model).propertyNames[
-          orm.getEntityByModel(model).columnNames.indexOf(key)
-        ]
-    );
-    const modelData = modelKeys.reduce(
-      (data: any, key: string, index: number) => {
-        data[key] = values[index];
-        return data;
-      },
-      {}
-    );
+    const entity = orm.getEntityByModel(model);
+    const modelData: any = {};
+    for (let i = 0; i < sqlColumns.length; i++) {
+      const propertyName = entity.columnToPropertyMap.get(sqlColumns[i]);
+      if (propertyName) {
+        modelData[propertyName] = values[i];
+      }
+    }
     return new Constructor(modelData);
   };
 
   const getValueBySqlColumn = (model: IModel, sqlColumn: string): string => {
-    return model[
-      orm.getEntityByModel(model).propertyNames[
-        orm.getEntityByModel(model).columnNames.indexOf(sqlColumn)
-      ] as keyof typeof model
-    ];
+    const entity = orm.getEntityByModel(model);
+    const propertyName = entity.columnToPropertyMap.get(sqlColumn);
+    return propertyName
+      ? model[propertyName as keyof typeof model]
+      : (undefined as any);
   };
 
   const getSqlColumnForPropertyName = (
     model: IModel,
     propertyName: string
   ): string => {
-    return orm.getEntityByModel(model).columnNames[
-      orm.getEntityByModel(model).propertyNames.indexOf(propertyName)
-    ];
+    const entity = orm.getEntityByModel(model);
+    const column = entity.propertyToColumnMap.get(propertyName);
+    return column as string;
   };
 
   /* ------------------------------------------------------------------------*/
@@ -230,64 +244,76 @@ export const create = ({
   /* ------------------------------------------------------------------------*/
 
   // Standard create
-  const create = <T extends IModel>(model: T): T => {
+  const create = <T extends IModel>(model: T): Promise<T> => {
+    const entity = orm.getEntityByModel(model);
     const { columns, values, valuesVar } = getSqlInsertParts(model);
     const query = `
-      INSERT INTO "${orm.getEntityByModel(model).tableName}" ( ${columns} )
+      INSERT INTO "${entity.tableName}" ( ${columns} )
       VALUES ( ${valuesVar} )
-      RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
+      RETURNING ${entity.selectColumnsClause};
     `;
     return orm.one<T>(query, values);
   };
 
   // Standard update
-  const update = <T extends IModel>(model: T, { on = 'id' } = {}): T => {
+  const update = <T extends IModel>(
+    model: T,
+    { on = 'id' } = {}
+  ): Promise<T> => {
+    const entity = orm.getEntityByModel(model);
     const { clause, idVar, values } = getSqlUpdateParts(model, on);
     const query = `
-      UPDATE "${orm.getEntityByModel(model).tableName}"
+      UPDATE "${entity.tableName}"
       SET ${clause}
-      WHERE "${
-        orm.getEntityByModel(model).tableName
-      }".${getSqlColumnForPropertyName(model, on)} = ${idVar}
-      RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
+      WHERE "${entity.tableName}".${getSqlColumnForPropertyName(
+      model,
+      on
+    )} = ${idVar}
+      RETURNING ${entity.selectColumnsClause};
     `;
     return orm.one<T>(query, values);
   };
 
   // Standard delete
-  const _delete = <T extends IModel>(model: T): void => {
+  const _delete = <T extends IModel>(model: T): Promise<void> => {
+    const entity = orm.getEntityByModel(model);
     const id = (model as any).id;
     const query = `
-      DELETE FROM "${orm.getEntityByModel(model).tableName}"
-      WHERE "${orm.getEntityByModel(model).tableName}".id = $(id)
+      DELETE FROM "${entity.tableName}"
+      WHERE "${entity.tableName}".id = $(id)
     `;
     return orm.none(query, { id });
   };
 
-  const deleteMatching = <T extends IModel>(model: T) => {
+  const deleteMatching = <T extends IModel>(model: T): Promise<void> => {
+    const entity = orm.getEntityByModel(model);
     const { whereClause, values } = getMatchingParts(model);
     const query = `
-      DELETE FROM "${orm.getEntityByModel(model).tableName}"
+      DELETE FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
     return orm.none(query, values);
   };
 
-  const getMatching = <T extends IModel>(model: T): T => {
+  const getMatching = <T extends IModel>(model: T): Promise<T> => {
+    const entity = orm.getEntityByModel(model);
     const { whereClause, values } = getMatchingParts(model);
     const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
     return orm.one<T>(query, values);
   };
 
-  const getOneOrNoneMatching = <T extends IModel>(model: T): T | void => {
+  const getOneOrNoneMatching = <T extends IModel>(
+    model: T
+  ): Promise<T | void> => {
+    const entity = orm.getEntityByModel(model);
     const { whereClause, values } = getMatchingParts(model);
     const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
     return orm.oneOrNone<T>(query, values);
@@ -295,21 +321,25 @@ export const create = ({
 
   const getAnyMatching = <T extends ICollection<IModel>>(
     model: IModel
-  ): T | void => {
+  ): Promise<T | void> => {
+    const entity = orm.getEntityByModel(model);
     const { whereClause, values } = getMatchingParts(model);
     const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
     return orm.any<T>(query, values);
   };
 
-  const getAllMatching = <T extends ICollection<IModel>>(model: IModel): T => {
+  const getAllMatching = <T extends ICollection<IModel>>(
+    model: IModel
+  ): Promise<T> => {
+    const entity = orm.getEntityByModel(model);
     const { whereClause, values } = getMatchingParts(model);
     const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
     return orm.many<T>(query, values);

package/test-utils/nine/models/feature-switch.ts

@@ -5,13 +5,13 @@ export const tableName: string = 'feature_switch';
 export const columns: IColumns = ['id', 'label', 'on'];
 
 interface IFeatureSwitchProps {
-  id: number;
+  id: string | number;
   label: string;
   on: boolean;
 }
 
 export class FeatureSwitch implements IModel {
-  id: number;
+  id: string | number;
   label: string;
   on: boolean;