prostgles-server 2.0.201 → 2.0.202

package/dist/DboBuilder.js

@@ -29,6 +29,8 @@ const QueryBuilder_1 = require("./QueryBuilder");
 const PubSubManager_1 = require("./PubSubManager");
 const insertDataParse_1 = require("./DboBuilder/insertDataParse");
 const insert_1 = require("./DboBuilder/insert");
+const update_1 = require("./DboBuilder/update");
+const delete_1 = require("./DboBuilder/delete");
 const Filtering_1 = require("./Filtering");
 exports.pgp = pgPromise({
     promiseLib: Bluebird
@@ -104,10 +106,15 @@ exports.makeErr = makeErr;
 exports.EXISTS_KEYS = ["$exists", "$notExists", "$existsJoined", "$notExistsJoined"];
 const FILTER_FUNCS = QueryBuilder_1.FUNCTIONS.filter(f => f.canBeUsedForFilter);
 function parseError(e) {
-    // console.trace("INTERNAL ERROR: ", e);
     let res = e instanceof Error ? e.message : (!Object.keys(e || {}).length ? e : (e && e.toString) ? e.toString() : e);
-    if (isPlainObject(e))
-        res = JSON.stringify(e, null, 2);
+    if (isPlainObject(e)) {
+        if (typeof e.err === "string") {
+            res = e.err;
+        }
+        else {
+            res = JSON.stringify(e, null, 2);
+        }
+    }
     return res;
 }
 exports.parseError = parseError;
@@ -1653,76 +1660,7 @@ class TableHandler extends ViewHandler {
         };
     }
     async update(filter, newData, params, tableRules, localParams) {
-        try {
-            const parsedRules = await this.parseUpdateRules(filter, newData, params, tableRules, localParams);
-            if (localParams?.testRule) {
-                return parsedRules;
-            }
-            const { fields, validateRow, forcedData, finalUpdateFilter, returningFields, forcedFilter, filterFields } = parsedRules;
-            let { returning, multi = true, onConflictDoNothing = false, fixIssues = false } = params || {};
-            const { returnQuery = false } = localParams ?? {};
-            if (params) {
-                const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
-                const bad_params = Object.keys(params).filter(k => !good_params.includes(k));
-                if (bad_params && bad_params.length)
-                    throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-            }
-            const { data, allowedCols } = this.validateNewData({ row: newData, forcedData, allowedFields: fields, tableRules, fixIssues });
-            /* Patch data */
-            let patchedTextData = [];
-            this.columns.map(c => {
-                const d = data[c.name];
-                if (c.data_type === "text" && d && isPlainObject(d) && !["from", "to"].find(key => typeof d[key] !== "number")) {
-                    const unrecProps = Object.keys(d).filter(k => !["from", "to", "text", "md5"].includes(k));
-                    if (unrecProps.length)
-                        throw "Unrecognised params in textPatch field: " + unrecProps.join(", ");
-                    patchedTextData.push({ ...d, fieldName: c.name });
-                }
-            });
-            if (patchedTextData && patchedTextData.length) {
-                if (tableRules && !tableRules.select)
-                    throw "Select needs to be permitted to patch data";
-                const rows = await this.find(filter, { select: patchedTextData.reduce((a, v) => ({ ...a, [v.fieldName]: 1 }), {}) }, undefined, tableRules);
-                if (rows.length !== 1) {
-                    throw "Cannot patch data within a filter that affects more/less than 1 row";
-                }
-                patchedTextData.map(p => {
-                    data[p.fieldName] = (0, prostgles_types_1.unpatchText)(rows[0][p.fieldName], p);
-                });
-                // https://w3resource.com/PostgreSQL/overlay-function.p hp
-                //  overlay(coalesce(status, '') placing 'hom' from 2 for 0)
-            }
-            let nData = { ...data };
-            // if(tableRules && tableRules.update && tableRules?.update?.validate){
-            //     nData = await tableRules.update.validate(nData);
-            // }
-            let query = await this.colSet.getUpdateQuery(nData, allowedCols, validateRow); //pgp.helpers.update(nData, columnSet) + " ";
-            query += (await this.prepareWhere({
-                filter,
-                forcedFilter,
-                filterFields,
-                localParams,
-                tableRule: tableRules
-            })).where;
-            if (onConflictDoNothing)
-                query += " ON CONFLICT DO NOTHING ";
-            let qType = "none";
-            if (returning) {
-                qType = multi ? "any" : "one";
-                query += this.makeReturnQuery(await this.prepareReturning(returning, this.parseFieldFilter(returningFields)));
-            }
-            if (returnQuery)
-                return query;
-            if (this.t) {
-                return this.t[qType](query).catch((err) => makeErr(err, localParams, this, fields));
-            }
-            return this.db.tx(t => t[qType](query)).catch(err => makeErr(err, localParams, this, fields));
-        }
-        catch (e) {
-            if (localParams && localParams.testRule)
-                throw e;
-            throw { err: parseError(e), msg: `Issue with dbo.${this.name}.update(${JSON.stringify(filter || {}, null, 2)}, ${JSON.stringify(newData || {}, null, 2)}, ${JSON.stringify(params || {}, null, 2)})` };
-        }
+        return update_1.update.bind(this)(filter, newData, params, tableRules, localParams);
     }
     ;
     validateNewData({ row, forcedData, allowedFields, tableRules, fixIssues = false }) {
@@ -1756,105 +1694,7 @@ class TableHandler extends ViewHandler {
         return "";
     }
     async delete(filter, params, param3_unused, table_rules, localParams) {
-        try {
-            const { returning } = params || {};
-            filter = filter || {};
-            this.checkFilter(filter);
-            // table_rules = table_rules || {};
-            let forcedFilter = {}, filterFields = "*", returningFields = "*", validate;
-            const { testRule = false, returnQuery = false } = localParams || {};
-            if (table_rules) {
-                if (!table_rules.delete)
-                    throw "delete rules missing";
-                forcedFilter = table_rules.delete.forcedFilter;
-                filterFields = table_rules.delete.filterFields;
-                returningFields = table_rules.delete.returningFields;
-                validate = table_rules.delete.validate;
-                if (!returningFields)
-                    returningFields = (0, utils_1.get)(table_rules, "select.fields");
-                if (!returningFields)
-                    returningFields = (0, utils_1.get)(table_rules, "delete.filterFields");
-                if (!filterFields)
-                    throw ` Invalid delete rule for ${this.name}. filterFields missing `;
-                /* Safely test publish rules */
-                if (testRule) {
-                    await this.validateViewRules({ filterFields, returningFields, forcedFilter, rule: "delete" });
-                    return true;
-                }
-            }
-            if (params) {
-                const good_params = ["returning"];
-                const bad_params = Object.keys(params).filter(k => !good_params.includes(k));
-                if (bad_params && bad_params.length)
-                    throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-            }
-            let queryType = 'none';
-            let _query = "DELETE FROM " + this.escapedName;
-            const filterOpts = (await this.prepareWhere({
-                filter,
-                forcedFilter,
-                filterFields,
-                localParams,
-                tableRule: table_rules
-            }));
-            _query += filterOpts.where;
-            if (validate) {
-                const _filter = filterOpts.filter;
-                await validate(_filter);
-            }
-            let returningQuery = "";
-            if (returning) {
-                queryType = "any";
-                if (!returningFields) {
-                    throw "Returning dissallowed";
-                }
-                returningQuery = this.makeReturnQuery(await this.prepareReturning(returning, this.parseFieldFilter(returningFields)));
-                _query += returningQuery;
-            }
-            if (returnQuery)
-                return _query;
-            /**
-             * Delete file
-             */
-            const dbHandler = (this.t || this.db);
-            if (this.is_media && this.dboBuilder.prostgles.fileManager) {
-                if (this.dboBuilder.prostgles.opts.fileTable?.delayedDelete) {
-                    return dbHandler[queryType](`UPDATE ${(0, prostgles_types_1.asName)(this.name)} SET deleted = now() ${filterOpts.where} ${returningQuery};`);
-                }
-                else {
-                    const txDelete = async (tbl) => {
-                        if (!tbl.t)
-                            throw new Error("Missing transaction object t");
-                        const files = await this.find(filterOpts.filter);
-                        for await (const file of files) {
-                            await tbl.t?.any(`DELETE FROM ${(0, prostgles_types_1.asName)(this.name)} WHERE id = ` + "${id}", file);
-                            await tbl.dboBuilder.prostgles.fileManager?.deleteFile(file.name);
-                        }
-                        if (returning) {
-                            return files.map(f => (0, PubSubManager_1.pickKeys)(f, ["id", "name"]));
-                        }
-                    };
-                    if (localParams?.dbTX) {
-                        return txDelete(localParams.dbTX[this.name]);
-                    }
-                    else if (this.t) {
-                        return txDelete(this);
-                    }
-                    else {
-                        return this.dboBuilder.getTX(tx => {
-                            return txDelete(tx[this.name]);
-                        });
-                    }
-                }
-            }
-            return dbHandler[queryType](_query).catch((err) => makeErr(err, localParams));
-        }
-        catch (e) {
-            // console.trace(e)
-            if (localParams && localParams.testRule)
-                throw e;
-            throw { err: parseError(e), msg: `Issue with dbo.${this.name}.delete(${JSON.stringify(filter || {}, null, 2)}, ${JSON.stringify(params || {}, null, 2)})` };
-        }
+        return delete_1._delete.bind(this)(filter, params, param3_unused, table_rules, localParams);
     }
     ;
     remove(filter, params, param3_unused, tableRules, localParams) {