prostgles-server 4.2.192 → 4.2.193

package/lib/ProstglesTypes.ts

@@ -1,11 +1,7 @@
 import { FileColumnConfig } from "prostgles-types";
 import { Auth, AuthRequestParams, SessionUser } from "./Auth/AuthTypes";
 import { EventTriggerTagFilter } from "./Event_Trigger_Tags";
-import {
-  CloudClient,
-  ImageOptions,
-  LocalConfig,
-} from "./FileManager/FileManager";
+import { CloudClient, ImageOptions, LocalConfig } from "./FileManager/FileManager";
 import { DbConnection, OnReadyCallback } from "./initProstgles";
 import { EventInfo } from "./Logging";
 import { ExpressApp, RestApiConfig } from "./RestApi";
@@ -20,11 +16,7 @@ import pg from "pg-promise/typescript/pg-subset";
 import { AnyObject } from "prostgles-types";
 import type { Server } from "socket.io";
 import { DB } from "./Prostgles";
-import {
-  Publish,
-  PublishMethods,
-  PublishParams,
-} from "./PublishParser/PublishParser";
+import { Awaitable, Publish, PublishMethods, PublishParams } from "./PublishParser/PublishParser";
 
 /**
  * Allows uploading and downloading files.
@@ -102,12 +94,7 @@ export type FileTableConfig = {
   localConfig?: LocalConfig;
 };
 
-export const JOIN_TYPES = [
-  "one-many",
-  "many-one",
-  "one-one",
-  "many-many",
-] as const;
+export const JOIN_TYPES = ["one-many", "many-one", "one-one", "many-many"] as const;
 export type Join = {
   tables: [string, string];
   on: { [key: string]: string }[]; // Allow multi references to table
@@ -115,10 +102,7 @@ export type Join = {
 };
 type Joins = Join[] | "inferred";
 
-export type ProstglesInitOptions<
-  S = void,
-  SUser extends SessionUser = SessionUser,
-> = {
+export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUser> = {
   /**
    * Database connection details and options
    */
@@ -187,9 +171,7 @@ export type ProstglesInitOptions<
   /**
    * If defined and resolves to true then the connected client can run SQL queries
    */
-  publishRawSQL?(
-    params: PublishParams<S, SUser>,
-  ): (boolean | "*") | Promise<boolean | "*">;
+  publishRawSQL?(params: PublishParams<S, SUser>): Awaitable<boolean | "*">;
 
   /**
    * Server-side functions that can be invoked by the client
@@ -236,14 +218,14 @@ export type ProstglesInitOptions<
    * Use for connection verification. Will disconnect socket on any errors
    */
   onSocketConnect?: (
-    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket },
+    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket }
   ) => void | Promise<void>;
 
   /**
    * Called when a socket disconnects
    */
   onSocketDisconnect?: (
-    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket },
+    args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket }
   ) => void | Promise<void>;
 
   /**
@@ -281,11 +263,7 @@ export type ProstglesInitOptions<
    * - `OnSchemaChangeCallback` - custom callback to be fired. Nothing else triggered
    * Useful for development
    */
