prostgles-server 4.2.187 → 4.2.188

package/lib/DboBuilder/QueryStreamer.ts

@@ -13,10 +13,7 @@ import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 import { DB } from "../initProstgles";
 import { DboBuilder } from "./DboBuilder";
 import { PRGLIOSocket } from "./DboBuilderTypes";
-import {
-  getErrorAsObject,
-  getSerializedClientErrorFromPGError,
-} from "./dboBuilderUtils";
+import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./dboBuilderUtils";
 import { getDetailedFieldInfo } from "./runSQL";
 const Cursor: typeof CursorType = require("pg-cursor");
 
@@ -62,27 +59,19 @@ export class QueryStreamer {
     };
     this.adminClient = this.getConnection(
       (error) => {
-        if (
-          error.message?.includes("database") &&
-          error.message?.includes("does not exist")
-        )
+        if (error.message?.includes("database") && error.message?.includes("does not exist"))
           return;
         console.log("Admin client error. Reconnecting...", error);
         setAdminClient();
       },
-      { keepAlive: true },
+      { keepAlive: true }
     );
     this.adminClient.connect();
   }
 
-  getConnection = (
-    onError: ((err: any) => void) | undefined,
-    extraOptions?: pg.ClientConfig,
-  ) => {
+  getConnection = (onError: ((err: any) => void) | undefined, extraOptions?: pg.ClientConfig) => {
     const connectionInfo =
-      typeof this.db.$cn === "string"
-        ? { connectionString: this.db.$cn }
-        : (this.db.$cn as any);
+      typeof this.db.$cn === "string" ? { connectionString: this.db.$cn } : (this.db.$cn as any);
     const client = new pg.Client({ ...connectionInfo, ...extraOptions });
     client.on("error", (err) => {
       onError?.(err);
@@ -100,9 +89,7 @@ export class QueryStreamer {
     delete this.socketQueries[socketId];
   };
 
-  create = async (
-    query: ClientStreamedRequest,
-  ): Promise<SocketSQLStreamServer> => {
+  create = async (query: ClientStreamedRequest): Promise<SocketSQLStreamServer> => {
     const { socket, persistConnection } = query;
     const socketId = socket.id;
     const id = getSetShortSocketId(socketId);
@@ -123,10 +110,10 @@ export class QueryStreamer {
         if (errored) return;
         errored = true;
 
-        const errorWithoutQuery = getSerializedClientErrorFromPGError(
-          rawError,
-          { type: "sql", localParams: { socket } },
-        );
+        const errorWithoutQuery = getSerializedClientErrorFromPGError(rawError, {
+          type: "sql",
+          localParams: { socket },
+        });
         // For some reason query is not present on the error object from sql stream mode
         const error = { ...errorWithoutQuery, query: query.query };
         socket.emit(channel, {
@@ -135,14 +122,12 @@ export class QueryStreamer {
         } satisfies SocketSQLStreamPacket);
       },
     };
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     this.socketQueries[socketId]![id] ??= socketQuery;
     let processID = -1;
     let streamState: "started" | "ended" | "errored" | undefined;
 
-    const startStream = async (
-      client: pg.Client | undefined,
-      query: ClientStreamedRequest,
-    ) => {
+    const startStream = async (client: pg.Client | undefined, query: ClientStreamedRequest) => {
       const socketQuery = this.socketQueries[socketId]?.[id];
       if (!socketQuery) {
         throw "socket query not found";
@@ -157,10 +142,8 @@ export class QueryStreamer {
       }:
         | { reachedEnd: true; rows: any[]; info: Info }
         | { reachedEnd: false; rows: any[]; info: Omit<Info, "command"> }) => {
-        if (!info?.fields) throw "No fields";
-        const fields = getDetailedFieldInfo.bind(this.dboBuilder)(
-          info.fields as any,
-        );
+        if (!(info as any).fields) throw "No fields";
+        const fields = getDetailedFieldInfo.bind(this.dboBuilder)(info.fields as any);
         const packet: SocketSQLStreamPacket = {
           type: "data",
           rows,
@@ -193,16 +176,14 @@ export class QueryStreamer {
 
         if (
           query.options?.streamLimit &&
-          (!Number.isInteger(query.options.streamLimit) ||
-            query.options.streamLimit < 0)
+          (!Number.isInteger(query.options.streamLimit) || query.options.streamLimit < 0)
         ) {
           throw "streamLimit must be a positive integer";
         }
-        const batchSize = query.options?.streamLimit
-          ? Math.min(1e3, query.options?.streamLimit)
-          : 1e3;
+        const batchSize =
+          query.options?.streamLimit ? Math.min(1e3, query.options.streamLimit) : 1e3;
         const cursor = currentClient.query(
-          new Cursor(query.query, undefined, { rowMode: "array" }),
+          new Cursor(query.query, undefined, { rowMode: "array" })
         );
         this.socketQueries[socketId]![id]!.cursor = cursor;
         let streamLimitReached = false;
@@ -221,8 +202,7 @@ export class QueryStreamer {
               ]) as Info;
               rowsSent += rowChunk.length;
               streamLimitReached = Boolean(
-                query.options?.streamLimit &&
-                  rowsSent >= query.options.streamLimit,
+                query.options?.streamLimit && rowsSent >= query.options.streamLimit
               );
               reachedEnd = rowChunk.length < batchSize;
               emit({
@@ -241,14 +221,11 @@ export class QueryStreamer {
             cursor.close();
           } catch (error: any) {
             streamState = "errored";
-            if (
-              error.message ===
-              "cannot insert multiple commands into a prepared statement"
-            ) {
+            if (error.message === "cannot insert multiple commands into a prepared statement") {
               this.dboBuilder.dbo.sql!(
                 query.query,
                 {},
-                { returnType: "arrayMode", hasParams: false },
+                { returnType: "arrayMode", hasParams: false }
               )
                 .then((res) => {
                   emit({
@@ -276,10 +253,7 @@ export class QueryStreamer {
       socket.removeAllListeners(channel);
       delete this.socketQueries[socketId]?.[id];
     };
-    const stop = async (
-      opts: { terminate?: boolean } | undefined,
-      cb: BasicCallback,
-    ) => {
+    const stop = async (opts: { terminate?: boolean } | undefined, cb: BasicCallback) => {
       const { client: queryClient } = this.socketQueries[socketId]?.[id] ?? {};
       if (!queryClient) return;
       if (opts?.terminate) {
@@ -288,12 +262,10 @@ export class QueryStreamer {
         }, 4e3);
       }
       try {
-        const stopFunction = opts?.terminate
-          ? "pg_terminate_backend"
-          : "pg_cancel_backend";
+        const stopFunction = opts?.terminate ? "pg_terminate_backend" : "pg_cancel_backend";
         const rows = await this.adminClient.query(
           `SELECT ${stopFunction}(pid), pid, state, query FROM pg_stat_activity WHERE pid = $1`,
-          [processID],
+          [processID]
         );
         cleanup();
         cb({ processID, info: rows.rows[0] });
@@ -313,10 +285,7 @@ export class QueryStreamer {
     socket.removeAllListeners(channel);
     socket.on(
       channel,
-      async (
-        _data: { query: string; params: any } | undefined,
-        cb: BasicCallback,
-      ) => {
+      async (_data: { query: string; params: any } | undefined, cb: BasicCallback) => {
         if (streamState === "started") {
           return cb(processID, "Already started");
         }
@@ -340,7 +309,7 @@ export class QueryStreamer {
           cb(processID, getErrorAsObject(err) ?? "Something went wrong");
         }
         runCount++;
-      },
+      }
     );
 
     /** If not started within 5 seconds then assume it will never happen */

package/lib/DboBuilder/TableHandler/DataValidator.ts

@@ -2,21 +2,19 @@ import {
   AnyObject,
   ColumnInfo,
   FieldFilter,
-  ValidatedColumnInfo,
   asName,
   getKeys,
   isEmpty,
   isObject,
   pickKeys,
-  unpatchText,
 } from "prostgles-types/dist";
-import { ValidateRowBasic } from "../../PublishParser/PublishParser";
 import { DBHandlerServer } from "../../Prostgles";
+import { ValidateRowBasic } from "../../PublishParser/PublishParser";
 import { asValue } from "../../PubSubManager/PubSubManager";
 import { LocalParams, TableSchemaColumn, pgp } from "../DboBuilder";
-import { TableHandler, ValidatedParams } from "./TableHandler";
 import { parseFunctionObject } from "../QueryBuilder/QueryBuilder";
 import { validateObj } from "../ViewHandler/ViewHandler";
+import { TableHandler, ValidatedParams } from "./TableHandler";
 
 type RowFieldDataPlain = {
   type: "plain";
@@ -58,10 +56,7 @@ export class DataValidator {
 
   parse = async (args: ParseDataArgs) => {
     const { command } = args;
-    const rowFieldData = await getValidatedRowFieldData(
-      args,
-      this.tableHandler,
-    );
+    const rowFieldData = await getValidatedRowFieldData(args, this.tableHandler);
     const parsedRowFieldData = await getParsedRowFieldData(rowFieldData, args);
     if (command === "update") {
       if (rowFieldData.some((rowParts) => rowParts.length === 0)) {
@@ -71,8 +66,7 @@ export class DataValidator {
 
     return {
       parsedRowFieldData,
-      getQuery: () =>
-        getQuery(command, parsedRowFieldData, this.tableHandler.escapedName),
+      getQuery: () => getQuery(command, parsedRowFieldData, this.tableHandler.escapedName),
     };
   };
 }
@@ -80,23 +74,20 @@ export class DataValidator {
 const getQuery = (
   type: "insert" | "update",
   parsedRowFieldData: ParsedRowFieldData[][],
-  escapedTableName: string,
+  escapedTableName: string
 ): string => {
   if (type === "insert") {
     const uniqueColumns = Array.from(
-      new Set(
-        parsedRowFieldData.flatMap((row) => row.map((r) => r.escapedCol)),
-      ),
+      new Set(parsedRowFieldData.flatMap((row) => row.map((r) => r.escapedCol)))
     );
     const values = parsedRowFieldData
       .map(
         (row) =>
-          `(${uniqueColumns.map((colName) => row.find((r) => r.escapedCol === colName)?.escapedVal ?? "DEFAULT")})`,
+          `(${uniqueColumns.map((colName) => row.find((r) => r.escapedCol === colName)?.escapedVal ?? "DEFAULT")})`
       )
       .join(",\n");
-    const whatToInsert = !uniqueColumns.length
-      ? "DEFAULT VALUES"
-      : `(${uniqueColumns}) VALUES ${values}`;
+    const whatToInsert =
+      !uniqueColumns.length ? "DEFAULT VALUES" : `(${uniqueColumns}) VALUES ${values}`;
     return `INSERT INTO ${escapedTableName} ${whatToInsert} `;
   } else {
     const query =
@@ -104,9 +95,7 @@ const getQuery = (
         .map((rowParts) => {
           return (
             `UPDATE ${escapedTableName} SET ` +
-            rowParts
-              .map((r) => `${r.escapedCol} = ${r.escapedVal} `)
-              .join(",\n")
+            rowParts.map((r) => `${r.escapedCol} = ${r.escapedVal} `).join(",\n")
           );
         })
         .join(";\n") + " ";
@@ -142,10 +131,7 @@ const getValidatedRow = ({
   if (!column_names.length) {
     throw "table column_names mising";
   }
-  const validatedAllowedColumns = tableHandler.parseFieldFilter(
-    allowedCols,
-    false,
-  );
+  const validatedAllowedColumns = tableHandler.parseFieldFilter(allowedCols, false);
 
   let finalRow = { ...row };
   if (removeDisallowedFields && !isEmpty(finalRow)) {
@@ -179,7 +165,7 @@ export const prepareNewData = async ({
   tableConfigurator,
   tableHandler,
 }: ValidatedParams) => {
-  const synced_field = (tableRules ?? {})?.sync?.synced_field;
+  const synced_field = (tableRules ?? {}).sync?.synced_field;
 
   /* Update synced_field if sync is on and missing */
   if (synced_field && !row[synced_field]) {
@@ -201,16 +187,8 @@ export const prepareNewData = async ({
       col,
       value: data[col],
     });
-    const colConfig = tableConfigurator?.getColumnConfig(
-      tableHandler.name,
-      col,
-    );
-    if (
-      colConfig &&
-      isObject(colConfig) &&
-      "isText" in colConfig &&
-      data[col]
-    ) {
+    const colConfig = tableConfigurator?.getColumnConfig(tableHandler.name, col);
+    if (colConfig && isObject(colConfig) && "isText" in colConfig && data[col]) {
       if (colConfig.lowerCased) {
         data[col] = data[col].toString().toLowerCase();
       }
@@ -235,7 +213,7 @@ export const prepareNewData = async ({
  */
 const getValidatedRowFieldData = async (
   { allowedCols, rows, validationOptions, dbTx, command }: ParseDataArgs,
-  tableHandler: TableHandler,
+  tableHandler: TableHandler
 ) => {
   if (!allowedCols.length && command === "update") {
     throw "allowedColumns cannot be empty";
@@ -255,7 +233,7 @@ const getValidatedRowFieldData = async (
         });
       }
       const keysAddedDuringValidate = Object.keys(row).filter(
-        (newKey) => !initialRowKeys.includes(newKey),
+        (newKey) => !initialRowKeys.includes(newKey)
       );
 
       const getColumn = (fieldName: string) => {
@@ -269,44 +247,42 @@ const getValidatedRowFieldData = async (
         return column;
       };
 
-      const rowPartValues = Object.entries(row).map(
-        ([fieldName, fieldValue]) => {
-          const column = getColumn(fieldName);
-          if (isObject(fieldValue)) {
-            // const textPatch = getTextPatch(column, fieldValue);
-            // if(textPatch){
-            //   return {
-            //     type: "plain",
-            //     column,
-            //     fieldValue: textPatch,
-            //   } satisfies RowFieldData;
-            // }
-
-            const [firstKey, ...otherkeys] = Object.keys(fieldValue);
-            const func =
-              firstKey && !otherkeys.length
-                ? convertionFuncs.some((f) => `$${f.name}` === firstKey)
-                : undefined;
-            if (func) {
-              const { funcName, args } = parseFunctionObject(fieldValue);
-              return {
-                type: "function",
-                column,
-                funcName,
-                args,
-              } satisfies RowFieldData;
-            }
+      const rowPartValues = Object.entries(row).map(([fieldName, fieldValue]) => {
+        const column = getColumn(fieldName);
+        if (isObject(fieldValue)) {
+          // const textPatch = getTextPatch(column, fieldValue);
+          // if(textPatch){
+          //   return {
+          //     type: "plain",
+          //     column,
+          //     fieldValue: textPatch,
+          //   } satisfies RowFieldData;
+          // }
+
+          const [firstKey, ...otherkeys] = Object.keys(fieldValue);
+          const func =
+            firstKey && !otherkeys.length ?
+              convertionFuncs.some((f) => `$${f.name}` === firstKey)
+            : undefined;
+          if (func) {
+            const { funcName, args } = parseFunctionObject(fieldValue);
+            return {
+              type: "function",
+              column,
+              funcName,
+              args,
+            } satisfies RowFieldData;
           }
-          return {
-            type: "plain",
-            column: getColumn(fieldName),
-            fieldValue,
-          } satisfies RowFieldData;
-        },
-      );
+        }
+        return {
+          type: "plain",
+          column: getColumn(fieldName),
+          fieldValue,
+        } satisfies RowFieldData;
+      });
 
       return rowPartValues;
-    }),
+    })
   );
 
   return rowFieldData;
@@ -320,7 +296,7 @@ const getTextPatch = async (c: TableSchemaColumn, fieldValue: any) => {
     !["from", "to"].find((key) => typeof fieldValue[key] !== "number")
   ) {
     const unrecProps = Object.keys(fieldValue).filter(
-      (k) => !["from", "to", "text", "md5"].includes(k),
+      (k) => !["from", "to", "text", "md5"].includes(k)
     );
     if (unrecProps.length) {
       throw "Unrecognised params in textPatch field: " + unrecProps.join(", ");
@@ -352,7 +328,7 @@ const getTextPatch = async (c: TableSchemaColumn, fieldValue: any) => {
 
 const getParsedRowFieldDataFunction = async (
   rowPart: RowFieldDataFunction,
-  args: ParseDataArgs,
+  args: ParseDataArgs
 ) => {
   const func = convertionFuncs.find((f) => `$${f.name}` === rowPart.funcName);
   if (!func) {
@@ -364,10 +340,7 @@ const getParsedRowFieldDataFunction = async (
   return func.getQuery(rowPart);
 };
 
-const getParsedRowFieldData = async (
-  rowFieldData: RowFieldData[][],
-  args: ParseDataArgs,
-) => {
+const getParsedRowFieldData = async (rowFieldData: RowFieldData[][], args: ParseDataArgs) => {
   const parsedRowFieldData = Promise.all(
     rowFieldData.map((rowParts) => {
       return Promise.all(
@@ -377,12 +350,8 @@ const getParsedRowFieldData = async (
             escapedVal = await getParsedRowFieldDataFunction(rowPart, args);
           } else {
             /** Prevent pg-promise formatting jsonb */
-            const colIsJSON = ["json", "jsonb"].includes(
-              rowPart.column.data_type,
-            );
-            escapedVal = pgp.as.format(colIsJSON ? "$1:json" : "$1", [
-              rowPart.fieldValue,
-            ]);
+            const colIsJSON = ["json", "jsonb"].includes(rowPart.column.data_type);
+            escapedVal = pgp.as.format(colIsJSON ? "$1:json" : "$1", [rowPart.fieldValue]);
           }
 
           /**
@@ -394,9 +363,9 @@ const getParsedRowFieldData = async (
             escapedCol: asName(rowPart.column.name),
             escapedVal,
           };
-        }),
+        })
       );
-    }),
+    })
   );
 
   return parsedRowFieldData;
@@ -426,12 +395,11 @@ const convertionFuncs: ConvertionFunc[] = [
           const argList = args.map((arg) => asValue(arg)).join(", ");
           return `${name}(${argList})`;
         },
-      }) satisfies ConvertionFunc,
+      }) satisfies ConvertionFunc
   ),
   {
     name: "to_timestamp",
-    getQuery: ({ args }) =>
-      `to_timestamp(${asValue(args[0])}::BIGINT/1000.0)::timestamp`,
+    getQuery: ({ args }) => `to_timestamp(${asValue(args[0])}::BIGINT/1000.0)::timestamp`,
   },
   {
     name: "merge",

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -48,7 +48,7 @@ export class TableHandler extends ViewHandler {
     tableOrViewInfo: TableSchema,
     dboBuilder: DboBuilder,
     tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
-    joinPaths?: JoinPaths,
+    joinPaths?: JoinPaths
   ) {
     super(db, tableOrViewInfo, dboBuilder, tx, joinPaths);
 
@@ -76,20 +76,14 @@ export class TableHandler extends ViewHandler {
     param2?: InsertParams,
     param3_unused?: undefined,
     tableRules?: TableRule,
-    _localParams?: LocalParams,
+    _localParams?: LocalParams
   ): Promise<any | any[] | boolean> {
-    return insert.bind(this)(
-      rowOrRows,
-      param2,
-      param3_unused,
-      tableRules,
-      _localParams,
-    );
+    return insert.bind(this)(rowOrRows, param2, param3_unused, tableRules, _localParams);
   }
 
   prepareReturning = async (
     returning: Select | undefined,
-    allowedFields: string[],
+    allowedFields: string[]
   ): Promise<SelectItem[]> => {
     const result: SelectItem[] = [];
     if (returning) {
@@ -98,9 +92,7 @@ export class TableHandler extends ViewHandler {
         allowedFields,
         allowedOrderByFields: allowedFields,
         computedFields: COMPUTED_FIELDS,
-        functions: FUNCTIONS.filter(
-          (f) => f.type === "function" && f.singleColArg,
-        ),
+        functions: FUNCTIONS.filter((f) => f.type === "function" && f.singleColArg),
         isView: this.is_view,
         columns: this.columns,
       });
@@ -122,15 +114,9 @@ export class TableHandler extends ViewHandler {
     params?: DeleteParams,
     param3_unused?: undefined,
     table_rules?: TableRule,
-    localParams?: LocalParams,
+    localParams?: LocalParams
   ): Promise<any> {
-    return _delete.bind(this)(
-      filter,
-      params,
-      param3_unused,
-      table_rules,
-      localParams,
-    );
+    return _delete.bind(this)(filter, params, param3_unused, table_rules, localParams);
   }
 
   remove(
@@ -138,7 +124,7 @@ export class TableHandler extends ViewHandler {
     params?: UpdateParams,
     param3_unused?: undefined,
     tableRules?: TableRule,
-    localParams?: LocalParams,
+    localParams?: LocalParams
   ) {
     return this.delete(filter, params, param3_unused, tableRules, localParams);
   }
@@ -151,7 +137,7 @@ export class TableHandler extends ViewHandler {
     params: { select?: FieldFilter },
     param3_unused: undefined,
     table_rules: TableRule,
-    localParams: LocalParams,
+    localParams: LocalParams
   ) {
     const start = Date.now();
     try {
@@ -159,50 +145,38 @@ export class TableHandler extends ViewHandler {
         throw "Cannot subscribe. PubSubManager not initiated";
       }
 
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!localParams) throw "Sync not allowed within the server code";
       const { socket } = localParams;
       if (!socket) throw "socket missing";
 
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!table_rules || !table_rules.sync || !table_rules.select)
         throw "sync or select table rules missing";
 
       if (this.tx) throw "Sync not allowed within transactions";
 
       const ALLOWED_PARAMS = ["select"];
-      const invalidParams = Object.keys(params || {}).filter(
-        (k) => !ALLOWED_PARAMS.includes(k),
-      );
+      const invalidParams = Object.keys(params).filter((k) => !ALLOWED_PARAMS.includes(k));
       if (invalidParams.length)
-        throw (
-          "Invalid or dissallowed params found: " + invalidParams.join(", ")
-        );
+        throw "Invalid or dissallowed params found: " + invalidParams.join(", ");
 
       const { synced_field, allow_delete }: SyncRule = table_rules.sync;
 
       if (!table_rules.sync.id_fields.length || !synced_field) {
-        const err =
-          "INTERNAL ERROR: id_fields OR synced_field missing from publish";
+        const err = "INTERNAL ERROR: id_fields OR synced_field missing from publish";
         console.error(err);
         throw err;
       }
 
-      const id_fields = this.parseFieldFilter(
-        table_rules.sync.id_fields,
-        false,
-      );
+      const id_fields = this.parseFieldFilter(table_rules.sync.id_fields, false);
       const syncFields = [...id_fields, synced_field];
 
-      const allowedSelect = this.parseFieldFilter(
-        table_rules?.select.fields ?? false,
-      );
+      const allowedSelect = this.parseFieldFilter(table_rules.select.fields);
       if (syncFields.find((f) => !allowedSelect.includes(f))) {
         throw `INTERNAL ERROR: sync field missing from publish.${this.name}.select.fields`;
       }
-      const select = this.getAllowedSelectFields(
-        params?.select ?? "*",
-        allowedSelect,
-        false,
-      );
+      const select = this.getAllowedSelectFields(params.select ?? "*", allowedSelect, false);
       if (!select.length) throw "Empty select not allowed";
 
       /* Add sync fields if missing */
@@ -216,9 +190,9 @@ export class TableHandler extends ViewHandler {
         { select, limit: 0 },
         undefined,
         table_rules,
-        localParams,
+        localParams
       ).then(async (_isValid) => {
-        const { filterFields, forcedFilter } = table_rules?.select || {};
+        const { filterFields, forcedFilter } = table_rules.select || {};
         const condition = (
           await this.prepareWhere({
             select: undefined,