pure-orm 4.0.0-4 → 4.0.0-7

package/src/{factory.ts → core.ts}

@@ -1,4 +1,4 @@
-const camelCase = require('camelcase');
+import camelCase from 'camelcase';
 
 export interface IColumnData {
   column: string;
@@ -54,19 +54,52 @@ export interface IEntityInternal<T extends IModel> {
 }
 export type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
 
-export interface CreateOptions {
-  entities: IEntities<any>;
-  db: any;
-  logError?: (err: Error) => void;
+export interface ICreateCoreOptions {
+  entities: IEntities<IModel>;
 }
 
-export const create = ({
-  entities: externalEntities,
-  db,
-  logError
-}: CreateOptions) => {
-  const entities: IEntitiesInternal<any> = externalEntities.map(
-    (d: IEntity<any>) => {
+export interface ICore {
+  /* ------------------------------------------------------------------------*/
+  /* Object Relational Mapping methods --------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  /* Note these construction methods ensure their count against the number of
+   * generated top level business objects - independent of the number of
+   * relational rows passed in as a result from a database driver query.
+   * Thus, for example, `one` understands that there may be multiple result
+   * rows (which a database driver's `one` query method would throw at) but
+   * which correctly nest into one Model.)
+   */
+
+  createFromDatabase: <T extends ICollection<IModel>>(rows: any) => T;
+  createAnyFromDatabase: <T extends ICollection<IModel>>(
+    rows: any,
+    rootKey: string | IModel
+  ) => T;
+  createOneFromDatabase: <T extends IModel>(rows: any) => T;
+  createOneOrNoneFromDatabase: <T extends IModel>(rows: any) => T | void;
+  createManyFromDatabase: <T extends ICollection<IModel>>(rows: any) => T;
+
+  /* ------------------------------------------------------------------------*/
+  /* Helpful Properties -----------------------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  /* The tables property gives access to the sql select clause string for
+   * each entity based on it's `displayName`. This property can be used when
+   * writing raw SQL as the select clause, which handles quoting column names
+   * and namespacing them to the table to avoid collisions and as required
+   * for PureORM mapping.
+   */
+  tables: { [key: string]: { columns: string } };
+  getEntityByModel: (model: IModel) => IEntityInternal<IModel>;
+  getEntityByTableName: (tableName: string) => IEntityInternal<IModel>;
+}
+
+export const createCore = ({
+  entities: externalEntities
+}: ICreateCoreOptions): ICore => {
+  const entities: IEntitiesInternal<IModel> = externalEntities.map(
+    (d: IEntity<IModel>) => {
       const tableName = d.tableName;
       const displayName = d.displayName || camelCase(d.tableName);
       const collectionDisplayName =
@@ -146,7 +179,7 @@ export const create = ({
     }
   );
 
-  const getEntityByTableName = (tableName: string): IEntityInternal<any> => {
+  const getEntityByTableName = (tableName: string): IEntityInternal<IModel> => {
     const entity = entities.find((data) => data.tableName == tableName);
     if (!entity) {
       throw new Error(`Could not find entity for table ${tableName}`);
@@ -154,7 +187,7 @@ export const create = ({
     return entity;
   };
 
-  const getEntityByModel = (model: IModel): IEntityInternal<any> => {
+  const getEntityByModel = (model: IModel): IEntityInternal<IModel> => {
     const entity = entities.find((data) => data.Model == model.constructor);
     if (!entity) {
       throw new Error(`Could not find entity for class ${model.constructor}`);
@@ -162,15 +195,6 @@ export const create = ({
     return entity;
   };
 
-  const defaultErrorHandler = (err: Error) => {
-    if (!(err.name === 'QueryResultError')) {
-      if (logError) {
-        logError(err);
-      }
-    }
-    throw err;
-  };
-
   /*
    * In:
    *  [
@@ -379,360 +403,83 @@ export const create = ({
     return Object.keys(result).reduce((obj: any, text: string) => {
       const tableName = text.split('#')[0];
       const column = text.split('#')[1];
+      if (!tableName || !column) {
+        throw new Error('Column names must be namespaced to table');
+      }
       obj[tableName] = obj[tableName] || {};
       obj[tableName][column] = result[text as keyof typeof result];
       return obj;
     }, {});
   };
 
-  const createFromDatabase = <T extends ICollection<IModel>>(
-    _result: Array<object> | object
-  ): T | undefined => {
-    const result = Array.isArray(_result) ? _result : [_result];
+  const createFromDatabase = <T extends ICollection<IModel>>(rows: any): T => {
+    const result = Array.isArray(rows) ? rows : [rows];
     const objectified = result.map(objectifyDatabaseResult);
     const boified = objectified.map(mapToBos);
     const clumps = clumpIntoGroups(boified);
     const nested = clumps.map(nestClump);
     const models = nested.map((n) => Object.values(n)[0]);
     const Collection = getEntityByModel(models[0]).Collection;
-    return models.length ? (new Collection({ models }) as T) : void 0;
+    return <T>new Collection({ models });
   };
 
-  const createOneFromDatabase = <T extends IModel>(_result: any): T => {
-    const collection = createFromDatabase<ICollection<IModel>>(_result);
-    if (!collection) {
+  const createAnyFromDatabase = <T extends ICollection<IModel>>(
+    rows: any,
+    rootKey: string | IModel
+  ): T => {
+    if (!rows || !rows.length) {
+      const Collection =
+        typeof rootKey === 'string'
+          ? getEntityByTableName(rootKey).Collection
+          : getEntityByModel(rootKey).Collection;
+      return new Collection({ models: [] }) as T;
+    }
+    return <T>createFromDatabase<T>(rows);
+  };
+
+  const createOneFromDatabase = <T extends IModel>(rows: any): T => {
+    if (!rows || !rows.length) {
       throw Error('Did not get one.');
     }
-    if (!collection || collection.models.length === 0) {
+    const collection = createFromDatabase<ICollection<IModel>>(rows);
+    if (!collection || !collection.models || collection.models.length === 0) {
       throw Error('Did not get one.');
     } else if (collection.models.length > 1) {
       throw Error('Got more than one.');
     }
-    return collection.models[0] as T;
+    return <T>collection.models[0];
   };
 
   const createOneOrNoneFromDatabase = <T extends IModel>(
-    _result: any
+    rows: any
   ): T | void => {
-    if (!_result) {
-      return _result;
-    }
-    const collection = createFromDatabase(_result);
-    if (collection && collection.models.length > 1) {
-      throw Error('Got more than one.');
+    if (!rows || !rows.length) {
+      return void 0;
     }
-    return collection && (collection.models[0] as T);
+    return <T>createOneFromDatabase(rows);
   };
 
   const createManyFromDatabase = <T extends ICollection<IModel>>(
-    _result: any
+    rows: any
   ): T => {
-    const collection = createFromDatabase(_result);
-    if (!collection || collection.models.length === 0) {
+    if (!rows || !rows.length) {
       throw Error('Did not get at least one.');
     }
-    return collection as T;
-  };
-
-  const getSqlInsertParts = (model: IModel) => {
-    const columns = getEntityByModel(model)
-      .columnNames.filter(
-        (column: string, index: number) =>
-          model[
-            getEntityByModel(model).propertyNames[index] as keyof typeof model
-          ] !== void 0
-      )
-      .map((col: string) => `"${col}"`)
-      .join(', ');
-    const values = 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}`
-    );
-    return { columns, values, valuesVar };
-  };
-
-  const getSqlUpdateParts = (model: IModel, on = 'id') => {
-    const clauseArray = getEntityByModel(model)
-      .columnNames.filter(
-        (sqlColumn: string, index: number) =>
-          model[
-            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 = 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]];
-    return { clause, idVar, values };
-  };
-
-  const getMatchingParts = (model: IModel) => {
-    const whereClause = getEntityByModel(model)
-      .propertyNames.map((property: string, index: number) =>
-        model[property as keyof typeof model] != null
-          ? `"${getEntityByModel(model).tableName}"."${
-              getEntityByModel(model).columnNames[index]
-            }"`
-          : null
-      )
-      .filter((x: string | null) => x != null)
-      .map((x: string | null, i: number) => `${x} = $${i + 1}`)
-      .join(' AND ');
-    const values = 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);
-    return { whereClause, values };
-  };
-
-  // 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 whereClause = getEntityByModel(model)
-      .propertyNames.map((property: string, index: number) =>
-        model[property as keyof typeof model] != null
-          ? `"${getEntityByModel(model).tableName}"."${
-              getEntityByModel(model).columnNames[index]
-            }"`
-          : null
-      )
-      .filter((x: string | null) => x != null)
-      .map((x: string | null, i: number) => `${x} = $(${i + 1})`)
-      .join(' AND ');
-    const values = 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 }),
-        {}
-      );
-    return { whereClause, values };
-  };
-
-  const getNewWith = (model: IModel, sqlColumns: any, values: any) => {
-    const Constructor = model.constructor as any;
-    const modelKeys = sqlColumns.map(
-      (key: string) =>
-        getEntityByModel(model).propertyNames[
-          getEntityByModel(model).columnNames.indexOf(key)
-        ]
-    );
-    const modelData = modelKeys.reduce(
-      (data: any, key: string, index: number) => {
-        data[key] = values[index];
-        return data;
-      },
-      {}
-    );
-    return new Constructor(modelData);
-  };
-
-  const getValueBySqlColumn = (model: IModel, sqlColumn: string) => {
-    return model[
-      getEntityByModel(model).propertyNames[
-        getEntityByModel(model).columnNames.indexOf(sqlColumn)
-      ] as keyof typeof model
-    ];
-  };
-  /* ------------------------------------------------------------------------*/
-  /* Query functions --------------------------------------------------------*/
-  /* ------------------------------------------------------------------------*/
-
-  const one = <T extends IModel>(
-    query: string,
-    values?: object,
-    errorHandler = defaultErrorHandler
-  ): T => {
-    return db
-      .many(query, values)
-      .then((rows: any) => createOneFromDatabase(rows))
-      .catch(errorHandler);
-  };
-
-  const oneOrNone = <T extends IModel>(
-    query: string,
-    values?: object,
-    errorHandler = defaultErrorHandler
-  ): T | void => {
-    return db
-      .any(query, values)
-      .then((rows: any) => createOneOrNoneFromDatabase(rows))
-      .catch(errorHandler);
-  };
-
-  const many = <T extends ICollection<IModel>>(
-    query: string,
-    values?: object,
-    errorHandler = defaultErrorHandler
-  ): T => {
-    return db
-      .any(query, values)
-      .then((rows: any) => createManyFromDatabase(rows))
-      .catch(errorHandler);
-  };
-
-  const any = <T extends ICollection<IModel>>(
-    query: string,
-    values?: object,
-    errorHandler = defaultErrorHandler
-  ): T | void => {
-    return db
-      .any(query, values)
-      .then((rows: any) => createFromDatabase(rows))
-      .catch(errorHandler);
-  };
-
-  const none = (
-    query: string,
-    values?: object,
-    errorHandler = defaultErrorHandler
-  ): void => {
-    return db
-      .none(query, values)
-      .then(() => null)
-      .catch(errorHandler);
-  };
-
-  /* ------------------------------------------------------------------------*/
-  /* Built-in basic CRUD functions ------------------------------------------*/
-  /* ------------------------------------------------------------------------*/
-
-  // Standard create
-  const create = <T extends IModel>(model: T): T => {
-    const { columns, values, valuesVar } = getSqlInsertParts(model);
-    const query = `
-      INSERT INTO "${getEntityByModel(model).tableName}" ( ${columns} )
-      VALUES ( ${valuesVar} )
-      RETURNING ${getEntityByModel(model).selectColumnsClause};
-    `;
-    return one<T>(query, values);
-  };
-
-  // Standard update
-  const update = <T extends IModel>(model: T, { on = 'id' } = {}): T => {
-    const { clause, idVar, values } = getSqlUpdateParts(model, on);
-    const query = `
-      UPDATE "${getEntityByModel(model).tableName}"
-      SET ${clause}
-      WHERE "${getEntityByModel(model).tableName}".${on} = ${idVar}
-      RETURNING ${getEntityByModel(model).selectColumnsClause};
-    `;
-    return one<T>(query, values);
-  };
-
-  // Standard delete
-  const _delete = <T extends IModel>(model: T): void => {
-    const id = (model as any).id;
-    const query = `
-      DELETE FROM "${getEntityByModel(model).tableName}"
-      WHERE "${getEntityByModel(model).tableName}".id = $(id)
-    `;
-    return none(query, { id });
-  };
-
-  const deleteMatching = <T extends IModel>(model: T) => {
-    const { whereClause, values } = getMatchingParts(model);
-    const query = `
-      DELETE FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-    return none(query, values);
-  };
-
-  const getMatching = <T extends IModel>(model: T): T => {
-    const { whereClause, values } = getMatchingParts(model);
-    const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-    return one<T>(query, values);
-  };
-
-  const getOneOrNoneMatching = <T extends IModel>(model: T): T | void => {
-    const { whereClause, values } = getMatchingParts(model);
-    const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-    return oneOrNone<T>(query, values);
-  };
-
-  const getAnyMatching = <T extends ICollection<IModel>>(
-    model: IModel
-  ): T | void => {
-    const { whereClause, values } = getMatchingParts(model);
-    const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-    return any<T>(query, values);
-  };
-
-  const getAllMatching = <T extends ICollection<IModel>>(model: IModel): T => {
-    const { whereClause, values } = getMatchingParts(model);
-    const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-    return many<T>(query, values);
+    return <T>createFromDatabase(rows);
   };
 
   return {
-    // Query Helper Function
-    nestClump,
-    clumpIntoGroups,
-    mapToBos,
-    objectifyDatabaseResult,
+    getEntityByModel,
+    getEntityByTableName,
     createFromDatabase,
+    createAnyFromDatabase,
     createOneFromDatabase,
     createOneOrNoneFromDatabase,
     createManyFromDatabase,
-    getSqlInsertParts,
-    getSqlUpdateParts,
-    getMatchingParts,
-    getMatchingPartsObject,
-    getNewWith,
-    getValueBySqlColumn,
-    // Query Functions
-    one,
-    oneOrNone,
-    many,
-    any,
-    none,
-    // Built-in basic CRUD functions
-    create,
-    update,
-    delete: _delete,
-    deleteMatching,
-    getMatching,
-    getOneOrNoneMatching,
-    getAnyMatching,
-    getAllMatching,
-    tables: entities.reduce((accum: any, data: IEntityInternal<any>) => {
-      accum[data.displayName] = data.selectColumnsClause;
+    tables: entities.reduce((accum: any, data: IEntityInternal<IModel>) => {
+      accum[data.displayName] = {
+        columns: data.selectColumnsClause
+      };
       return accum;
     }, {})
   };

package/src/driver-integrations/index.ts

@@ -0,0 +1,56 @@
+import { ICore, IModel, ICollection } from '../core';
+
+export interface ICreateForDriverOptions {
+  core: ICore;
+  db: any;
+  logError?: (err: Error) => never;
+}
+
+export interface ICoreIntegratedDriver extends ICore {
+  /* ------------------------------------------------------------------------*/
+  /* Query methods ----------------------------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  /* Note these query methods ensure their count against the number of
+   * generated top level business objects which are created - not the number
+   * of relational rows returned from the database driver! Thus, for example,
+   * `one` understands that there may be multiple result rows (which a
+   * database driver's `one` query method would throw at) but which correctly
+   * nest into one Model.)
+   */
+
+  // Execute a query returning a single model, or throws.
+  one: <T extends IModel>(
+    query: string,
+    values?: object,
+    errorHandler?: (err: Error) => never
+  ) => 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;
+
+  // 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;
+
+  // Execute a query returning a Collection.
+  any: <T extends ICollection<IModel>>(
+    query: string,
+    values?: object,
+    errorHandler?: (err: Error) => never
+  ) => T | void;
+
+  // Execute a query returning null.
+  none: (
+    query: string,
+    values?: object,
+    errorHandler?: (err: Error) => never
+  ) => void;
+}

package/src/driver-integrations/pgp.ts

@@ -0,0 +1,92 @@
+import { IModel, ICollection } from '../core';
+import { ICreateForDriverOptions, ICoreIntegratedDriver } from './index';
+
+export const createForPGP = ({
+  core,
+  db,
+  logError
+}: ICreateForDriverOptions): ICoreIntegratedDriver => {
+  const defaultErrorHandler = (err: Error) => {
+    if (!(err.name === 'QueryResultError')) {
+      if (logError) {
+        logError(err);
+      }
+    }
+    throw err;
+  };
+
+  /* ------------------------------------------------------------------------*/
+  /* Query functions --------------------------------------------------------*/
+  /* ------------------------------------------------------------------------*/
+
+  const one = <T extends IModel>(
+    query: string,
+    values?: object,
+    errorHandler = defaultErrorHandler
+  ): T => {
+    return db
+      .many(query, values)
+      .then((rows: any) => core.createOneFromDatabase(rows))
+      .catch(errorHandler);
+  };
+
+  const oneOrNone = <T extends IModel>(
+    query: string,
+    values?: object,
+    errorHandler = defaultErrorHandler
+  ): T | void => {
+    return db
+      .any(query, values)
+      .then((rows: any) => core.createOneOrNoneFromDatabase(rows))
+      .catch(errorHandler);
+  };
+
+  const many = <T extends ICollection<IModel>>(
+    query: string,
+    values?: object,
+    errorHandler = defaultErrorHandler
+  ): T => {
+    return db
+      .any(query, values)
+      .then((rows: any) => core.createManyFromDatabase(rows))
+      .catch(errorHandler);
+  };
+
+  const any = <T extends ICollection<IModel>>(
+    query: string,
+    values?: object,
+    errorHandler = defaultErrorHandler
+  ): T | void => {
+    return db
+      .result(query, values)
+      .then((result: any) =>
+        core.createAnyFromDatabase(
+          result.rows,
+          result.fields[0].name.split('#')[0]
+        )
+      )
+      .catch(errorHandler);
+  };
+
+  const none = (
+    query: string,
+    values?: object,
+    errorHandler = defaultErrorHandler
+  ): void => {
+    return db
+      .none(query, values)
+      .then(() => null)
+      .catch(errorHandler);
+  };
+
+  return Object.assign({}, core, {
+    // Query Functions
+    one,
+    oneOrNone,
+    many,
+    any,
+    none,
+    // provide direct access to db
+    db
+  });
+};

package/src/index.ts

@@ -1,8 +1,10 @@
 export {
-  create,
-  CreateOptions,
+  createCore,
+  ICreateCoreOptions,
+  ICore,
   IModel,
   IModelClass,
   ICollection,
   IColumns
-} from './factory';
+} from './core';
+export { create, ICreateOptions, IPureORM } from './orm';