prostgles-server 2.0.185 → 2.0.188

package/lib/DboBuilder/insert.ts

@@ -0,0 +1,138 @@
+import pgPromise from "pg-promise";
+import { AnyObject, asName, FieldFilter, get, InsertParams, isObject } from "prostgles-types";
+import { isPojoObject, LocalParams, makeErr, parseError, pgp, TableHandler } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+
+export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, _localParams?: LocalParams): Promise<any | any[] | boolean> {
+  const localParams = _localParams || {};
+  const { dbTX } = localParams
+  try {
+
+    const { returning, onConflictDoNothing, fixIssues = false } = param2 || {};
+    const { testRule = false, returnQuery = false } = localParams || {};
+
+    let returningFields: FieldFilter | undefined,
+      forcedData: AnyObject | undefined,
+      fields: FieldFilter | undefined;
+
+    if (tableRules) {
+      if (!tableRules.insert) throw "insert rules missing for " + this.name;
+      returningFields = tableRules.insert.returningFields;
+      forcedData = tableRules.insert.forcedData;
+      fields = tableRules.insert.fields;
+
+      /* If no returning fields specified then take select fields as returning */
+      if (!returningFields) returningFields = get(tableRules, "select.fields") || get(tableRules, "insert.fields");
+
+      if (!fields) throw ` invalid insert rule for ${this.name} -> fields missing `;
+
+      /* Safely test publish rules */
+      if (testRule) {
+        // if(this.is_media && tableRules.insert.preValidate) throw "Media table cannot have a preValidate. It already is used internally by prostgles for file upload";
+        await this.validateViewRules({ fields, returningFields, forcedFilter: forcedData, rule: "insert" });
+        if (forcedData) {
+          const keys = Object.keys(forcedData);
+          if (keys.length) {
+            try {
+              const colset = new pgp.helpers.ColumnSet(this.columns.filter(c => keys.includes(c.name)).map(c => ({ name: c.name, cast: c.udt_name === "uuid" ? c.udt_name : undefined }))),
+                values = pgp.helpers.values(forcedData, colset),
+                colNames = this.prepareSelect(keys, this.column_names);
+              await this.db.any("EXPLAIN INSERT INTO " + this.escapedName + " (${colNames:raw}) SELECT * FROM ( VALUES ${values:raw} ) t WHERE FALSE;", { colNames, values })
+            } catch (e) {
+              throw "\nissue with forcedData: \nVALUE: " + JSON.stringify(forcedData, null, 2) + "\nERROR: " + e;
+            }
+          }
+        }
+
+        return true;
+      }
+    }
+
+    let conflict_query = "";
+    if (typeof onConflictDoNothing === "boolean" && onConflictDoNothing) {
+      conflict_query = " ON CONFLICT DO NOTHING ";
+    }
+
+    if (param2) {
+      const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
+      const bad_params = Object.keys(param2).filter(k => !good_params.includes(k));
+      if (bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
+    }
+
+    if (!rowOrRows) rowOrRows = {}; //throw "Provide data in param1";
+    let returningSelect = this.makeReturnQuery(await this.prepareReturning(returning, this.parseFieldFilter(returningFields)));
+    const makeQuery = async (_row: AnyObject | undefined, isOne = false) => {
+      let row = { ..._row };
+
+      if (!isPojoObject(row)) {
+        console.trace(row)
+        throw "\ninvalid insert data provided -> " + JSON.stringify(row);
+      }
+
+      const { data, allowedCols } = this.validateNewData({ row, forcedData, allowedFields: fields, tableRules, fixIssues });
+      let _data = { ...data };
+
+      let insertQ = "";
+      if (!Object.keys(_data).length) insertQ = `INSERT INTO ${asName(this.name)} DEFAULT VALUES `;
+      else insertQ = await this.colSet.getInsertQuery(_data, allowedCols, tableRules?.insert?.validate) // pgp.helpers.insert(_data, columnSet); 
+      return insertQ + conflict_query + returningSelect;
+    };
+
+    let query = "";
+    let queryType: keyof pgPromise.ITask<{}> = "none";
+
+    /**
+     * If media it will: upload file and continue insert
+     * If nested insert it will: make separate inserts and not continue main insert
+     */
+    const insRes = await this.insertDataParse(rowOrRows, param2, param3_unused, tableRules, localParams);
+    const { data, insertResult } = insRes;
+    if ("insertResult" in insRes) {
+      return insertResult;
+    }
+
+    if (Array.isArray(data)) {
+      // if(returning) throw "Sorry but [returning] is dissalowed for multi insert";
+      let queries = await Promise.all(data.map(async p => {
+        const q = await makeQuery(p);
+        return q;
+      }));
+
+      query = pgp.helpers.concat(queries);
+      if (returning) queryType = "many";
+    } else {
+      query = await makeQuery(data, true);
+      if (returning) queryType = "one";
+    }
+
+    if (returnQuery) return query;
+    let result;
+
+    if (this.dboBuilder.prostgles.opts.DEBUG_MODE) {
+      console.log(this.t?.ctx?.start, "insert in " + this.name, data);
+    }
+
+    const tx = dbTX?.[this.name]?.t || this.t;
+
+    const allowedFieldKeys = this.parseFieldFilter(fields);
+    if (tx) {
+      result = (tx as any)[queryType](query).catch((err: any) => makeErr(err, localParams, this, allowedFieldKeys));
+    } else {
+      result = this.db.tx(t => (t as any)[queryType](query)).catch(err => makeErr(err, localParams, this, allowedFieldKeys));
+    }
+
+    return result;
+  } catch (e) {
+    if (localParams && localParams.testRule) throw e;
+
+    // ${JSON.stringify(rowOrRows || {}, null, 2)}, 
+    // ${JSON.stringify(param2 || {}, null, 2)}
+    throw {
+      err: parseError(e), msg: `Issue with dbo.${this.name}.insert(...)`,
+      args: {
+        1: rowOrRows,
+        2: param2
+      }
+    };
+  }
+};

package/lib/DboBuilder/insertDataParse.d.ts

@@ -0,0 +1,11 @@
+import { AnyObject, InsertParams } from "prostgles-types";
+import { LocalParams, TableHandler } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+/**
+ * Used for doing referenced inserts within a single transaction
+ */
+export declare function insertDataParse(this: TableHandler, data: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, _localParams?: LocalParams): Promise<{
+    data?: AnyObject | AnyObject[];
+    insertResult?: AnyObject | AnyObject[];
+}>;
+//# sourceMappingURL=insertDataParse.d.ts.map

package/lib/DboBuilder/insertDataParse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertDataParse.d.ts","sourceRoot":"","sources":["insertDataParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAqC,YAAY,EAAgD,MAAM,iBAAiB,CAAC;AAC3I,OAAO,EAA4B,WAAW,EAAmC,YAAY,EAAiB,MAAM,eAAe,CAAC;AACpI,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C;;GAEG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAC/B,MAAM,CAAC,EAAE,YAAY,EACrB,aAAa,CAAC,EAAE,SAAS,EACzB,UAAU,CAAC,EAAE,SAAS,EACtB,YAAY,CAAC,EAAE,WAAW,GACzB,OAAO,CAAC;IACT,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;IAC/B,YAAY,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;CACxC,CAAC,CAgSD"}

package/lib/DboBuilder/insertDataParse.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertDataParse = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const DboBuilder_1 = require("../DboBuilder");
+const PubSubManager_1 = require("../PubSubManager");
+/**
+ * Used for doing referenced inserts within a single transaction
+ */
+async function insertDataParse(data, param2, param3_unused, tableRules, _localParams) {
+    const localParams = _localParams || {};
+    let dbTX = localParams?.dbTX || this.dbTX;
+    const MEDIA_COL_NAMES = ["data", "name"];
+    const isMultiInsert = Array.isArray(data);
+    const getExtraKeys = (d) => (0, prostgles_types_1.getKeys)(d).filter(k => {
+        /* If media then use file insert columns */
+        if (this.is_media) {
+            return !this.column_names.concat(MEDIA_COL_NAMES).includes(k);
+        }
+        else if (!this.columns.find(c => c.name === k)) {
+            if (!(0, DboBuilder_1.isPojoObject)(d[k]) && !Array.isArray(d[k])) {
+                throw new Error("Invalid/Dissalowed field in data: " + k);
+            }
+            else if (!this.dboBuilder.dbo[k]) {
+                throw new Error("Invalid/Dissalowed nested insert table name in data: " + k);
+            }
+            return true;
+        }
+        return false;
+    });
+    const ALLOWED_COL_TYPES = ["int2", "int4", "int8", "numeric", "uuid", "text", "varchar", "char"];
+    const getColumnInserts = (d) => (0, prostgles_types_1.getKeys)(d)
+        .filter(k => d[k] && (0, DboBuilder_1.isPojoObject)(d[k]))
+        .map(k => {
+        const insertedCol = this.columns.find(c => c.name === k &&
+            ALLOWED_COL_TYPES.includes(c.udt_name));
+        if (insertedCol && (insertedCol.references?.fcols.length !== 1 ||
+            this.columns.some(c => 
+            // c.name !== insertedCol.name && // a bit reduntant: Cannot have one col reference two columns
+            c.references &&
+                c.references?.ftable === insertedCol.references?.ftable && // same ftable
+                c.references?.fcols[0] !== insertedCol.references?.fcols[0] // different fcols
+            ))) {
+            throw "A reference column insert is not possible for multiple column relationships";
+        }
+        if (insertedCol) {
+            return {
+                tableName: insertedCol.references.ftable,
+                col: insertedCol.name,
+                fcol: insertedCol.references.fcols[0]
+            };
+        }
+        return undefined;
+    }).filter(prostgles_types_1.isDefined);
+    /**
+     * True when: nested table data is provided within
+     *    [nestedTable] property key
+     *    OR
+     *    [referencing_column] property key
+     * If true then will do the full insert within this function
+     * Nested insert is not allowed for the file table
+     * */
+    const isNestedInsert = this.is_media ? false : (isMultiInsert ? data : [data]).some(d => getExtraKeys(d).length || getColumnInserts(d).length);
+    /**
+     * Make sure nested insert uses a transaction
+     */
+    if (isNestedInsert && !dbTX) {
+        return {
+            insertResult: await this.dboBuilder.getTX((dbTX) => dbTX[this.name].insert(data, param2, param3_unused, tableRules, { dbTX, ...localParams }))
+        };
+    }
+    // if(!dbTX && this.t) dbTX = this.d;
+    const preValidate = tableRules?.insert?.preValidate, validate = tableRules?.insert?.validate;
+    let _data = await Promise.all((isMultiInsert ? data : [data]).map(async (row) => {
+        if (preValidate) {
+            row = await preValidate(row);
+        }
+        const dataKeys = Object.keys(row);
+        const extraKeys = getExtraKeys(row);
+        const colInserts = getColumnInserts(row);
+        /* Upload file then continue insert */
+        if (this.is_media) {
+            if (!this.dboBuilder.prostgles?.fileManager)
+                throw "fileManager not set up";
+            const { data, name } = row;
+            if (dataKeys.length !== 2)
+                throw "Expecting only two properties: { name: string; data: File }";
+            // if(!Buffer.isBuffer(data)) throw "data is not of type Buffer"
+            if (!data)
+                throw "data not provided";
+            if (typeof name !== "string") {
+                throw "name is not of type string";
+            }
+            const media_id = (await this.db.oneOrNone("SELECT gen_random_uuid() as name")).name;
+            const type = await this.dboBuilder.prostgles.fileManager.getMIME(data, name);
+            const media_name = `${media_id}.${type.ext}`;
+            let media = {
+                id: media_id,
+                name: media_name,
+                original_name: name,
+                extension: type.ext,
+                content_type: type.mime
+            };
+            if (validate) {
+                media = await validate(media);
+            }
+            const _media = await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
+                item: {
+                    data,
+                    name: media.name ?? "????",
+                    content_type: media.content_type
+                },
+                // imageCompression: {
+                //     inside: {
+                //         width: 1100,
+                //         height: 630
+                //     }
+                // }
+            });
+            return {
+                ...media,
+                ..._media,
+            };
+            /* Potentially a nested join */
+        }
+        else if (extraKeys.length || colInserts.length) {
+            /* Ensure we're using the same transaction */
+            const _this = this.t ? this : dbTX[this.name];
+            const omitedKeys = extraKeys.concat(colInserts.map(c => c.col));
+            // let rootData = isMultiInsert? data.map(d => omitKeys(d, omitedKeys)) : omitKeys(data, omitedKeys);
+            let rootData = (0, PubSubManager_1.omitKeys)(row, omitedKeys);
+            let insertedChildren;
+            let targetTableRules;
+            /** Insert referenced first and then populate root data with referenced keys */
+            if (colInserts.length) {
+                for await (const colInsert of colInserts) {
+                    const colRows = await referencedInsert(_this, dbTX, localParams, colInsert.tableName, row[colInsert.col]);
+                    if (!Array.isArray(colRows) || colRows.length !== 1 || [null, undefined].includes(colRows[0][colInsert.fcol])) {
+                        throw new Error("Could not do nested column insert: Unexpected return " + JSON.stringify(colRows));
+                    }
+                    const foreignKey = colRows[0][colInsert.fcol];
+                    rootData[colInsert.col] = foreignKey;
+                }
+            }
+            const fullRootResult = await _this.insert(rootData, { returning: "*" }, undefined, tableRules, localParams);
+            let returnData;
+            const returning = param2?.returning;
+            if (returning) {
+                returnData = {};
+                const returningItems = await this.prepareReturning(returning, this.parseFieldFilter(tableRules?.insert?.returningFields));
+                returningItems.filter(s => s.selected).map(rs => {
+                    returnData[rs.alias] = fullRootResult[rs.alias];
+                });
+            }
+            await Promise.all(extraKeys.map(async (targetTable) => {
+                const childDataItems = Array.isArray(row[targetTable]) ? row[targetTable] : [row[targetTable]];
+                const thisInfo = await this.getInfo();
+                const childInsert = async (cdata, tableName) => {
+                    return referencedInsert(this, dbTX, localParams, tableName, cdata);
+                };
+                const jp = await getJoinPath(this, targetTable);
+                const { path } = jp;
+                const [tbl1, tbl2, tbl3] = path;
+                targetTableRules = await canInsert(this, targetTable, localParams); //  tbl3
+                const cols2 = this.dboBuilder.dbo[tbl2].columns || [];
+                if (!this.dboBuilder.dbo[tbl2])
+                    throw "Invalid/disallowed table: " + tbl2;
+                const colsRefT1 = cols2?.filter(c => c.references?.cols.length === 1 && c.references?.ftable === tbl1);
+                if (!path.length) {
+                    throw "Nested inserts join path not found for " + [this.name, targetTable];
+                }
+                else if (path.length === 2) {
+                    if (targetTable !== tbl2)
+                        throw "Did not expect this";
+                    if (!colsRefT1.length)
+                        throw `Target table ${tbl2} does not reference any columns from the root table ${this.name}. Cannot do nested insert`;
+                    // console.log(childDataItems, JSON.stringify(colsRefT1, null, 2))
+                    insertedChildren = await childInsert(childDataItems.map((d) => {
+                        let result = { ...d };
+                        colsRefT1.map(col => {
+                            result[col.references.cols[0]] = fullRootResult[col.references.fcols[0]];
+                        });
+                        return result;
+                    }), targetTable);
+                    // console.log({ insertedChildren })
+                }
+                else if (path.length === 3) {
+                    if (targetTable !== tbl3)
+                        throw "Did not expect this";
+                    const colsRefT3 = cols2?.filter(c => c.references?.cols.length === 1 && c.references?.ftable === tbl3);
+                    if (!colsRefT1.length || !colsRefT3.length)
+                        throw "Incorrectly referenced or missing columns for nested insert";
+                    const fileTable = this.dboBuilder.prostgles.fileManager?.tableName;
+                    if (targetTable !== fileTable) {
+                        throw "Only media allowed to have nested inserts more than 2 tables apart";
+                    }
+                    /* We expect tbl2 to have only 2 columns (media_id and foreign_id) */
+                    if (!cols2 || !(cols2.filter(c => c.references?.ftable === fileTable).length === 1 &&
+                        cols2.filter(c => c.references?.ftable === _this.name).length === 1)) {
+                        console.log({ tbl1, tbl2, tbl3, name: _this.name, tthisName: this.name });
+                        throw "Second joining table not of expected format. Must contain exactly one reference column for each table (file table and target table)  ";
+                    }
+                    insertedChildren = await childInsert(childDataItems, targetTable);
+                    /* Insert in key_lookup table */
+                    await Promise.all(insertedChildren.map(async (t3Child) => {
+                        let tbl2Row = {};
+                        colsRefT3.map(col => {
+                            tbl2Row[col.name] = t3Child[col.references.fcols[0]];
+                        });
+                        colsRefT1.map(col => {
+                            tbl2Row[col.name] = fullRootResult[col.references.fcols[0]];
+                        });
+                        // console.log({ rootResult, tbl2Row, t3Child, colsRefT3, colsRefT1, t: this.t?.ctx?.start });
+                        await childInsert(tbl2Row, tbl2); //.then(() => {});
+                    }));
+                }
+                else {
+                    console.error(JSON.stringify({ path, thisTable: this.name, targetTable }, null, 2));
+                    throw "Unexpected path for Nested inserts";
+                }
+                /* Return also the nested inserted data */
+                if (targetTableRules && insertedChildren?.length && returning) {
+                    const targetTableHandler = dbTX[targetTable];
+                    const targetReturning = await targetTableHandler.prepareReturning("*", targetTableHandler.parseFieldFilter(targetTableRules?.insert?.returningFields));
+                    let clientTargetInserts = insertedChildren.map(d => {
+                        let _d = { ...d };
+                        let res = {};
+                        targetReturning.map(r => {
+                            res[r.alias] = _d[r.alias];
+                        });
+                        return res;
+                    });
+                    returnData[targetTable] = clientTargetInserts.length === 1 ? clientTargetInserts[0] : clientTargetInserts;
+                }
+            }));
+            return returnData;
+        }
+        return row;
+    }));
+    let result = isMultiInsert ? _data : _data[0];
+    // if(validate && !isNestedInsert){
+    //     result = isMultiInsert? await Promise.all(_data.map(async d => await validate({ ...d }))) : await validate({ ..._data[0] });
+    // }
+    let res = isNestedInsert ?
+        { insertResult: result } :
+        { data: result };
+    return res;
+}
+exports.insertDataParse = insertDataParse;
+/* Must be allowed to insert into referenced table */
+const canInsert = async (tableHandler, targetTable, localParams) => {
+    const childRules = await tableHandler.dboBuilder.publishParser?.getValidatedRequestRuleWusr({ tableName: targetTable, command: "insert", localParams });
+    if (!childRules || !childRules.insert)
+        throw "Dissallowed nested insert into table " + childRules;
+    return childRules;
+};
+const getJoinPath = async (tableHandler, targetTable) => {
+    const jp = tableHandler.dboBuilder.joinPaths.find(jp => jp.t1 === tableHandler.name && jp.t2 === targetTable);
+    if (!jp) {
+        console.trace(tableHandler.dboBuilder.joinPaths);
+        const pref = tableHandler.dboBuilder.prostgles.opts.joins !== "inferred" ? "Joins are not inferred! " : "";
+        throw new Error(`${pref}Could not find a single join path for the nested data ( sourceTable: ${tableHandler.name} targetTable: ${targetTable} ) `);
+    }
+    return jp;
+};
+const referencedInsert = async (tableHandler, dbTX, localParams, targetTable, targetData) => {
+    const thisInfo = await tableHandler.getInfo();
+    await getJoinPath(tableHandler, targetTable);
+    if (!targetData || !dbTX?.[targetTable] || !("insert" in dbTX[targetTable]))
+        throw new Error("childInsertErr: Table handler missing for referenced table: " + targetTable);
+    const childRules = await canInsert(tableHandler, targetTable, localParams);
+    if (thisInfo.has_media === "one" && thisInfo.media_table_name === targetTable && Array.isArray(targetData) && targetData.length > 1) {
+        throw "Constraint check fail: Cannot insert more than one record into " + JSON.stringify(targetTable);
+    }
+    return Promise.all((Array.isArray(targetData) ? targetData : [targetData])
+        .map(m => dbTX[targetTable]
+        .insert(m, { returning: "*" }, undefined, childRules, localParams)
+        .catch(e => {
+        console.trace({ childInsertErr: e });
+        return Promise.reject({ childInsertErr: e });
+    })));
+};