prostgles-server 4.2.183 → 4.2.185

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -1,63 +1,96 @@
-import { DBSchemaTable, MethodKey, TableInfo, TableSchemaErrors, TableSchemaForClient, getKeys, pickKeys } from "prostgles-types";
+import {
+  DBSchemaTable,
+  MethodKey,
+  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 { PublishObject, PublishParser } from "./PublishParser";
 import { TABLE_METHODS } from "../Prostgles";
 
-type Args = ({
-  socket: PRGLIOSocket;
-  httpReq?: undefined;
-} | {
-  httpReq: ExpressReq;
-  socket?: undefined;
-}) & {
+type Args = (
+  | {
+      socket: PRGLIOSocket;
+      httpReq?: undefined;
+    }
+  | {
+      httpReq: ExpressReq;
+      socket?: undefined;
+    }
+) & {
   userData: AuthResult | undefined;
-}
-
-export async function getSchemaFromPublish(this: PublishParser, { userData, ...clientReq }: Args): Promise<{ schema: TableSchemaForClient; tables: DBSchemaTable[]; tableSchemaErrors: TableSchemaErrors }> {
+};
+
+export async function getSchemaFromPublish(
+  this: PublishParser,
+  { userData, ...clientReq }: Args,
+): Promise<{
+  schema: TableSchemaForClient;
+  tables: DBSchemaTable[];
+  tableSchemaErrors: TableSchemaErrors;
+}> {
   const schema: TableSchemaForClient = {};
   const tableSchemaErrors: TableSchemaErrors = {};
-  let tables: DBSchemaTable[] = []
+  let tables: DBSchemaTable[] = [];
 
   try {
     /* Publish tables and views based on socket */
-    const clientInfo = userData ?? await this.prostgles.authHandler?.getClientInfo(clientReq);
+    const clientInfo =
+      userData ?? (await this.prostgles.authHandler?.getClientInfo(clientReq));
 
     let _publish: PublishObject | undefined;
     try {
       _publish = await this.getPublish(clientReq, clientInfo);
-    } catch(err){
-      console.error("Error within then Publish function ", err)
+    } catch (err) {
+      console.error("Error within then Publish function ", err);
       throw err;
     }
 
-
     if (_publish && Object.keys(_publish).length) {
       let txKey = "tx";
       if (!this.prostgles.opts.transactions) txKey = "";
-      if (typeof this.prostgles.opts.transactions === "string") txKey = this.prostgles.opts.transactions;
+      if (typeof this.prostgles.opts.transactions === "string")
+        txKey = this.prostgles.opts.transactions;
 
-      const tableNames = Object.keys(_publish).filter(k => !txKey || txKey !== k);
+      const tableNames = Object.keys(_publish).filter(
+        (k) => !txKey || txKey !== k,
+      );
 
       const fileTableName = this.prostgles.fileManager?.tableName;
-      if(fileTableName && this.dbo[fileTableName]?.is_media && !tableNames.includes(fileTableName)){
-        const isReferenced = this.prostgles.dboBuilder.tablesOrViews?.some(t => t.columns.some(c => c.references?.some(r => r.ftable === fileTableName)))
-        if(isReferenced){
+      if (
+        fileTableName &&
+        this.dbo[fileTableName]?.is_media &&
+        !tableNames.includes(fileTableName)
+      ) {
+        const isReferenced = this.prostgles.dboBuilder.tablesOrViews?.some(
+          (t) =>
+            t.columns.some((c) =>
+              c.references?.some((r) => r.ftable === fileTableName),
+            ),
+        );
+        if (isReferenced) {
           tableNames.unshift(fileTableName);
         }
       }
-      await Promise.all(tableNames
-        .map(async tableName => {
+      await Promise.all(
+        tableNames.map(async (tableName) => {
           if (!this.dbo[tableName]) {
             const errMsg = [
               `Table ${tableName} does not exist`,
-              `Expecting one of: ${JSON.stringify(this.prostgles.dboBuilder.tablesOrViews?.map(tov => tov.name))}`,
-              `DBO tables: ${JSON.stringify(Object.keys(this.dbo).filter(k => (this.dbo[k] as any).find))}`,
+              `Expecting one of: ${JSON.stringify(this.prostgles.dboBuilder.tablesOrViews?.map((tov) => tov.name))}`,
+              `DBO tables: ${JSON.stringify(Object.keys(this.dbo).filter((k) => (this.dbo[k] as any).find))}`,
             ].join("\n");
             throw errMsg;
           }
 
-          const table_rules = await this.getTableRules({ localParams: clientReq, tableName }, clientInfo);
+          const table_rules = await this.getTableRules(
+            { localParams: clientReq, tableName },
+            clientInfo,
+          );
 
           if (table_rules && Object.keys(table_rules).length) {
             schema[tableName] = {};
@@ -70,68 +103,107 @@ export async function getSchemaFromPublish(this: PublishParser, { userData, ...c
               methods = getKeys(table_rules) as any;
             }
 
-            if(!this.prostgles.dboBuilder.canSubscribe){
-              methods = methods.filter(m => !["subscribe", "subscribeOne", "sync", "unsubscribe", "unsync"].includes(m));
+            if (!this.prostgles.dboBuilder.canSubscribe) {
+              methods = methods.filter(
+                (m) =>
+                  ![
+                    "subscribe",
+                    "subscribeOne",
+                    "sync",
+                    "unsubscribe",
+                    "unsync",
+                  ].includes(m),
+              );
             }
 
-            await Promise.all(methods.filter(m => m !== "select" as any)
-            .map(async method => {
-              if (method === "sync" && table_rules[method]) {
-
-                /* Pass sync info */
-                tableSchema[method] = table_rules[method];
-              } else if ((table_rules as any)[method]) {
-
-                tableSchema[method] = method === "insert"? pickKeys(table_rules.insert!, ["allowedNestedInserts"]) : {};
-
-                /* Test for issues with the common table CRUD methods () */
-                if (TABLE_METHODS.includes(method as any)) {
-
-                  try {
-                    const valid_table_command_rules = await this.getValidatedRequestRule({ tableName, command: method, localParams: clientReq }, clientInfo);
-                    if(this.prostgles.opts.testRulesOnConnect){
-                      await (this.dbo[tableName] as any)[method]({}, {}, {}, valid_table_command_rules, { ...clientReq, isRemoteRequest: true, testRule: true });
+            await Promise.all(
+              methods
+                .filter((m) => m !== ("select" as any))
+                .map(async (method) => {
+                  if (method === "sync" && table_rules[method]) {
+                    /* Pass sync info */
+                    tableSchema[method] = table_rules[method];
+                  } else if ((table_rules as any)[method]) {
+                    tableSchema[method] =
+                      method === "insert"
+                        ? pickKeys(table_rules.insert!, [
+                            "allowedNestedInserts",
+                          ])
+                        : {};
+
+                    /* Test for issues with the common table CRUD methods () */
+                    if (TABLE_METHODS.includes(method as any)) {
+                      try {
+                        const valid_table_command_rules =
+                          await this.getValidatedRequestRule(
+                            {
+                              tableName,
+                              command: method,
+                              localParams: clientReq,
+                            },
+                            clientInfo,
+                          );
+                        if (this.prostgles.opts.testRulesOnConnect) {
+                          await (this.dbo[tableName] as any)[method](
+                            {},
+                            {},
+                            {},
+                            valid_table_command_rules,
+                            {
+                              ...clientReq,
+                              isRemoteRequest: true,
+                              testRule: true,
+                            },
+                          );
+                        }
+                      } catch (e) {
+                        tableSchemaErrors[tableName] ??= {};
+                        tableSchemaErrors[tableName]![method] = {
+                          error: "Internal publish error. Check server logs",
+                        };
+
+                        throw {
+                          ...getErrorAsObject(e),
+                          publish_path: `publish.${tableName}.${method}: \n   -> ${e}`,
+                        };
+                      }
                     }
 
-                  } catch (e) {
-                    tableSchemaErrors[tableName] ??= {};
-                    tableSchemaErrors[tableName]![method] = { error: "Internal publish error. Check server logs" };
-
-                    throw {
-                      ...getErrorAsObject(e),
-                      publish_path: `publish.${tableName}.${method}: \n   -> ${e}`
-                    };
-                  }
-                }
-
-                if (method === "getInfo" || method === "getColumns") {
-                  const tableRules = await this.getValidatedRequestRule({ tableName, command: method, localParams: clientReq }, clientInfo);
-                  const res = await (this.dbo[tableName] as any)[method](undefined, undefined, undefined, tableRules, { ...clientReq, isRemoteRequest: true });
-                  if (method === "getInfo") {
-                    tableInfo = res;
-                  } else if (method === "getColumns") {
-                    tableColumns = res;
+                    if (method === "getInfo" || method === "getColumns") {
+                      const tableRules = await this.getValidatedRequestRule(
+                        { tableName, command: method, localParams: clientReq },
+                        clientInfo,
+                      );
+                      const res = await (this.dbo[tableName] as any)[method](
+                        undefined,
+                        undefined,
+                        undefined,
+                        tableRules,
+                        { ...clientReq, isRemoteRequest: true },
+                      );
+                      if (method === "getInfo") {
+                        tableInfo = res;
+                      } else if (method === "getColumns") {
+                        tableColumns = res;
+                      }
+                    }
                   }
-                }
-              }
-            }));
+                }),
+            );
 
             if (tableInfo && tableColumns) {
-
               tables.push({
                 name: tableName,
                 info: tableInfo,
-                columns: tableColumns
-              })
+                columns: tableColumns,
+              });
             }
           }
 
           return true;
-        })
+        }),
       );
     }
-
-
   } catch (e) {
     console.error("Prostgles \nERRORS IN PUBLISH: ", JSON.stringify(e));
     throw e;
@@ -139,4 +211,4 @@ export async function getSchemaFromPublish(this: PublishParser, { userData, ...c
 
   tables = tables.sort((a, b) => a.name.localeCompare(b.name));
   return { schema, tables, tableSchemaErrors };
-}
+}

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -5,41 +5,65 @@ import { ViewHandler } from "../DboBuilder/ViewHandler/ViewHandler";
 import { DEFAULT_SYNC_BATCH_SIZE } from "../PubSubManager/PubSubManager";
 import { PublishParser } from "./PublishParser";
 import {
-  DboTable, ParsedPublishTable, PublishObject, PublishTableRule,
-  PublishViewRule, RULE_TO_METHODS, SubscribeRule
+  DboTable,
+  ParsedPublishTable,
+  PublishObject,
+  PublishTableRule,
+  PublishViewRule,
+  RULE_TO_METHODS,
+  SubscribeRule,
 } from "./publishTypesAndUtils";
 
-export async function getTableRulesWithoutFileTable(this: PublishParser, { tableName, localParams }: DboTable, clientInfo?: AuthResult, overridenPublish?: PublishObject): Promise<ParsedPublishTable | undefined> {
-
-  if (!localParams || !tableName) throw { stack: ["getTableRules()"], message: "publish OR socket OR dbo OR tableName are missing" };
-
-  const _publish = overridenPublish ?? await this.getPublish(localParams, clientInfo);
+export async function getTableRulesWithoutFileTable(
+  this: PublishParser,
+  { tableName, localParams }: DboTable,
+  clientInfo?: AuthResult,
+  overridenPublish?: PublishObject,
+): Promise<ParsedPublishTable | undefined> {
+  if (!localParams || !tableName)
+    throw {
+      stack: ["getTableRules()"],
+      message: "publish OR socket OR dbo OR tableName are missing",
+    };
+
+  const _publish =
+    overridenPublish ?? (await this.getPublish(localParams, clientInfo));
 
   const raw_table_rules = _publish[tableName];
-  if (!raw_table_rules || isObject(raw_table_rules) && Object.values(raw_table_rules).every(v => !v)) {
+  if (
+    !raw_table_rules ||
+    (isObject(raw_table_rules) &&
+      Object.values(raw_table_rules).every((v) => !v))
+  ) {
     return undefined;
   }
 
   let parsed_table: ParsedPublishTable = {};
 
   /* Get view or table specific rules */
-  const tHandler = (this.dbo[tableName] as TableHandler | ViewHandler);
+  const tHandler = this.dbo[tableName] as TableHandler | ViewHandler;
   const is_view = tHandler.is_view;
   /**
    * Allow subscribing to a view if it has primary key columns from other tables
    */
-  const canSubscribe = (!is_view || tHandler.columns.some(c => c.references));
+  const canSubscribe = !is_view || tHandler.columns.some((c) => c.references);
   if (!tHandler) {
-    throw { stack: ["getTableRules()"], message: `${tableName} could not be found in dbo` };
+    throw {
+      stack: ["getTableRules()"],
+      message: `${tableName} could not be found in dbo`,
+    };
   }
-  
-  const MY_RULES = RULE_TO_METHODS.filter(r => {
 
+  const MY_RULES = RULE_TO_METHODS.filter((r) => {
     /** Check PG User privileges */
     const pgUserIsAllowedThis = tHandler.tableOrViewInfo.privileges[r.sqlRule];
     let result = (!is_view || !r.table_only) && pgUserIsAllowedThis;
 
-    if (!pgUserIsAllowedThis && isObject(raw_table_rules) && (raw_table_rules as PublishTableRule)[r.sqlRule]) {
+    if (
+      !pgUserIsAllowedThis &&
+      isObject(raw_table_rules) &&
+      (raw_table_rules as PublishTableRule)[r.sqlRule]
+    ) {
       throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
     }
 
@@ -51,63 +75,84 @@ export async function getTableRulesWithoutFileTable(this: PublishParser, { table
     //   }
     // }
 
-    if(r.rule === "subscribe" && !canSubscribe){
+    if (r.rule === "subscribe" && !canSubscribe) {
       result = false;
     }
 
     return result;
   });
 
-
-
   /* All methods allowed. Add no limits for table rules */
   if ([true, "*"].includes(raw_table_rules as any)) {
     parsed_table = {};
-    MY_RULES.filter(r => r.no_limits).forEach(r => {
-      parsed_table[r.rule] = { ...r.no_limits as object } as any;
+    MY_RULES.filter((r) => r.no_limits).forEach((r) => {
+      parsed_table[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])
+    const allRuleKeys: (keyof PublishViewRule | keyof PublishTableRule)[] =
+      getKeys(raw_table_rules);
+    const dissallowedRuleKeys = allRuleKeys.filter(
+      (m) => !(raw_table_rules as PublishTableRule)[m],
+    );
 
-    MY_RULES.map(r => {
+    MY_RULES.map((r) => {
       /** Unless specifically disabled these are allowed */
-      if (["getInfo", "getColumns"].includes(r.rule) && !dissallowedRuleKeys.includes(r.rule as any)) {
+      if (
+        ["getInfo", "getColumns"].includes(r.rule) &&
+        !dissallowedRuleKeys.includes(r.rule as any)
+      ) {
         parsed_table[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) {
+      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;
 
         /** 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]
+        parsed_table[r.rule] = (raw_table_rules as any)[r.rule];
       }
     });
 
-    allRuleKeys.filter(m => parsed_table[m])
+    allRuleKeys
+      .filter((m) => parsed_table[m])
       .forEach((method) => {
         const rule = parsed_table[method];
-        
-        const rm = MY_RULES.find(r => r.rule === method || (r.methods as readonly string[]).includes(method));
+
+        const rm = MY_RULES.find(
+          (r) =>
+            r.rule === method ||
+            (r.methods as readonly string[]).includes(method),
+        );
         if (!rm) {
           let extraInfo = "";
-          if (is_view && RULE_TO_METHODS.find(r => !is_view && r.rule === method || (r.methods as any).includes(method))) {
+          if (
+            is_view &&
+            RULE_TO_METHODS.find(
+              (r) =>
+                (!is_view && r.rule === method) ||
+                (r.methods as any).includes(method),
+            )
+          ) {
             extraInfo = "You've specified table rules to a view\n";
           }
-          throw `Invalid rule in publish.${tableName} -> ${method} \n${extraInfo}Expecting any of: ${MY_RULES.flatMap(r => [r.rule, ...r.methods]).join(", ")}`;
+          throw `Invalid rule in publish.${tableName} -> ${method} \n${extraInfo}Expecting any of: ${MY_RULES.flatMap((r) => [r.rule, ...r.methods]).join(", ")}`;
         }
 
         /* Check RULES for invalid params */
         /* Methods do not have params -> They use them from rules */
         if (method === rm.rule && isObject(rule)) {
           const method_params = Object.keys(rule);
-          const allowed_params = Object.keys(rm?.allowed_params)
-          const iparam = method_params.find(p => !allowed_params.includes(p));
+          const allowed_params = Object.keys(rm?.allowed_params);
+          const iparam = method_params.find((p) => !allowed_params.includes(p));
           if (iparam) {
             throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${allowed_params.join(", ")}`;
           }
@@ -115,7 +160,6 @@ export async function getTableRulesWithoutFileTable(this: PublishParser, { table
 
         /* Add default params (if missing) */
         if (method === "sync") {
-
           if ([true, "*"].includes(parsed_table[method] as any)) {
             throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
           }
@@ -132,35 +176,41 @@ export async function getTableRulesWithoutFileTable(this: PublishParser, { table
         const subKey = "subscribe" as const;
 
         if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
-          const sr = MY_RULES.find(r => r.rule === 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 };
+            parsed_table[subKey] = { ...(sr.no_limits as SubscribeRule) };
+            parsed_table.subscribeOne = { ...(sr.no_limits as SubscribeRule) };
           }
         }
       });
-
   } else {
-    throw "Unexpected publish"
+    throw "Unexpected publish";
   }
 
-  const getImpliedMethods = (tableRules: ParsedPublishTable): ParsedPublishTable => {
+  const getImpliedMethods = (
+    tableRules: ParsedPublishTable,
+  ): ParsedPublishTable => {
     const res = { ...tableRules };
 
     /* Add implied methods if not specifically dissallowed */
-    MY_RULES.map(r => {
-
+    MY_RULES.map((r) => {
       /** THIS IS A MESS -> some methods cannot be dissallowed (unsync, unsubscribe...) */
-      r.methods.forEach(method => {
-        const isAllowed = tableRules[r.rule] && (tableRules as any)[method] === undefined;
+      r.methods.forEach((method) => {
+        const isAllowed =
+          tableRules[r.rule] && (tableRules as any)[method] === undefined;
         if (isAllowed) {
-
-          if (method === "updateBatch" && (!tableRules.update || tableRules.update.checkFilter || tableRules.update.postValidate)) {
+          if (
+            method === "updateBatch" &&
+            (!tableRules.update ||
+              tableRules.update.checkFilter ||
+              tableRules.update.postValidate)
+          ) {
             // not allowed
-
-          } else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
+          } else if (
+            method === "upsert" &&
+            (!tableRules.update || !tableRules.insert)
+          ) {
             // not allowed
-
           } else {
             (res as any)[method] ??= true;
           }
@@ -169,9 +219,9 @@ export async function getTableRulesWithoutFileTable(this: PublishParser, { table
     });
 
     return res;
-  }
+  };
 
   parsed_table = getImpliedMethods(parsed_table);
 
-  return parsed_table; 
-}
+  return parsed_table;
+}