prostgles-server 4.2.183 → 4.2.185

package/lib/onSocketConnected.ts

@@ -8,16 +8,16 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
   if (this.destroyed) {
     console.log("Socket connected to destroyed instance");
     socket.disconnect();
-    return
+    return;
   }
   this.connectedSockets.push(socket);
 
   try {
     await this.opts.onLog?.({
-      type: "connect", 
+      type: "connect",
       sid: this.authHandler?.getSID({ socket }),
       socketId: socket.id,
-      connectedSocketIds: this.connectedSockets.map(s => s.id)
+      connectedSocketIds: this.connectedSockets.map((s) => s.id),
     });
 
     if (!this.db || !this.dbo) throw new Error("db/dbo missing");
@@ -25,78 +25,113 @@ export async function onSocketConnected(this: Prostgles, socket: PRGLIOSocket) {
 
     if (this.opts.onSocketConnect) {
       try {
-        const getUser = async () => { return await this.authHandler?.getClientInfo({ socket }); }
-        await this.opts.onSocketConnect({ socket, dbo: dbo as any, db, getUser });
-      } catch(error) {
-        const connectionError = error instanceof Error? error.message : typeof error === "string"? error : JSON.stringify(error);
+        const getUser = async () => {
+          return await this.authHandler?.getClientInfo({ socket });
+        };
+        await this.opts.onSocketConnect({
+          socket,
+          dbo: dbo as any,
+          db,
+          getUser,
+        });
+      } catch (error) {
+        const connectionError =
+          error instanceof Error
+            ? error.message
+            : typeof error === "string"
+              ? error
+              : JSON.stringify(error);
         socket.emit(CHANNELS.CONNECTION, { connectionError });
         socket.disconnect();
         return;
       }
     }
 
-    socket.removeAllListeners(CHANNELS.DEFAULT)
-    socket.on(CHANNELS.DEFAULT, async (args: SocketRequestParams, cb = (..._callback: any[]) => { /* Empty */}) => {
-      runClientRequest.bind(this)({  ...args, type: "socket", socket })
-        .then(res => {
-          cb(null, res)
-        }).catch(err => {
-          cb(err);
-        });
-    });
+    socket.removeAllListeners(CHANNELS.DEFAULT);
+    socket.on(
+      CHANNELS.DEFAULT,
+      async (
+        args: SocketRequestParams,
+        cb = (..._callback: any[]) => {
+          /* Empty */
+        },
+      ) => {
+        runClientRequest
+          .bind(this)({ ...args, type: "socket", socket })
+          .then((res) => {
+            cb(null, res);
+          })
+          .catch((err) => {
+            cb(err);
+          });
+      },
+    );
 
     socket.on("disconnect", () => {
-
       this.dbEventsManager?.removeNotice(socket);
       this.dbEventsManager?.removeNotify(undefined, socket);
-      this.connectedSockets = this.connectedSockets.filter(s => s.id !== socket.id);
+      this.connectedSockets = this.connectedSockets.filter(
+        (s) => s.id !== socket.id,
+      );
       this.dboBuilder.queryStreamer.onDisconnect(socket.id);
-      this.opts.onLog?.({ 
-        type: "disconnect", 
+      this.opts.onLog?.({
+        type: "disconnect",
         sid: this.authHandler?.getSID({ socket }),
         socketId: socket.id,
-        connectedSocketIds: this.connectedSockets.map(s => s.id)
+        connectedSocketIds: this.connectedSockets.map((s) => s.id),
       });
 
       if (this.opts.onSocketDisconnect) {
-        const getUser = async () => { return await this.authHandler?.getClientInfo({ socket }); }
+        const getUser = async () => {
+          return await this.authHandler?.getClientInfo({ socket });
+        };
         this.opts.onSocketDisconnect({ socket, dbo: dbo as any, db, getUser });
       }
     });
 
-    socket.removeAllListeners(CHANNELS.METHOD)
-    socket.on(CHANNELS.METHOD, async ({ method, params }: SocketMethodRequest, cb = (..._callback: any) => { /* Empty */ }) => {
-      runClientMethod.bind(this)({
-        type: "socket",
-        socket,
-        method,
-        params
-      }).then(res => {
-        cb(null, res)
-      }).catch(err => {
-        makeSocketError(cb, err)
-      });
-    });
+    socket.removeAllListeners(CHANNELS.METHOD);
+    socket.on(
+      CHANNELS.METHOD,
+      async (
+        { method, params }: SocketMethodRequest,
+        cb = (..._callback: any) => {
+          /* Empty */
+        },
+      ) => {
+        runClientMethod
+          .bind(this)({
+            type: "socket",
+            socket,
+            method,
+            params,
+          })
+          .then((res) => {
+            cb(null, res);
+          })
+          .catch((err) => {
+            makeSocketError(cb, err);
+          });
+      },
+    );
 
     this.pushSocketSchema(socket);
   } catch (e) {
-    console.trace("setSocketEvents: ", e)
+    console.trace("setSocketEvents: ", e);
   }
 }
 
-
 export function makeSocketError(cb: (err: AnyObject) => void, err: any) {
   cb(getErrorAsObject(err));
 }
 
 type SocketRequestParams = {
   tableName: string;
-  command: typeof TABLE_METHODS[number];
+  command: (typeof TABLE_METHODS)[number];
   param1: any;
   param2: any;
   param3: any;
-}
+};
 type SocketMethodRequest = {
   method: string;
   params: any;
-}
+};

