pure-orm 4.0.2 → 4.1.4

package/dist/example/data-access/person.d.ts

@@ -1,2 +1,2 @@
 import { Person } from '../models/person';
-export declare const getPerson: (id: number) => Person;
+export declare const getPerson: (id: number) => Promise<Person>;

package/dist/src/core.d.ts

@@ -4,20 +4,20 @@ export interface IColumnData {
     references?: IModelClass;
     primaryKey?: boolean;
 }
-export declare type IColumn = IColumnData | string;
-export declare type IColumns = Array<IColumn> | (() => Array<IColumn>);
+export type IColumn = IColumnData | string;
+export 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 type IColumnInternal = IColumnInternalData;
+export type IColumnsInternal = Array<IColumnInternal>;
 export interface IModel {
     [key: string]: any;
 }
-export declare type IModelClass = new (props: any) => IModel;
+export type IModelClass = new (props: any) => IModel;
 export interface ICollection<T extends IModel> {
     models: Array<T>;
 }
@@ -29,7 +29,7 @@ export interface IEntity<T extends IModel> {
     Model: new (props: any) => T;
     Collection: new ({ models }: any) => ICollection<T>;
 }
-export declare type IEntities<T extends IModel> = Array<IEntity<T>>;
+export type IEntities<T extends IModel> = Array<IEntity<T>>;
 export interface IEntityInternal<T extends IModel> {
     tableName: string;
     displayName: string;
@@ -44,8 +44,14 @@ export interface IEntityInternal<T extends IModel> {
     references: object;
     selectColumnsClause: string;
     getPkId: (model: IModel) => string;
+    columnToPropertyMap: Map<string, string>;
+    propertyToColumnMap: Map<string, string>;
+    referencesEntries: Array<{
+        property: string;
+        ModelClass: IModelClass;
+    }>;
 }
-export declare type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
+export type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
 export interface ICreateCoreOptions {
     entities: IEntities<IModel>;
 }

package/dist/src/core.js

@@ -28,17 +28,33 @@ const createCore = ({ entities: externalEntities }) => {
         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('');
+            let id = '';
+            for (let i = 0; i < primaryKeys.length; i++) {
+                const part = model[primaryKeys[i]];
+                if (part !== void 0 && part !== null) {
+                    id += String(part);
+                }
+            }
+            return id;
         };
-        const references = columns
-            .filter((x) => x.references)
-            .reduce((accum, item) => Object.assign({}, accum, {
-            [item.property]: item.references
-        }), {});
+        const references = {};
+        const referencesEntries = [];
+        for (const col of columns) {
+            if (col.references) {
+                references[col.property] = col.references;
+                referencesEntries.push({
+                    property: col.property,
+                    ModelClass: col.references
+                });
+            }
+        }
+        const columnToPropertyMap = new Map();
+        const propertyToColumnMap = new Map();
+        for (let i = 0; i < columnNames.length; i++) {
+            columnToPropertyMap.set(columnNames[i], propertyNames[i]);
+            propertyToColumnMap.set(propertyNames[i], columnNames[i]);
+        }
         const selectColumnsClause = prefixedColumnNames
             .map((prefixed, index) => `"${tableName}".${columnNames[index]} as "${prefixed}"`)
             .join(', ');
@@ -55,7 +71,10 @@ const createCore = ({ entities: externalEntities }) => {
             primaryKeys,
             references,
             selectColumnsClause,
-            getPkId
+            getPkId,
+            columnToPropertyMap,
+            propertyToColumnMap,
+            referencesEntries
         };
     });
     const tableNameToEntityMap = entities.reduce((map, entity) => {
@@ -83,200 +102,250 @@ const createCore = ({ entities: externalEntities }) => {
     const getEntityByModel = (model) => {
         return getEntityByModelClass(model.constructor);
     };
-    /*
-     * 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 indexes = Object.values(getEntityByModel(model).references)
-                        .map((x, i) => x === parent.constructor ? i : null)
-                        .filter((x, i) => x != null);
-                    if (!indexes.length) {
-                        return false;
-                    }
-                    for (const index of indexes) {
-                        const property = Object.keys(getEntityByModel(model).references)[index];
-                        if (model[property] === parent.id) {
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                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;
-                        }
-                    }
+    const entityReferencePlans = new Map();
+    for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        const plans = new Array(entity.referencesEntries.length);
+        for (let j = 0; j < entity.referencesEntries.length; j++) {
+            const ref = entity.referencesEntries[j];
+            plans[j] = {
+                property: ref.property,
+                targetEntity: getEntityByModelClass(ref.ModelClass)
+            };
+        }
+        entityReferencePlans.set(entity, plans);
+    }
+    const getPkIdFromRow = (row, primaryKeyRowKeys) => {
+        let id = '';
+        for (let i = 0; i < primaryKeyRowKeys.length; i++) {
+            const part = row[primaryKeyRowKeys[i]];
+            if (part !== void 0 && part !== null) {
+                id += String(part);
+            }
+        }
+        return id;
+    };
+    const buildEntityRowPlans = (sampleRow) => {
+        const plansByTable = new Map();
+        const tableOrder = [];
+        for (const text in sampleRow) {
+            if (!Object.prototype.hasOwnProperty.call(sampleRow, text)) {
+                continue;
+            }
+            const hashIndex = text.indexOf('#');
+            if (hashIndex === -1) {
+                throw new Error('Column names must be namespaced to table');
+            }
+            const tableName = text.substring(0, hashIndex);
+            const column = text.substring(hashIndex + 1);
+            let plan = plansByTable.get(tableName);
+            if (!plan) {
+                const entity = getEntityByTableName(tableName);
+                const primaryKeyRowKeys = entity.primaryKeys.map((pk) => `${tableName}#${pk}`);
+                plan = {
+                    entity,
+                    columnPlans: [],
+                    primaryKeyRowKeys
+                };
+                plansByTable.set(tableName, plan);
+                tableOrder.push(tableName);
+            }
+            let propertyName = plan.entity.columnToPropertyMap.get(column);
+            if (!propertyName) {
+                if (column.startsWith('meta_')) {
+                    propertyName = (0, camelcase_1.default)(column);
                 }
-                if (nodePointingToIt) {
-                    nodePointingToIt[getEntityByModel(model).displayName] = model;
+                else {
+                    throw Error(`No property name for "${column}" in business object "${plan.entity.displayName}". Non-spec'd columns must begin with "meta_".`);
                 }
-                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]
-                            });
-                    }
+            }
+            plan.columnPlans.push({
+                rowKey: text,
+                propertyName
+            });
+        }
+        const orderedPlans = new Array(tableOrder.length);
+        for (let i = 0; i < tableOrder.length; i++) {
+            orderedPlans[i] = plansByTable.get(tableOrder[i]);
+        }
+        return orderedPlans;
+    };
+    const materializeModelsFromRow = (row, entityRowPlans, rootScopedModelsByEntity, rowModels, rowModelPkIds, rowCreatedWithPkIndexes) => {
+        rowCreatedWithPkIndexes.length = 0;
+        for (let i = 0; i < entityRowPlans.length; i++) {
+            const plan = entityRowPlans[i];
+            const pkId = getPkIdFromRow(row, plan.primaryKeyRowKeys);
+            rowModelPkIds[i] = pkId;
+            if (pkId) {
+                let modelsForEntity = rootScopedModelsByEntity.get(plan.entity);
+                if (!modelsForEntity) {
+                    modelsForEntity = new Map();
+                    rootScopedModelsByEntity.set(plan.entity, modelsForEntity);
                 }
                 else {
-                    if (!getEntityByModel(model).getPkId(model)) {
-                        // If the join is fruitless; todo: add a test for this path
-                        return;
+                    const existing = modelsForEntity.get(pkId);
+                    if (existing) {
+                        rowModels[i] = existing;
+                        continue;
                     }
-                    throw Error(`Could not find how this BO fits: ${JSON.stringify(model)} ${getEntityByModel(model).tableName}`);
                 }
-                nodes = [model, ...nodes];
-            });
-        });
-        return built;
+            }
+            else if (i !== 0) {
+                // No primary key means this is typically an outer-joined null row.
+                // Skip model construction for non-root entities since it cannot link.
+                rowModels[i] = void 0;
+                continue;
+            }
+            const props = {};
+            for (let j = 0; j < plan.columnPlans.length; j++) {
+                const columnPlan = plan.columnPlans[j];
+                props[columnPlan.propertyName] = row[columnPlan.rowKey];
+            }
+            const model = new plan.entity.Model(props);
+            if (pkId) {
+                // modelsForEntity is guaranteed to be initialized above for pk rows.
+                rootScopedModelsByEntity.get(plan.entity).set(pkId, model);
+                rowCreatedWithPkIndexes.push(i);
+            }
+            rowModels[i] = model;
+        }
+        return rowModels[0];
+    };
+    const getRootScopeKey = (row, rootEntity, rootPrimaryKeys) => {
+        let rootScopeKey = '';
+        for (let i = 0; i < rootPrimaryKeys.length; i++) {
+            if (i > 0) {
+                rootScopeKey += '@';
+            }
+            const value = row[`${rootEntity.tableName}#${rootPrimaryKeys[i]}`];
+            rootScopeKey += value === void 0 || value === null ? '' : String(value);
+        }
+        return rootScopeKey;
+    };
+    const ensureRootScopeState = (rootScopeKey, rootScopeStateByKey) => {
+        let state = rootScopeStateByKey.get(rootScopeKey);
+        if (!state) {
+            state = {
+                modelsByEntity: new Map()
+            };
+            rootScopeStateByKey.set(rootScopeKey, state);
+        }
+        return state;
+    };
+    const ensureCollectionMembership = (rootScopeState) => {
+        if (!rootScopeState.collectionMembership) {
+            rootScopeState.collectionMembership = new WeakMap();
+        }
+        return rootScopeState.collectionMembership;
+    };
+    const linkSourceToTarget = ({ sourceEntity, sourceModel, sourceModelPkId, targetEntity, targetModel, collectionMembership }) => {
+        sourceModel[targetEntity.displayName] =
+            targetModel;
+        let collection = targetModel[sourceEntity.collectionDisplayName];
+        if (!collection) {
+            const Collection = sourceEntity.Collection;
+            collection = new Collection({ models: [] });
+            targetModel[sourceEntity.collectionDisplayName] = collection;
+        }
+        let byCollection = collectionMembership.get(targetModel);
+        if (!byCollection) {
+            byCollection = new Map();
+            collectionMembership.set(targetModel, byCollection);
+        }
+        let memberIds = byCollection.get(sourceEntity);
+        if (!memberIds) {
+            memberIds = new Set();
+            byCollection.set(sourceEntity, memberIds);
+        }
+        if (!memberIds.has(sourceModelPkId)) {
+            collection.models.push(sourceModel);
+            memberIds.add(sourceModelPkId);
+        }
     };
     /*
-     * 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}]
-     *    ]
-     *  ]
+     * createFromDatabase architecture:
+     * 1) Compile row plans once (column -> property mapping per entity/table).
+     * 2) Materialize models per row with scoped de-duplication by root scope key.
+     * 3) Index models by root scope + entity + entity primary key.
+     * 4) Link refs incrementally as new models appear.
+     * 5) Return root models in first-seen root scope order.
      */
-    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]);
+    const createFromDatabase = (rows) => {
+        var _a;
+        const result = Array.isArray(rows) ? rows : [rows];
+        const len = result.length;
+        const entityRowPlans = buildEntityRowPlans(result[0]);
+        const selectedEntities = new Set();
+        for (let i = 0; i < entityRowPlans.length; i++) {
+            selectedEntities.add(entityRowPlans[i].entity);
+        }
+        const applicableRefPlans = new Map();
+        for (let i = 0; i < entityRowPlans.length; i++) {
+            const entity = entityRowPlans[i].entity;
+            const refs = entityReferencePlans.get(entity) || [];
+            const filteredRefs = refs.filter((ref) => selectedEntities.has(ref.targetEntity));
+            applicableRefPlans.set(entity, filteredRefs);
+        }
+        const rootEntity = entityRowPlans[0].entity;
+        const rootPrimaryKeys = rootEntity.primaryKeys;
+        const rootScopeOrder = [];
+        const rootModelsByScopeKey = new Map();
+        const rootScopeStateByKey = new Map();
+        let currentRootScopeKey = void 0;
+        let currentRootScopeState = void 0;
+        const rowModels = new Array(entityRowPlans.length);
+        const rowModelPkIds = new Array(entityRowPlans.length);
+        const rowCreatedWithPkIndexes = [];
+        // Phase 1: materialize and index model instances by root scope + entity.
+        for (let i = 0; i < len; i++) {
+            const row = result[i];
+            const rootScopeKey = getRootScopeKey(row, rootEntity, rootPrimaryKeys);
+            let rootScopeState = currentRootScopeState;
+            if (!rootScopeState || rootScopeKey !== currentRootScopeKey) {
+                rootScopeState = ensureRootScopeState(rootScopeKey, rootScopeStateByKey);
+                currentRootScopeKey = rootScopeKey;
+                currentRootScopeState = rootScopeState;
             }
-            else {
-                accum.set(id, [item]);
+            const rootModel = materializeModelsFromRow(row, entityRowPlans, rootScopeState.modelsByEntity, rowModels, rowModelPkIds, rowCreatedWithPkIndexes);
+            if (!rootModelsByScopeKey.has(rootScopeKey)) {
+                rootScopeOrder.push(rootScopeKey);
+                rootModelsByScopeKey.set(rootScopeKey, rootModel);
             }
-            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 = (0, camelcase_1.default)(column);
+            for (let c = 0; c < rowCreatedWithPkIndexes.length; c++) {
+                const j = rowCreatedWithPkIndexes[c];
+                const sourceModel = rowModels[j];
+                const sourceModelPkId = rowModelPkIds[j];
+                const sourceEntity = entityRowPlans[j].entity;
+                const refs = applicableRefPlans.get(sourceEntity);
+                if (!refs || refs.length === 0) {
+                    continue;
+                }
+                for (let r = 0; r < refs.length; r++) {
+                    const ref = refs[r];
+                    const refId = sourceModel[ref.property];
+                    if (refId == null) {
+                        continue;
                     }
-                    else {
-                        throw Error(`No property name for "${column}" in business object "${entity.displayName}". Non-spec'd columns must begin with "meta_".`);
+                    const targetPkId = String(refId);
+                    const target = (_a = rootScopeState.modelsByEntity
+                        .get(ref.targetEntity)) === null || _a === void 0 ? void 0 : _a.get(targetPkId);
+                    if (target) {
+                        linkSourceToTarget({
+                            sourceEntity,
+                            sourceModel,
+                            sourceModelPkId,
+                            targetEntity: ref.targetEntity,
+                            targetModel: target,
+                            collectionMembership: ensureCollectionMembership(rootScopeState)
+                        });
                     }
                 }
-                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];
-            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 = (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 models = new Array(rootScopeOrder.length);
+        for (let i = 0; i < rootScopeOrder.length; i++) {
+            models[i] = rootModelsByScopeKey.get(rootScopeOrder[i]);
+        }
         const Collection = getEntityByModel(models[0]).Collection;
         return new Collection({ models });
     };