prostgles-server 4.2.440 → 4.2.442

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -20,7 +20,7 @@ const SUBSCRIBE_METHODS = ["subscribe", "subscribeOne", "sync", "unsubscribe", "
 export async function getSchemaFromPublish(
   this: PublishParser,
   { userData, ...clientReq }: Args,
-  scope: PermissionScope | undefined
+  scope: PermissionScope | undefined,
 ): Promise<{
   schema: TableSchemaForClient;
   tables: DBSchemaTable[];
@@ -60,7 +60,7 @@ export async function getSchemaFromPublish(
         !tableNames.includes(fileTableName)
       ) {
         const isReferenced = this.prostgles.dboBuilder.tablesOrViews?.some((t) =>
-          t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName))
+          t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
         );
         if (isReferenced) {
           tableNames.unshift(fileTableName);
@@ -77,17 +77,17 @@ export async function getSchemaFromPublish(
             throw errMsg;
           }
 
-          const tableRules = await this.getTableRules({ clientReq, tableName }, clientInfo);
+          const parsedTableRule = await this.getTableRules({ clientReq, tableName }, clientInfo);
 
-          if (!tableRules || isEmpty(tableRules)) return;
-          if (!isObject(tableRules)) {
+          if (!parsedTableRule || isEmpty(parsedTableRule)) return;
+          if (!isObject(parsedTableRule)) {
             throw `Invalid tableRules for table ${tableName}. Expecting an object`;
           }
 
           schema[tableName] = {};
           const tableSchema = schema[tableName];
-          const methods = getKeys(tableRules).filter(
-            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m)
+          const methods = getKeys(parsedTableRule).filter(
+            (m) => canSubscribe || !includes(SUBSCRIBE_METHODS, m),
           );
           let tableInfo: TableInfo | undefined;
           let tableColumns: DBSchemaTable["columns"] | undefined;
@@ -98,25 +98,25 @@ export async function getSchemaFromPublish(
               .map(async (method) => {
                 if (method === "sync") {
                   /* Pass sync info */
-                  tableSchema[method] = tableRules[method];
-                } else if (includes(getKeys(tableRules), method) && tableRules[method]) {
+                  tableSchema[method] = parsedTableRule[method];
+                } else if (includes(getKeys(parsedTableRule), method) && parsedTableRule[method]) {
                   //@ts-ignore
                   tableSchema[method] =
                     method === "insert" ?
-                      pickKeys(tableRules[method], ["allowedNestedInserts"])
+                      pickKeys(parsedTableRule[method], ["allowedNestedInserts"])
                     : ({} as AnyObject);
 
                   /* Test for issues with the common table CRUD methods () */
                   if (includes(TABLE_METHODS, method)) {
                     try {
-                      const parsedTableRule = await this.getValidatedRequestRule(
+                      this.validateRequestRule(
                         {
                           tableName,
                           command: method,
                           clientReq,
                         },
-                        clientInfo,
-                        scope
+                        parsedTableRule,
+                        scope,
                       );
                       if (this.prostgles.opts.testRulesOnConnect) {
                         await (this.dbo[tableName] as TableHandler)[method](
@@ -128,7 +128,7 @@ export async function getSchemaFromPublish(
                             ...clientReq,
                             isRemoteRequest: {},
                             testRule: true,
-                          }
+                          },
                         );
                       }
                     } catch (e) {
@@ -146,17 +146,17 @@ export async function getSchemaFromPublish(
                   }
 
                   if (method === "getInfo" || method === "getColumns") {
-                    const tableRules = await this.getValidatedRequestRule(
+                    this.validateRequestRule(
                       { tableName, command: method, clientReq },
-                      clientInfo,
-                      scope
+                      parsedTableRule,
+                      scope,
                     );
                     const res = await (this.dbo[tableName] as TableHandler)[method](
                       undefined,
                       undefined,
                       undefined,
-                      tableRules,
-                      { ...clientReq, isRemoteRequest: {} }
+                      parsedTableRule,
+                      { ...clientReq, isRemoteRequest: {} },
                     );
                     if (method === "getInfo") {
                       tableInfo = res as TableInfo;
@@ -165,7 +165,7 @@ export async function getSchemaFromPublish(
                     }
                   }
                 }
-              })
+              }),
           );
 
           if (tableInfo && tableColumns) {
@@ -175,7 +175,7 @@ export async function getSchemaFromPublish(
               columns: tableColumns,
             });
           }
-        })
+        }),
       );
     }
   } catch (error) {

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -9,7 +9,6 @@ import type {
   ParsedPublishTable,
   PublishTableRule,
   PublishViewRule,
-  SubscribeRule,
 } from "./publishTypesAndUtils";
 import { type PublishObject, RULE_TO_METHODS } from "./publishTypesAndUtils";
 
@@ -17,7 +16,7 @@ export async function getTableRulesWithoutFileTable(
   this: PublishParser,
   { tableName, clientReq }: DboTable,
   clientInfo: AuthResultWithSID | undefined,
-  overridenPublish?: PublishObject
+  overridenPublish?: PublishObject,
 ): Promise<ParsedPublishTable | undefined> {
   if (!tableName) throw new Error("tableName is missing in getTableRules");
 
@@ -111,7 +110,7 @@ export async function getTableRulesWithoutFileTable(
         const rule = parsedTableRule[method];
 
         const ruleInfo = MY_RULES.find(
-          (r) => r.rule === method || (r.methods as readonly string[]).includes(method)
+          (r) => r.rule === method || (r.methods as readonly string[]).includes(method),
         );
         if (!ruleInfo) {
           let extraInfo = "";
@@ -120,7 +119,7 @@ export async function getTableRulesWithoutFileTable(
             RULE_TO_METHODS.find(
               (r) =>
                 r.table_only &&
-                (r.rule === method || (r.methods as readonly string[]).includes(method))
+                (r.rule === method || (r.methods as readonly string[]).includes(method)),
             )
           ) {
             extraInfo = "You've specified table rules to a view\n";
@@ -159,8 +158,8 @@ export async function getTableRulesWithoutFileTable(
         if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
           const sr = MY_RULES.find((r) => r.rule === subKey);
           if (sr && canSubscribe) {
-            parsedTableRule[subKey] = { ...(sr.no_limits) };
-            parsedTableRule.subscribeOne = { ...(sr.no_limits) };
+            parsedTableRule[subKey] = { ...sr.no_limits };
+            parsedTableRule.subscribeOne = { ...sr.no_limits };
           }
         }
       });

package/lib/initProstgles.ts

@@ -155,6 +155,24 @@ export const initProstgles = async function (
         }
       },
     });
