prostgles-server 4.2.58 → 4.2.60

package/lib/DboBuilder/TableHandler/upsert.ts

@@ -2,11 +2,11 @@ import { AnyObject, UpdateParams } from "prostgles-types";
 import { TableHandler } from "./TableHandler";
 import { Filter, LocalParams } from "../DboBuilderTypes";
 import { TableRule } from "../../PublishParser/publishTypesAndUtils";
-import { parseError } from "../dboBuilderUtils";
+import { getErrorAsObject, parseError } from "../dboBuilderUtils";
 
 export const upsert = async function(this: TableHandler, filter: Filter, newData: AnyObject, params?: UpdateParams, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
+  const start = Date.now();
   try {
-    await this._log({ command: "upsert", localParams, data: { filter, newData, params } });
     const _upsert = async function (tblH: TableHandler) {
       return tblH.find(filter, { select: "", limit: 1 }, undefined, table_rules, localParams)
         .then(exists => {
@@ -22,10 +22,13 @@ export const upsert = async function(this: TableHandler, filter: Filter, newData
     if (!this.tx) {
       return this.dboBuilder.getTX(dbTX => _upsert(dbTX[this.name] as TableHandler))
     } else {
-      return _upsert(this);
+      const result = await _upsert(this);
+      await this._log({ command: "upsert", localParams, data: { filter, newData, params }, duration: Date.now() - start });
+      return result;
     }
 
   } catch (e) {
+    await this._log({ command: "upsert", localParams, data: { filter, newData, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
     if (localParams && localParams.testRule) throw e;
     throw parseError(e, `dbo.${this.name}.upsert()`);
   }

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -85,8 +85,8 @@ export class ViewHandler {
     });
   } 
 
-  _log = ({ command, data, localParams }: Pick<TableEvent, "command" | "data" | "localParams">) => {
-    return this.dboBuilder.prostgles.opts.onLog?.({ type: "table", tableName: this.name, command, data, localParams })
+  _log = ({ command, data, localParams, duration, error }: Pick<TableEvent, "command" | "data" | "localParams"> & { duration: number; error?: any; }) => {
+    return this.dboBuilder.prostgles.opts.onLog?.({ type: "table", tableName: this.name, command, data, localParams, duration, error });
   }
 
   getRowHashSelect(allowedFields: FieldFilter, alias?: string, tableAlias?: string): string {
@@ -268,17 +268,17 @@ export class ViewHandler {
   }
   find = find.bind(this);
   
-  async findOne(filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
+  async findOne(filter?: Filter, selectParams?: SelectParams, _param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
 
     try {
-      await this._log({ command: "find", localParams, data: { filter, selectParams } });
-      const { select = "*", orderBy, offset = 0 } = selectParams || {};
-      if (selectParams) {
-        const good_params = ["select", "orderBy", "offset"];
-        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(", ");
+      const { limit, ...params } = selectParams ?? {};
+      if (limit) {
+        throw "limit not allowed in findOne()";
       }
-      return this.find(filter, { select, orderBy, limit: 1, offset, returnType: "row" }, undefined, table_rules, localParams);
+      const start = Date.now();
+      const result = await this.find(filter, { ...params, limit: 1, returnType: "row" }, undefined, table_rules, localParams);
+      await this._log({ command: "find", localParams, data: { filter, selectParams }, duration: Date.now() - start });
+      return result;
     } catch (e) {
       if (localParams && localParams.testRule) throw e;
       throw parseError(e, `Issue with dbo.${this.name}.findOne()`);

package/lib/DboBuilder/ViewHandler/count.ts

@@ -1,5 +1,5 @@
 import { SelectParams } from "prostgles-types";
-import { parseError, withUserRLS } from "../dboBuilderUtils";
+import { getErrorAsObject, parseError, withUserRLS } from "../dboBuilderUtils";
 import { ViewHandler } from "./ViewHandler";
 import { Filter, LocalParams } from "../DboBuilder";
 import { TableRule } from "../../PublishParser/publishTypesAndUtils";
@@ -7,9 +7,9 @@ import { TableRule } from "../../PublishParser/publishTypesAndUtils";
 export async function count(this: ViewHandler, _filter?: Filter, selectParams?: SelectParams, _param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<number> {
   const filter = _filter || {};
   const { limit: _limit, ...selectParamsWithoutLimit } = selectParams ?? {};
+  const start = Date.now();
   try {
-    await this._log({ command: "count", localParams, data: { filter } });
-    return await this.find(filter, { select: selectParamsWithoutLimit?.select ?? "", limit: 0 }, undefined, table_rules, localParams)
+    const result = await this.find(filter, { select: selectParamsWithoutLimit?.select ?? "", limit: 0 }, undefined, table_rules, localParams)
       .then(async _allowed => {
         const findQuery = await this.find(
           filter, 
@@ -28,7 +28,11 @@ export async function count(this: ViewHandler, _filter?: Filter, selectParams?:
         const handler = this.tx?.t ?? this.db;
         return handler.one(query).then(({ count }) => +count);
       });
+
+    await this._log({ command: "count", localParams, data: { filter }, duration: Date.now() - start });
+    return result;
   } catch (e) {
+    await this._log({ command: "count", localParams, data: { filter }, duration: Date.now() - start, error: getErrorAsObject(e) });
     if (localParams && localParams.testRule) throw e;
     throw parseError(e, `dbo.${this.name}.count()`)
   }

package/lib/DboBuilder/ViewHandler/find.ts

@@ -1,6 +1,6 @@
 
 import { SelectParams, isObject } from "prostgles-types";
-import { Filter, LocalParams, getClientErrorFromPGError, parseError, withUserRLS } from "../DboBuilder";
+import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, parseError, withUserRLS } from "../DboBuilder";
 import { canRunSQL } from "../runSQL";
 import { TableRule } from "../../PublishParser/PublishParser";
 import { getNewQuery } from "../QueryBuilder/getNewQuery";
@@ -10,8 +10,9 @@ import { ViewHandler } from "./ViewHandler";
 import { NewQuery } from "../QueryBuilder/QueryBuilder";
 
 export const find = async function(this: ViewHandler, filter?: Filter, selectParams?: SelectParams, _?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any[]> {
+  const start = Date.now();
+  const command = selectParams?.limit === 1 && selectParams?.returnType === "row"? "findOne" : "find";
   try {
-    await this._log({ command: "find", localParams, data: { filter, selectParams } });
     filter = filter || {};
     const allowedReturnTypes = Object.keys({ 
       row: 1, statement: 1, value: 1, values: 1, 
@@ -92,7 +93,7 @@ export const find = async function(this: ViewHandler, filter?: Filter, selectPar
       return ((localParams?.returnQuery === "noRLS"? queryWithoutRLS : queryWithRLS) as unknown as any[]);
     }
 
-    return runQueryReturnType({ 
+    const result = await runQueryReturnType({ 
       queryWithoutRLS, 
       queryWithRLS, 
       returnType, 
@@ -101,7 +102,10 @@ export const find = async function(this: ViewHandler, filter?: Filter, selectPar
       newQuery,
     });
 
+    await this._log({ command, localParams, data: { filter, selectParams }, duration: Date.now() - start });
+    return result;
   } catch (e) {
+    this._log({ command, localParams, data: { filter, selectParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
     if (localParams && localParams.testRule) throw e;
     throw parseError(e, `dbo.${this.name}.find()`);
   }

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -1,17 +1,20 @@
-import { 
-  TableInfo as TInfo, pickKeys,
- } from "prostgles-types/dist";
-import { LocalParams } from "../DboBuilder";
+import {
+  TableInfo as TInfo
+} from "prostgles-types/dist";
 import { TableRule } from "../../PublishParser/PublishParser";
+import { LocalParams } from "../DboBuilder";
 import { ViewHandler } from "./ViewHandler";
 
 export async function getInfo(this: ViewHandler, lang?: string, param2?: any, param3?: any, tableRules?: TableRule, localParams?: LocalParams): Promise<TInfo> {
-  await this._log({ command: "getInfo", localParams, data: { lang } });
   const p = this.getValidatedRules(tableRules, localParams);
-  if (!p.getInfo) throw "Not allowed";
+  if (!p.getInfo) {
+    await this._log({ command: "getInfo", localParams, data: { lang }, duration: 0, error: "Not allowed" });
+    throw "Not allowed";
+  }
 
   const fileTableName = this.dboBuilder.prostgles?.opts?.fileTable?.tableName;
 
+  await this._log({ command: "getInfo", localParams, data: { lang }, duration: 0 });
   return {
     oid: this.tableOrViewInfo.oid,
     comment: this.tableOrViewInfo.comment,

package/lib/DboBuilder/ViewHandler/size.ts

@@ -2,12 +2,12 @@ import { SelectParams } from "prostgles-types";
 import { Filter, LocalParams } from "../DboBuilderTypes";
 import { ViewHandler } from "./ViewHandler"
 import { TableRule } from "../../PublishParser/publishTypesAndUtils";
-import { parseError, withUserRLS } from "../dboBuilderUtils";
+import { getErrorAsObject, parseError, withUserRLS } from "../dboBuilderUtils";
 export async function size(this: ViewHandler, _filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<string> {
   const filter = _filter || {};
+  const start = Date.now();
   try {
-    await this._log({ command: "size", localParams, data: { filter, selectParams } });
-    return await this.find(filter, { ...selectParams, limit: 2 }, undefined, table_rules, localParams)
+    const result = await this.find(filter, { ...selectParams, limit: 2 }, undefined, table_rules, localParams)
       .then(async _allowed => {
         
         const q: string = await this.find(
@@ -28,7 +28,10 @@ export async function size(this: ViewHandler, _filter?: Filter, selectParams?: S
 
         return (this.tx?.t || this.db).one(query).then(({ size }) => size || '0');
       });
+    await this._log({ command: "size", localParams, data: { filter, selectParams }, duration: Date.now() - start });
+    return result;
   } catch (e) {
+    await this._log({ command: "size", localParams, data: { filter, selectParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
     if (localParams && localParams.testRule) throw e;
     throw parseError(e, `dbo.${this.name}.size()`);
   }

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -1,6 +1,6 @@
 import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
 import { TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, parseError } from "../DboBuilder";
+import { Filter, LocalParams, getErrorAsObject, parseError } from "../DboBuilder";
 import { NewQuery } from "../QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler";
 import { getSubscribeRelatedTables } from "../getSubscribeRelatedTables";
@@ -27,9 +27,8 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
 async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<SubscriptionChannels>
 async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs?: LocalFuncs, table_rules?: TableRule, localParams?: LocalParams): Promise<{ unsubscribe: () => any } | SubscriptionChannels> 
 {
-
+  const start = Date.now();
   try {
-    await this._log({ command: "subscribe", localParams, data: { filter, params } });
 
     if (this.tx) {
       throw "subscribe not allowed within transactions";
@@ -82,13 +81,15 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
     if (!localFuncs) {    
 
       const { socket } = localParams ?? {};
-      return pubSubManager.addSub({
+      const result = await pubSubManager.addSub({
         ...commonSubOpts,
         socket, 
         localFuncs: undefined,
         socket_id: socket?.id, 
       });
 
+      await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start });
+      return result;
     } else {
 
       const { channelName } = await pubSubManager.addSub({ 
@@ -102,10 +103,12 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
         const pubSubManager = await this.dboBuilder.getPubSubManager();
         pubSubManager.removeLocalSub(channelName, localFuncs)
       };
+      await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start });
       const res: { unsubscribe: () => any } = Object.freeze({ unsubscribe })
       return res;
     }
   } catch (e) {
+    await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
     if (localParams && localParams.testRule) throw e;
     throw parseError(e, `dbo.${this.name}.subscribe()`);
   }

package/lib/DboBuilder/getColumns.ts

@@ -1,9 +1,9 @@
-import { 
-  AnyObject, PG_COLUMN_UDT_DATA_TYPE, 
-  ValidatedColumnInfo, _PG_geometric, isObject 
+import {
+  AnyObject, PG_COLUMN_UDT_DATA_TYPE,
+  ValidatedColumnInfo, _PG_geometric, isObject
 } from "prostgles-types";
-import { isPlainObject, LocalParams, parseError, postgresToTsType } from "./DboBuilder";
 import { TableRule } from "../PublishParser/PublishParser";
+import { LocalParams, getErrorAsObject, parseError, postgresToTsType } from "./DboBuilder";
 import { TableHandler } from "./TableHandler/TableHandler";
 import { ViewHandler } from "./ViewHandler/ViewHandler";
 
@@ -17,9 +17,8 @@ export async function getColumns(
   tableRules?: TableRule,
   localParams?: LocalParams
 ): Promise<ValidatedColumnInfo[]> {
-
+  const start = Date.now();
   try {
-    await this._log({ command: "getColumns", localParams, data: { lang, params } });
 
     const p = this.getValidatedRules(tableRules, localParams);
 
@@ -94,9 +93,11 @@ export async function getColumns(
         return result;
       }).filter(c => c.select || c.update || c.delete || c.insert)
 
+    await this._log({ command: "getColumns", localParams, data: { lang, params }, duration: Date.now() - start });
     return columns;
 
   } catch (e) {
+    await this._log({ command: "getColumns", localParams, data: { lang, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
     throw parseError(e, `db.${this.name}.getColumns()`);
   }
 }

package/lib/Logging.ts

@@ -19,6 +19,8 @@ export namespace EventTypes {
     command: keyof TableHandler;
     data: AnyObject;
     localParams: LocalParams | undefined;
+    duration: number;
+    error?: any;
   };
 
   export type Sync = {

package/lib/Prostgles.ts

@@ -705,7 +705,7 @@ export class Prostgles {
       socket.emit(CHANNELS.SCHEMA, clientSchema);
 
     } catch (err) {
-      socket.emit(CHANNELS.SCHEMA, { err });
+      socket.emit(CHANNELS.SCHEMA, { err: getErrorAsObject(err) });
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.58",
+  "version": "4.2.60",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/server/DBoGenerated.d.ts

@@ -246,6 +246,18 @@ export type DBSchemaGenerated = {
       name?: null | string;
     };
   };
+  logs: {
+    is_view: false;
+    select: true;
+    insert: true;
+    update: true;
+    delete: true;
+    columns: {
+      created_at?: string;
+      id?: string;
+      request?: null | any;
+    };
+  };
   lookup_col1: {
     is_view: false;
     select: true;
@@ -292,6 +304,19 @@ export type DBSchemaGenerated = {
       y?: null | number;
     };
   };
+  plans: {
+    is_view: false;
+    select: true;
+    insert: true;
+    update: true;
+    delete: true;
+    columns: {
+      id: string;
+      info?: null | any;
+      name: string;
+      price?: null | string;
+    };
+  };
   "prostgles_test.basic": {
     is_view: false;
     select: true;
@@ -388,6 +413,17 @@ export type DBSchemaGenerated = {
       srtext?: null | string;
     };
   };
+  subscriptions: {
+    is_view: false;
+    select: true;
+    insert: true;
+    update: true;
+    delete: true;
+    columns: {
+      created_at?: string;
+      plan_id: string;
+    };
+  };
   symbols: {
     is_view: false;
     select: true;

package/tests/server/package-lock.json

@@ -21,7 +21,7 @@
     },
     "../..": {
       "name": "prostgles-server",
-      "version": "4.2.57",
+      "version": "4.2.59",
       "license": "MIT",
       "dependencies": {
         "bluebird": "^3.7.2",