pure-orm 4.0.2 → 4.1.4

package/dist/src/orm.js

@@ -12,161 +12,222 @@ const create = ({ entities: externalEntities, db, logError }) => {
     else {
         throw new Error(`You're database driver is not yet supported. You can make a PR to add it, or use the \`createCore\` export which doesn't try to abstract over the database driver, and instead you pass the results of the database driver queries to it.`);
     }
-    /* ------------------------------------------------------------------------*/
-    /* Helper Utilities for CRUD functions ------------------------------------*/
-    /* ------------------------------------------------------------------------*/
+    const helperPlanByEntity = new Map();
+    const getHelperPlan = (entity) => {
+        let plan = helperPlanByEntity.get(entity);
+        if (!plan) {
+            const quotedColumns = new Array(entity.columnNames.length);
+            const updateClausePrefixes = new Array(entity.columnNames.length);
+            const wherePositionalPrefixes = new Array(entity.columnNames.length);
+            const whereNamedPrefixes = new Array(entity.columnNames.length);
+            for (let i = 0; i < entity.columnNames.length; i++) {
+                const column = entity.columnNames[i];
+                quotedColumns[i] = `"${column}"`;
+                updateClausePrefixes[i] = `"${column}" = $`;
+                wherePositionalPrefixes[i] = `"${entity.tableName}"."${column}" = $`;
+                whereNamedPrefixes[i] = `"${entity.tableName}"."${column}" = $(`;
+            }
+            plan = {
+                quotedColumns,
+                updateClausePrefixes,
+                wherePositionalPrefixes,
+                whereNamedPrefixes
+            };
+            helperPlanByEntity.set(entity, plan);
+        }
+        return plan;
+    };
     const getSqlInsertParts = (model) => {
-        const columns = orm
-            .getEntityByModel(model)
-            .columnNames.filter((column, index) => model[orm.getEntityByModel(model).propertyNames[index]] !== void 0)
-            .map((col) => `"${col}"`)
-            .join(', ');
-        const values = orm
-            .getEntityByModel(model)
-            .propertyNames.map((property) => model[property])
-            .filter((value) => value !== void 0);
-        const valuesVar = values.map((value, index) => `$${index + 1}`);
+        const entity = orm.getEntityByModel(model);
+        const { columnNames, propertyNames } = entity;
+        const helperPlan = getHelperPlan(entity);
+        let columns = '';
+        const values = [];
+        const valuesVar = [];
+        let paramIndex = 1;
+        for (let i = 0; i < columnNames.length; i++) {
+            const val = model[propertyNames[i]];
+            if (val !== void 0) {
+                if (columns) {
+                    columns += ', ';
+                }
+                columns += helperPlan.quotedColumns[i];
+                values.push(val);
+                valuesVar.push(`$${paramIndex}`);
+                paramIndex++;
+            }
+        }
         return { columns, values, valuesVar };
     };
     const getSqlUpdateParts = (model, on = 'id') => {
-        const clauseArray = orm
-            .getEntityByModel(model)
-            .columnNames.filter((sqlColumn, index) => model[orm.getEntityByModel(model).propertyNames[index]] !== void 0)
-            .map((sqlColumn, index) => `"${sqlColumn}" = $${index + 1}`);
-        const clause = clauseArray.join(', ');
-        const idVar = `$${clauseArray.length + 1}`;
-        const _values = orm
-            .getEntityByModel(model)
-            .propertyNames.map((property) => model[property])
-            .filter((value) => value !== void 0);
-        const values = [..._values, model[on]];
+        const entity = orm.getEntityByModel(model);
+        const { columnNames, propertyNames } = entity;
+        const helperPlan = getHelperPlan(entity);
+        let clause = '';
+        const values = [];
+        let paramIndex = 1;
+        for (let i = 0; i < columnNames.length; i++) {
+            const val = model[propertyNames[i]];
+            if (val !== void 0) {
+                if (clause) {
+                    clause += ', ';
+                }
+                clause += helperPlan.updateClausePrefixes[i] + paramIndex;
+                values.push(val);
+                paramIndex++;
+            }
+        }
+        const idVar = `$${paramIndex}`;
+        values.push(model[on]);
         return { clause, idVar, values };
     };
     const getMatchingParts = (model) => {
-        const whereClause = orm
-            .getEntityByModel(model)
-            .propertyNames.map((property, index) => model[property] != null
-            ? `"${orm.getEntityByModel(model).tableName}"."${orm.getEntityByModel(model).columnNames[index]}"`
-            : null)
-            .filter((x) => x != null)
-            .map((x, i) => `${x} = $${i + 1}`)
-            .join(' AND ');
-        const values = orm
-            .getEntityByModel(model)
-            .propertyNames.map((property) => model[property] != null
-            ? model[property]
-            : null)
-            .filter((x) => x != null);
+        const entity = orm.getEntityByModel(model);
+        const { propertyNames, columnNames } = entity;
+        const helperPlan = getHelperPlan(entity);
+        const values = [];
+        let paramIndex = 1;
+        let whereClause = '';
+        for (let i = 0; i < propertyNames.length; i++) {
+            const val = model[propertyNames[i]];
+            if (val != null) {
+                if (whereClause) {
+                    whereClause += ' AND ';
+                }
+                whereClause += helperPlan.wherePositionalPrefixes[i] + paramIndex;
+                values.push(val);
+                paramIndex++;
+            }
+        }
         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 = orm
-            .getEntityByModel(model)
-            .propertyNames.map((property, index) => model[property] != null
-            ? `"${orm.getEntityByModel(model).tableName}"."${orm.getEntityByModel(model).columnNames[index]}"`
-            : null)
-            .filter((x) => x != null)
-            .map((x, i) => `${x} = $(${i + 1})`)
-            .join(' AND ');
-        const values = orm
-            .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 }), {});
+        const entity = orm.getEntityByModel(model);
+        const { propertyNames, columnNames } = entity;
+        const helperPlan = getHelperPlan(entity);
+        const values = {};
+        let paramIndex = 1;
+        let whereClause = '';
+        for (let i = 0; i < propertyNames.length; i++) {
+            const val = model[propertyNames[i]];
+            if (val != null) {
+                if (whereClause) {
+                    whereClause += ' AND ';
+                }
+                whereClause += helperPlan.whereNamedPrefixes[i] + paramIndex + ')';
+                values[paramIndex] = val;
+                paramIndex++;
+            }
+        }
         return { whereClause, values };
     };
     const getNewWith = (model, sqlColumns, values) => {
         const Constructor = model.constructor;
-        const modelKeys = sqlColumns.map((key) => orm.getEntityByModel(model).propertyNames[orm.getEntityByModel(model).columnNames.indexOf(key)]);
-        const modelData = modelKeys.reduce((data, key, index) => {
-            data[key] = values[index];
-            return data;
-        }, {});
+        const entity = orm.getEntityByModel(model);
+        const modelData = {};
+        for (let i = 0; i < sqlColumns.length; i++) {
+            const propertyName = entity.columnToPropertyMap.get(sqlColumns[i]);
+            if (propertyName) {
+                modelData[propertyName] = values[i];
+            }
+        }
         return new Constructor(modelData);
     };
     const getValueBySqlColumn = (model, sqlColumn) => {
-        return model[orm.getEntityByModel(model).propertyNames[orm.getEntityByModel(model).columnNames.indexOf(sqlColumn)]];
+        const entity = orm.getEntityByModel(model);
+        const propertyName = entity.columnToPropertyMap.get(sqlColumn);
+        return propertyName
+            ? model[propertyName]
+            : undefined;
     };
     const getSqlColumnForPropertyName = (model, propertyName) => {
-        return orm.getEntityByModel(model).columnNames[orm.getEntityByModel(model).propertyNames.indexOf(propertyName)];
+        const entity = orm.getEntityByModel(model);
+        const column = entity.propertyToColumnMap.get(propertyName);
+        return column;
     };
     /* ------------------------------------------------------------------------*/
     /* Built-in basic CRUD functions ------------------------------------------*/
     /* ------------------------------------------------------------------------*/
     // Standard create
     const create = (model) => {
+        const entity = orm.getEntityByModel(model);
         const { columns, values, valuesVar } = getSqlInsertParts(model);
         const query = `
-      INSERT INTO "${orm.getEntityByModel(model).tableName}" ( ${columns} )
+      INSERT INTO "${entity.tableName}" ( ${columns} )
       VALUES ( ${valuesVar} )
-      RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
+      RETURNING ${entity.selectColumnsClause};
     `;
         return orm.one(query, values);
     };
     // Standard update
     const update = (model, { on = 'id' } = {}) => {
+        const entity = orm.getEntityByModel(model);
         const { clause, idVar, values } = getSqlUpdateParts(model, on);
         const query = `
-      UPDATE "${orm.getEntityByModel(model).tableName}"
+      UPDATE "${entity.tableName}"
       SET ${clause}
-      WHERE "${orm.getEntityByModel(model).tableName}".${getSqlColumnForPropertyName(model, on)} = ${idVar}
-      RETURNING ${orm.getEntityByModel(model).selectColumnsClause};
+      WHERE "${entity.tableName}".${getSqlColumnForPropertyName(model, on)} = ${idVar}
+      RETURNING ${entity.selectColumnsClause};
     `;
         return orm.one(query, values);
     };
     // Standard delete
     const _delete = (model) => {
+        const entity = orm.getEntityByModel(model);
         const id = model.id;
         const query = `
-      DELETE FROM "${orm.getEntityByModel(model).tableName}"
-      WHERE "${orm.getEntityByModel(model).tableName}".id = $(id)
+      DELETE FROM "${entity.tableName}"
+      WHERE "${entity.tableName}".id = $(id)
     `;
         return orm.none(query, { id });
     };
     const deleteMatching = (model) => {
+        const entity = orm.getEntityByModel(model);
         const { whereClause, values } = getMatchingParts(model);
         const query = `
-      DELETE FROM "${orm.getEntityByModel(model).tableName}"
+      DELETE FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
         return orm.none(query, values);
     };
     const getMatching = (model) => {
+        const entity = orm.getEntityByModel(model);
         const { whereClause, values } = getMatchingParts(model);
         const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
         return orm.one(query, values);
     };
     const getOneOrNoneMatching = (model) => {
+        const entity = orm.getEntityByModel(model);
         const { whereClause, values } = getMatchingParts(model);
         const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
         return orm.oneOrNone(query, values);
     };
     const getAnyMatching = (model) => {
+        const entity = orm.getEntityByModel(model);
         const { whereClause, values } = getMatchingParts(model);
         const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
         return orm.any(query, values);
     };
     const getAllMatching = (model) => {
+        const entity = orm.getEntityByModel(model);
         const { whereClause, values } = getMatchingParts(model);
         const query = `
-      SELECT ${orm.getEntityByModel(model).selectColumnsClause}
-      FROM "${orm.getEntityByModel(model).tableName}"
+      SELECT ${entity.selectColumnsClause}
+      FROM "${entity.tableName}"
       WHERE ${whereClause};
     `;
         return orm.many(query, values);