prostgles-server 4.2.159 → 4.2.161

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -0,0 +1,141 @@
+import { DBSchemaTable, MethodKey, TableInfo, TableSchemaForClient, getKeys, pickKeys } from "prostgles-types";
+import { AuthResult, ExpressReq } from "../Auth/AuthTypes";
+import { getErrorAsObject, PRGLIOSocket } from "../DboBuilder/DboBuilder";
+import { PublishObject, PublishParser } from "./PublishParser"
+import { TABLE_METHODS } from "../Prostgles";
+
+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[] }> {
+  const schema: TableSchemaForClient = {};
+  let tables: DBSchemaTable[] = []
+
+  try {
+    /* Publish tables and views based on socket */
+    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)
+      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;
+
+      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){
+          tableNames.unshift(fileTableName);
+        }
+      }
+      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))}`,
+            ].join("\n");
+            throw errMsg;
+          }
+
+          const table_rules = await this.getTableRules({ localParams: clientReq, tableName }, clientInfo);
+
+          if (table_rules && Object.keys(table_rules).length) {
+            schema[tableName] = {};
+            const tableSchema = schema[tableName]!;
+            let methods: MethodKey[] = [];
+            let tableInfo: TableInfo | undefined;
+            let tableColumns: DBSchemaTable["columns"] | undefined;
+
+            if (typeof table_rules === "object") {
+              methods = getKeys(table_rules) as any;
+            }
+
+            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 });
+                    }
+
+                  } catch (e) {
+                    tableSchema[method] = { 
+                      err: "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 (tableInfo && tableColumns) {
+
+              tables.push({
+                name: tableName,
+                info: tableInfo,
+                columns: tableColumns
+              })
+            }
+          }
+
+          return true;
+        })
+      );
+    }
+
+
+  } catch (e) {
+    console.error("Prostgles \nERRORS IN PUBLISH: ", JSON.stringify(e));
+    throw e;
+  }
+
+  tables = tables.sort((a, b) => a.name.localeCompare(b.name));
+  return { schema, tables };
+}

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -0,0 +1,177 @@
+import { getKeys, isObject } from "prostgles-types";
+import { AuthResult } from "../Auth/AuthTypes";
+import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
+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
+} 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);
+
+  const raw_table_rules = _publish[tableName];
+  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 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));
+  if (!tHandler) {
+    throw { stack: ["getTableRules()"], message: `${tableName} could not be found in dbo` };
+  }
+  
+  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]) {
+      throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
+    }
+
+    // TODO: Implement comprehensive canSubscribe check
+    // if ((r.rule === "subscribe" || r.rule === "sync") && !this.prostgles.isSuperUser) {
+    //   result = false;
+    //   if (isObject(raw_table_rules) && (raw_table_rules as PublishTableRule)[r.rule]) {
+    //     throw `Cannot publish realtime rule ${tableName}.${r.rule}. Superuser is required for this`
+    //   }
+    // }
+
+    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;
+    });
+
+    /** 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])
+
+    MY_RULES.map(r => {
+      /** Unless specifically disabled these are allowed */
+      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) {
+        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]
+      }
+    });
+
+    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));
+        if (!rm) {
+          let extraInfo = "";
+          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(", ")}`;
+        }
+
+        /* 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));
+          if (iparam) {
+            throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${allowed_params.join(", ")}`;
+          }
+        }
+
+        /* 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 } ";
+          }
+
+          if (typeof parsed_table[method]?.throttle !== "number") {
+            parsed_table[method]!.throttle = 100;
+          }
+          if (typeof parsed_table[method]?.batch_size !== "number") {
+            parsed_table[method]!.batch_size = DEFAULT_SYNC_BATCH_SIZE;
+          }
+        }
+
+        /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
+        const subKey = "subscribe" as const;
+
+        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 };
+          }
+        }
+      });
+
+  } else {
+    throw "Unexpected publish"
+  }
+
+  const getImpliedMethods = (tableRules: ParsedPublishTable): ParsedPublishTable => {
+    const res = { ...tableRules };
+
+    /* Add implied methods if not specifically dissallowed */
+    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;
+        if (isAllowed) {
+
+          if (method === "updateBatch" && (!tableRules.update || tableRules.update.checkFilter || tableRules.update.postValidate)) {
+            // not allowed
+
+          } else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
+            // not allowed
+
+          } else {
+            (res as any)[method] ??= true;
+          }
+        }
+      });
+    });
+
+    return res;
+  }
+
+  parsed_table = getImpliedMethods(parsed_table);
+
+  return parsed_table; 
+}