prostgles-server 4.2.192 → 4.2.194

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -16,25 +16,20 @@ import {
 
 export async function getTableRulesWithoutFileTable(
   this: PublishParser,
-  { tableName, localParams }: DboTable,
+  { tableName, clientReq }: DboTable,
   clientInfo?: AuthResult,
   overridenPublish?: PublishObject
 ): Promise<ParsedPublishTable | undefined> {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (!localParams || !tableName)
-    throw new Error("publish OR socket OR dbo OR tableName are missing");
+  if (!tableName) throw new Error("publish OR socket OR dbo OR tableName are missing");
 
-  const _publish = overridenPublish ?? (await this.getPublish(localParams, clientInfo));
+  const publish = overridenPublish ?? (clientReq && (await this.getPublish(clientReq, clientInfo)));
 
-  const raw_table_rules = _publish?.[tableName];
-  if (
-    !raw_table_rules ||
-    (isObject(raw_table_rules) && Object.values(raw_table_rules).every((v) => !v))
-  ) {
+  const rawTableRule = publish?.[tableName];
+  if (!rawTableRule || (isObject(rawTableRule) && Object.values(rawTableRule).every((v) => !v))) {
     return undefined;
   }
 
-  let parsed_table: ParsedPublishTable = {};
+  let parsedTableRule: ParsedPublishTable = {};
 
   /* Get view or table specific rules */
   const tHandler = this.dbo[tableName] as TableHandler | ViewHandler | undefined;
@@ -57,8 +52,8 @@ export async function getTableRulesWithoutFileTable(
 
     if (
       !pgUserIsAllowedThis &&
-      isObject(raw_table_rules) &&
-      (raw_table_rules as PublishTableRule)[r.sqlRule]
+      isObject(rawTableRule) &&
+      (rawTableRule as PublishTableRule)[r.sqlRule]
     ) {
       throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
     }
@@ -79,19 +74,16 @@ export async function getTableRulesWithoutFileTable(
   });
 
   /* All methods allowed. Add no limits for table rules */
-  if ([true, "*"].includes(raw_table_rules as any)) {
-    parsed_table = {};
+  if ([true, "*"].includes(rawTableRule as any)) {
+    parsedTableRule = {};
     MY_RULES.filter((r) => r.no_limits).forEach((r) => {
-      parsed_table[r.rule] = { ...(r.no_limits as object) } as any;
+      parsedTableRule[r.rule] = { ...(r.no_limits as object) } as any;
     });
 
     /** Specific rules allowed */
-  } else if (isObject(raw_table_rules) && getKeys(raw_table_rules).length) {
-    const allRuleKeys: (keyof PublishViewRule | keyof PublishTableRule)[] =
-      getKeys(raw_table_rules);
-    const dissallowedRuleKeys = allRuleKeys.filter(
-      (m) => !(raw_table_rules as PublishTableRule)[m]
-    );
+  } else if (isObject(rawTableRule) && getKeys(rawTableRule).length) {
+    const allRuleKeys: (keyof PublishViewRule | keyof PublishTableRule)[] = getKeys(rawTableRule);
+    const dissallowedRuleKeys = allRuleKeys.filter((m) => !(rawTableRule as PublishTableRule)[m]);
 
     MY_RULES.map((r) => {
       /** Unless specifically disabled these are allowed */
@@ -99,27 +91,24 @@ export async function getTableRulesWithoutFileTable(
         ["getInfo", "getColumns"].includes(r.rule) &&
         !dissallowedRuleKeys.includes(r.rule as any)
       ) {
-        parsed_table[r.rule] = r.no_limits as any;
+        parsedTableRule[r.rule] = r.no_limits as any;
         return;
       }
 
       /** Add no_limit values for implied/ fully allowed methods */
-      if (
-        [true, "*"].includes((raw_table_rules as PublishTableRule)[r.rule] as any) &&
-        r.no_limits
-      ) {
-        parsed_table[r.rule] = Object.assign({}, r.no_limits) as any;
+      if ([true, "*"].includes((rawTableRule as PublishTableRule)[r.rule] as any) && r.no_limits) {
+        parsedTableRule[r.rule] = Object.assign({}, r.no_limits) as any;
 
         /** Carry over detailed config */
-      } else if (isObject((raw_table_rules as any)[r.rule])) {
-        parsed_table[r.rule] = (raw_table_rules as any)[r.rule];
+      } else if (isObject((rawTableRule as any)[r.rule])) {
+        parsedTableRule[r.rule] = (rawTableRule as any)[r.rule];
       }
     });
 
     allRuleKeys
-      .filter((m) => parsed_table[m])
+      .filter((m) => parsedTableRule[m])
       .forEach((method) => {
-        const rule = parsed_table[method];
+        const rule = parsedTableRule[method];
 
         const ruleInfo = MY_RULES.find(
           (r) => r.rule === method || (r.methods as readonly string[]).includes(method)
@@ -150,15 +139,15 @@ export async function getTableRulesWithoutFileTable(
 
         /* Add default params (if missing) */
         if (method === "sync") {
-          if ([true, "*"].includes(parsed_table[method] as any)) {
+          if ([true, "*"].includes(parsedTableRule[method] as any)) {
             throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
           }
 
-          if (typeof parsed_table[method]?.throttle !== "number") {
-            parsed_table[method]!.throttle = 100;
+          if (typeof parsedTableRule[method]?.throttle !== "number") {
+            parsedTableRule[method]!.throttle = 100;
           }
-          if (typeof parsed_table[method]?.batch_size !== "number") {
-            parsed_table[method]!.batch_size = DEFAULT_SYNC_BATCH_SIZE;
+          if (typeof parsedTableRule[method]?.batch_size !== "number") {
+            parsedTableRule[method]!.batch_size = DEFAULT_SYNC_BATCH_SIZE;
           }
         }
 
@@ -168,8 +157,8 @@ export async function getTableRulesWithoutFileTable(
         if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
           const sr = MY_RULES.find((r) => r.rule === subKey);
           if (sr && canSubscribe) {
-            parsed_table[subKey] = { ...(sr.no_limits as SubscribeRule) };
-            parsed_table.subscribeOne = { ...(sr.no_limits as SubscribeRule) };
+            parsedTableRule[subKey] = { ...(sr.no_limits as SubscribeRule) };
+            parsedTableRule.subscribeOne = { ...(sr.no_limits as SubscribeRule) };
           }
         }
       });
@@ -203,7 +192,7 @@ export async function getTableRulesWithoutFileTable(
     return res;
   };
 
-  parsed_table = getImpliedMethods(parsed_table);
+  parsedTableRule = getImpliedMethods(parsedTableRule);
 
-  return parsed_table;
+  return parsedTableRule;
 }

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -1,12 +1,6 @@
 import { AnyObject, DBSchema, FullFilter, Method, RULE_METHODS } from "prostgles-types";
 import type { DBOFullyTyped, PublishFullyTyped } from "../DBSchemaBuilder";
-import {
-  CommonTableRules,
-  Filter,
-  LocalParams,
-  PRGLIOSocket,
-  TableOrViewInfo,
-} from "../DboBuilder/DboBuilder";
+import { CommonTableRules, Filter, LocalParams, TableOrViewInfo } from "../DboBuilder/DboBuilder";
 import { DB, DBHandlerServer } from "../Prostgles";
 
 export type PublishMethods<S = void, SUser extends SessionUser = SessionUser> = (
@@ -15,20 +9,13 @@ export type PublishMethods<S = void, SUser extends SessionUser = SessionUser> =
 
 export type Awaitable<T> = T | Promise<T>;
 
-type Request = {
-  socket?: any;
-  httpReq?: any;
-};
-
-export type DboTable = Request & {
+export type DboTable = {
   tableName: string;
-  localParams: LocalParams;
+  clientReq: AuthClientRequest | undefined;
+};
+export type DboTableCommand = DboTable & {
+  command: string;
 };
-export type DboTableCommand = Request &
-  DboTable & {
-    command: string;
-    localParams: LocalParams;
-  };
 
 export const RULE_TO_METHODS = [
   {
@@ -147,8 +134,8 @@ export const RULE_TO_METHODS = [
 ] as const;
 
 import { FieldFilter, SelectParams } from "prostgles-types";
+import { AuthClientRequest, SessionUser } from "../Auth/AuthTypes";
 import { TableSchemaColumn } from "../DboBuilder/DboBuilderTypes";
-import { SessionUser } from "../Auth/AuthTypes";
 
 export type InsertRequestData = {
   data: object | object[];
@@ -449,7 +436,7 @@ export type PublishParams<S = void, SUser extends SessionUser = SessionUser> = {
   dbo: DBOFullyTyped<S>;
   db: DB;
   user?: SUser["user"];
-  socket: PRGLIOSocket;
+  clientReq: AuthClientRequest;
   tables: DbTableInfo[];
 };
 export type RequestParams = { dbo?: DBHandlerServer; socket?: any };

package/lib/RestApi.ts

@@ -58,14 +58,14 @@ export class RestApi {
       schema: `${routePrefix}/schema`,
     };
     this.expressApp = expressApp;
-    expressApp.post(this.routes.db, jsonParser, this.onPost);
+    expressApp.post(this.routes.db, jsonParser, this.onPostTableCommand);
     expressApp.post(this.routes.sql, jsonParser, this.onPostSql);
     expressApp.post(this.routes.methods, jsonParser, this.onPostMethod);
     expressApp.post(this.routes.schema, jsonParser, this.onPostSchema);
   }
 
   destroy = () => {
-    this.expressApp.removeListener(this.routes.db, this.onPost);
+    this.expressApp.removeListener(this.routes.db, this.onPostTableCommand);
     this.expressApp.removeListener(this.routes.sql, this.onPostSql);
     this.expressApp.removeListener(this.routes.methods, this.onPostMethod);
   };
@@ -74,54 +74,62 @@ export class RestApi {
     const params = req.body || [];
 
     try {
-      const data = await runClientMethod.bind(this.prostgles)({
-        type: "http",
-        httpReq: req,
-        method,
-        params,
-      });
+      const data = await runClientMethod.bind(this.prostgles)(
+        {
+          method,
+          params,
+        },
+        {
+          res,
+          httpReq: req,
+        }
+      );
       res.json(data);
     } catch (rawError) {
       const error = getSerializedClientErrorFromPGError(rawError, {
         type: "method",
-        localParams: { httpReq: req },
+        localParams: { clientReq: { httpReq: req, res } },
       });
       res.status(400).json({ error });
     }
   };
   onPostSchema = async (req: ExpressReq, res: ExpressRes) => {
     try {
-      const data = await this.prostgles.getClientSchema({ httpReq: req });
+      const data = await this.prostgles.getClientSchema({ httpReq: req, res });
       res.json(data);
     } catch (rawError) {
       const error = getSerializedClientErrorFromPGError(rawError, {
         type: "method",
-        localParams: { httpReq: req },
+        localParams: { clientReq: { httpReq: req, res } },
       });
       res.status(400).json({ error });
     }
   };
   onPostSql = async (req: ExpressReq, res: ExpressRes) => {
-    const [query, args, options] = req.body || [];
+    const [query, params, options] = req.body || [];
     try {
-      const data = await runClientSqlRequest.bind(this.prostgles)({
-        type: "http",
-        httpReq: req,
-        query,
-        args,
-        options,
-      });
+      const data = await runClientSqlRequest.bind(this.prostgles)(
+        {
+          query,
+          params,
+          options,
+        },
+        {
+          res,
+          httpReq: req,
+        }
+      );
       res.json(data);
     } catch (rawError) {
       const error = getSerializedClientErrorFromPGError(rawError, {
         type: "sql",
-        localParams: { httpReq: req },
+        localParams: { clientReq: { httpReq: req, res } },
       });
       res.status(400).json({ error });
     }
   };
 
-  onPost = async (req: ExpressReq, res: ExpressRes) => {
+  onPostTableCommand = async (req: ExpressReq, res: ExpressRes) => {
     const { params } = req;
     const { tableName, command } = params;
     if (!tableName || typeof tableName !== "string") {
@@ -135,20 +143,24 @@ export class RestApi {
 
     try {
       const [param1, param2, param3] = req.body || [];
-      const data = await runClientRequest.bind(this.prostgles)({
-        type: "http",
-        httpReq: req,
-        tableName,
-        command,
-        param1,
-        param2,
-        param3,
-      });
+      const data = await runClientRequest.bind(this.prostgles)(
+        {
+          tableName,
+          command,
+          param1,
+          param2,
+          param3,
+        },
+        {
+          httpReq: req,
+          res,
+        }
+      );
       res.json(data);
     } catch (rawError) {
       const error = getSerializedClientErrorFromPGError(rawError, {
         type: "tableMethod",
-        localParams: { httpReq: req },
+        localParams: { clientReq: { httpReq: req, res } },
         view: this.prostgles.dboBuilder.dbo[tableName],
       });
       res.status(400).json({ error });

package/lib/initProstgles.ts

@@ -70,14 +70,12 @@ export type InitResult = {
   options: ProstglesInitOptions;
 };
 
-const clientOnlyUpdateKeys = [
-  "auth",
-] as const satisfies (keyof UpdateableOptions)[];
+const clientOnlyUpdateKeys = ["auth"] as const satisfies (keyof UpdateableOptions)[];
 
 export const initProstgles = async function (
   this: Prostgles,
   onReady: OnReadyCallbackBasic,
-  reason: OnInitReason,
+  reason: OnInitReason
 ): Promise<InitResult> {
   this.loaded = false;
 
@@ -96,16 +94,14 @@ export const initProstgles = async function (
       try {
         const url = new URL(connString);
         existingAppName =
-          url.searchParams.get("application_name") ??
-          url.searchParams.get("ApplicationName") ??
-          "";
+          url.searchParams.get("application_name") ?? url.searchParams.get("ApplicationName") ?? "";
       } catch (e) {}
     }
 
     const conObj =
-      typeof this.opts.dbConnection === "string"
-        ? { connectionString: this.opts.dbConnection }
-        : this.opts.dbConnection;
+      typeof this.opts.dbConnection === "string" ?
+        { connectionString: this.opts.dbConnection }
+      : this.opts.dbConnection;
     const application_name = `prostgles ${this.appId} ${existingAppName}`;
 
     /* 1. Connect to db */
@@ -149,14 +145,7 @@ export const initProstgles = async function (
       /* 3.9 Check auth config */
       await this.initAuthHandler();
 
-      this.publishParser = new PublishParser(
-        this.opts.publish,
-        this.opts.publishMethods as any,
-        this.opts.publishRawSQL,
-        this.dbo!,
-        this.db,
-        this as any,
-      );
+      this.publishParser = new PublishParser(this);
       this.dboBuilder.publishParser = this.publishParser;
 
       /* 4. Set publish and auth listeners */
@@ -221,9 +210,7 @@ export const initProstgles = async function (
          * While others also affect the server and onReady should be called
          */
         if (
-          getKeys(newOpts).every((updatedKey) =>
-            clientOnlyUpdateKeys.includes(updatedKey as any),
-          )
+          getKeys(newOpts).every((updatedKey) => clientOnlyUpdateKeys.includes(updatedKey as any))
         ) {
           await this.setSocketEvents();
         } else {
@@ -279,52 +266,52 @@ const getDbConnection = function ({
   const onQueryOrError:
     | undefined
     | ((error: any, ctx: pgPromise.IEventContext<pg.IClient>) => void) =
-    !onQuery && !DEBUG_MODE
-      ? undefined
-      : (error, ctx) => {
-          if (onQuery) {
-            onQuery(error, ctx);
-          } else if (DEBUG_MODE) {
-            if (error) {
-              console.error(error, ctx);
-            } else {
-              console.log(ctx);
-            }
+    !onQuery && !DEBUG_MODE ?
+      undefined
+    : (error, ctx) => {
+        if (onQuery) {
+          onQuery(error, ctx);
+        } else if (DEBUG_MODE) {
+          if (error) {
+            console.error(error, ctx);
+          } else {
+            console.log(ctx);
           }
-        };
+        }
+      };
 
   const pgp: PGP = pgPromise({
-    ...(onQueryOrError
-      ? {
-          query: (ctx) => onQueryOrError(undefined, ctx),
-          error: onQueryOrError,
-        }
-      : {}),
-    ...(onNotice || DEBUG_MODE
-      ? {
-          connect: function ({ client, useCount }) {
-            const isFresh = !useCount;
-            if (isFresh && !client.listeners("notice").length) {
-              client.on("notice", function (msg) {
-                if (onNotice) {
-                  onNotice(msg, msg?.message);
-                } else {
-                  console.log("notice: %j", msg?.message);
-                }
-              });
-            }
-            if (isFresh && !client.listeners("error").length) {
-              client.on("error", function (msg) {
-                if (onNotice) {
-                  onNotice(msg, msg?.message);
-                } else {
-                  console.log("error: %j", msg?.message);
-                }
-              });
-            }
-          },
-        }
-      : {}),
+    ...(onQueryOrError ?
+      {
+        query: (ctx) => onQueryOrError(undefined, ctx),
+        error: onQueryOrError,
+      }
+    : {}),
+    ...(onNotice || DEBUG_MODE ?
+      {
+        connect: function ({ client, useCount }) {
+          const isFresh = !useCount;
+          if (isFresh && !client.listeners("notice").length) {
+            client.on("notice", function (msg) {
+              if (onNotice) {
+                onNotice(msg, msg?.message);
+              } else {
+                console.log("notice: %j", msg?.message);
+              }
+            });
+          }
+          if (isFresh && !client.listeners("error").length) {
+            client.on("error", function (msg) {
+              if (onNotice) {
+                onNotice(msg, msg?.message);
+              } else {
+                console.log("error: %j", msg?.message);
+              }
+            });
+          }
+        },
+      }
+    : {}),
   });
   // pgp.pg.defaults.max = 70;
 

package/lib/onSocketConnected.ts

@@ -26,7 +26,7 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
     if (this.opts.onSocketConnect) {
       try {
         const getUser = async () => {
-          return await this.authHandler?.getClientInfo({ socket });
+          return await this.authHandler?.getUserFromRequest({ socket });
         };
         await this.opts.onSocketConnect({
           socket,
@@ -55,7 +55,7 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
         }
       ) => {
         runClientRequest
-          .bind(this)({ ...args, type: "socket", socket })
+          .bind(this)(args, { socket })
           .then((res) => {
             cb(null, res);
           })
@@ -79,7 +79,7 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
 
       if (this.opts.onSocketDisconnect) {
         const getUser = async () => {
-          return await this.authHandler?.getClientInfo({ socket });
+          return await this.authHandler?.getUserFromRequest({ socket });
         };
         this.opts.onSocketDisconnect({ socket, dbo: dbo as any, db, getUser });
       }
@@ -95,12 +95,15 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
         }
       ) => {
         runClientMethod
-          .bind(this)({
-            type: "socket",
-            socket,
-            method,
-            params,
-          })
+          .bind(this)(
+            {
+              method,
+              params,
+            },
+            {
+              socket,
+            }
+          )
           .then((res) => {
             cb(null, res);
           })