prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -1,7 +1,17 @@
-import { AnyObject, asName, ParsedJoinPath, reverseParsedPath, SubscribeParams } from "prostgles-types";
+import {
+  AnyObject,
+  asName,
+  ParsedJoinPath,
+  reverseParsedPath,
+  SubscribeParams,
+} from "prostgles-types";
 import { TableRule } from "../PublishParser/PublishParser";
 import { log, ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
-import { Filter, getSerializedClientErrorFromPGError, LocalParams } from "./DboBuilder";
+import {
+  Filter,
+  getSerializedClientErrorFromPGError,
+  LocalParams,
+} from "./DboBuilder";
 import { NewQuery } from "./QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler/ViewHandler";
 
@@ -11,69 +21,100 @@ type Args = {
   table_rules: TableRule<AnyObject, void> | undefined;
   localParams: LocalParams | undefined;
   newQuery: NewQuery;
-}
+};
 
 /**
  * When subscribing to a view: we identify underlying tables to subscribe to them
  * When subscribing to a table: we identify joined tables to subscribe to them
  */
-export async function getSubscribeRelatedTables(this: ViewHandler, { filter, localParams, newQuery }: Args){
-
+export async function getSubscribeRelatedTables(
+  this: ViewHandler,
+  { filter, localParams, 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")
+    const { current_schema } = await this.db.oneOrNone("SELECT current_schema");
 
     /** Get list of used columns and their parent tables */
-    let { def } = (await this.db.oneOrNone("SELECT pg_get_viewdef(${viewName}) as def", { viewName })) as { def: string };
+    let { def } = (await this.db.oneOrNone(
+      "SELECT pg_get_viewdef(${viewName}) as def",
+      { viewName },
+    )) as { def: string };
     def = def.trim();
     if (def.endsWith(";")) {
       def = def.slice(0, -1);
     }
     if (!def || typeof def !== "string") {
-      throw getSerializedClientErrorFromPGError("Could get view definition", { type: "tableMethod", localParams, view: this,  });
+      throw getSerializedClientErrorFromPGError("Could get view definition", {
+        type: "tableMethod",
+        localParams,
+        view: this,
+      });
     }
-    const { fields } = await this.dboBuilder.dbo.sql!(`SELECT * FROM ( \n ${def} \n ) prostgles_subscribe_view_definition LIMIT 0`, {});
-    const tableColumns = fields.filter(f => f.tableName && f.columnName);
+    const { fields } = await this.dboBuilder.dbo.sql!(
+      `SELECT * FROM ( \n ${def} \n ) prostgles_subscribe_view_definition LIMIT 0`,
+      {},
+    );
+    const tableColumns = fields.filter((f) => f.tableName && f.columnName);
 
     /** Create exists filters for each table */
-    const tableIds: string[] = Array.from(new Set(tableColumns.map(tc => tc.tableID!.toString())));
+    const tableIds: string[] = Array.from(
+      new Set(tableColumns.map((tc) => tc.tableID!.toString())),
+    );
     viewOptions = {
       type: "view",
       viewName,
       definition: def,
-      relatedTables: []
-    }
-    viewOptions.relatedTables = await Promise.all(tableIds.map(async tableID => {
-      const table = this.dboBuilder.USER_TABLES!.find(t => t.relid === +tableID)!;
-      let tableCols = tableColumns.filter(tc => tc.tableID!.toString() === tableID);
-
-      /** If table has primary keys and they are all in this view then use only primary keys */
-      if (table?.pkey_columns?.every(pkey => tableCols.some(c => c.columnName === pkey))) {
-        tableCols = tableCols.filter(c => table?.pkey_columns?.includes(c.columnName!))
-      } else {
-        /** Exclude non comparable data types */
-        tableCols = tableCols.filter(c => !["json", "xml"].includes(c.udt_name))
-      }
-
-      const { relname: tableName, schemaname: tableSchema } = table;
+      relatedTables: [],
+    };
+    viewOptions.relatedTables = await Promise.all(
+      tableIds.map(async (tableID) => {
+        const table = this.dboBuilder.USER_TABLES!.find(
+          (t) => t.relid === +tableID,
+        )!;
+        let tableCols = tableColumns.filter(
+          (tc) => tc.tableID!.toString() === tableID,
+        );
+
+        /** If table has primary keys and they are all in this view then use only primary keys */
+        if (
+          table?.pkey_columns?.every((pkey) =>
+            tableCols.some((c) => c.columnName === pkey),
+          )
+        ) {
+          tableCols = tableCols.filter((c) =>
+            table?.pkey_columns?.includes(c.columnName!),
+          );
+        } else {
+          /** Exclude non comparable data types */
+          tableCols = tableCols.filter(
+            (c) => !["json", "xml"].includes(c.udt_name),
+          );
+        }
 
-      if (tableCols.length) {
+        const { relname: tableName, schemaname: tableSchema } = table;
 
-        const tableNameEscaped = tableSchema === current_schema ? table.relname : [tableSchema, tableName].map(v => JSON.stringify(v)).join(".");
+        if (tableCols.length) {
+          const tableNameEscaped =
+            tableSchema === current_schema
+              ? table.relname
+              : [tableSchema, tableName]
+                  .map((v) => JSON.stringify(v))
+                  .join(".");
 
-        const fullCondition = `EXISTS (
+          const fullCondition = `EXISTS (
               SELECT 1
               FROM ${viewNameEscaped}
-              WHERE ${tableCols.map(c => `${tableNameEscaped}.${JSON.stringify(c.columnName)} = ${viewNameEscaped}.${JSON.stringify(c.name)}`).join(" AND \n")}
+              WHERE ${tableCols.map((c) => `${tableNameEscaped}.${JSON.stringify(c.columnName)} = ${viewNameEscaped}.${JSON.stringify(c.name)}`).join(" AND \n")}
               AND ${condition || "TRUE"}
             )`;
 
-        try {
-          const { count } = await this.db.oneOrNone(`
+          try {
+            const { count } = await this.db.oneOrNone(`
             WITH ${asName(tableName)} AS (
               SELECT * 
               FROM ${asName(tableName)}
@@ -86,43 +127,56 @@ export async function getSubscribeRelatedTables(this: ViewHandler, { filter, loc
             ) prostgles_view_ref_table_test
           `);
 
-          const relatedTableSubscription = {
-            tableName: tableName!,
-            tableNameEscaped,
-            condition: fullCondition,
-          }
+            const relatedTableSubscription = {
+              tableName: tableName!,
+              tableNameEscaped,
+              condition: fullCondition,
+            };
 
-          if (count.toString() === '0') {
-            return relatedTableSubscription;
+            if (count.toString() === "0") {
+              return relatedTableSubscription;
+            }
+          } catch (e) {
+            log(
+              `Could not not override subscribed view (${this.name}) table (${tableName}). Will not check condition`,
+              e,
+            );
           }
-        } catch (e) {
-          log(`Could not not override subscribed view (${this.name}) table (${tableName}). Will not check condition`, e);
         }
-      }
-
-      return {
-        tableName,
-        tableNameEscaped: JSON.stringify(tableName),// [table.schemaname, table.relname].map(v => JSON.stringify(v)).join("."),
-        condition: "TRUE"
-      }
 
-    }))
+        return {
+          tableName,
+          tableNameEscaped: JSON.stringify(tableName), // [table.schemaname, table.relname].map(v => JSON.stringify(v)).join("."),
+          condition: "TRUE",
+        };
+      }),
+    );
 
     /** Get list of remaining used inner tables */
-    const allUsedTables: { table_name: string; table_schema: string; }[] = await this.db.any(
-      "SELECT distinct table_name, table_schema FROM information_schema.view_column_usage WHERE view_name = ${viewName}",
-      { viewName }
-    );
+    const allUsedTables: { table_name: string; table_schema: string }[] =
+      await this.db.any(
+        "SELECT distinct table_name, table_schema FROM information_schema.view_column_usage WHERE view_name = ${viewName}",
+        { viewName },
+      );
 
     /** Remaining tables will have listeners on all records (condition = "TRUE") */
-    const remainingInnerTables = allUsedTables.filter(at => !tableColumns.some(dc => dc.tableName === at.table_name && dc.tableSchema === at.table_schema));
+    const remainingInnerTables = allUsedTables.filter(
+      (at) =>
+        !tableColumns.some(
+          (dc) =>
+            dc.tableName === at.table_name &&
+            dc.tableSchema === at.table_schema,
+        ),
+    );
     viewOptions.relatedTables = [
       ...viewOptions.relatedTables,
-      ...remainingInnerTables.map(t => ({
+      ...remainingInnerTables.map((t) => ({
         tableName: t.table_name,
-        tableNameEscaped: [t.table_name, t.table_schema].map(v => JSON.stringify(v)).join("."),
-        condition: "TRUE"
-      }))
+        tableNameEscaped: [t.table_name, t.table_schema]
+          .map((v) => JSON.stringify(v))
+          .join("."),
+        condition: "TRUE",
+      })),
     ];
 
     if (!viewOptions.relatedTables.length) {
@@ -133,51 +187,58 @@ export async function getSubscribeRelatedTables(this: ViewHandler, { filter, loc
   } else {
     viewOptions = {
       type: "table",
-      relatedTables: []
-    }
+      relatedTables: [],
+    };
 
     const nonExistsFilter = newQuery.whereOpts.exists.length ? {} : filter;
-    const pushRelatedTable = async (relatedTableName: string, joinPath: ParsedJoinPath[]) => {
+    const pushRelatedTable = async (
+      relatedTableName: string,
+      joinPath: ParsedJoinPath[],
+    ) => {
       const relatedTableOrViewHandler = this.dboBuilder.dbo[relatedTableName];
       if (!relatedTableOrViewHandler) {
         throw `Table ${relatedTableName} not found`;
       }
 
-      const alreadyPushed = viewOptions?.relatedTables.find(rt => rt.tableName === relatedTableName)
-      if(alreadyPushed || relatedTableOrViewHandler.is_view){
-        return
+      const alreadyPushed = viewOptions?.relatedTables.find(
+        (rt) => rt.tableName === relatedTableName,
+      );
+      if (alreadyPushed || relatedTableOrViewHandler.is_view) {
+        return;
       }
 
       viewOptions ??= {
         type: "table",
-        relatedTables: []
-      }
+        relatedTables: [],
+      };
       viewOptions.relatedTables.push({
         tableName: relatedTableName,
         tableNameEscaped: asName(relatedTableName),
-        condition: (await relatedTableOrViewHandler!.prepareWhere!({
-          select: undefined,
-          filter: {
-            $existsJoined: {
-              path: reverseParsedPath(joinPath, this.name),
-              filter: nonExistsFilter
-            }
-          },
-          addWhere: false,
-          localParams: undefined,
-          tableRule: undefined
-        })).where
+        condition: (
+          await relatedTableOrViewHandler!.prepareWhere!({
+            select: undefined,
+            filter: {
+              $existsJoined: {
+                path: reverseParsedPath(joinPath, this.name),
+                filter: nonExistsFilter,
+              },
+            },
+            addWhere: false,
+            localParams: undefined,
+            tableRule: undefined,
+          })
+        ).where,
       });
-    }
+    };
 
     /**
      * Avoid nested exists error. Will affect performance
      */
-    for await (const j of (newQuery.joins ?? [])) {
+    for await (const j of newQuery.joins ?? []) {
       await pushRelatedTable(j.table, j.joinPath);
     }
-    for await (const e of newQuery.whereOpts.exists.filter(e => e.isJoined)) {
-      if(!e.isJoined) throw `Not possible`;
+    for await (const e of newQuery.whereOpts.exists.filter((e) => e.isJoined)) {
+      if (!e.isJoined) throw `Not possible`;
       const targetTable = e.parsedPath.at(-1)!.table;
       await pushRelatedTable(targetTable, e.parsedPath);
     }
@@ -187,4 +248,4 @@ export async function getSubscribeRelatedTables(this: ViewHandler, { filter, loc
   }
 
   return viewOptions;
-}
+}

package/lib/DboBuilder/getTablesForSchemaPostgresSQL.ts

@@ -6,7 +6,10 @@ import { clone } from "../utils";
 import { TableSchema, TableSchemaColumn } from "./DboBuilderTypes";
 import { ProstglesInitOptions } from "../ProstglesTypes";
 
-const getMaterialViews = (db: DBorTx, schema: ProstglesInitOptions["schemaFilter"]) => {
+const getMaterialViews = (
+  db: DBorTx,
+  schema: ProstglesInitOptions["schemaFilter"],
+) => {
   const { sql, schemaNames } = getSchemaFilter(schema);
 
   const query = `
@@ -97,7 +100,9 @@ where nspname = 'public' and relname = 'test_view';
   return db.any(query, { schemaNames });
 };
 
-export const getSchemaFilter = (schema: ProstglesInitOptions["schemaFilter"] = { public: 1 }) => {
+export const getSchemaFilter = (
+  schema: ProstglesInitOptions["schemaFilter"] = { public: 1 },
+) => {
   const schemaNames = Object.keys(schema);
   const isInclusive = Object.values(schema).every((v) => v);
   if (!schemaNames.length) {
@@ -114,7 +119,7 @@ export const getSchemaFilter = (schema: ProstglesInitOptions["schemaFilter"] = {
 // Reason: this query gets blocked by prostgles.app_triggers from PubSubManager.addTrigger in some cases (pg_dump locks that table)
 export async function getTablesForSchemaPostgresSQL(
   { db, runSQL }: DboBuilder,
-  schema: ProstglesInitOptions["schemaFilter"]
+  schema: ProstglesInitOptions["schemaFilter"],
 ): Promise<{
   result: TableSchema[];
   durations: Record<string, number>;
@@ -160,7 +165,7 @@ export async function getTablesForSchemaPostgresSQL(
       )
       SELECT * FROM  fk
       `,
-        { schemaNames }
+        { schemaNames },
       );
 
       return { fkeys };
@@ -212,8 +217,9 @@ export async function getTablesForSchemaPostgresSQL(
     }
 
     const getTVColumns = await tryCatch(async () => {
-      const columns: (TableSchemaColumn & { table_oid: number })[] = await t.any(
-        `
+      const columns: (TableSchemaColumn & { table_oid: number })[] =
+        await t.any(
+          `
           SELECT
             table_oid
               , ccc.column_name as name ,
@@ -275,8 +281,8 @@ export async function getTablesForSchemaPostgresSQL(
           WHERE table_schema ${sql}
           ORDER BY table_oid, ordinal_position
       `,
-        { schemaNames }
-      );
+          { schemaNames },
+        );
 
       return { columns };
     });
@@ -285,7 +291,8 @@ export async function getTablesForSchemaPostgresSQL(
     }
 
     const getViewParentTables = await tryCatch(async () => {
-      const parent_tables: { oid: number; table_names: string[] }[] = await t.any(`
+      const parent_tables: { oid: number; table_names: string[] }[] =
+        await t.any(`
         SELECT cl_r.oid, cl_r.relname as view_name, array_agg(DISTINCT cl_d.relname) AS table_names 
         FROM pg_rewrite AS r 
         JOIN pg_class AS cl_r ON r.ev_class = cl_r.oid 
@@ -331,18 +338,18 @@ export async function getTablesForSchemaPostgresSQL(
         --GROUP BY t.table_schema, t.table_name, t.is_view, t.view_definition, t.oid
         ORDER BY schema, name
         `;
-      const tablesAndViews = ((await t.any(query, { schemaNames })) as TableSchema[]).map(
-        (table) => {
-          table.columns =
-            clone(getTVColumns.columns)
-              .filter((c) => c.table_oid === table.oid)
-              .map((c) => omitKeys(c, ["table_oid"])) ?? [];
-          table.parent_tables =
-            getViewParentTables.parent_tables?.find((vr) => vr.oid === table.oid)?.table_names ??
-            [];
-          return table;
-        }
-      );
+      const tablesAndViews = (
+        (await t.any(query, { schemaNames })) as TableSchema[]
+      ).map((table) => {
+        table.columns =
+          clone(getTVColumns.columns)
+            .filter((c) => c.table_oid === table.oid)
+            .map((c) => omitKeys(c, ["table_oid"])) ?? [];
+        table.parent_tables =
+          getViewParentTables.parent_tables?.find((vr) => vr.oid === table.oid)
+            ?.table_names ?? [];
+        return table;
+      });
       return { tablesAndViews };
     });
     if (getTablesAndViews.error || !getTablesAndViews.tablesAndViews) {
@@ -365,7 +372,9 @@ export async function getTablesForSchemaPostgresSQL(
       console.error(getHyperTablesReq.error);
     }
 
-    let result = getTablesAndViews.tablesAndViews.concat(getMaterialViewsReq.materialViews);
+    let result = getTablesAndViews.tablesAndViews.concat(
+      getMaterialViewsReq.materialViews,
+    );
     result = await Promise.all(
       result.map(async (table) => {
         table.name = table.escaped_identifier;
@@ -379,7 +388,7 @@ export async function getTablesForSchemaPostgresSQL(
           allowAllIfNoColumns ?? table.columns.some((c) => c.privileges.UPDATE);
         table.columns = table.columns.map((c) => {
           const refs = getFkeys.fkeys!.filter(
-            (fc) => fc.oid === table.oid && fc.cols.includes(c.name)
+            (fc) => fc.oid === table.oid && fc.cols.includes(c.name),
           );
           if (refs.length)
             c.references = refs.map((_ref) => {
@@ -395,25 +404,30 @@ export async function getTablesForSchemaPostgresSQL(
         let viewFCols: Pick<TableSchemaColumn, "name" | "references">[] = [];
         if (table.is_view) {
           try {
-            const view_definition =
-              table.view_definition?.endsWith(";") ?
-                table.view_definition.slice(0, -1)
+            const view_definition = table.view_definition?.endsWith(";")
+              ? table.view_definition.slice(0, -1)
               : table.view_definition;
             const { fields } = (await runSQL(
               `SELECT * FROM \n ( ${view_definition!} \n) t LIMIT 0`,
               {},
               {},
-              undefined
+              undefined,
             )) as SQLResult<undefined>;
-            const ftables = result.filter((r) => fields.some((f) => f.tableID === r.oid));
+            const ftables = result.filter((r) =>
+              fields.some((f) => f.tableID === r.oid),
+            );
             ftables.forEach((ft) => {
               const fFields = fields.filter((f) => f.tableID === ft.oid);
               const pkeys = ft.columns.filter((c) => c.is_pkey);
-              const fFieldPK = fFields.filter((ff) => pkeys.some((p) => p.name === ff.columnName));
+              const fFieldPK = fFields.filter((ff) =>
+                pkeys.some((p) => p.name === ff.columnName),
+              );
               const refCols =
-                pkeys.length && fFieldPK.length === pkeys.length ?
-                  fFieldPK
-                : fFields.filter((ff) => !["json", "jsonb", "xml"].includes(ff.udt_name));
+                pkeys.length && fFieldPK.length === pkeys.length
+                  ? fFieldPK
+                  : fFields.filter(
+                      (ff) => !["json", "jsonb", "xml"].includes(ff.udt_name),
+                    );
               const _fcols: typeof viewFCols = refCols.map((ff) => {
                 const d: Pick<TableSchemaColumn, "name" | "references"> = {
                   name: ff.columnName!,
@@ -438,13 +452,11 @@ export async function getTablesForSchemaPostgresSQL(
           if (col.has_default) {
             /** Hide pkey default value */
             col.column_default =
-              (
-                col.udt_name !== "uuid" &&
-                !col.is_pkey &&
-                !col.column_default.startsWith("nextval(")
-              ) ?
-                col.column_default
-              : null;
+              col.udt_name !== "uuid" &&
+              !col.is_pkey &&
+              !col.column_default.startsWith("nextval(")
+                ? col.column_default
+                : null;
           }
 
           const viewFCol = viewFCols?.find((fc) => fc.name === col.name);
@@ -454,14 +466,19 @@ export async function getTablesForSchemaPostgresSQL(
 
           return col;
         });
-        table.isHyperTable = getHyperTablesReq.hyperTables?.includes(table.name);
+        table.isHyperTable = getHyperTablesReq.hyperTables?.includes(
+          table.name,
+        );
 
         table.uniqueColumnGroups = uniqueColsReq.data
-          ?.filter((r) => r.table_name === table.name && r.table_schema === table.schema)
+          ?.filter(
+            (r) =>
+              r.table_name === table.name && r.table_schema === table.schema,
+          )
           .map((r) => r.column_names);
 
         return table;
-      })
+      }),
     );
 
     const res = {
@@ -493,11 +510,11 @@ const getHyperTables = async (db: DBorTx): Promise<string[] | undefined> => {
           AND table_schema = ${schema} \
           AND table_name = 'hypertable' \
     );",
-    { schema }
+    { schema },
   );
   if (res.exists) {
     const tables: { table_name: string }[] = await db.any(
-      "SELECT table_name FROM " + asName(schema) + ".hypertable;"
+      "SELECT table_name FROM " + asName(schema) + ".hypertable;",
     );
     return tables.map((t) => t.table_name);
   }