pure-orm 4.0.0-5 → 4.0.0-8

package/dist/example/factories/orm.d.ts

@@ -1,48 +1,2 @@
-declare const orm: {
-    nestClump: (clump: import("../../src/factory").IModel[][]) => object;
-    clumpIntoGroups: (processed: import("../../src/factory").IModel[][]) => import("../../src/factory").IModel[][][];
-    mapToBos: (objectified: any) => import("../../src/factory").IModel[];
-    objectifyDatabaseResult: (result: object) => any;
-    createFromDatabase: <T extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(_result: object | object[]) => T | undefined;
-    createOneFromDatabase: <T_1 extends import("../../src/factory").IModel>(_result: any) => T_1;
-    createOneOrNoneFromDatabase: <T_2 extends import("../../src/factory").IModel>(_result: any) => void | T_2;
-    createManyFromDatabase: <T_3 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(_result: any) => T_3;
-    getSqlInsertParts: (model: import("../../src/factory").IModel) => {
-        columns: string;
-        values: any[];
-        valuesVar: string[];
-    };
-    getSqlUpdateParts: (model: import("../../src/factory").IModel, on?: string) => {
-        clause: string;
-        idVar: string;
-        values: any[];
-    };
-    getMatchingParts: (model: import("../../src/factory").IModel) => {
-        whereClause: string;
-        values: any[];
-    };
-    getMatchingPartsObject: (model: import("../../src/factory").IModel) => {
-        whereClause: string;
-        values: any;
-    };
-    getNewWith: (model: import("../../src/factory").IModel, sqlColumns: any, values: any) => any;
-    getValueBySqlColumn: (model: import("../../src/factory").IModel, sqlColumn: string) => any;
-    one: <T_4 extends import("../../src/factory").IModel>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => T_4;
-    oneOrNone: <T_5 extends import("../../src/factory").IModel>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void | T_5;
-    many: <T_6 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => T_6;
-    any: <T_7 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void | T_7;
-    none: (query: string, values?: object | undefined, errorHandler?: (err: Error) => never) => void;
-    create: <T_8 extends import("../../src/factory").IModel>(model: T_8) => T_8;
-    update: <T_9 extends import("../../src/factory").IModel>(model: T_9, { on }?: {
-        on?: string | undefined;
-    }) => T_9;
-    delete: <T_10 extends import("../../src/factory").IModel>(model: T_10) => void;
-    deleteMatching: <T_11 extends import("../../src/factory").IModel>(model: T_11) => void;
-    getMatching: <T_12 extends import("../../src/factory").IModel>(model: T_12) => T_12;
-    getOneOrNoneMatching: <T_13 extends import("../../src/factory").IModel>(model: T_13) => void | T_13;
-    getAnyMatching: <T_14 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(model: import("../../src/factory").IModel) => void | T_14;
-    getAllMatching: <T_15 extends import("../../src/factory").ICollection<import("../../src/factory").IModel>>(model: import("../../src/factory").IModel) => T_15;
-    tables: any;
-    db: any;
-};
+declare const orm: import("../../src/orm").IPureORM;
 export default orm;

package/dist/example/models/employer.d.ts

@@ -16,7 +16,7 @@ export declare class Employers implements ICollection<Employer> {
 }
 export declare const employerEntity: {
     tableName: string;
-    columns: import("../../src/factory").IColumn[];
+    columns: import("../../src/core").IColumn[];
     Model: typeof Employer;
     Collection: typeof Employers;
 };

package/dist/example/models/job.d.ts

@@ -28,7 +28,7 @@ export declare class Jobs implements ICollection<Job> {
 }
 export declare const jobEntity: {
     tableName: string;
-    columns: import("../../src/factory").IColumn[];
+    columns: import("../../src/core").IColumn[];
     Model: typeof Job;
     Collection: typeof Jobs;
 };

package/dist/example/models/person.d.ts

@@ -18,7 +18,7 @@ export declare class Persons implements ICollection<Person> {
 }
 export declare const personEntity: {
     tableName: string;
-    columns: import("../../src/factory").IColumn[];
+    columns: import("../../src/core").IColumn[];
     Model: typeof Person;
     Collection: typeof Persons;
 };

package/dist/src/core.d.ts

