prostgles-server 3.0.87 → 3.0.89

package/lib/PublishParser.js

@@ -112,7 +112,7 @@ class PublishParser {
         };
     }
     async getAllowedMethods(socket, userData) {
-        let methods = {};
+        const methods = {};
         const publishParams = await this.getPublishParams({ socket }, userData);
         const _methods = await applyParamsIfFunc(this.publishMethods, publishParams);
         if (_methods && Object.keys(_methods).length) {
@@ -136,9 +136,9 @@ class PublishParser {
      */
     async getPublish(localParams, clientInfo) {
         const publishParams = await this.getPublishParams(localParams, clientInfo);
-        let _publish = await applyParamsIfFunc(this.publish, publishParams);
+        const _publish = await applyParamsIfFunc(this.publish, publishParams);
         if (_publish === "*") {
-            let publish = {};
+            const publish = {};
             this.prostgles.dboBuilder.tablesOrViews?.map(tov => {
                 publish[tov.name] = "*";
             });
@@ -155,7 +155,7 @@ class PublishParser {
             throw "INTERNAL ERROR: dbo is missing";
         if (!command || !tableName)
             throw "command OR tableName are missing";
-        let rtm = RULE_TO_METHODS.find(rtms => rtms.methods.includes(command));
+        const rtm = RULE_TO_METHODS.find(rtms => rtms.methods.includes(command));
         if (!rtm) {
             throw "Invalid command: " + command;
         }
@@ -173,7 +173,7 @@ class PublishParser {
         const schm = localParams?.socket?.prostgles?.schema?.[tableName]?.[command];
         if (schm && schm.err)
             throw schm.err;
-        let table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
+        const table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
         if (!table_rule)
             throw { stack: ["getValidatedRequestRule()"], message: "Invalid or disallowed table: " + tableName };
         if (command === "upsert") {
@@ -188,143 +188,140 @@ class PublishParser {
             throw { stack: ["getValidatedRequestRule()"], message: `Invalid or disallowed command: ${tableName}.${command}` };
     }
     async getTableRules({ tableName, localParams }, clientInfo) {
-        try {
-            if (!localParams || !tableName)
-                throw { stack: ["getTableRules()"], message: "publish OR socket OR dbo OR tableName are missing" };
-            let _publish = await this.getPublish(localParams, clientInfo);
-            const raw_table_rules = _publish[tableName];
-            if (!raw_table_rules || (0, prostgles_types_1.isObject)(raw_table_rules) && Object.values(raw_table_rules).every(v => !v)) {
-                return undefined;
+        if (!localParams || !tableName)
+            throw { stack: ["getTableRules()"], message: "publish OR socket OR dbo OR tableName are missing" };
+        const _publish = await this.getPublish(localParams, clientInfo);
+        const raw_table_rules = _publish[tableName];
+        if (!raw_table_rules || (0, prostgles_types_1.isObject)(raw_table_rules) && Object.values(raw_table_rules).every(v => !v)) {
+            return undefined;
+        }
+        let parsed_table = {};
+        /* Get view or table specific rules */
+        const tHandler = this.dbo[tableName];
+        const is_view = tHandler.is_view;
+        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 && (0, DboBuilder_1.isPlainObject)(raw_table_rules) && raw_table_rules[r.sqlRule]) {
+                throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
+            }
+            if ((r.rule === "subscribe" || r.rule === "sync") && !this.prostgles.isSuperUser) {
+                result = false;
+                if ((0, DboBuilder_1.isPlainObject)(raw_table_rules) && raw_table_rules[r.rule]) {
+                    throw `Cannot publish realtime rule ${tableName}.${r.rule}. Superuser is required for this`;
+                }
             }
-            let parsed_table = {};
-            /* Get view or table specific rules */
-            const tHandler = this.dbo[tableName];
-            const is_view = tHandler.is_view;
-            const canSubscribe = (!is_view || tHandler.columns.some(c => c.references));
-            if (!tHandler) {
-                throw { stack: ["getTableRules()"], message: `${tableName} could not be found in dbo` };
+            if (r.rule === "subscribe" && !canSubscribe) {
+                result = false;
             }
-            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 && (0, DboBuilder_1.isPlainObject)(raw_table_rules) && raw_table_rules[r.sqlRule]) {
-                    throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
+            return result;
+        });
+        /* All methods allowed. Add no limits for table rules */
+        if ([true, "*"].includes(raw_table_rules)) {
+            parsed_table = {};
+            MY_RULES.filter(r => r.no_limits).forEach(r => {
+                parsed_table[r.rule] = { ...r.no_limits };
+            });
+            /** Specific rules allowed */
+        }
+        else if ((0, DboBuilder_1.isPlainObject)(raw_table_rules) && (0, prostgles_types_1.getKeys)(raw_table_rules).length) {
+            const allRuleKeys = (0, prostgles_types_1.getKeys)(raw_table_rules);
+            const dissallowedRuleKeys = allRuleKeys.filter(m => !raw_table_rules[m]);
+            MY_RULES.map(r => {
+                /** Unless specifically disabled these are allowed */
+                if (["getInfo", "getColumns"].includes(r.rule) && !dissallowedRuleKeys.includes(r.rule)) {
+                    parsed_table[r.rule] = r.no_limits;
+                    return;
                 }
-                if ((r.rule === "subscribe" || r.rule === "sync") && !this.prostgles.isSuperUser) {
-                    result = false;
-                    if ((0, DboBuilder_1.isPlainObject)(raw_table_rules) && raw_table_rules[r.rule]) {
-                        throw `Cannot publish realtime rule ${tableName}.${r.rule}. Superuser is required for this`;
-                    }
+                /** Add no_limit values for implied/ fully allowed methods */
+                if ([true, "*"].includes(raw_table_rules[r.rule]) && r.no_limits) {
+                    parsed_table[r.rule] = Object.assign({}, r.no_limits);
+                    /** Carry over detailed config */
                 }
-                if (r.rule === "subscribe" && !canSubscribe) {
-                    result = false;
+                else if ((0, DboBuilder_1.isPlainObject)(raw_table_rules[r.rule])) {
+                    parsed_table[r.rule] = raw_table_rules[r.rule];
                 }
-                return result;
             });
-            /* All methods allowed. Add no limits for table rules */
-            if ([true, "*"].includes(raw_table_rules)) {
-                parsed_table = {};
-                MY_RULES.filter(r => r.no_limits).forEach(r => {
-                    parsed_table[r.rule] = { ...r.no_limits };
-                });
-                /** Specific rules allowed */
-            }
-            else if ((0, DboBuilder_1.isPlainObject)(raw_table_rules) && (0, prostgles_types_1.getKeys)(raw_table_rules).length) {
-                const allRuleKeys = (0, prostgles_types_1.getKeys)(raw_table_rules);
-                const dissallowedRuleKeys = allRuleKeys.filter(m => !raw_table_rules[m]);
-                MY_RULES.map(r => {
-                    /** Unless specifically disabled these are allowed */
-                    if (["getInfo", "getColumns"].includes(r.rule) && !dissallowedRuleKeys.includes(r.rule)) {
-                        parsed_table[r.rule] = r.no_limits;
-                        return;
+            allRuleKeys.filter(m => parsed_table[m])
+                .forEach((method) => {
+                const rule = parsed_table[method];
+                const rm = MY_RULES.find(r => r.rule === method || r.methods.includes(method));
+                if (!rm) {
+                    let extraInfo = "";
+                    if (is_view && RULE_TO_METHODS.find(r => !is_view && r.rule === method || r.methods.includes(method))) {
+                        extraInfo = "You've specified table rules to a view\n";
                     }
-                    /** Add no_limit values for implied/ fully allowed methods */
-                    if ([true, "*"].includes(raw_table_rules[r.rule]) && r.no_limits) {
-                        parsed_table[r.rule] = Object.assign({}, r.no_limits);
-                        /** Carry over detailed config */
+                    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 && (0, prostgles_types_1.isObject)(rule)) {
+                    const method_params = (0, prostgles_types_1.getKeys)(rule);
+                    const iparam = method_params.find(p => !rm?.allowed_params.includes(p));
+                    if (iparam) {
+                        throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${rm.allowed_params.join(", ")}`;
                     }
-                    else if ((0, DboBuilder_1.isPlainObject)(raw_table_rules[r.rule])) {
-                        parsed_table[r.rule] = raw_table_rules[r.rule];
+                }
+                /* Add default params (if missing) */
+                if (method === "sync") {
+                    if ([true, "*"].includes(parsed_table[method])) {
+                        throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
                     }
-                });
-                allRuleKeys.filter(m => parsed_table[m])
-                    .forEach((method) => {
-                    const rule = parsed_table[method];
-                    let rm = MY_RULES.find(r => r.rule === method || r.methods.includes(method));
-                    if (!rm) {
-                        let extraInfo = "";
-                        if (is_view && RULE_TO_METHODS.find(r => !is_view && r.rule === method || r.methods.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(", ")}`;
+                    if (typeof parsed_table[method]?.throttle !== "number") {
+                        parsed_table[method].throttle = 100;
                     }
-                    /* Check RULES for invalid params */
-                    /* Methods do not have params -> They use them from rules */
-                    if (method === rm.rule && (0, prostgles_types_1.isObject)(rule)) {
-                        let method_params = (0, prostgles_types_1.getKeys)(rule);
-                        let iparam = method_params.find(p => !rm?.allowed_params.includes(p));
-                        if (iparam) {
-                            throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${rm.allowed_params.join(", ")}`;
-                        }
+                    if (typeof parsed_table[method]?.batch_size !== "number") {
+                        parsed_table[method].batch_size = PubSubManager_1.DEFAULT_SYNC_BATCH_SIZE;
                     }
-                    /* Add default params (if missing) */
-                    if (method === "sync") {
-                        if ([true, "*"].includes(parsed_table[method])) {
-                            throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
-                        }
-                        if (typeof parsed_table[method]?.throttle !== "number") {
-                            parsed_table[method].throttle = 100;
+                }
+                /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
+                const subKey = "subscribe";
+                if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
+                    const sr = MY_RULES.find(r => r.rule === subKey);
+                    if (sr && canSubscribe) {
+                        parsed_table[subKey] = { ...sr.no_limits };
+                        parsed_table.subscribeOne = { ...sr.no_limits };
+                    }
+                }
+            });
+        }
+        else {
+            throw "Unexpected publish";
+        }
+        const getImpliedMethods = (tableRules) => {
+            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[method] === undefined;
+                    if (isAllowed) {
+                        if (method === "updateBatch" && !tableRules.update) {
+                            // not allowed
                         }
-                        if (typeof parsed_table[method]?.batch_size !== "number") {
-                            parsed_table[method].batch_size = PubSubManager_1.DEFAULT_SYNC_BATCH_SIZE;
+                        else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
+                            // not allowed
                         }
-                    }
-                    /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
-                    const subKey = "subscribe";
-                    if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
-                        const sr = MY_RULES.find(r => r.rule === subKey);
-                        if (sr && canSubscribe) {
-                            parsed_table[subKey] = { ...sr.no_limits };
-                            parsed_table.subscribeOne = { ...sr.no_limits };
+                        else {
+                            res[method] ??= true;
                         }
                     }
                 });
-            }
-            else {
-                throw "Unexpected publish";
-            }
-            const getImpliedMethods = (tableRules) => {
-                let 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[method] === undefined;
-                        if (isAllowed) {
-                            if (method === "updateBatch" && !tableRules.update) {
-                            }
-                            else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
-                            }
-                            else {
-                                res[method] ??= true;
-                            }
-                        }
-                    });
-                });
-                return res;
-            };
-            parsed_table = getImpliedMethods(parsed_table);
-            return parsed_table;
-        }
-        catch (e) {
-            throw e;
-        }
+            });
+            return res;
+        };
+        parsed_table = getImpliedMethods(parsed_table);
+        return parsed_table;
     }
     /* Prepares schema for client. Only allowed views and commands will be present */
     async getSchemaFromPublish(socket, userData) {
-        let schema = {};
-        let tables = [];
+        const schema = {};
+        const tables = [];
         try {
             /* Publish tables and views based on socket */
             const clientInfo = userData ?? await this.prostgles.authHandler?.getClientInfo({ socket });
@@ -381,7 +378,7 @@ class PublishParser {
                                     }
                                 }
                                 if (method === "getInfo" || method === "getColumns") {
-                                    let tableRules = await this.getValidatedRequestRule({ tableName, command: method, localParams: { socket } }, clientInfo);
+                                    const tableRules = await this.getValidatedRequestRule({ tableName, command: method, localParams: { socket } }, clientInfo);
                                     const res = await this.dbo[tableName][method](undefined, undefined, undefined, tableRules, { socket, isRemoteRequest: true });
                                     if (method === "getInfo") {
                                         tableInfo = res;