prostgles-server 4.0.35 → 4.0.37

package/lib/DboBuilder/ViewHandler.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewHandler = void 0;
-const makeSelectQuery_1 = require("../DboBuilder/QueryBuilder/makeSelectQuery");
 const getCondition_1 = require("./getCondition");
-const runSQL_1 = require("../DboBuilder/runSQL");
 const prostgles_types_1 = require("prostgles-types");
 const DboBuilder_1 = require("../DboBuilder");
 const PubSubManager_1 = require("../PubSubManager/PubSubManager");
@@ -11,6 +9,7 @@ const QueryBuilder_1 = require("./QueryBuilder/QueryBuilder");
 const Functions_1 = require("./QueryBuilder/Functions");
 const getColumns_1 = require("./getColumns");
 const subscribe_1 = require("./subscribe");
+const find_1 = require("./find");
 class ColSet {
     opts;
     constructor(columns, tableName) {
@@ -497,81 +496,7 @@ class ViewHandler {
             };
         }
     }
-    async find(filter, selectParams, param3_unused, tableRules, localParams) {
-        try {
-            filter = filter || {};
-            const allowedReturnTypes = ["row", "value", "values", "statement"];
-            const { returnType } = selectParams || {};
-            if (returnType && !allowedReturnTypes.includes(returnType)) {
-                throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`;
-            }
-            const { testRule = false, returnQuery = false, returnNewQuery } = localParams || {};
-            if (testRule)
-                return [];
-            if (selectParams) {
-                const good_params = ["select", "orderBy", "offset", "limit", "returnType", "groupBy"];
-                const bad_params = Object.keys(selectParams).filter(k => !good_params.includes(k));
-                if (bad_params && bad_params.length)
-                    throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-            }
-            /* Validate publish */
-            if (tableRules) {
-                if (!tableRules.select)
-                    throw "select rules missing for " + this.name;
-                const fields = tableRules.select.fields;
-                const maxLimit = tableRules.select.maxLimit;
-                if (tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !(0, DboBuilder_1.isPlainObject)(tableRules.select))
-                    throw `\nINVALID publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`;
-                if (!fields)
-                    throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
-                if (maxLimit && !Number.isInteger(maxLimit))
-                    throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
-            }
-            const q = await (0, QueryBuilder_1.getNewQuery)(this, filter, selectParams, param3_unused, tableRules, localParams, this.columns), _query = (0, makeSelectQuery_1.makeSelectQuery)(this, q, undefined, undefined, selectParams);
-            // console.log(_query, JSON.stringify(q, null, 2))
-            if (testRule) {
-                try {
-                    await this.db.any("EXPLAIN " + _query);
-                    return [];
-                }
-                catch (e) {
-                    console.error(e);
-                    throw `INTERNAL ERROR: Publish config is not valid for publish.${this.name}.select `;
-                }
-            }
-            /** Used for subscribe  */
-            if (returnNewQuery)
-                return q;
-            if (returnQuery)
-                return _query;
-            if (returnType === "statement") {
-                if (!(await (0, runSQL_1.canRunSQL)(this.dboBuilder.prostgles, localParams))) {
-                    throw `Not allowed:  {returnType: "statement"} requires sql privileges `;
-                }
-                return _query;
-            }
-            if (["row", "value"].includes(returnType)) {
-                return (this.t || this.db).oneOrNone(_query).then(data => {
-                    return (data && returnType === "value") ? Object.values(data)[0] : data;
-                }).catch(err => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this));
-            }
-            else {
-                return (this.t || this.db).any(_query).then(data => {
-                    if (returnType === "values") {
-                        return data.map(d => Object.values(d)[0]);
-                    }
-                    return data;
-                }).catch(err => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this));
-            }
-        }
-        catch (e) {
-            // console.trace(e)
-            if (localParams && localParams.testRule)
-                throw e;
-            throw (0, DboBuilder_1.parseError)(e, `dbo.${this.name}.find()`);
-            // throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find()`, args: { filter, selectParams} };
-        }
-    }
+    find = find_1.find.bind(this);
     findOne(filter, selectParams, param3_unused, table_rules, localParams) {
         try {
             const { select = "*", orderBy, offset = 0 } = selectParams || {};

package/lib/DboBuilder/ViewHandler.ts

@@ -1,8 +1,6 @@
-import { makeSelectQuery } from "../DboBuilder/QueryBuilder/makeSelectQuery";
 import { getCondition } from "./getCondition";
 
 import * as pgPromise from 'pg-promise';
-import { canRunSQL } from "../DboBuilder/runSQL";
 import {
   ColumnInfo, FieldFilter, SelectParams,
   OrderBy,
@@ -16,17 +14,19 @@ import {
 import { DB, DBHandlerServer, Join } from "../Prostgles";
 import {
   DboBuilder, escapeTSNames, ExistsFilterConfig,Filter, isPlainObject,
-  JoinInfo, LocalParams, makeErrorFromPGError, parseError, pgp, postgresToTsType, SortItem,
+  JoinInfo, LocalParams, parseError, pgp, postgresToTsType, SortItem,
   TableHandlers, TableSchema, ValidatedTableRules
 } from "../DboBuilder";
 import { Graph } from "../shortestPath";
 import { TableRule, UpdateRule, ValidateRow } from "../PublishParser";
 import { asValue } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
-import { asNameAlias,  getNewQuery, SelectItem, SelectItemValidated } from "./QueryBuilder/QueryBuilder";
+import { asNameAlias,  SelectItem, SelectItemValidated } from "./QueryBuilder/QueryBuilder";
 import { COMPUTED_FIELDS, FieldSpec } from "./QueryBuilder/Functions"; 
 import { getColumns } from "./getColumns";
 import { LocalFuncs, subscribe } from "./subscribe";
+import { find } from "./find";
+
 export type JoinPaths = {
   t1: string;
   t2: string;
@@ -600,82 +600,8 @@ export class ViewHandler {
     }
 
   }
-
-  async find(filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any[]> {
-    try {
-      filter = filter || {};
-      const allowedReturnTypes: Array<SelectParams["returnType"]> = ["row", "value", "values", "statement"]
-      const { returnType } = selectParams || {};
-      if (returnType && !allowedReturnTypes.includes(returnType)) {
-        throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`
-      }
-
-      const { testRule = false, returnQuery = false, returnNewQuery } = localParams || {};
-
-      if (testRule) return [];
-      if (selectParams) {
-        const good_params: Array<keyof SelectParams> = ["select", "orderBy", "offset", "limit", "returnType", "groupBy"];
-        const bad_params = Object.keys(selectParams).filter(k => !good_params.includes(k as any));
-        if (bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
-      }
-
-      /* Validate publish */
-      if (tableRules) { 
-
-        if (!tableRules.select) throw "select rules missing for " + this.name;
-        const fields = tableRules.select.fields; 
-        const maxLimit = tableRules.select.maxLimit;
-
-        if (<any>tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !isPlainObject(tableRules.select)) throw `\nINVALID publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`
-        if (!fields) throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
-        if (maxLimit && !Number.isInteger(maxLimit)) throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
-      }
-
-      const q = await getNewQuery(this as unknown as TableHandler, filter, selectParams, param3_unused, tableRules, localParams, this.columns),
-        _query = makeSelectQuery(this as unknown as TableHandler, q, undefined, undefined, selectParams);
-      // console.log(_query, JSON.stringify(q, null, 2))
-      if (testRule) {
-        try {
-          await this.db.any("EXPLAIN " + _query);
-          return [];
-        } catch (e) {
-          console.error(e);
-          throw `INTERNAL ERROR: Publish config is not valid for publish.${this.name}.select `
-        }
-      }
-
-      /** Used for subscribe  */
-      if(returnNewQuery) return (q as unknown as any);
-      if (returnQuery) return (_query as unknown as any[]);
-
-      if (returnType === "statement") {
-        if (!(await canRunSQL(this.dboBuilder.prostgles, localParams))) {
-          throw `Not allowed:  {returnType: "statement"} requires sql privileges `
-        }
-        return _query as unknown as any[];
-      }
-
-      if (["row", "value"].includes(returnType!)) {
-        return (this.t || this.db).oneOrNone(_query).then(data => {
-          return (data && returnType === "value") ? Object.values(data)[0] : data;
-        }).catch(err => makeErrorFromPGError(err, localParams, this));
-      } else {
-        return (this.t || this.db).any(_query).then(data => {
-          if (returnType === "values") {
-            return data.map(d => Object.values(d)[0]);
-          }
-          return data;
-        }).catch(err => makeErrorFromPGError(err, localParams, this));
-      }
-
-    } catch (e) {
-      // console.trace(e)
-      if (localParams && localParams.testRule) throw e;
-      throw parseError(e, `dbo.${this.name}.find()`);
-      // throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find()`, args: { filter, selectParams} };
-    }
-  }
-
+  find = find.bind(this);
+  
   findOne(filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
 
     try {

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

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["delete.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,YAAY,EAAe,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,MAAM,EAAE,WAAW,EAAoC,MAAM,eAAe,CAAC;AACtF,OAAO,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAsB,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CA6HrL"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["delete.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,YAAY,EAAe,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,MAAM,EAAE,WAAW,EAAc,MAAM,eAAe,CAAC;AAChE,OAAO,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,wBAAsB,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAgIrL"}

package/lib/DboBuilder/delete.js

@@ -4,6 +4,7 @@ exports._delete = void 0;
 const prostgles_types_1 = require("prostgles-types");
 const DboBuilder_1 = require("../DboBuilder");
 const PubSubManager_1 = require("../PubSubManager/PubSubManager");
+const find_1 = require("./find");
 async function _delete(filter, params, param3_unused, table_rules, localParams) {
     try {
         const { returning } = params || {};
@@ -32,7 +33,8 @@ async function _delete(filter, params, param3_unused, table_rules, localParams)
             }
         }
         if (params) {
-            const good_params = ["returning"];
+            const good_paramsObj = { returning: 1, returnType: 1 };
+            const good_params = Object.keys(good_paramsObj);
             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(", ");
@@ -112,7 +114,8 @@ async function _delete(filter, params, param3_unused, table_rules, localParams)
                 }
             }
         }
-        return dbHandler[queryType](_query).catch((err) => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams));
+        return (0, find_1.runQueryReturnType)(_query, params?.returnType, this, localParams);
+        // return dbHandler[queryType](_query).catch((err: any) => makeErrorFromPGError(err, localParams));
     }
     catch (e) {
         // console.trace(e)

package/lib/DboBuilder/delete.ts

@@ -1,9 +1,10 @@
 import pgPromise from "pg-promise";
 import { AnyObject, asName, DeleteParams, FieldFilter } from "prostgles-types";
-import { Filter, LocalParams, makeErrorFromPGError, parseError } from "../DboBuilder";
+import { Filter, LocalParams, parseError } from "../DboBuilder";
 import { DeleteRule, TableRule } from "../PublishParser";
 import { pickKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
+import { runQueryReturnType } from "./find";
 
 export async function _delete(this: TableHandler, filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
   try {
@@ -40,7 +41,8 @@ export async function _delete(this: TableHandler, filter?: Filter, params?: Dele
 
 
     if (params) {
-      const good_params = ["returning"];
+      const good_paramsObj: Record<keyof DeleteParams, 1> = { returning: 1, returnType: 1 };
+      const good_params = Object.keys(good_paramsObj);
       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(", ");
     }
@@ -124,7 +126,9 @@ export async function _delete(this: TableHandler, filter?: Filter, params?: Dele
       }
     }
 
-    return dbHandler[queryType](_query).catch((err: any) => makeErrorFromPGError(err, localParams));
+    return runQueryReturnType(_query, params?.returnType, this, localParams);
+
+    // return dbHandler[queryType](_query).catch((err: any) => makeErrorFromPGError(err, localParams));
   } catch (e) {
     // console.trace(e)
     if (localParams && localParams.testRule) throw e;

package/lib/DboBuilder/find.d.ts

@@ -0,0 +1,8 @@
+import { SelectParams } from "prostgles-types";
+import { Filter, LocalParams } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
+import { ViewHandler } from "./ViewHandler";
+export declare const find: (this: ViewHandler, filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams) => Promise<any[]>;
+export declare const runQueryReturnType: (query: string, returnType: SelectParams["returnType"], handler: ViewHandler | TableHandler, localParams: LocalParams | undefined) => Promise<any>;
+//# sourceMappingURL=find.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["find.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAoC,MAAM,eAAe,CAAC;AAGtF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,eAAO,MAAM,IAAI,SAAwB,WAAW,WAAW,MAAM,iBAAiB,YAAY,kBAAkB,SAAS,eAAe,SAAS,gBAAgB,WAAW,KAAG,QAAQ,GAAG,EAAE,CAuD/L,CAAA;AAGD,eAAO,MAAM,kBAAkB,UAAiB,MAAM,cAAc,YAAY,CAAC,YAAY,CAAC,WAAW,WAAW,GAAG,YAAY,eAAe,WAAW,GAAG,SAAS,iBAoBxK,CAAA"}

package/lib/DboBuilder/find.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQueryReturnType = exports.find = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const DboBuilder_1 = require("../DboBuilder");
+const makeSelectQuery_1 = require("../DboBuilder/QueryBuilder/makeSelectQuery");
+const runSQL_1 = require("../DboBuilder/runSQL");
+const QueryBuilder_1 = require("./QueryBuilder/QueryBuilder");
+const find = async function (filter, selectParams, param3_unused, tableRules, localParams) {
+    try {
+        filter = filter || {};
+        const allowedReturnTypes = ["row", "value", "values", "statement"];
+        const { returnType } = selectParams || {};
+        if (returnType && !allowedReturnTypes.includes(returnType)) {
+            throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`;
+        }
+        const { testRule = false, returnQuery = false, returnNewQuery } = localParams || {};
+        if (testRule)
+            return [];
+        if (selectParams) {
+            const good_params = ["select", "orderBy", "offset", "limit", "returnType", "groupBy"];
+            const bad_params = Object.keys(selectParams).filter(k => !good_params.includes(k));
+            if (bad_params && bad_params.length)
+                throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
+        }
+        /* Validate publish */
+        if (tableRules) {
+            if (!tableRules.select)
+                throw "select rules missing for " + this.name;
+            const fields = tableRules.select.fields;
+            const maxLimit = tableRules.select.maxLimit;
+            if (tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !(0, prostgles_types_1.isObject)(tableRules.select))
+                throw `\nINVALID publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`;
+            if (!fields)
+                throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
+            if (maxLimit && !Number.isInteger(maxLimit))
+                throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
+        }
+        const q = await (0, QueryBuilder_1.getNewQuery)(this, filter, selectParams, param3_unused, tableRules, localParams, this.columns), _query = (0, makeSelectQuery_1.makeSelectQuery)(this, q, undefined, undefined, selectParams);
+        // console.log(_query, JSON.stringify(q, null, 2))
+        if (testRule) {
+            try {
+                await this.db.any("EXPLAIN " + _query);
+                return [];
+            }
+            catch (e) {
+                console.error(e);
+                throw `INTERNAL ERROR: Publish config is not valid for publish.${this.name}.select `;
+            }
+        }
+        /** Used for subscribe  */
+        if (returnNewQuery)
+            return q;
+        if (returnQuery)
+            return _query;
+        return (0, exports.runQueryReturnType)(_query, returnType, this, localParams);
+    }
+    catch (e) {
+        // console.trace(e)
+        if (localParams && localParams.testRule)
+            throw e;
+        throw (0, DboBuilder_1.parseError)(e, `dbo.${this.name}.find()`);
+        // throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find()`, args: { filter, selectParams} };
+    }
+};
+exports.find = find;
+const runQueryReturnType = async (query, returnType, handler, localParams) => {
+    if (returnType === "statement") {
+        if (!(await (0, runSQL_1.canRunSQL)(handler.dboBuilder.prostgles, localParams))) {
+            throw `Not allowed:  {returnType: "statement"} requires sql privileges `;
+        }
+        return query;
+    }
+    else if (["row", "value"].includes(returnType)) {
+        return (handler.t || handler.db).oneOrNone(query).then(data => {
+            return (data && returnType === "value") ? Object.values(data)[0] : data;
+        }).catch(err => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this));
+    }
+    else {
+        return (handler.t || handler.db).any(query).then(data => {
+            if (returnType === "values") {
+                return data.map(d => Object.values(d)[0]);
+            }
+            return data;
+        }).catch(err => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this));
+    }
+};
+exports.runQueryReturnType = runQueryReturnType;

package/lib/DboBuilder/find.ts

@@ -0,0 +1,89 @@
+
+import { SelectParams, isObject } from "prostgles-types";
+import { Filter, LocalParams, makeErrorFromPGError, parseError } from "../DboBuilder";
+import { makeSelectQuery } from "../DboBuilder/QueryBuilder/makeSelectQuery";
+import { canRunSQL } from "../DboBuilder/runSQL";
+import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
+import { getNewQuery } from "./QueryBuilder/QueryBuilder";
+import { ViewHandler } from "./ViewHandler";
+
+export const find = async function(this: ViewHandler, filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any[]> {
+  try {
+    filter = filter || {};
+    const allowedReturnTypes: Array<SelectParams["returnType"]> = ["row", "value", "values", "statement"]
+    const { returnType } = selectParams || {};
+    if (returnType && !allowedReturnTypes.includes(returnType)) {
+      throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`
+    }
+
+    const { testRule = false, returnQuery = false, returnNewQuery } = localParams || {};
+
+    if (testRule) return [];
+    if (selectParams) {
+      const good_params: Array<keyof SelectParams> = ["select", "orderBy", "offset", "limit", "returnType", "groupBy"];
+      const bad_params = Object.keys(selectParams).filter(k => !good_params.includes(k as any));
+      if (bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
+    }
+
+    /* Validate publish */
+    if (tableRules) { 
+
+      if (!tableRules.select) throw "select rules missing for " + this.name;
+      const fields = tableRules.select.fields; 
+      const maxLimit = tableRules.select.maxLimit;
+
+      if (<any>tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !isObject(tableRules.select)) throw `\nINVALID publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`
+      if (!fields) throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
+      if (maxLimit && !Number.isInteger(maxLimit)) throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
+    }
+
+    const q = await getNewQuery(this as unknown as TableHandler, filter, selectParams, param3_unused, tableRules, localParams, this.columns),
+      _query = makeSelectQuery(this as unknown as TableHandler, q, undefined, undefined, selectParams);
+    // console.log(_query, JSON.stringify(q, null, 2))
+    if (testRule) {
+      try {
+        await this.db.any("EXPLAIN " + _query);
+        return [];
+      } catch (e) {
+        console.error(e);
+        throw `INTERNAL ERROR: Publish config is not valid for publish.${this.name}.select `
+      }
+    }
+
+    /** Used for subscribe  */
+    if(returnNewQuery) return (q as unknown as any);
+    if (returnQuery) return (_query as unknown as any[]);
+
+    return runQueryReturnType(_query, returnType, this, localParams);
+
+  } catch (e) {
+    // console.trace(e)
+    if (localParams && localParams.testRule) throw e;
+    throw parseError(e, `dbo.${this.name}.find()`);
+    // throw { err: parseError(e), msg: `Issue with dbo.${this.name}.find()`, args: { filter, selectParams} };
+  }
+}
+
+
+export const runQueryReturnType = async (query: string, returnType: SelectParams["returnType"], handler: ViewHandler | TableHandler, localParams: LocalParams | undefined) => {
+
+  if (returnType === "statement") {
+    if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams))) {
+      throw `Not allowed:  {returnType: "statement"} requires sql privileges `
+    }
+    return query as unknown as any[];
+
+  } else if (["row", "value"].includes(returnType!)) {
+    return (handler.t || handler.db).oneOrNone(query).then(data => {
+      return (data && returnType === "value") ? Object.values(data)[0] : data;
+    }).catch(err => makeErrorFromPGError(err, localParams, this));
+  } else {
+    return (handler.t || handler.db).any(query).then(data => {
+      if (returnType === "values") {
+        return data.map(d => Object.values(d)[0]);
+      }
+      return data;
+    }).catch(err => makeErrorFromPGError(err, localParams, this));
+  }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["insert.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAqC,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAE,WAAW,EAAyC,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,CAsL1N"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["insert.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAqC,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAE,WAAW,EAAyC,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,CAwL1N"}

package/lib/DboBuilder/insert.js

@@ -63,8 +63,9 @@ async function insert(rowOrRows, param2, param3_unused, tableRules, localParams)
             conflict_query = " ON CONFLICT DO NOTHING ";
         }
         if (param2) {
-            const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
-            const bad_params = (0, prostgles_types_1.getKeys)(param2).filter(k => !good_params.includes(k));
+            const good_paramsObj = { returning: 1, returnType: 1, fixIssues: 1, onConflictDoNothing: 1 };
+            const good_params = Object.keys(good_paramsObj);
+            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(", ");
         }
@@ -91,6 +92,7 @@ async function insert(rowOrRows, param2, param3_unused, tableRules, localParams)
                 insertQ = `INSERT INTO ${(0, prostgles_types_1.asName)(this.name)} DEFAULT VALUES `;
             }
             else {
+                //@ts-ignore
                 insertQ = await this.colSet.getInsertQuery(_data, allowedCols, this.dbTX || this.dboBuilder.dbo, tableRules?.[ACTION]?.validate); // pgp.helpers.insert(_data, columnSet); 
             }
             return insertQ + conflict_query + returningSelect;

package/lib/DboBuilder/insert.ts

@@ -74,8 +74,9 @@ export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObje
     }
 
     if (param2) {
-      const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
-      const bad_params = getKeys(param2).filter(k => !good_params.includes(k));
+      const good_paramsObj: Record<keyof InsertParams, 1> = { returning: 1, returnType: 1, fixIssues: 1, onConflictDoNothing: 1 };
+      const good_params = Object.keys(good_paramsObj);
+      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(", ");
     }
 
@@ -107,6 +108,7 @@ export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObje
         await tableRules?.[ACTION]?.validate?.(_data, this.dbTX || this.dboBuilder.dbo);
         insertQ = `INSERT INTO ${asName(this.name)} DEFAULT VALUES `;
       } else {
+        //@ts-ignore
         insertQ = await this.colSet.getInsertQuery(_data, allowedCols, this.dbTX || this.dboBuilder.dbo, tableRules?.[ACTION]?.validate) // pgp.helpers.insert(_data, columnSet); 
       }
       return insertQ + conflict_query + returningSelect;

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

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAiB,WAAW,EAA2C,MAAM,eAAe,CAAC;AAC5G,OAAO,EAAE,SAAS,EAAe,MAAM,kBAAkB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA+JzL"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAiB,WAAW,EAA2C,MAAM,eAAe,CAAC;AAC5G,OAAO,EAAE,SAAS,EAAe,MAAM,kBAAkB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAmKzL"}

package/lib/DboBuilder/update.js

@@ -5,6 +5,7 @@ const prostgles_types_1 = require("prostgles-types");
 const DboBuilder_1 = require("../DboBuilder");
 const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 const uploadFile_1 = require("./uploadFile");
+const find_1 = require("./find");
 async function update(filter, _newData, params, tableRules, localParams) {
     const ACTION = "update";
     try {
@@ -51,7 +52,8 @@ async function update(filter, _newData, params, tableRules, localParams) {
         const { returning, multi = true, onConflictDoNothing = false, fixIssues = false } = params || {};
         const { returnQuery = false } = localParams ?? {};
         if (params) {
-            const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
+            const good_paramsObj = { returning: 1, returnType: 1, fixIssues: 1, onConflictDoNothing: 1, multi: 1 };
+            const good_params = Object.keys(good_paramsObj);
             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(", ");
@@ -106,6 +108,9 @@ async function update(filter, _newData, params, tableRules, localParams) {
         }
         if (returnQuery)
             return query;
+        if (params?.returnType) {
+            return (0, find_1.runQueryReturnType)(query, params.returnType, this, localParams);
+        }
         let result;
         if (this.t) {
             result = await (this.t)[qType](query).catch((err) => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this, fields));

package/lib/DboBuilder/update.ts

@@ -4,6 +4,7 @@ import { TableRule, ValidateRow } from "../PublishParser";
 import { omitKeys, pickKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
 import { isFile, uploadFile } from "./uploadFile"
+import { runQueryReturnType } from "./find";
 
 export async function update(this: TableHandler, filter: Filter, _newData: AnyObject, params?: UpdateParams, tableRules?: TableRule, localParams?: LocalParams): Promise<AnyObject | void> {
   const ACTION = "update";
@@ -56,9 +57,9 @@ export async function update(this: TableHandler, filter: Filter, _newData: AnyOb
     const { returning, multi = true, onConflictDoNothing = false, fixIssues = false } = params || {};
     const { returnQuery = false } = localParams ?? {};
 
-
     if (params) {
-      const good_params = ["returning", "multi", "onConflictDoNothing", "fixIssues"];
+      const good_paramsObj: Record<keyof UpdateParams, 1> = { returning: 1, returnType: 1, fixIssues: 1, onConflictDoNothing: 1, multi: 1 };
+      const good_params = Object.keys(good_paramsObj);
       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(", ");
     }
@@ -127,6 +128,10 @@ export async function update(this: TableHandler, filter: Filter, _newData: AnyOb
 
     if (returnQuery) return query as unknown as void;
 
+    if(params?.returnType){
+      return runQueryReturnType(query, params.returnType, this, localParams);
+    }
+
     let result;
     if (this.t) {
       result = await (this.t)[qType](query).catch((err: any) => makeErrorFromPGError(err, localParams, this, fields));

package/lib/JSONBValidation/validation.js

@@ -120,7 +120,7 @@ function getJSONBSchemaTSTypes(schema, colOpts, outerLeading = "", tables) {
                     type = !cols ? "any" : `{ ${cols.map(c => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${(0, DboBuilder_1.postgresToTsType)(c.udt_name)}; `).join(" ")} }`;
                 }
             }
-            return `${fieldType.nullable ? `null |` : ""} ${type}${l.isArray ? "[]" : ""}`;
+            return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray ? "[]" : ""}`;
         }
         else
             throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType, schema }, null, 2);

package/lib/JSONBValidation/validation.ts

@@ -126,7 +126,7 @@ export function getJSONBSchemaTSTypes(schema: JSONB.JSONBSchema, colOpts: ColOpt
           type = !cols? "any" : `{ ${cols.map(c => `${JSON.stringify(c.name)}: ${c.is_nullable? "null | " : "" } ${postgresToTsType(c.udt_name)}; `).join(" ")} }`
         }
       }
-      return `${fieldType.nullable ? `null |` : ""} ${type}${l.isArray? "[]" : ""}`;
+      return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray? "[]" : ""}`;
 
     } else throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType, schema }, null, 2)
   } 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.0.35",
+  "version": "4.0.37",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,7 +40,7 @@
     "check-disk-space": "^3.3.1",
     "file-type": "^17.1.4",
     "pg-promise": "^11.3.0",
-    "prostgles-types": "^4.0.15",
+    "prostgles-types": "^4.0.16",
     "sharp": "^0.31.0"
   },
   "devDependencies": {

package/tests/client/PID.txt

@@ -1 +1 @@
-26897
+38429