+
+    /** Drop stale triggers */
+    await db
+      .any(
+        `
+      WITH active_app_ids AS (
+        SELECT DISTINCT (string_to_array(application_name, ' '))[2] AS app_id
+        FROM pg_stat_activity
+        WHERE application_name LIKE 'prostgles %'
+      )
+      DELETE FROM prostgles.app_triggers
+      WHERE app_id NOT IN (SELECT app_id FROM active_app_ids)
+      AND app_id != $1
+      `,
+        [this.appId],
+      )
+      .catch(() => {});
+
     this.db = db;
     this.pgp = pgp;
     this.isSuperUser = await getIsSuperUser(db);

package/lib/runClientRequest.ts

@@ -101,11 +101,12 @@ export const runClientRequest = async function (
   if (clientInfo === "new-session-redirect") {
     throw clientInfo;
   }
-  const parsedTableRule = await this.publishParser.getValidatedRequestRule(
-    { tableName, command, clientReq },
+
+  const parsedTableRule = await this.publishParser.getParsedTableRule(
+    { tableName, clientReq },
     clientInfo,
-    scope,
   );
+  this.publishParser.validateRequestRule({ tableName, command, clientReq }, parsedTableRule, scope);
 
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (!parsedTableRule) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.440",
+  "version": "4.2.442",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "pg": "^8.15.6",
     "pg-cursor": "^2.17.0",
     "pg-promise": "^12.6.0",
-    "prostgles-types": "^4.0.208"
+    "prostgles-types": "^4.0.209"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",