pure-orm 4.0.0-0 → 4.0.0-3

package/dist/src/factory.js

@@ -0,0 +1,512 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const camelCase = require('camelcase');
+const create = ({ entities: externalEntities, db, logError }) => {
+    const entities = externalEntities.map((d) => {
+        const tableName = d.tableName;
+        const displayName = d.displayName || camelCase(d.tableName);
+        const collectionDisplayName = d.collectionDisplayName || `${displayName}s`;
+        const columns = d.columns.map((d) => {
+            if (typeof d === 'string') {
+                return {
+                    column: d,
+                    property: camelCase(d),
+                    primaryKey: false
+                };
+            }
+            return Object.assign({ column: d.column, property: d.property || camelCase(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);
+        const prefixedColumnNames = columnNames.map((col) => `${tableName}#${col}`);
+        const Model = d.Model;
+        const Collection = d.Collection;
+        const pkColumnsData = columns.filter((x) => x.primaryKey);
+        const _primaryKeys = pkColumnsData.map((x) => x.column);
+        const primaryKeys = _primaryKeys.length > 0 ? _primaryKeys : ['id'];
+        // Returns unique identifier of model (the values of the primary keys)
+        const getPkId = (model) => {
+            return primaryKeys
+                .map((key) => model[key])
+                .join('');
+        };
+        const references = columns
+            .filter((x) => x.references)
+            .reduce((accum, item) => Object.assign({}, accum, {
+            [item.property]: item.references
+        }), {});
+        const selectColumnsClause = prefixedColumnNames
+            .map((prefixed, index) => `"${tableName}".${columnNames[index]} as "${prefixed}"`)
+            .join(', ');
+        return {
+            tableName,
+            displayName,
+            collectionDisplayName,
+            columns,
+            propertyNames,
+            Model,
+            Collection,
+            columnNames,
+            prefixedColumnNames,
+            primaryKeys,
+            references,
+            selectColumnsClause,
+            getPkId
+        };
+    });
+    const getEntityByTableName = (tableName) => {
+        const entity = entities.find((data) => data.tableName == tableName);
+        if (!entity) {
+            throw new Error(`Could not find entity for table ${tableName}`);
+        }
+        return entity;
+    };
+    const getEntityByModel = (model) => {
+        const entity = entities.find((data) => data.Model == 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:
+     *  [
+     *    [Article {id: 32}, ArticleTag {id: 54}]
+     *    [Article {id: 32}, ArticleTag {id: 55}]
+     *  ]
+     * Out:
+     *  Article {id: 32, ArticleTags articleTags: [ArticleTag {id: 54}, ArticleTag {id: 55}]
+     */
+    const nestClump = (clump) => {
+        clump = clump.map((x) => Object.values(x));
+        const root = clump[0][0];
+        clump = clump.map((row) => row.filter((item, index) => index !== 0));
+        const built = { [getEntityByModel(root).displayName]: root };
+        let nodes = [root];
+        // Wowzer is this both CPU and Memory inefficient
+        clump.forEach((array) => {
+            array.forEach((_model) => {
+                const nodeAlreadySeen = nodes.find((x) => x.constructor.name === _model.constructor.name &&
+                    getEntityByModel(x).getPkId(x) ===
+                        getEntityByModel(_model).getPkId(_model));
+                const model = nodeAlreadySeen || _model;
+                const isNodeAlreadySeen = !!nodeAlreadySeen;
+                const nodePointingToIt = nodes.find((node) => {
+                    const indexes = Object.values(getEntityByModel(node).references)
+                        .map((x, i) => x === model.constructor ? i : null)
+                        .filter((x, i) => x != null);
+                    if (!indexes.length) {
+                        return false;
+                    }
+                    for (const index of indexes) {
+                        const property = Object.keys(getEntityByModel(node).references)[index];
+                        if (node[property] === model.id) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+                // For first obj type which is has an instance in nodes array,
+                // get its index in nodes array
+                const indexOfOldestParent = array.reduce((answer, obj) => {
+                    if (answer != null) {
+                        return answer;
+                    }
+                    const index = nodes.findIndex((n) => n.constructor === obj.constructor);
+                    if (index !== -1) {
+                        return index;
+                    }
+                    return null;
+                }, null) || 0;
+                const parentHeirarchy = [
+                    root,
+                    ...nodes.slice(0, indexOfOldestParent + 1).reverse()
+                ];
+                const nodeItPointsTo = parentHeirarchy.find((parent) => {
+                    const index = Object.values(getEntityByModel(model).references).indexOf(parent.constructor);
+                    if (index === -1) {
+                        return false;
+                    }
+                    const property = Object.keys(getEntityByModel(model).references)[index];
+                    return model[property] === parent.id;
+                });
+                if (isNodeAlreadySeen) {
+                    if (nodeItPointsTo && !nodePointingToIt) {
+                        nodes = [model, ...nodes];
+                        return;
+                    }
+                    // If the nodePointingToIt (eg, parcel_event) is part of an
+                    // existing collection on this node (eg, parcel) which is a
+                    // nodeAlreadySeen, early return so we don't create it (parcel) on
+                    // the nodePointingToIt (parcel_event), since it (parcel) has been
+                    // shown to be the parent (of parcel_events).
+                    if (nodePointingToIt) {
+                        const ec = model[getEntityByModel(nodePointingToIt)
+                            .collectionDisplayName];
+                        if (ec && ec.models.find((m) => m === nodePointingToIt)) {
+                            nodes = [model, ...nodes];
+                            return;
+                        }
+                    }
+                }
+                if (nodePointingToIt) {
+                    nodePointingToIt[getEntityByModel(model).displayName] = model;
+                }
+                else if (nodeItPointsTo) {
+                    let collection = nodeItPointsTo[getEntityByModel(model).collectionDisplayName];
+                    if (collection) {
+                        collection.models.push(model);
+                    }
+                    else {
+                        const Collection = getEntityByModel(model).Collection;
+                        nodeItPointsTo[getEntityByModel(model).collectionDisplayName] =
+                            new Collection({
+                                models: [model]
+                            });
+                    }
+                }
+                else {
+                    if (!getEntityByModel(model).getPkId(model)) {
+                        // If the join is fruitless; todo: add a test for this path
+                        return;
+                    }
+                    throw Error(`Could not find how this BO fits: ${JSON.stringify(model)} ${getEntityByModel(model).tableName}`);
+                }
+                nodes = [model, ...nodes];
+            });
+        });
+        return built;
+    };
+    /*
+     * Clump array of flat objects into groups based on id of root
+     * In:
+     *  [
+     *    [Article {id: 32}, ArticleTag {id: 54}]
+     *    [Article {id: 32}, ArticleTag {id: 55}]
+     *    [Article {id: 33}, ArticleTag {id: 56}]
+     *  ]
+     * Out:
+     *  [
+     *    [
+     *      [Article {id: 32}, ArticleTag {id: 54}]
+     *      [Article {id: 32}, ArticleTag {id: 55}]
+     *    ]
+     *    [
+     *      [Article {id: 33}, ArticleTag {id: 56}]
+     *    ]
+     *  ]
+     */
+    const clumpIntoGroups = (processed) => {
+        const root = processed[0][0];
+        const rootBo = root.constructor;
+        const clumps = processed.reduce((accum, item) => {
+            const id = getEntityByModel(root)
+                .primaryKeys.map((key) => { var _a; return (_a = item.find((x) => x.constructor === rootBo)) === null || _a === void 0 ? void 0 : _a[key]; })
+                .join('@');
+            if (accum.has(id)) {
+                accum.set(id, [...accum.get(id), item]);
+            }
+            else {
+                accum.set(id, [item]);
+            }
+            return accum;
+        }, new Map());
+        return [...clumps.values()];
+    };
+    const mapToBos = (objectified) => {
+        return Object.keys(objectified).map((tableName) => {
+            const entity = getEntityByTableName(tableName);
+            const propified = Object.keys(objectified[tableName]).reduce((obj, column) => {
+                let propertyName = entity.propertyNames[entity.columnNames.indexOf(column)];
+                if (!propertyName) {
+                    if (column.startsWith('meta_')) {
+                        propertyName = camelCase(column);
+                    }
+                    else {
+                        throw Error(`No property name for "${column}" in business object "${entity.displayName}". Non-spec'd columns must begin with "meta_".`);
+                    }
+                }
+                obj[propertyName] = objectified[tableName][column];
+                return obj;
+            }, {});
+            return new entity.Model(propified);
+        });
+    };
+    /*
+     * Make objects (based on special table#column names) from flat database
+     * return value.
+     */
+    const objectifyDatabaseResult = (result) => {
+        return Object.keys(result).reduce((obj, text) => {
+            const tableName = text.split('#')[0];
+            const column = text.split('#')[1];
+            obj[tableName] = obj[tableName] || {};
+            obj[tableName][column] = result[text];
+            return obj;
+        }, {});
+    };
+    const createFromDatabase = (_result) => {
+        const result = Array.isArray(_result) ? _result : [_result];
+        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;
+    };
+    const createOneFromDatabase = (_result) => {
+        const collection = createFromDatabase(_result);
+        if (!collection) {
+            throw Error('Did not get one.');
+        }
+        if (!collection || 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];
+    };
+    const createOneOrNoneFromDatabase = (_result) => {
+        if (!_result) {
+            return _result;
+        }
+        const collection = createFromDatabase(_result);
+        if (collection && collection.models.length > 1) {
+            throw Error('Got more than one.');
+        }
+        return collection && collection.models[0];
+    };
+    const createManyFromDatabase = (_result) => {
+        const collection = createFromDatabase(_result);
+        if (!collection || collection.models.length === 0) {
+            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 {
+        // Query Helper Function
+        nestClump,
+        clumpIntoGroups,
+        mapToBos,
+        objectifyDatabaseResult,
+        createFromDatabase,
+        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, data) => {
+            accum[data.displayName] = data.selectColumnsClause;
+            return accum;
+        }, {})
+    };
+};
+exports.create = create;

package/dist/src/factory.spec.d.ts

@@ -0,0 +1 @@
+export {};