pure-orm 4.0.2 → 4.1.4

package/src/core.ts

@@ -51,6 +51,9 @@ 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 type IEntitiesInternal<T extends IModel> = Array<IEntityInternal<T>>;
 
@@ -137,22 +140,38 @@ export const createCore = ({
       const _primaryKeys = pkColumnsData.map((x: IColumnInternal) => x.column);
       const primaryKeys = _primaryKeys.length > 0 ? _primaryKeys : ['id'];
 
-      // Returns unique identifier of model (the values of the primary keys)
       const getPkId = (model: IModel): string => {
-        return primaryKeys
-          .map((key: string) => model[key as keyof typeof model])
-          .join('');
+        let id = '';
+        for (let i = 0; i < primaryKeys.length; i++) {
+          const part = model[primaryKeys[i] as keyof typeof model];
+          if (part !== void 0 && part !== null) {
+            id += String(part);
+          }
+        }
+        return id;
       };
 
-      const references = columns
-        .filter((x: IColumnInternal) => x.references)
-        .reduce(
-          (accum: any, item: IColumnInternal) =>
-            Object.assign({}, accum, {
-              [item.property]: item.references
-            }),
-          {}
-        );
+      const references: any = {};
+      const referencesEntries: Array<{
+        property: string;
+        ModelClass: IModelClass;
+      }> = [];
+      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<string, string>();
+      const propertyToColumnMap = new Map<string, string>();
+      for (let i = 0; i < columnNames.length; i++) {
+        columnToPropertyMap.set(columnNames[i], propertyNames[i]);
+        propertyToColumnMap.set(propertyNames[i], columnNames[i]);
+      }
 
       const selectColumnsClause = prefixedColumnNames
         .map(
@@ -174,7 +193,10 @@ export const createCore = ({
         primaryKeys,
         references,
         selectColumnsClause,
-        getPkId
+        getPkId,
+        columnToPropertyMap,
+        propertyToColumnMap,
+        referencesEntries
       };
     }
   );
@@ -223,237 +245,357 @@ export const createCore = ({
     return getEntityByModelClass(model.constructor as IModelClass);
   };
 
-  /*
-   * 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: Array<Array<IModel>>): object => {
-    clump = clump.map((x: Array<IModel>) => Object.values(x));
-    const root = clump[0][0];
-    clump = clump.map((row: Array<IModel>) =>
-      row.filter((item: IModel, index: number) => index !== 0)
-    );
-    const built = { [getEntityByModel(root).displayName]: root };
-
-    let nodes = [root];
-
-    // Wowzer is this both CPU and Memory inefficient
-    clump.forEach((array: Array<IModel>) => {
-      array.forEach((_model: IModel) => {
-        const nodeAlreadySeen = nodes.find(
-          (x: IModel) =>
-            x.constructor.name === _model.constructor.name &&
-            getEntityByModel(x).getPkId(x) ===
-              getEntityByModel(_model).getPkId(_model)
+  const entityReferencePlans = new Map<
+    IEntityInternal<IModel>,
+    Array<{ property: string; targetEntity: IEntityInternal<IModel> }>
+  >();
+  for (let i = 0; i < entities.length; i++) {
+    const entity = entities[i];
+    const plans = new Array<{
+      property: string;
+      targetEntity: IEntityInternal<IModel>;
+    }>(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);
+  }
+
+  interface IRowColumnPlan {
+    rowKey: string;
+    propertyName: string;
+  }
+  interface IEntityRowPlan {
+    entity: IEntityInternal<IModel>;
+    columnPlans: Array<IRowColumnPlan>;
+    primaryKeyRowKeys: Array<string>;
+  }
+
+  const getPkIdFromRow = (
+    row: any,
+    primaryKeyRowKeys: Array<string>
+  ): string => {
+    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: any): Array<IEntityRowPlan> => {
+    const plansByTable = new Map<string, IEntityRowPlan>();
+    const tableOrder: Array<string> = [];
+    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: string) => `${tableName}#${pk}`
         );
-        const model = nodeAlreadySeen || _model;
-        const isNodeAlreadySeen = !!nodeAlreadySeen;
-        const nodePointingToIt = nodes.find((node) => {
-          const indexes = Object.values(getEntityByModel(node).references)
-            .map((x: IModelClass, i: number) =>
-              x === model.constructor ? i : null
-            )
-            .filter((x: number | null, i) => x != null) as Array<number>;
-          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: number | null, obj: IModel) => {
-            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: IModelClass, i: number) =>
-              x === parent.constructor ? i : null
-            )
-            .filter((x: number | null, i) => x != null) as Array<number>;
-          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 as keyof typeof model
-              ];
-            if (ec && ec.models.find((m: IModel) => 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]
-              });
-          }
+        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 = camelCase(column);
         } 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
-            }`
+            `No property name for "${column}" in business object "${plan.entity.displayName}". Non-spec'd columns must begin with "meta_".`
           );
         }
-        nodes = [model, ...nodes];
+      }
+      plan.columnPlans.push({
+        rowKey: text,
+        propertyName
       });
-    });
+    }
 
-    return built;
+    const orderedPlans = new Array<IEntityRowPlan>(tableOrder.length);
+    for (let i = 0; i < tableOrder.length; i++) {
+      orderedPlans[i] = plansByTable.get(tableOrder[i]) as IEntityRowPlan;
+    }
+    return orderedPlans;
   };
 
-  /*
-   * 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: Array<Array<IModel>>
-  ): Array<Array<Array<IModel>>> => {
-    const root = processed[0][0];
-    const rootBo = root.constructor;
-    const clumps = processed.reduce((accum: any, item: Array<IModel>) => {
-      const id = getEntityByModel(root)
-        .primaryKeys.map(
-          (key: string) =>
-            item.find((x: IModel) => x.constructor === rootBo)?.[key]
-        )
-        .join('@');
-      if (accum.has(id)) {
-        accum.set(id, [...accum.get(id), item]);
-      } else {
-        accum.set(id, [item]);
+  const materializeModelsFromRow = (
+    row: any,
+    entityRowPlans: Array<IEntityRowPlan>,
+    rootScopedModelsByEntity: IModelsByEntity,
+    rowModels: Array<IModel | void>,
+    rowModelPkIds: Array<string>,
+    rowCreatedWithPkIndexes: Array<number>
+  ): IModel => {
+    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<string, IModel>();
+          rootScopedModelsByEntity.set(plan.entity, modelsForEntity);
+        } else {
+          const existing = modelsForEntity.get(pkId);
+          if (existing) {
+            rowModels[i] = existing;
+            continue;
+          }
+        }
+      } 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;
       }
-      return accum;
-    }, new Map());
-    return [...clumps.values()];
+      const props: any = {};
+      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) as Map<string, IModel>).set(
+          pkId,
+          model
+        );
+        rowCreatedWithPkIndexes.push(i);
+      }
+      rowModels[i] = model;
+    }
+    return rowModels[0] as IModel;
   };
 
-  const mapToBos = (objectified: any) => {
-    return Object.keys(objectified).map((tableName) => {
-      const entity = getEntityByTableName(tableName);
-      const propified = Object.keys(objectified[tableName]).reduce(
-        (obj: any, 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);
-    });
+  type IModelsByEntity = Map<IEntityInternal<IModel>, Map<string, IModel>>;
+  interface IRootScopeState {
+    modelsByEntity: IModelsByEntity;
+    collectionMembership?: WeakMap<
+      IModel,
+      Map<IEntityInternal<IModel>, Set<string>>
+    >;
+  }
+  type IRootScopeStateByKey = Map<string, IRootScopeState>;
+
+  const getRootScopeKey = (
+    row: any,
+    rootEntity: IEntityInternal<IModel>,
+    rootPrimaryKeys: Array<string>
+  ): string => {
+    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;
   };
 
-  /*
-   * Make objects (based on special table#column names) from flat database
-   * return value.
-   */
-  const objectifyDatabaseResult = (result: object) => {
-    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 ensureRootScopeState = (
+    rootScopeKey: string,
+    rootScopeStateByKey: IRootScopeStateByKey
+  ): IRootScopeState => {
+    let state = rootScopeStateByKey.get(rootScopeKey);
+    if (!state) {
+      state = {
+        modelsByEntity: new Map<IEntityInternal<IModel>, Map<string, IModel>>()
+      };
+      rootScopeStateByKey.set(rootScopeKey, state);
+    }
+    return state;
+  };
+
+  const ensureCollectionMembership = (
+    rootScopeState: IRootScopeState
+  ): WeakMap<IModel, Map<IEntityInternal<IModel>, Set<string>>> => {
+    if (!rootScopeState.collectionMembership) {
+      rootScopeState.collectionMembership = new WeakMap<
+        IModel,
+        Map<IEntityInternal<IModel>, Set<string>>
+      >();
+    }
+    return rootScopeState.collectionMembership;
+  };
+
+  const linkSourceToTarget = ({
+    sourceEntity,
+    sourceModel,
+    sourceModelPkId,
+    targetEntity,
+    targetModel,
+    collectionMembership
+  }: {
+    sourceEntity: IEntityInternal<IModel>;
+    sourceModel: IModel;
+    sourceModelPkId: string;
+    targetEntity: IEntityInternal<IModel>;
+    targetModel: IModel;
+    collectionMembership: WeakMap<
+      IModel,
+      Map<IEntityInternal<IModel>, Set<string>>
+    >;
+  }) => {
+    sourceModel[targetEntity.displayName as keyof typeof sourceModel] =
+      targetModel;
+
+    let collection =
+      targetModel[
+        sourceEntity.collectionDisplayName as keyof typeof targetModel
+      ];
+    if (!collection) {
+      const Collection = sourceEntity.Collection;
+      collection = new Collection({ models: [] });
+      targetModel[
+        sourceEntity.collectionDisplayName as keyof typeof targetModel
+      ] = collection;
+    }
+
+    let byCollection = collectionMembership.get(targetModel);
+    if (!byCollection) {
+      byCollection = new Map<IEntityInternal<IModel>, Set<string>>();
+      collectionMembership.set(targetModel, byCollection);
+    }
+    let memberIds = byCollection.get(sourceEntity);
+    if (!memberIds) {
+      memberIds = new Set<string>();
+      byCollection.set(sourceEntity, memberIds);
+    }
+    if (!memberIds.has(sourceModelPkId)) {
+      collection.models.push(sourceModel);
+      memberIds.add(sourceModelPkId);
+    }
   };
 
+  /*
+   * 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 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 len = result.length;
+    const entityRowPlans = buildEntityRowPlans(result[0]);
+    const selectedEntities = new Set<IEntityInternal<IModel>>();
+    for (let i = 0; i < entityRowPlans.length; i++) {
+      selectedEntities.add(entityRowPlans[i].entity);
+    }
+    const applicableRefPlans = new Map<
+      IEntityInternal<IModel>,
+      Array<{ property: string; targetEntity: IEntityInternal<IModel> }>
+    >();
+    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: Array<string> = [];
+    const rootModelsByScopeKey = new Map<string, IModel>();
+    const rootScopeStateByKey: IRootScopeStateByKey = new Map();
+    let currentRootScopeKey: string | void = void 0;
+    let currentRootScopeState: IRootScopeState | void = void 0;
+    const rowModels = new Array<IModel | void>(entityRowPlans.length);
+    const rowModelPkIds = new Array<string>(entityRowPlans.length);
+    const rowCreatedWithPkIndexes: Array<number> = [];
+
+    // 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: IRootScopeState | void = currentRootScopeState;
+      if (!rootScopeState || rootScopeKey !== currentRootScopeKey) {
+        rootScopeState = ensureRootScopeState(
+          rootScopeKey,
+          rootScopeStateByKey
+        );
+        currentRootScopeKey = rootScopeKey;
+        currentRootScopeState = rootScopeState;
+      }
+      const rootModel = materializeModelsFromRow(
+        row,
+        entityRowPlans,
+        rootScopeState.modelsByEntity,
+        rowModels,
+        rowModelPkIds,
+        rowCreatedWithPkIndexes
+      );
+      if (!rootModelsByScopeKey.has(rootScopeKey)) {
+        rootScopeOrder.push(rootScopeKey);
+        rootModelsByScopeKey.set(rootScopeKey, rootModel);
+      }
+
+      for (let c = 0; c < rowCreatedWithPkIndexes.length; c++) {
+        const j = rowCreatedWithPkIndexes[c];
+        const sourceModel = rowModels[j] as IModel;
+        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 as keyof typeof sourceModel];
+          if (refId == null) {
+            continue;
+          }
+          const targetPkId = String(refId);
+          const target = rootScopeState.modelsByEntity
+            .get(ref.targetEntity)
+            ?.get(targetPkId);
+          if (target) {
+            linkSourceToTarget({
+              sourceEntity,
+              sourceModel,
+              sourceModelPkId,
+              targetEntity: ref.targetEntity,
+              targetModel: target,
+              collectionMembership: ensureCollectionMembership(rootScopeState)
+            });
+          }
+        }
+      }
+    }
+
+    const models = new Array<IModel>(rootScopeOrder.length);
+    for (let i = 0; i < rootScopeOrder.length; i++) {
+      models[i] = rootModelsByScopeKey.get(rootScopeOrder[i]) as IModel;
+    }
     const Collection = getEntityByModel(models[0]).Collection;
     return <T>new Collection({ models });
   };