@@ -0,0 +1,66 @@
+export interface IColumnData {
+    column: string;
+    property?: string;
+    references?: IModelClass;
+    primaryKey?: boolean;
+}
+export declare type IColumn = IColumnData | string;
+export declare type IColumns = Array<IColumn> | (() => Array<IColumn>);
+export interface IColumnInternalData {
+    column: string;
+    property: string;
+    references?: IModelClass;
+    primaryKey: boolean;
+}
+export declare type IColumnInternal = IColumnInternalData;
+export declare type IColumnsInternal = Array<IColumnInternal>;
+export interface IModel {
+    [key: string]: any;
+}
+export declare type IModelClass = new (props: any) => IModel;
+export interface ICollection<T extends IModel> {
+    models: Array<T>;
+}
+export interface IEntity<T extends IModel> {
+    tableName: string;
+    displayName?: string;
+    collectionDisplayName?: string;
+    columns: IColumns;
+    Model: new (props: any) => T;
+    Collection: new ({ models }: any) => ICollection<T>;
+}
+export declare type IEntities<T extends IModel> = Array<IEntity<T>>;
+export interface IEntityInternal<T extends IModel> {
+    tableName: string;
+    displayName: string;
+    collectionDisplayName: string;
+    columns: IColumnsInternal;
+    propertyNames: Array<string>;
+    Model: new (props: any) => T;
+    Collection: new ({ models }: any) => ICollection<T>;
+    columnNames: Array<string>;
+    prefixedColumnNames: Array<string>;
+    primaryKeys: Array<string>;
+    references: object;
+    selectColumnsClause: string;
+    getPkId: (model: IModel) => string;
+}
+export declare type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
+export interface ICreateCoreOptions {
+    entities: IEntities<IModel>;
+}
+export interface ICore {
+    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;
+    tables: {
+        [key: string]: {
+            columns: string;
+        };
+    };
+    getEntityByModel: (model: IModel) => IEntityInternal<IModel>;
+    getEntityByTableName: (tableName: string) => IEntityInternal<IModel>;
+}
+export declare const createCore: ({ entities: externalEntities }: ICreateCoreOptions) => ICore;

package/dist/src/{factory.js → core.js}

