prostgles-server 4.2.34 → 4.2.36

package/lib/DboBuilder/getCondition.ts

@@ -81,7 +81,7 @@ export async function getCondition(
   });
 
   let allowedSelect: SelectItem[] = [];
-  /* Select aliases take precedence over col names. This is to ensure filters work correctly and even on computed cols*/
+  /* Select aliases take precedence over col names. This is to ensure filters work correctly even on computed cols*/
   if (select) {
     /* Allow filtering by selected fields/funcs */
     allowedSelect = select.filter(s => {
@@ -96,23 +96,24 @@ export async function getCondition(
   }
 
   /* Add remaining allowed fields */
+  const remainingNonSelectedColumns: SelectItem[] = p.allColumns.filter(c =>
+    allowed_colnames.includes(c.name) &&
+    !allowedSelect.find(s => s.alias === c.name)
+  ).map(f => ({
+    type: f.type,
+    alias: f.name,
+    columnName: f.type === "column"? f.name : undefined as any,
+    getQuery: (tableAlias) => f.getQuery({
+      tableAlias,
+      allColumns: this.columns,
+      allowedFields: allowed_colnames
+    }),
+    selected: false,
+    getFields: () => [f.name],
+    column_udt_type: f.type === "column" ? this.columns.find(c => c.name === f.name)?.udt_name : undefined
+  }))
   allowedSelect = allowedSelect.concat(
-    p.allColumns.filter(c =>
-      allowed_colnames.includes(c.name) &&
-      !allowedSelect.find(s => s.alias === c.name)
-    ).map(f => ({
-      type: f.type,
-      alias: f.name,
-      columnName: f.type === "column"? f.name : undefined as any,
-      getQuery: (tableAlias) => f.getQuery({
-        tableAlias,
-        allColumns: this.columns,
-        allowedFields: allowed_colnames
-      }),
-      selected: false,
-      getFields: () => [f.name],
-      column_udt_type: f.type === "column" ? this.columns.find(c => c.name === f.name)?.udt_name : undefined
-    }))
+    remainingNonSelectedColumns
   );
 
   /* Parse complex filters
@@ -180,15 +181,14 @@ export async function getCondition(
       will make an exists filter
   */
 
-  const filterKeys = Object.keys(filter).filter(k => k !== complexFilterKey && !funcFilter.find(ek => ek.name === k) && !computedFields.find(cf => cf.name === k) && !existsConfigs.find(ek => ek.existType === k));
-  // if(allowed_colnames){
-  //     const aliasedColumns = (select || []).filter(s => 
-  //         ["function", "computed", "column"].includes(s.type) && allowed_colnames.includes(s.alias) ||  
-  //         s.getFields().find(f => allowed_colnames.includes(f))
-  //     ).map(s => s.alias);
-  //     const validCols = [...allowed_colnames, ...aliasedColumns];
+  const filterKeys = Object.keys(filter)
+    .filter(k => 
+      k !== complexFilterKey && 
+      !funcFilter.find(ek => ek.name === k) && 
+      !computedFields.find(cf => cf.name === k) && 
+      !existsConfigs.find(ek => ek.existType === k)
+    );
 
-  // }
   const validFieldNames = allowedSelect.map(s => s.alias);
   const invalidColumn = filterKeys
     .find(fName => !validFieldNames.find(c =>
@@ -202,7 +202,9 @@ export async function getCondition(
     ));
 
   if (invalidColumn) {
-    throw `Table: ${this.name} -> disallowed/inexistent columns in filter: ${invalidColumn} \n  Expecting one of: ${allowedSelect.map(s => s.type === "column" ? s.getQuery() : s.alias).join(", ")}`;
+    const allowedCols = allowedSelect.map(s => s.type === "column" ? s.getQuery() : s.alias).join(", ");
+    const errMessage = `Table: ${this.name} -> disallowed/inexistent columns in filter: ${invalidColumn} \n  Expecting one of: ${allowedCols}`;
+    throw errMessage;
   }
 
   /* TODO: Allow filter funcs */

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -1,7 +1,7 @@
 import { AnyObject, asName, reverseParsedPath, SubscribeParams } from "prostgles-types";
-import { ExistsFilterConfig, Filter, LocalParams, getClientErrorFromPGError } from "./DboBuilder";
 import { TableRule } from "../PublishParser/PublishParser";
 import { log, ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
+import { Filter, getClientErrorFromPGError, LocalParams } from "./DboBuilder";
 import { NewQuery } from "./QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler/ViewHandler";
 
@@ -10,17 +10,14 @@ type Args = {
   filter: Filter;
   table_rules: TableRule<AnyObject, void> | undefined;
   localParams: LocalParams | undefined;
-  condition: string;
-  filterOpts: {
-    where: string;
-    filter: AnyObject;
-    exists: ExistsFilterConfig[];
-  };
+  newQuery: NewQuery;
 }
-export async function getSubscribeRelatedTables(this: ViewHandler, { selectParams, filter, localParams, table_rules, condition, filterOpts }: Args){
+export async function getSubscribeRelatedTables(this: ViewHandler, { selectParams, filter, localParams, table_rules, newQuery }: Args){
 
   let viewOptions: ViewSubscriptionOptions | undefined = undefined;
+  const { condition } = newQuery.whereOpts;
   if (this.is_view) {
+    /** TODO: this needs to be memoized on schema fetch */
     const viewName = this.name;
     const viewNameEscaped = this.escapedName;
     const { current_schema } = await this.db.oneOrNone("SELECT current_schema")
@@ -129,7 +126,6 @@ export async function getSubscribeRelatedTables(this: ViewHandler, { selectParam
 
     /** Any joined table used within select or filter must also be added a trigger for this recordset */
   } else {
-    const newQuery = await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, { ...localParams, returnNewQuery: true }) as unknown as NewQuery;
     viewOptions = {
       type: "table",
       relatedTables: []
@@ -137,7 +133,7 @@ export async function getSubscribeRelatedTables(this: ViewHandler, { selectParam
     /**
      * Avoid nested exists error. Will affect performance
      */
-    const nonExistsFilter = filterOpts.exists.length ? {} : filter;
+    const nonExistsFilter = newQuery.whereOpts.exists.length ? {} : filter;
     for await (const j of (newQuery.joins ?? [])) {
       if (!viewOptions!.relatedTables.find(rt => rt.tableName === j.table)) {
         /**

package/lib/DboBuilder/runSQL.ts

@@ -1,9 +1,9 @@
-import { AnyObject, SQLOptions, SQLResult, SQLResultInfo } from "prostgles-types";
-import { DboBuilder, LocalParams, pgp, postgresToTsType } from "./DboBuilder";
-import { DB, Prostgles } from "../Prostgles";
-import { PubSubManager } from "../PubSubManager/PubSubManager";
 import { ParameterizedQuery as PQ, ParameterizedQuery } from 'pg-promise';
 import pg from "pg-promise/typescript/pg-subset";
+import { AnyObject, SQLOptions, SQLResult, SQLResultInfo } from "prostgles-types";
+import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
+import { DB, Prostgles } from "../Prostgles";
+import { DboBuilder, LocalParams, pgp, postgresToTsType } from "./DboBuilder";
 
 
 export async function runSQL(this: DboBuilder, queryWithoutRLS: string, args: undefined | AnyObject | any[], options: SQLOptions | undefined, localParams?: LocalParams) {
@@ -117,7 +117,7 @@ export const watchSchemaFallback = async function(this: DboBuilder, { queryWitho
       this.prostgles.onSchemaChange({ command, query: queryWithoutRLS })
     } else if (queryWithoutRLS) {
       const cleanedQuery = queryWithoutRLS.toLowerCase().replace(/\s\s+/g, ' ');
-      if (PubSubManager.SCHEMA_ALTERING_QUERIES.some(q => cleanedQuery.includes(q.toLowerCase() + " "))) {
+      if (EVENT_TRIGGER_TAGS.some(q => cleanedQuery.includes(q.toLowerCase() + " "))) {
         this.prostgles.onSchemaChange({ command, query: queryWithoutRLS })
       }
     }

package/lib/DboBuilder/subscribe.ts

@@ -1,7 +1,7 @@
 import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
-import { Filter, LocalParams, parseError } from "./DboBuilder";
 import { TableRule } from "../PublishParser/PublishParser";
-import { omitKeys } from "../PubSubManager/PubSubManager"; 
+import { Filter, LocalParams, parseError } from "./DboBuilder";
+import { NewQuery } from "./QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getSubscribeRelatedTables } from "./getSubscribeRelatedTables";
 
@@ -42,10 +42,10 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
       throw " Cannot have localFunc AND socket ";
     }
 
-    const { filterFields, forcedFilter } = table_rules?.select || {},
-      filterOpts = await this.prepareWhere({ filter, forcedFilter, addWhere: false, filterFields, tableAlias: undefined, localParams, tableRule: table_rules }),
-      condition = filterOpts.where,
-      { throttle = 0, throttleOpts, ...selectParams } = params;
+    const { throttle = 0, throttleOpts, ...selectParams } = params;
+
+    /** Ensure request is valid */
+    await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams);   
 
     /** app_triggers condition field has an index which limits it's value. 
      * TODO: use condition md5 hash 
@@ -58,16 +58,18 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
       throw "Subscribe not possible. Must be superuser to add triggers 1856";
     }
 
-    /** Ensure request is valid */
-    await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams);
-
-    const viewOptions = await getSubscribeRelatedTables.bind(this)({ filter, selectParams, table_rules, localParams, condition, filterOpts })
+    const newQuery: NewQuery = await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, { ...localParams, returnNewQuery: true }) as any;
+    const viewOptions = await getSubscribeRelatedTables.bind(this)({ 
+      filter, selectParams, 
+      table_rules, localParams, 
+      newQuery
+    });
 
     const commonSubOpts = {
       table_info: this.tableOrViewInfo,
       viewOptions,
       table_rules,
-      condition,
+      condition: newQuery.whereOpts.condition,
       table_name: this.name,
       filter: { ...filter },
       params: { ...selectParams },
@@ -109,4 +111,4 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
   }
 }
 
-export { subscribe }
+export { subscribe };

package/lib/Filtering.ts

@@ -244,13 +244,9 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
        * geom && st_makeenvelope(funcArgs)
        */
       const filterValueKeys = Object.keys(filterValue);
-      // if(!filterValueKeys.length || filterValueKeys.length !== 1){
-      //   return mErr("Bad filter. Expecting a nested object with one key only but got: " + JSON.stringify(filterValue, null, 2));
-      // }
       funcName = filterValueKeys[0] as any;
       if(ALLOWED_FUNCS.includes(funcName as any)){
         funcArgs = filterValue[funcName as any];
-        // return mErr(`Bad filter. Nested function ${funcName} could not be found. Expecting one of: ${ALLOWED_FUNCS}`);
       } else {
         funcName = undefined;
       }

package/lib/PubSubManager/PubSubManager.ts

@@ -3,28 +3,28 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { DBHandlerServer, DboBuilder, PRGLIOSocket, TableInfo, TableOrViewInfo, canEXECUTE } from "../DboBuilder/DboBuilder";
 import { PostgresNotifListenManager } from "../PostgresNotifListenManager";
-import { addSync } from "./addSync";
-import { TableOrViewInfo, TableInfo, DBHandlerServer, DboBuilder, PRGLIOSocket, canEXECUTE } from "../DboBuilder/DboBuilder";
 import { DB, isSuperUser } from "../Prostgles";
+import { addSync } from "./addSync";
 import { initPubSubManager } from "./initPubSubManager";
 
 import * as Bluebird from "bluebird";
 import * as pgPromise from 'pg-promise';
 import pg from 'pg-promise/typescript/pg-subset';
 
-import { SelectParams, FieldFilter, asName, WAL, AnyObject, SubscribeParams } from "prostgles-types";
+import { AnyObject, FieldFilter, SelectParams, SubscribeParams, WAL } from "prostgles-types";
 
-import { syncData } from "../SyncReplication";
+import { find, pickKeys, tryCatch } from "prostgles-types/dist/util";
+import { LocalFuncs, getOnDataFunc, matchesLocalFuncs } from "../DboBuilder/subscribe";
+import { EVENT_TRIGGER_TAGS } from "../Event_Trigger_Tags";
+import { EventTypes } from "../Logging";
 import { TableRule } from "../PublishParser/PublishParser";
-import { find, getKeys, isObject, pickKeys, tryCatch } from "prostgles-types/dist/util";
-import { DB_OBJ_NAMES } from "./getInitQuery";
+import { syncData } from "../SyncReplication";
 import { addSub } from "./addSub";
+import { DB_OBJ_NAMES } from "./getInitQuery";
 import { notifListener } from "./notifListener";
 import { pushSubData } from "./pushSubData";
-import { getOnDataFunc, LocalFuncs, matchesLocalFuncs } from "../DboBuilder/subscribe";
-import { EVENT_TRIGGER_TAGS, EventTriggerTag } from "../Event_Trigger_Tags";
-import { EventTypes } from "../Logging";
 
 type PGP = pgPromise.IMain<{}, pg.IClient>;
 const pgp: PGP = pgPromise({
@@ -150,21 +150,6 @@ export type Subscription = Pick<SubscriptionParams,
 export class PubSubManager {
   static DELIMITER = '|$prstgls$|' as const;
 
-  static SCHEMA_ALTERING_QUERIES = [
-    'CREATE TABLE', 
-    'ALTER TABLE', 
-    'DROP TABLE', 
-    'CREATE VIEW', 
-    'DROP VIEW', 
-    'ALTER VIEW', 
-    'CREATE TABLE AS', 
-    'SELECT INTO',
-    'REVOKE',
-    'GRANT',
-    'CREATE POLICY', 
-    'DROP POLICY', 
-  ] as const;
-
   static EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID = "prostgles internal query that should be excluded from schema watch " as const;
 
   public static canCreate = async (db: DB) => {
@@ -265,19 +250,6 @@ export class PubSubManager {
     if (watchSchema && !(await isSuperUser(this.db))) {
       console.warn("prostgles watchSchema requires superuser db user. Will not watch using event triggers")
     }
-    let EVENT_TAG_LIST: typeof EVENT_TRIGGER_TAGS[number][] = ['COMMENT', 'CREATE TABLE', 'ALTER TABLE', 'DROP TABLE', 'CREATE VIEW', 'DROP VIEW', 'ALTER VIEW', 'CREATE TABLE AS', 'SELECT INTO', 'CREATE POLICY'];
-    if(watchSchema === "*"){
-      EVENT_TAG_LIST = EVENT_TRIGGER_TAGS.slice(0);
-    } else if (isObject(watchSchema) && typeof watchSchema !== "function"){
-      const watchSchemaKeys = getKeys(watchSchema);
-      const isInclusive = Object.values(watchSchema).every(v => v);
-      EVENT_TAG_LIST = EVENT_TRIGGER_TAGS
-        .slice(0)
-        .filter(v => {
-          const matches = watchSchemaKeys.includes(v);
-          return isInclusive? matches : !matches;
-        });
-    }
 
     try {
 
@@ -368,7 +340,7 @@ export class PubSubManager {
 
                 DROP EVENT TRIGGER IF EXISTS ${DB_OBJ_NAMES.schema_watch_trigger};
                 CREATE EVENT TRIGGER ${DB_OBJ_NAMES.schema_watch_trigger} ON ddl_command_end
-                WHEN TAG IN (\${EVENT_TAG_LIST:csv})
+                WHEN TAG IN (\${EVENT_TRIGGER_TAGS:csv})
                 EXECUTE PROCEDURE ${DB_OBJ_NAMES.schema_watch_func}();
 
             END IF;
@@ -379,7 +351,7 @@ export class PubSubManager {
 
 
         COMMIT;
-      `, { EVENT_TAG_LIST });
+      `, { EVENT_TRIGGER_TAGS });
       
       await this.db.any(query)
       .catch(e => {
@@ -608,4 +580,4 @@ export class PubSubManager {
 
 export const parseCondition = (condition: string): string => condition && condition.trim().length ? condition : "TRUE"
 
-export { pickKeys, omitKeys } from "prostgles-types"
+export { omitKeys, pickKeys } from "prostgles-types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.34",
+  "version": "4.2.36",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
     "pg-cursor": "^2.10.3",
     "pg-promise": "^11.5.4",
     "prostgles-client": "^4.0.53",
-    "prostgles-types": "^4.0.71"
+    "prostgles-types": "^4.0.73"
   },
   "devDependencies": {
     "@types/bluebird": "^3.5.36",

package/tests/client/hooks.spec.ts

@@ -0,0 +1,119 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { strict as assert } from "assert";
+import { describe, test } from "node:test";
+import type { DBHandlerClient } from "./index";
+const jsdom = require("jsdom");
+const { JSDOM } = jsdom;
+const { window } = new JSDOM(`<!DOCTYPE html>`);
+global.window = window;
+global.document = window.document;
+
+const expectValues = (result: { current: any; }, expectedValues: any[]) => {
+  let step = 0;
+  return waitFor(() => {
+    assert.deepStrictEqual(expectedValues[step], result.current);
+    const finished = step === expectedValues.length - 1;
+    step++;
+    if(!finished) throw new Error("Not finished"); 
+  });
+}
+
+export const clientHooks = async (db: DBHandlerClient) => {
+
+  await describe("Client hooks", async (t) => {
+    const defaultFilter = { name: "abc" };
+      
+    await Promise.all([
+      "useFind",
+      "useSubscribe",
+      "useFindOne",
+      "useSubscribeOne",
+    ].map(async hookName => {
+      await test(hookName, async (t) => {
+        const expectsOne = hookName.includes("One");
+        const options = {
+          select: { added: "$Mon" },
+          limit: expectsOne? undefined : 1
+        };
+        const { result, rerender } = renderHook((filter = defaultFilter) => db.items4[hookName]!(filter, options));
+        const expectedData = expectsOne? { added: "Dec" } : [{ added: "Dec" }];
+        // Initial state
+        assert.deepStrictEqual(result.current, { data: undefined, isLoading: true, error: undefined });
+        
+        // First fetch
+        await waitFor(() => {
+          assert.deepStrictEqual(
+            result.current, 
+            { 
+              data: expectedData, error: undefined, isLoading: false
+            }
+          );
+        });
+
+        // Rerender with different filter
+        rerender({ named: "error" });
+
+        // TODO fix first re-render result (useFetch setResult in async block might be affecting this)
+        // assert.deepStrictEqual(result.current, { data: undefined, isLoading: true, error: undefined });
+
+        await waitFor(() => {
+          assert.deepStrictEqual(
+            result.current, 
+            { 
+              data: undefined, 
+              error: {
+                message: 'Table: items4 -> disallowed/inexistent columns in filter: named \n' +
+                  '  Expecting one of: added, "id", "public", "name"',
+              },
+              isLoading: false
+            }
+          );
+        });
+      });
+    }));
+
+    await Promise.all([
+      { 
+        hookName: "useCount", 
+        result1: { data: 2, error: undefined, isLoading: false },
+        result2: [
+          { data: 2, error: undefined, isLoading: false },
+          { data: 0, error: undefined, isLoading: false },
+        ]
+      },
+      { 
+        hookName: "useSize", 
+        result1: { data: "93", error: undefined, isLoading: false },
+        result2: [
+          { data: "93", error: undefined, isLoading: false },
+          { data: "0", error: undefined, isLoading: false },
+        ]
+      },
+    ].map(async ({ hookName, result1, result2 }) => {
+      await test(hookName, async (t) => {
+        const { result, rerender } = renderHook((filter = defaultFilter) => db.items4[hookName](filter));
+        // Initial state
+        assert.deepStrictEqual(result.current, { data: undefined, isLoading: true, error: undefined });
+        
+        // First fetch
+        await waitFor(() => {
+          assert.deepStrictEqual(
+            result.current, 
+            result1
+          );
+        });
+  
+        // Rerender with different filter
+        rerender({ id: -1 });
+  
+        // New count
+        await expectValues(
+          result,
+          result2
+        );
+      });
+
+    }));
+
+  });
+}

package/tests/client/index.ts

@@ -7,6 +7,7 @@ import { clientRestApi } from "../clientRestApi.spec";
 import { clientFileTests } from "../clientFileTests.spec"; 
 import { InitOptions } from "prostgles-client/dist/prostgles";
 export { DBHandlerClient, Auth } from "prostgles-client/dist/prostgles";
+import { clientHooks } from "./hooks.spec";
 
 const start = Date.now();
 const log = (msgOrObj: any, extra?: any) => {
@@ -26,19 +27,19 @@ const tests: Record<string, ClientTestSpec> = {
     onRun: async (db, methods, tableSchema, auth) => {
       await isomorphicQueries(db, log);
       await clientOnlyQueries(db, auth, log, methods, tableSchema, TEST_NAME);
+      await clientHooks(db);
     },
   },
   files: {
     onRun: async (db, methods, tableSchema, auth) => {
       await clientFileTests(db, auth, log, methods, tableSchema)
     },
-
   },
   rest_api: {
     onRun: async (db, methods, tableSchema, auth) => {
       await clientRestApi(db, auth, log, methods, tableSchema, TEST_NAME);
     }
-  },
+  }
 };
 
 const test = tests[TEST_NAME];