-  watchSchema?:
-    | boolean
-    | EventTriggerTagFilter
-    | "hotReloadMode"
-    | OnSchemaChangeCallback;
+  watchSchema?: boolean | EventTriggerTagFilter | "hotReloadMode" | OnSchemaChangeCallback;
 
   /**
    * Called when a notice is received from the database
@@ -357,6 +335,6 @@ type OnMigrate = (args: {
   getConstraints: (
     table: string,
     column?: string,
-    types?: ColConstraint["type"][],
+    types?: ColConstraint["type"][]
   ) => Promise<ColConstraint[]>;
 }) => void;

package/lib/PubSubManager/PubSubManager.ts

@@ -295,7 +295,7 @@ export class PubSubManager {
 
       await this.db
         .tx((t) => t.any(query))
-        .catch((e) => {
+        .catch((e: any) => {
           console.error("prepareTriggers failed: ", e);
           throw e;
         });
@@ -545,10 +545,10 @@ export class PubSubManager {
       socketId: socket?.id,
       state: !addedTrigger.tbl ? "fail" : "ok",
       error: addedTrigger.error,
-      sid: this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket }),
+      sid: socket && this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket }),
       tableName: addedTrigger.tbl ?? params.table_name,
       connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
-      localParams: { socket },
+      localParams: socket && { clientReq: { socket } },
     });
 
     if (addedTrigger.error) throw addedTrigger.error;

package/lib/PubSubManager/addSync.ts

@@ -15,9 +15,7 @@ export async function addSync(
   this: PubSubManager,
   syncParams: AddSyncParams
 ): Promise<{ channelName: string }> {
-  const sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError({
-    socket: syncParams.socket,
-  });
+  const sid = this.dboBuilder.prostgles.authHandler?.getSIDNoError({ socket: syncParams.socket });
   const res = await tryCatchV2(async () => {
     const {
       socket = null,

package/lib/PublishParser/PublishParser.ts

@@ -1,7 +1,8 @@
 import { Method, getObjectEntries, isObject } from "prostgles-types";
-import { AuthResult, SessionUser } from "../Auth/AuthTypes";
-import { LocalParams } from "../DboBuilder/DboBuilder";
+import { AuthClientRequest, AuthResult, SessionUser } from "../Auth/AuthTypes";
+import { PublishFullyTyped } from "../DBSchemaBuilder";
 import { DB, DBHandlerServer, Prostgles } from "../Prostgles";
+import { ProstglesInitOptions } from "../ProstglesTypes";
 import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 import { getFileTableRules } from "./getFileTableRules";
 import { getSchemaFromPublish } from "./getSchemaFromPublish";
@@ -16,8 +17,6 @@ import {
   RULE_TO_METHODS,
   TableRule,
 } from "./publishTypesAndUtils";
-import { ProstglesInitOptions } from "../ProstglesTypes";
-import { PublishFullyTyped } from "../DBSchemaBuilder";
 
 export class PublishParser {
   publish: ProstglesInitOptions["publish"];
@@ -27,44 +26,37 @@ export class PublishParser {
   db: DB;
   prostgles: Prostgles;
 
-  constructor(
-    publish: any,
-    publishMethods: PublishMethods<void, SessionUser> | undefined,
-    publishRawSQL: any,
-    dbo: DBHandlerServer,
-    db: DB,
-    prostgles: Prostgles
-  ) {
-    this.publish = publish;
-    this.publishMethods = publishMethods;
-    this.publishRawSQL = publishRawSQL;
+  constructor(prostgles: Prostgles) {
+    this.prostgles = prostgles;
+    this.publish = prostgles.opts.publish;
+    this.publishMethods = prostgles.opts.publishMethods;
+    this.publishRawSQL = prostgles.opts.publishRawSQL;
+    const { dbo, db } = prostgles;
+    if (!dbo || !db) throw "INTERNAL ERROR: dbo and/or db missing";
     this.dbo = dbo;
     this.db = db;
-    this.prostgles = prostgles;
-
-    if (!this.publish) throw "INTERNAL ERROR: dbo and/or publish missing";
   }
 
   async getPublishParams(
-    localParams: LocalParams,
+    clientReq: AuthClientRequest,
     clientInfo?: AuthResult
   ): Promise<PublishParams> {
     return {
-      ...(clientInfo || (await this.prostgles.authHandler?.getClientInfo(localParams))),
+      ...(clientInfo || (await this.prostgles.authHandler?.getUserFromRequest(clientReq))),
       dbo: this.dbo as any,
       db: this.db,
-      socket: localParams.socket!,
+      clientReq,
       tables: this.prostgles.dboBuilder.tables,
     };
   }
 
   async getAllowedMethods(
-    reqInfo: Pick<LocalParams, "httpReq" | "socket">,
-    userData?: AuthResult
+    clientReq: AuthClientRequest,
+    userData: AuthResult | undefined
   ): Promise<{ [key: string]: Method }> {
     const methods: { [key: string]: Method } = {};
 
-    const publishParams = await this.getPublishParams(reqInfo, userData);
+    const publishParams = await this.getPublishParams(clientReq, userData);
     const _methods = await applyParamsIfFunc(this.publishMethods, publishParams);
 
     if (_methods && Object.keys(_methods).length) {
@@ -90,10 +82,10 @@ export class PublishParser {
    * Parses the first level of publish. (If false then nothing if * then all tables and views)
    */
   async getPublish(
-    localParams: LocalParams,
-    clientInfo?: AuthResult
+    clientReq: AuthClientRequest,
+    clientInfo: AuthResult
   ): Promise<PublishFullyTyped | undefined> {
-    const publishParams = await this.getPublishParams(localParams, clientInfo);
+    const publishParams = await this.getPublishParams(clientReq, clientInfo);
     const _publish = await applyParamsIfFunc(this.publish, publishParams);
 
     if (_publish === "*") {
@@ -106,32 +98,30 @@ export class PublishParser {
 
     return _publish || undefined;
   }
+
   async getValidatedRequestRuleWusr({
     tableName,
     command,
-    localParams,
+    clientReq,
   }: DboTableCommand): Promise<TableRule> {
-    const clientInfo = await this.prostgles.authHandler!.getClientInfo(localParams);
-    const rules = await this.getValidatedRequestRule(
-      { tableName, command, localParams },
-      clientInfo
-    );
+    const clientInfo = await this.prostgles.authHandler?.getUserFromRequest(clientReq);
+    const rules = await this.getValidatedRequestRule({ tableName, command, clientReq }, clientInfo);
     return rules;
   }
 
   async getValidatedRequestRule(
-    { tableName, command, localParams }: DboTableCommand,
-    clientInfo?: AuthResult
+    { tableName, command, clientReq }: DboTableCommand,
+    clientInfo: AuthResult | undefined
   ): Promise<TableRule> {
     if (!command || !tableName) throw "command OR tableName are missing";
 
-    const rtm = RULE_TO_METHODS.find((rtms) => (rtms.methods as any).includes(command));
+    const rtm = RULE_TO_METHODS.find((rtms) => rtms.methods.some((v) => v === command));
     if (!rtm) {
       throw "Invalid command: " + command;
     }
 
     /* Must be local request -> allow everything */
-    if (!localParams.socket && !localParams.httpReq) {
+    if (!clientReq) {
       return RULE_TO_METHODS.reduce(
         (a, v) => ({
           ...a,
@@ -145,19 +135,19 @@ export class PublishParser {
     if (!this.publish) throw "publish is missing";
 
     /* Get any publish errors for socket */
-    const errorInfo = localParams.socket?.prostgles?.tableSchemaErrors[tableName]?.[command];
+    const errorInfo = clientReq.socket?.prostgles?.tableSchemaErrors[tableName]?.[command];
 
     if (errorInfo) throw errorInfo.error;
 
-    const table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
-    if (!table_rule)
+    const tableRule = await this.getTableRules({ tableName, clientReq }, clientInfo);
+    if (!tableRule)
       throw {
         stack: ["getValidatedRequestRule()"],
         message: "Invalid or disallowed table: " + tableName,
       };
 
     if (command === "upsert") {
-      if (!table_rule.update || !table_rule.insert) {
+      if (!tableRule.update || !tableRule.insert) {
         throw {
           stack: ["getValidatedRequestRule()"],
           message: `Invalid or disallowed command: upsert`,
@@ -165,8 +155,8 @@ export class PublishParser {
       }
     }
 
-    if (table_rule[rtm.rule]) {
-      return table_rule;
+    if (tableRule[rtm.rule]) {
+      return tableRule;
     } else
       throw {
         stack: ["getValidatedRequestRule()"],
@@ -176,14 +166,14 @@ export class PublishParser {
 
   async getTableRules(
     args: DboTable,
-    clientInfo?: AuthResult
+    clientInfo: AuthResult | undefined
   ): Promise<ParsedPublishTable | undefined> {
     if (this.dbo[args.tableName]?.is_media) {
       const fileTablePublishRules = await this.getTableRulesWithoutFileTable(args, clientInfo);
       const { rules } = await getFileTableRules.bind(this)(
         args.tableName,
         fileTablePublishRules,
-        args.localParams,
+        args.clientReq,
         clientInfo
       );
       return rules;

package/lib/PublishParser/getFileTableRules.ts

@@ -1,6 +1,5 @@
 import { AnyObject, FullFilter, isDefined } from "prostgles-types";
-import { AuthResult } from "../Auth/AuthTypes";
-import { LocalParams } from "../DboBuilder/DboBuilder";
+import { AuthClientRequest, AuthResult } from "../Auth/AuthTypes";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import { PublishParser } from "./PublishParser";
 import { ParsedPublishTable, UpdateRule } from "./publishTypesAndUtils";
@@ -17,8 +16,8 @@ export async function getFileTableRules(
   this: PublishParser,
   fileTableName: string,
   fileTablePublishRules: ParsedPublishTable | undefined,
-  localParams: LocalParams,
-  clientInfo: AuthResult | undefined,
+  clientReq: AuthClientRequest | undefined,
+  clientInfo: AuthResult | undefined
 ) {
   const forcedDeleteFilters: FullFilter<AnyObject, void>[] = [];
   const forcedSelectFilters: FullFilter<AnyObject, void>[] = [];
@@ -28,7 +27,7 @@ export async function getFileTableRules(
     ?.filter((t) => !t.is_view && t.name !== fileTableName)
     .map((t) => {
       const refCols = t.columns.filter((c) =>
-        c.references?.some((r) => r.ftable === fileTableName),
+        c.references?.some((r) => r.ftable === fileTableName)
       );
       if (!refCols.length) return undefined;
       return {
@@ -39,65 +38,46 @@ export async function getFileTableRules(
     })
     .filter(isDefined);
   if (referencedColumns?.length) {
-    for await (const {
-      tableName,
-      fileColumns,
-      allColumns,
-    } of referencedColumns) {
-      const table_rules = await this.getTableRules(
-        { localParams, tableName },
-        clientInfo,
-      );
-      if (table_rules) {
+    for await (const { tableName, fileColumns, allColumns } of referencedColumns) {
+      const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo);
+      if (tableRules) {
         fileColumns.map((column) => {
           const path = [{ table: tableName, on: [{ id: column }] }];
-          if (table_rules.delete) {
+          if (tableRules.delete) {
             forcedDeleteFilters.push({
               $existsJoined: {
                 path,
-                filter: table_rules.delete.forcedFilter ?? {},
+                filter: tableRules.delete.forcedFilter ?? {},
               },
             });
           }
-          if (table_rules.select) {
-            const parsedFields = parseFieldFilter(
-              table_rules.select.fields,
-              false,
-              allColumns,
-            );
+          if (tableRules.select) {
+            const parsedFields = parseFieldFilter(tableRules.select.fields, false, allColumns);
             /** Must be allowed to view this column */
             if (parsedFields.includes(column as any)) {
               forcedSelectFilters.push({
                 $existsJoined: {
                   path,
-                  filter: table_rules.select.forcedFilter ?? {},
+                  filter: tableRules.select.forcedFilter ?? {},
                 },
               });
             }
           }
-          if (table_rules.insert) {
-            const parsedFields = parseFieldFilter(
-              table_rules.insert.fields,
-              false,
-              allColumns,
-            );
+          if (tableRules.insert) {
+            const parsedFields = parseFieldFilter(tableRules.insert.fields, false, allColumns);
             /** Must be allowed to view this column */
             if (parsedFields.includes(column as any)) {
               allowedNestedInserts.push({ table: tableName, column });
             }
           }
-          if (table_rules.update) {
-            const parsedFields = parseFieldFilter(
-              table_rules.update.fields,
-              false,
-              allColumns,
-            );
+          if (tableRules.update) {
+            const parsedFields = parseFieldFilter(tableRules.update.fields, false, allColumns);
             /** Must be allowed to view this column */
             if (parsedFields.includes(column as any)) {
               forcedUpdateFilters.push({
                 $existsJoined: {
                   path,
-                  filter: table_rules.update.forcedFilter ?? {},
+                  filter: tableRules.update.forcedFilter ?? {},
                 },
               });
             }
@@ -113,15 +93,13 @@ export async function getFileTableRules(
 
   const getForcedFilter = (
     rule: Pick<UpdateRule, "forcedFilter"> | undefined,
-    forcedFilters: FullFilter<AnyObject, void>[],
+    forcedFilters: FullFilter<AnyObject, void>[]
   ) => {
-    return rule && !rule.forcedFilter
-      ? {}
+    return rule && !rule.forcedFilter ?
+        {}
       : {
           forcedFilter: {
-            $or: forcedFilters.concat(
-              rule?.forcedFilter ? [rule.forcedFilter] : [],
-            ),
+            $or: forcedFilters.concat(rule?.forcedFilter ? [rule.forcedFilter] : []),
           },
         };
   };
@@ -151,17 +129,15 @@ export async function getFileTableRules(
     fileTableRule.insert = {
       fields: "*",
       ...fileTablePublishRules?.insert,
-      allowedNestedInserts: fileTablePublishRules?.insert
-        ? undefined
-        : allowedNestedInserts,
+      allowedNestedInserts: fileTablePublishRules?.insert ? undefined : allowedNestedInserts,
     };
   }
 
   /** Add missing implied methods (getColumns, getInfo) */
   const rules = await this.getTableRulesWithoutFileTable.bind(this)(
-    { localParams, tableName: fileTableName },
+    { clientReq, tableName: fileTableName },
     clientInfo,
-    { [fileTableName]: fileTableRule },
+    { [fileTableName]: fileTableRule }
   );
   return { rules, allowedInserts: allowedNestedInserts };
 }

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -1,27 +1,18 @@
 import {
   DBSchemaTable,
+  getKeys,
   MethodKey,
+  pickKeys,
   TableInfo,
   TableSchemaErrors,
   TableSchemaForClient,
-  getKeys,
-  pickKeys,
 } from "prostgles-types";
-import { AuthResult, ExpressReq } from "../Auth/AuthTypes";
-import { getErrorAsObject, PRGLIOSocket } from "../DboBuilder/DboBuilder";
-import { PublishObject, PublishParser } from "./PublishParser";
+import { AuthClientRequest, AuthResult } from "../Auth/AuthTypes";
+import { getErrorAsObject } from "../DboBuilder/DboBuilder";
 import { TABLE_METHODS } from "../Prostgles";
+import { PublishObject, PublishParser } from "./PublishParser";
 
-type Args = (
-  | {
-      socket: PRGLIOSocket;
-      httpReq?: undefined;
-    }
-  | {
-      httpReq: ExpressReq;
-      socket?: undefined;
-    }
-) & {
+type Args = AuthClientRequest & {
   userData: AuthResult | undefined;
 };
 
@@ -39,7 +30,8 @@ export async function getSchemaFromPublish(
 
   try {
     /* Publish tables and views based on socket */
-    const clientInfo = userData ?? (await this.prostgles.authHandler?.getClientInfo(clientReq));
+    const clientInfo =
+      userData ?? (await this.prostgles.authHandler?.getUserFromRequest(clientReq));
 
     let _publish: PublishObject | undefined;
     try {
@@ -81,10 +73,7 @@ export async function getSchemaFromPublish(
             throw errMsg;
           }
 
-          const table_rules = await this.getTableRules(
-            { localParams: clientReq, tableName },
-            clientInfo
-          );
+          const table_rules = await this.getTableRules({ clientReq, tableName }, clientInfo);
 
           if (table_rules && Object.keys(table_rules).length) {
             schema[tableName] = {};
@@ -117,13 +106,13 @@ export async function getSchemaFromPublish(
                       : {};
 
                     /* Test for issues with the common table CRUD methods () */
-                    if (TABLE_METHODS.includes(method as any)) {
+                    if (TABLE_METHODS.some((tm) => tm === method)) {
                       try {
                         const valid_table_command_rules = await this.getValidatedRequestRule(
                           {
                             tableName,
                             command: method,
-                            localParams: clientReq,
+                            clientReq,
                           },
                           clientInfo
                         );
@@ -156,7 +145,7 @@ export async function getSchemaFromPublish(
 
                     if (method === "getInfo" || method === "getColumns") {
                       const tableRules = await this.getValidatedRequestRule(
-                        { tableName, command: method, localParams: clientReq },
+                        { tableName, command: method, clientReq },
                         clientInfo
                       );
                       const res = await (this.dbo[tableName] as any)[method](