@@ -1,21 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const camelCase = require('camelcase');
-const create = ({ entities: externalEntities, db, logError }) => {
+exports.createCore = void 0;
+const camelcase_1 = __importDefault(require("camelcase"));
+const createCore = ({ entities: externalEntities }) => {
     const entities = externalEntities.map((d) => {
         const tableName = d.tableName;
-        const displayName = d.displayName || camelCase(d.tableName);
+        const displayName = d.displayName || (0, camelcase_1.default)(d.tableName);
         const collectionDisplayName = d.collectionDisplayName || `${displayName}s`;
         const columns = (typeof d.columns === 'function' ? d.columns() : d.columns).map((d) => {
             if (typeof d === 'string') {
                 return {
                     column: d,
-                    property: camelCase(d),
+                    property: (0, camelcase_1.default)(d),
                     primaryKey: false
                 };
             }
-            return Object.assign({ column: d.column, property: d.property || camelCase(d.column), primaryKey: d.primaryKey || false }, (d.references ? { references: d.references } : {}));
+            return Object.assign({ column: d.column, property: d.property || (0, camelcase_1.default)(d.column), primaryKey: d.primaryKey || false }, (d.references ? { references: d.references } : {}));
         });
         const propertyNames = columns.map((x) => x.property);
         const columnNames = columns.map((x) => x.column);
@@ -55,28 +58,28 @@ const create = ({ entities: externalEntities, db, logError }) => {
             getPkId
         };
     });
+    const tableNameToEntityMap = entities.reduce((map, entity) => {
+        map.set(entity.tableName, entity);
+        return map;
+    }, new Map());
     const getEntityByTableName = (tableName) => {
-        const entity = entities.find((data) => data.tableName == tableName);
+        const entity = tableNameToEntityMap.get(tableName);
         if (!entity) {
             throw new Error(`Could not find entity for table ${tableName}`);
         }
         return entity;
     };
+    const modelToEntityMap = entities.reduce((map, entity) => {
+        map.set(entity.Model, entity);
+        return map;
+    }, new Map());
     const getEntityByModel = (model) => {
-        const entity = entities.find((data) => data.Model == model.constructor);
+        const entity = modelToEntityMap.get(model.constructor);
         if (!entity) {
             throw new Error(`Could not find entity for class ${model.constructor}`);
         }
         return entity;
     };
-    const defaultErrorHandler = (err) => {
-        if (!(err.name === 'QueryResultError')) {
-            if (logError) {
-                logError(err);
-            }
-        }
-        throw err;
-    };
     /*
      * In:
      *  [
@@ -229,7 +232,7 @@ const create = ({ entities: externalEntities, db, logError }) => {
                 let propertyName = entity.propertyNames[entity.columnNames.indexOf(column)];
                 if (!propertyName) {
                     if (column.startsWith('meta_')) {
-                        propertyName = camelCase(column);
+                        propertyName = (0, camelcase_1.default)(column);
                     }
                     else {
                         throw Error(`No property name for "${column}" in business object "${entity.displayName}". Non-spec'd columns must begin with "meta_".`);
@@ -249,27 +252,39 @@ const create = ({ entities: externalEntities, db, logError }) => {
         return Object.keys(result).reduce((obj, text) => {
             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];
             return obj;
         }, {});
     };
-    const createFromDatabase = (_result) => {
-        const result = Array.isArray(_result) ? _result : [_result];
+    const createFromDatabase = (rows) => {
+        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 }) : void 0;
+        return new Collection({ models });
+    };
+    const createAnyFromDatabase = (rows, rootKey) => {
+        if (!rows || !rows.length) {
+            const Collection = typeof rootKey === 'string'
+                ? getEntityByTableName(rootKey).Collection
+                : getEntityByModel(rootKey).Collection;
+            return new Collection({ models: [] });
+        }
+        return createFromDatabase(rows);
     };
-    const createOneFromDatabase = (_result) => {
-        const collection = createFromDatabase(_result);
-        if (!collection) {
+    const createOneFromDatabase = (rows) => {
+        if (!rows || !rows.length) {
             throw Error('Did not get one.');
         }
-        if (!collection || collection.models.length === 0) {
+        const collection = createFromDatabase(rows);
+        if (!collection || !collection.models || collection.models.length === 0) {
             throw Error('Did not get one.');
         }
         else if (collection.models.length > 1) {
@@ -277,241 +292,32 @@ const create = ({ entities: externalEntities, db, logError }) => {
         }
         return collection.models[0];
     };
-    const createOneOrNoneFromDatabase = (_result) => {
-        if (!_result) {
-            return _result;
+    const createOneOrNoneFromDatabase = (rows) => {
+        if (!rows || !rows.length) {
+            return void 0;
         }
-        const collection = createFromDatabase(_result);
-        if (collection && collection.models.length > 1) {
-            throw Error('Got more than one.');
-        }
-        return collection && collection.models[0];
+        return createOneFromDatabase(rows);
     };
-    const createManyFromDatabase = (_result) => {
-        const collection = createFromDatabase(_result);
-        if (!collection || collection.models.length === 0) {
+    const createManyFromDatabase = (rows) => {
+        if (!rows || !rows.length) {
             throw Error('Did not get at least one.');
         }
-        return collection;
-    };
-    const getSqlInsertParts = (model) => {
-        const columns = getEntityByModel(model)
-            .columnNames.filter((column, index) => model[getEntityByModel(model).propertyNames[index]] !== void 0)
-            .map((col) => `"${col}"`)
-            .join(', ');
-        const values = getEntityByModel(model)
-            .propertyNames.map((property) => model[property])
-            .filter((value) => value !== void 0);
-        const valuesVar = values.map((value, index) => `$${index + 1}`);
-        return { columns, values, valuesVar };
-    };
-    const getSqlUpdateParts = (model, on = 'id') => {
-        const clauseArray = getEntityByModel(model)
-            .columnNames.filter((sqlColumn, index) => model[getEntityByModel(model).propertyNames[index]] !== void 0)
-            .map((sqlColumn, index) => `"${sqlColumn}" = $${index + 1}`);
-        const clause = clauseArray.join(', ');
-        const idVar = `$${clauseArray.length + 1}`;
-        const _values = getEntityByModel(model)
-            .propertyNames.map((property) => model[property])
-            .filter((value) => value !== void 0);
-        const values = [..._values, model[on]];
-        return { clause, idVar, values };
-    };
-    const getMatchingParts = (model) => {
-        const whereClause = getEntityByModel(model)
-            .propertyNames.map((property, index) => model[property] != null
-            ? `"${getEntityByModel(model).tableName}"."${getEntityByModel(model).columnNames[index]}"`
-            : null)
-            .filter((x) => x != null)
-            .map((x, i) => `${x} = $${i + 1}`)
-            .join(' AND ');
-        const values = getEntityByModel(model)
-            .propertyNames.map((property) => model[property] != null
-            ? model[property]
-            : null)
-            .filter((x) => 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) => {
-        const whereClause = getEntityByModel(model)
-            .propertyNames.map((property, index) => model[property] != null
-            ? `"${getEntityByModel(model).tableName}"."${getEntityByModel(model).columnNames[index]}"`
-            : null)
-            .filter((x) => x != null)
-            .map((x, i) => `${x} = $(${i + 1})`)
-            .join(' AND ');
-        const values = getEntityByModel(model)
-            .propertyNames.map((property) => model[property] != null
-            ? model[property]
-            : null)
-            .filter((x) => x != null)
-            .reduce((accum, val, index) => Object.assign({}, accum, { [index + 1]: val }), {});
-        return { whereClause, values };
-    };
-    const getNewWith = (model, sqlColumns, values) => {
-        const Constructor = model.constructor;
-        const modelKeys = sqlColumns.map((key) => getEntityByModel(model).propertyNames[getEntityByModel(model).columnNames.indexOf(key)]);
-        const modelData = modelKeys.reduce((data, key, index) => {
-            data[key] = values[index];
-            return data;
-        }, {});
-        return new Constructor(modelData);
-    };
-    const getValueBySqlColumn = (model, sqlColumn) => {
-        return model[getEntityByModel(model).propertyNames[getEntityByModel(model).columnNames.indexOf(sqlColumn)]];
-    };
-    /* ------------------------------------------------------------------------*/
-    /* Query functions --------------------------------------------------------*/
-    /* ------------------------------------------------------------------------*/
-    const one = (query, values, errorHandler = defaultErrorHandler) => {
-        return db
-            .many(query, values)
-            .then((rows) => createOneFromDatabase(rows))
-            .catch(errorHandler);
-    };
-    const oneOrNone = (query, values, errorHandler = defaultErrorHandler) => {
-        return db
-            .any(query, values)
-            .then((rows) => createOneOrNoneFromDatabase(rows))
-            .catch(errorHandler);
-    };
-    const many = (query, values, errorHandler = defaultErrorHandler) => {
-        return db
-            .any(query, values)
-            .then((rows) => createManyFromDatabase(rows))
-            .catch(errorHandler);
-    };
-    const any = (query, values, errorHandler = defaultErrorHandler) => {
-        return db
-            .any(query, values)
-            .then((rows) => createFromDatabase(rows))
-            .catch(errorHandler);
-    };
-    const none = (query, values, errorHandler = defaultErrorHandler) => {
-        return db
-            .none(query, values)
-            .then(() => null)
-            .catch(errorHandler);
-    };
-    /* ------------------------------------------------------------------------*/
-    /* Built-in basic CRUD functions ------------------------------------------*/
-    /* ------------------------------------------------------------------------*/
-    // Standard create
-    const create = (model) => {
-        const { columns, values, valuesVar } = getSqlInsertParts(model);
-        const query = `
-      INSERT INTO "${getEntityByModel(model).tableName}" ( ${columns} )
-      VALUES ( ${valuesVar} )
-      RETURNING ${getEntityByModel(model).selectColumnsClause};
-    `;
-        return one(query, values);
-    };
-    // Standard update
-    const update = (model, { on = 'id' } = {}) => {
-        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(query, values);
-    };
-    // Standard delete
-    const _delete = (model) => {
-        const id = model.id;
-        const query = `
-      DELETE FROM "${getEntityByModel(model).tableName}"
-      WHERE "${getEntityByModel(model).tableName}".id = $(id)
-    `;
-        return none(query, { id });
-    };
-    const deleteMatching = (model) => {
-        const { whereClause, values } = getMatchingParts(model);
-        const query = `
-      DELETE FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-        return none(query, values);
-    };
-    const getMatching = (model) => {
-        const { whereClause, values } = getMatchingParts(model);
-        const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-        return one(query, values);
-    };
-    const getOneOrNoneMatching = (model) => {
-        const { whereClause, values } = getMatchingParts(model);
-        const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-        return oneOrNone(query, values);
-    };
-    const getAnyMatching = (model) => {
-        const { whereClause, values } = getMatchingParts(model);
-        const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-        return any(query, values);
-    };
-    const getAllMatching = (model) => {
-        const { whereClause, values } = getMatchingParts(model);
-        const query = `
-      SELECT ${getEntityByModel(model).selectColumnsClause}
-      FROM "${getEntityByModel(model).tableName}"
-      WHERE ${whereClause};
-    `;
-        return many(query, values);
+        return 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 property for access to select columns clause string
         tables: entities.reduce((accum, data) => {
             accum[data.displayName] = {
                 columns: data.selectColumnsClause
             };
             return accum;
-        }, {}),
-        // provide direct access to db
-        db
+        }, {})
     };
 };
-exports.create = create;
+exports.createCore = createCore;