package/lib/runClientRequest.ts

@@ -1,6 +1,10 @@
-import { AnyObject, 
-  TableHandler, 
-  UserLike, getKeys, pickKeys } from "prostgles-types";
+import {
+  AnyObject,
+  TableHandler,
+  UserLike,
+  getKeys,
+  pickKeys,
+} from "prostgles-types";
 import { ExpressReq } from "./Auth/AuthTypes";
 import { LocalParams, PRGLIOSocket } from "./DboBuilder/DboBuilder";
 import { parseFieldFilter } from "./DboBuilder/ViewHandler/parseFieldFilter";
@@ -8,44 +12,55 @@ import { canRunSQL } from "./DboBuilder/runSQL";
 import { Prostgles } from "./Prostgles";
 import { TableHandler as TableHandlerServer } from "./DboBuilder/TableHandler/TableHandler";
 import { TableRule } from "./PublishParser/publishTypesAndUtils";
- 
-type ReqInfo = {
-  type: "socket";
-  socket: PRGLIOSocket;
-  httpReq?: undefined;
-} | {
-  type: "http";
-  httpReq: ExpressReq;
-  socket?: undefined;
-}
-type ReqInfoClient = {
-  socket: PRGLIOSocket;
-} | {
-  httpReq: ExpressReq;
-}
+
+type ReqInfo =
+  | {
+      type: "socket";
+      socket: PRGLIOSocket;
+      httpReq?: undefined;
+    }
+  | {
+      type: "http";
+      httpReq: ExpressReq;
+      socket?: undefined;
+    };
+type ReqInfoClient =
+  | {
+      socket: PRGLIOSocket;
+    }
+  | {
+      httpReq: ExpressReq;
+    };
 
 const TABLE_METHODS = {
-  find: 1, 
-  findOne: 1, 
-  count: 1, 
-  size: 1, 
+  find: 1,
+  findOne: 1,
+  count: 1,
+  size: 1,
   update: 1,
-  updateBatch: 1, 
-  delete: 1, 
-  upsert: 1, 
-  insert: 1, 
-  subscribe: 1, 
-  subscribeOne: 1, 
-  getColumns: 1, 
+  updateBatch: 1,
+  delete: 1,
+  upsert: 1,
+  insert: 1,
+  subscribe: 1,
+  subscribeOne: 1,
+  getColumns: 1,
   getInfo: 1,
   sync: 1,
-} as const satisfies Record<(keyof (TableHandler & Pick<TableHandlerServer, "sync">)), 1>;
+} as const satisfies Record<
+  keyof (TableHandler & Pick<TableHandlerServer, "sync">),
+  1
+>;
 
 const TABLE_METHODS_KEYS = getKeys(TABLE_METHODS);
-const SOCKET_ONLY_COMMANDS = ["subscribe", "subscribeOne", "sync"] as const satisfies typeof TABLE_METHODS_KEYS;
+const SOCKET_ONLY_COMMANDS = [
+  "subscribe",
+  "subscribeOne",
+  "sync",
+] as const satisfies typeof TABLE_METHODS_KEYS;
 
 type Args = ReqInfo & {
-  tableName: string; 
+  tableName: string;
   command: string;
   param1: any;
   param2: any;
@@ -53,114 +68,168 @@ type Args = ReqInfo & {
 };
 
 const getReqInfoClient = (reqInfo: ReqInfo): ReqInfoClient => {
-  if(reqInfo.type === "socket"){
+  if (reqInfo.type === "socket") {
     return { socket: reqInfo.socket };
   }
   return { httpReq: reqInfo.httpReq };
-}
+};
 
-type TableMethodFunctionWithRulesAndLocalParams = ((arg1: any, arg2: any, arg3: any, tableRule: TableRule, localParams: LocalParams) => any);
+type TableMethodFunctionWithRulesAndLocalParams = (
+  arg1: any,
+  arg2: any,
+  arg3: any,
+  tableRule: TableRule,
+  localParams: LocalParams,
+) => any;
 
-export const runClientRequest = async function(this: Prostgles, args: Args){
+export const runClientRequest = async function (this: Prostgles, args: Args) {
   /* Channel name will only include client-sent params so we ignore table_rules enforced params */
-  if ((args.type === "socket" && !args.socket) || (args.type === "http" && !args.httpReq) || !this.authHandler || !this.publishParser || !this.dbo) {
+  if (
+    (args.type === "socket" && !args.socket) ||
+    (args.type === "http" && !args.httpReq) ||
+    !this.authHandler ||
+    !this.publishParser ||
+    !this.dbo
+  ) {
     throw "socket/httpReq or authhandler missing";
   }
 
-  const { tableName, command: nonValidatedCommand, param1, param2, param3 } = args;
-  if(!TABLE_METHODS_KEYS.some(v => v === nonValidatedCommand)){
-    throw `Invalid command: ${nonValidatedCommand}. Expecting one of: ${TABLE_METHODS_KEYS};`
+  const {
+    tableName,
+    command: nonValidatedCommand,
+    param1,
+    param2,
+    param3,
+  } = args;
+  if (!TABLE_METHODS_KEYS.some((v) => v === nonValidatedCommand)) {
+    throw `Invalid command: ${nonValidatedCommand}. Expecting one of: ${TABLE_METHODS_KEYS};`;
   }
   const command = nonValidatedCommand as keyof TableHandler;
-  if(args.type !== "socket" && SOCKET_ONLY_COMMANDS.some(v => v === command)){
-    throw "The following commands cannot be completed over a non-websocket connection: " + SOCKET_ONLY_COMMANDS;
+  if (
+    args.type !== "socket" &&
+    SOCKET_ONLY_COMMANDS.some((v) => v === command)
+  ) {
+    throw (
+      "The following commands cannot be completed over a non-websocket connection: " +
+      SOCKET_ONLY_COMMANDS
+    );
   }
 
   const reqInfo = getReqInfoClient(args);
   const clientInfo = await this.authHandler.getClientInfo(args);
-  const validRules = await this.publishParser.getValidatedRequestRule({ tableName, command, localParams: reqInfo }, clientInfo);
+  const validRules = await this.publishParser.getValidatedRequestRule(
+    { tableName, command, localParams: reqInfo },
+    clientInfo,
+  );
   if (!validRules) {
     throw `Invalid OR disallowed request: ${tableName}.${command} `;
   }
 
-  const sessionUser: UserLike | undefined = !clientInfo?.user? undefined : {
-    ...parseFieldFilter(clientInfo.sessionFields ?? [] as any, false, Object.keys(clientInfo.user)),
-    ...pickKeys(clientInfo.user, ["id", "type"]) as UserLike,
-  }
-  const localParams: LocalParams = { ...reqInfo, isRemoteRequest: { user: sessionUser } }
-  if(param3 && (param3 as LocalParams).returnQuery){
+  const sessionUser: UserLike | undefined = !clientInfo?.user
+    ? undefined
+    : {
+        ...parseFieldFilter(
+          clientInfo.sessionFields ?? ([] as any),
+          false,
+          Object.keys(clientInfo.user),
+        ),
+        ...(pickKeys(clientInfo.user, ["id", "type"]) as UserLike),
+      };
+  const localParams: LocalParams = {
+    ...reqInfo,
+    isRemoteRequest: { user: sessionUser },
+  };
+  if (param3 && (param3 as LocalParams).returnQuery) {
     const isAllowed = await canRunSQL(this, localParams);
-    if(isAllowed){
+    if (isAllowed) {
       localParams.returnQuery = (param3 as LocalParams).returnQuery;
     } else {
       throw "Must be allowed to run sql to use returnQuery";
     }
   }
   const tableHandler = this.dbo[tableName];
-  if(!tableHandler || !tableHandler.column_names) throw `Invalid tableName ${tableName} provided`;
+  if (!tableHandler || !tableHandler.column_names)
+    throw `Invalid tableName ${tableName} provided`;
 
   /**
    * satisfies check is used to ensure rules arguments are correctly passed to each method
    */
-  const tableCommand = tableHandler[command]?.bind(tableHandler) satisfies undefined | TableMethodFunctionWithRulesAndLocalParams;
-  if(!tableCommand) throw `Invalid or disallowed command provided: ${command}`;
-  return (this.dbo[tableName]![command] as TableMethodFunctionWithRulesAndLocalParams)(param1, param2, param3, validRules, localParams);
+  const tableCommand = tableHandler[command]?.bind(tableHandler) satisfies
+    | undefined
+    | TableMethodFunctionWithRulesAndLocalParams;
+  if (!tableCommand) throw `Invalid or disallowed command provided: ${command}`;
+  return (
+    this.dbo[tableName]![command] as TableMethodFunctionWithRulesAndLocalParams
+  )(param1, param2, param3, validRules, localParams);
   // This approach is breaking context
   // const result = await (tableCommand as TableMethodFunctionWithRulesAndLocalParams)(param1, param2, param3, validRules, localParams);
   // return result;
-}
+};
 
-export const clientCanRunSqlRequest = async function(this: Prostgles, args: ReqInfo){
+export const clientCanRunSqlRequest = async function (
+  this: Prostgles,
+  args: ReqInfo,
+) {
   const reqInfo = getReqInfoClient(args);
-  if(!this.opts.publishRawSQL || typeof this.opts.publishRawSQL !== "function"){
-    return { allowed: false, reqInfo }
-  } 
+  if (
+    !this.opts.publishRawSQL ||
+    typeof this.opts.publishRawSQL !== "function"
+  ) {
+    return { allowed: false, reqInfo };
+  }
   const canRunSQL = async () => {
-    if(!this.authHandler){
+    if (!this.authHandler) {
       throw "authHandler missing";
-    } 
+    }
     const publishParams = await this.publishParser?.getPublishParams(reqInfo);
     const res = await this.opts.publishRawSQL?.(publishParams as any);
-    return Boolean(res && typeof res === "boolean" || res === "*");
-  }
+    return Boolean((res && typeof res === "boolean") || res === "*");
+  };
 
   const allowed = await canRunSQL();
   return { allowed, reqInfo };
-}
+};
 
 type ArgsSql = ReqInfo & {
   query: string;
   args?: AnyObject | any[];
   options?: any;
-}
-export const runClientSqlRequest = async function(this: Prostgles, params: ArgsSql){
+};
+export const runClientSqlRequest = async function (
+  this: Prostgles,
+  params: ArgsSql,
+) {
   const { allowed, reqInfo } = await clientCanRunSqlRequest.bind(this)(params);
-  if(!allowed){
+  if (!allowed) {
     throw "Not allowed to execute sql";
   }
   if (!this.dbo?.sql) throw "Internal error: sql handler missing";
   const { query, args, options } = params;
   return this.dbo.sql(query, args, options, reqInfo);
-}
-
-
+};
 
 type ArgsMethod = ReqInfo & {
   method: string;
-  params?: any[]
-}
-export const runClientMethod = async function(this: Prostgles, reqArgs: ArgsMethod){
-
+  params?: any[];
+};
+export const runClientMethod = async function (
+  this: Prostgles,
+  reqArgs: ArgsMethod,
+) {
   const reqInfo = getReqInfoClient(reqArgs);
   const { method, params = [] } = reqArgs;
   const methods = await this.publishParser?.getAllowedMethods(reqInfo);
 
   if (!methods || !methods[method]) {
-    throw ("Disallowed/missing method " + JSON.stringify(method));
-  } 
+    throw "Disallowed/missing method " + JSON.stringify(method);
+  }
 
   const methodDef = methods[method]!;
-  const onRun = (typeof methodDef === "function" || typeof (methodDef as any).then === "function")? (methodDef as (...args: any) => Promise<void>) : methodDef.run;
+  const onRun =
+    typeof methodDef === "function" ||
+    typeof (methodDef as any).then === "function"
+      ? (methodDef as (...args: any) => Promise<void>)
+      : methodDef.run;
   const res = await onRun(...params);
-  return res;  
-}
+  return res;
+};

package/lib/shortestPath.ts

@@ -1,85 +1,89 @@
 import { AnyObject } from "prostgles-types";
 
 const shortestDistanceNode = (distances: AnyObject, visited: AnyObject) => {
-	let shortest = null;
-
-	for (const node in distances) {
-		const currentIsShortest =
-			shortest === null || distances[node] < distances[shortest];
-		if (currentIsShortest && !visited.includes(node)) {
-			shortest = node;
-		}
-	}
-	return shortest;
+  let shortest = null;
+
+  for (const node in distances) {
+    const currentIsShortest =
+      shortest === null || distances[node] < distances[shortest];
+    if (currentIsShortest && !visited.includes(node)) {
+      shortest = node;
+    }
+  }
+  return shortest;
 };
 export type Graph = {
-	[key: string]: { [key: string]: number }
+  [key: string]: { [key: string]: number };
 };
 
-export const findShortestPath = (graph: Graph, startNode: string, endNode: string): { distance: number, path: string[] } => {
-	// establish object for recording distances from the start node
-	let distances: AnyObject = {};
-	distances[endNode] = "Infinity";
-	distances = Object.assign(distances, graph[startNode]);
-
-	// track paths
-	const parents: AnyObject = { endNode: null };
-	for (const child in graph[startNode]) {
-		parents[child] = startNode;
-	}
-
-	// track nodes that have already been visited
-	const visited: AnyObject = [];
-
-	// find the nearest node
-	let node = shortestDistanceNode(distances, visited);
-
-	// for that node
-	while (node) {
-		// find its distance from the start node & its child nodes
-		const distance = distances[node];
-		const children = graph[node];
-		// for each of those child nodes
-		for (const child in children) {
-			// make sure each child node is not the start node
-			if (String(child) === String(startNode)) {
-				continue;
-			} else {
-				// save the distance from the start node to the child node
-				const newdistance = distance + children[child];
-				// if there's no recorded distance from the start node to the child node in the distances object
-				// or if the recorded distance is shorter than the previously stored distance from the start node to the child node
-				// save the distance to the object
-				// record the path
-				if (!distances[child] || distances[child] > newdistance) {
-					distances[child] = newdistance;
-					parents[child] = node;
-				}
-			}
-		}
-		// move the node to the visited set
-		visited.push(node);
-		// move to the nearest neighbor node
-		node = shortestDistanceNode(distances, visited);
-	}
-
-	// using the stored paths from start node to end node
-	// record the shortest path
-	const shortestPath = [endNode];
-	let parent = parents[endNode];
-	while (parent) {
-		shortestPath.push(parent);
-		parent = parents[parent];
-	}
-	shortestPath.reverse();
-
-	// return the shortest path from start node to end node & its distance
-	const results = {
-		distance: distances[endNode],
-		path: shortestPath,
-	};
-
-	return results;
+export const findShortestPath = (
+  graph: Graph,
+  startNode: string,
+  endNode: string,
+): { distance: number; path: string[] } => {
+  // establish object for recording distances from the start node
+  let distances: AnyObject = {};
+  distances[endNode] = "Infinity";
+  distances = Object.assign(distances, graph[startNode]);
+
+  // track paths
+  const parents: AnyObject = { endNode: null };
+  for (const child in graph[startNode]) {
+    parents[child] = startNode;
+  }
+
+  // track nodes that have already been visited
+  const visited: AnyObject = [];
+
+  // find the nearest node
+  let node = shortestDistanceNode(distances, visited);
+
+  // for that node
+  while (node) {
+    // find its distance from the start node & its child nodes
+    const distance = distances[node];
+    const children = graph[node];
+    // for each of those child nodes
+    for (const child in children) {
+      // make sure each child node is not the start node
+      if (String(child) === String(startNode)) {
+        continue;
+      } else {
+        // save the distance from the start node to the child node
+        const newdistance = distance + children[child];
+        // if there's no recorded distance from the start node to the child node in the distances object
+        // or if the recorded distance is shorter than the previously stored distance from the start node to the child node
+        // save the distance to the object
+        // record the path
+        if (!distances[child] || distances[child] > newdistance) {
+          distances[child] = newdistance;
+          parents[child] = node;
+        }
+      }
+    }
+    // move the node to the visited set
+    visited.push(node);
+    // move to the nearest neighbor node
+    node = shortestDistanceNode(distances, visited);
+  }
+
+  // using the stored paths from start node to end node
+  // record the shortest path
+  const shortestPath = [endNode];
+  let parent = parents[endNode];
+  while (parent) {
+    shortestPath.push(parent);
+    parent = parents[parent];
+  }
+  shortestPath.reverse();
+
+  // return the shortest path from start node to end node & its distance
+  const results = {
+    distance: distances[endNode],
+    path: shortestPath,
+  };
+
+  return results;
 };
 
 /* Usage: 
@@ -119,4 +123,4 @@ const graph = {
 findShortestPath(graph, 'start', 'end');
 
 
-*/
+*/

package/lib/typeTests/DBoGenerated.d.ts

@@ -266,7 +266,11 @@ export type DBGeneratedSchema = {
     columns: {
       email: string;
       id?: number;
-      preferences: { showIntro?: boolean; theme?: "light" | "dark" | "auto"; others: any[] };
+      preferences: {
+        showIntro?: boolean;
+        theme?: "light" | "dark" | "auto";
+        others: any[];
+      };
       status: "active" | "disabled" | "pending";
     };
   };