prostgles-server 3.0.64 → 3.0.66

package/lib/DboBuilder/ViewHandler.ts

@@ -20,13 +20,13 @@ import {
 } from "../DboBuilder";
 import { Graph } from "../shortestPath";
 import { TableRule, UpdateRule, ValidateRow } from "../PublishParser";
-import { asValue, omitKeys } from "../PubSubManager";
+import { asValue, omitKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
 import { asNameAlias,  getNewQuery, parseFunctionObject, SelectItem, SelectItemValidated } from "./QueryBuilder/QueryBuilder";
 import { COMPUTED_FIELDS, FieldSpec, FUNCTIONS, parseFunction,  } from "./QueryBuilder/Functions";
 import { parseFilterItem } from "../Filtering";
 import { getColumns } from "./getColumns";
-
+import { LocalFunc, subscribe } from "./subscribe";
 export type JoinPaths = {
   t1: string;
   t2: string;
@@ -718,173 +718,24 @@ export class ViewHandler {
     }
   }
 
-
-
-  async subscribe(filter: Filter, params: SubscribeParams, localFunc: (items: AnyObject[]) => any): Promise<{ unsubscribe: () => any }>
-  async subscribe(filter: Filter, params: SubscribeParams, localFunc?: (items: AnyObject[]) => any, table_rules?: TableRule, localParams?: LocalParams): Promise<string>
-  async subscribe(filter: Filter, params: SubscribeParams = {}, localFunc?: (items: AnyObject[]) => any, table_rules?: TableRule, localParams?: LocalParams):
-    Promise<string | { unsubscribe: () => any }> {
-    try {
-      // if (this.is_view) throw "Cannot subscribe to a view";
-
-      if (this.t) throw "subscribe not allowed within transactions";
-      if (!localParams && !localFunc) throw " missing data. provide -> localFunc | localParams { socket } ";
-      if (localParams && localParams.socket && localFunc) {
-        console.error({ localParams, localFunc })
-        throw " Cannot have localFunc AND socket ";
-      }
-
-      const { filterFields, forcedFilter } = table_rules?.select || {},
-        filterOpts = await this.prepareWhere({ filter, forcedFilter, addKeywords: false, filterFields, tableAlias: undefined, localParams, tableRule: table_rules }),
-        condition = filterOpts.where,
-        throttle = params?.throttle || 0,
-        selectParams = omitKeys(params || {}, ["throttle"]);
- 
-      /** app_triggers condition field has an index which limits it's value */
-      const filterSize = JSON.stringify(filter || {}).length;
-      if (filterSize * 4 > 2704) {
-        throw "filter too big. Might exceed the btree version 4 maximum 2704. Use a primary key or a $rowhash filter instead"
-      }
-
-      if (!localFunc) {
-        if (!this.dboBuilder.prostgles.isSuperUser) throw "Subscribe not possible. Must be superuser to add triggers 1856";
-        return await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams)
-          .then(async isValid => {
-
-            let relatedTableSubscriptions: {
-              tableName: string;
-              tableNameEscaped: string;
-              condition: string;
-            }[] | undefined = undefined;
-
-            if(this.is_view){
-              const viewName = this.name;
-              const viewNameEscaped = this.escapedName;
-              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 };
-              def = def.trim();
-              if(def.endsWith(";")) {
-                def = def.slice(0, -1);
-              }
-              if(!def || typeof def !== "string") makeErr("Could get view definition");
-              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 = Array.from(new Set(tableColumns.map(tc => tc.tableID!.toString())));
-              relatedTableSubscriptions = tableIds.map(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;
-                if(!tableCols.length){
-                  return {
-                    tableName: tableName,
-                    tableNameEscaped: JSON.stringify(tableName),// [table.schemaname, table.relname].map(v => JSON.stringify(v)).join("."),
-                    condition: "TRUE"
-                  }
-                } 
-
-                const tableNameEscaped = tableSchema === current_schema? table.relname : [tableSchema, tableName].map(v => JSON.stringify(v)).join("."); 
-
-                const relatedTableSubscription = {
-                  tableName: tableName!,
-                  tableNameEscaped,
-                  condition: `EXISTS (
-                    SELECT 1
-                    FROM ${viewNameEscaped}
-                    WHERE ${tableCols.map(c => `${tableNameEscaped}.${JSON.stringify(c.columnName)} = ${viewNameEscaped}.${JSON.stringify(c.name)}`).join(" AND \n")}
-                    AND ${condition || "TRUE"}
-                  )`
-                }
-
-                return relatedTableSubscription;
-              })
-              
-              /** 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 }
-              );
-
-              /** 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));
-              relatedTableSubscriptions = [
-                ...relatedTableSubscriptions,
-                ...remainingInnerTables.map(t => ({
-                  tableName: t.table_name,
-                  tableNameEscaped: [t.table_name, t.table_schema].map(v => JSON.stringify(v)).join("."),
-                  condition: "TRUE"
-                }))
-              ];
-
-              if(!relatedTableSubscriptions.length){
-                throw "Could not subscribe to this view: no related tables found";
-              } 
-            }
-
-            const { socket } = localParams ?? {};
-            const pubSubManager = await this.dboBuilder.getPubSubManager();
-            return pubSubManager.addSub({
-              table_info: this.tableOrViewInfo,
-              socket,
-              table_rules,
-              table_name: this.name,
-              condition: condition,
-              relatedTableSubscriptions,
-              func: undefined,
-              filter: { ...filter },
-              params: { ...selectParams },
-              socket_id: socket?.id,
-              throttle,
-              last_throttled: 0, 
-            }).then(channelName => ({ channelName }));
-          }) as string;
-      } else {
-        const pubSubManager = await this.dboBuilder.getPubSubManager();
-        pubSubManager.addSub({
-          table_info: this.tableOrViewInfo,
-          socket: undefined,
-          table_rules,
-          condition,
-          func: localFunc,
-          filter: { ...filter },
-          params: { ...selectParams },
-          socket_id: undefined,
-          table_name: this.name,
-          throttle,
-          last_throttled: 0, 
-        }).then(channelName => ({ channelName }));
-        const unsubscribe = async () => {
-          const pubSubManager = await this.dboBuilder.getPubSubManager();
-          pubSubManager.removeLocalSub(this.name, condition, localFunc)
-        };
-        let res: { unsubscribe: () => any } = Object.freeze({ unsubscribe })
-        return res;
-      }
-    } catch (e) {
-      if (localParams && localParams.testRule) throw e;
-      throw parseError(e, `dbo.${this.name}.subscribe()`);
-    }
+  async subscribe(filter: Filter, params: SubscribeParams, localFunc: LocalFunc): Promise<{ unsubscribe: () => any }> 
+  async subscribe(filter: Filter, params: SubscribeParams, localFunc: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<string>
+  async subscribe(filter: Filter, params: SubscribeParams, localFunc?: LocalFunc, table_rules?: TableRule, localParams?: LocalParams): 
+    Promise<{ unsubscribe: () => any } | string> {
+      //@ts-ignore
+      return subscribe.bind(this)(filter, params, localFunc, table_rules, localParams);
   }
 
   /* This should only be called from server */
   subscribeOne(filter: Filter, params: SubscribeParams, localFunc: (item: AnyObject) => any): Promise<{ unsubscribe: () => any }>
-  subscribeOne(filter: Filter, params: SubscribeParams, localFunc: (item: AnyObject) => any, table_rules?: TableRule, localParams?: LocalParams): Promise<string>
-  subscribeOne(filter: Filter, params: SubscribeParams = {}, localFunc: (item: AnyObject) => any, table_rules?: TableRule, localParams?: LocalParams):
+  subscribeOne(filter: Filter, params: SubscribeParams, localFunc: undefined, table_rules: TableRule, localParams: LocalParams): Promise<string>
+  subscribeOne(filter: Filter, params: SubscribeParams = {}, localFunc?: (item: AnyObject) => any, table_rules?: TableRule, localParams?: LocalParams):
     Promise<string | { unsubscribe: () => any }> {
-    let func = localParams ? undefined : (rows: AnyObject[]) => localFunc(rows[0]);
-    return this.subscribe(filter, { ...params, limit: 2 }, func, table_rules, localParams);
+       
+      //@ts-ignore
+      let func = localParams? undefined : (rows: AnyObject[]) => localFunc(rows[0]); 
+      //@ts-ignore
+      return this.subscribe(filter, { ...params, limit: 2 }, func, table_rules, localParams);
   }
 
   async count(filter?: Filter, param2_unused?: undefined, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<number> {

package/lib/DboBuilder/delete.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._delete = void 0;
 const prostgles_types_1 = require("prostgles-types");
 const DboBuilder_1 = require("../DboBuilder");
-const PubSubManager_1 = require("../PubSubManager");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 async function _delete(filter, params, param3_unused, table_rules, localParams) {
     try {
         const { returning } = params || {};

package/lib/DboBuilder/delete.ts

@@ -2,7 +2,7 @@ import pgPromise from "pg-promise";
 import { AnyObject, asName, DeleteParams, FieldFilter } from "prostgles-types";
 import { Filter, LocalParams, makeErr, parseError } from "../DboBuilder";
 import { DeleteRule, TableRule } from "../PublishParser";
-import { pickKeys } from "../PubSubManager";
+import { pickKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
 
 export async function _delete(this: TableHandler, filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {

package/lib/DboBuilder/insert.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insert = void 0;
 const prostgles_types_1 = require("prostgles-types");
 const DboBuilder_1 = require("../DboBuilder");
-const PubSubManager_1 = require("../PubSubManager");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 async function insert(rowOrRows, param2, param3_unused, tableRules, localParams) {
     // const localParams = _localParams || {};
     const ACTION = "insert";

package/lib/DboBuilder/insert.ts

@@ -2,7 +2,7 @@ import pgPromise from "pg-promise";
 import { AnyObject, asName, FieldFilter, get, getKeys, InsertParams, isObject } from "prostgles-types";
 import { isPlainObject, LocalParams, makeErr, parseError, pgp } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
-import { asValue, omitKeys, pickKeys } from "../PubSubManager";
+import { asValue, omitKeys, pickKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
 
 export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any | any[] | boolean> {

package/lib/DboBuilder/insertDataParse.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertDataParse = void 0;
 const prostgles_types_1 = require("prostgles-types");
-const PubSubManager_1 = require("../PubSubManager");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 const uploadFile_1 = require("./uploadFile");
 /**
  * Used for doing referenced inserts within a single transaction

package/lib/DboBuilder/insertDataParse.ts

@@ -1,7 +1,7 @@
 import { AnyObject, getKeys, InsertParams, isDefined, isObject, PG_COLUMN_UDT_DATA_TYPE } from "prostgles-types";
 import { LocalParams, TableHandlers } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
-import { omitKeys } from "../PubSubManager";
+import { omitKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
 import { uploadFile } from "./uploadFile";
 

package/lib/DboBuilder/runSQL.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCreateTables = exports.canRunSQL = exports.runSQL = void 0;
 const DboBuilder_1 = require("../DboBuilder");
-const PubSubManager_1 = require("../PubSubManager");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 const { ParameterizedQuery: PQ } = require('pg-promise');
 async function runSQL(query, params, options, localParams) {
     if (query?.replace(/\s\s+/g, ' ').toLowerCase().includes("create extension pg_stat_statements")) {

package/lib/DboBuilder/runSQL.ts

@@ -1,7 +1,7 @@
 import { PG_COLUMN_UDT_DATA_TYPE, SQLHandler, SQLOptions, SQLResult } from "prostgles-types";
 import { DboBuilder, LocalParams, pgp, postgresToTsType } from "../DboBuilder";
 import { DB, Prostgles } from "../Prostgles";
-import { PubSubManager } from "../PubSubManager";
+import { PubSubManager } from "../PubSubManager/PubSubManager";
 const { ParameterizedQuery: PQ } = require('pg-promise');
 
 

package/lib/DboBuilder/subscribe.d.ts

@@ -0,0 +1,11 @@
+import { AnyObject, SubscribeParams } from "prostgles-types";
+import { Filter, LocalParams } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+import { ViewHandler } from "./ViewHandler";
+export declare type LocalFunc = (items: AnyObject[]) => any;
+declare function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFunc: LocalFunc): Promise<{
+    unsubscribe: () => any;
+}>;
+declare function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFunc: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<string>;
+export { subscribe };
+//# sourceMappingURL=subscribe.d.ts.map

package/lib/DboBuilder/subscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["subscribe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,oBAAY,SAAS,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,GAAG,CAAC;AAEpD,iBAAe,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,GAAG,CAAA;CAAE,CAAC,CAAA;AAC/I,iBAAe,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,GAAG,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AA4NzL,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/lib/DboBuilder/subscribe.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribe = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const DboBuilder_1 = require("../DboBuilder");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
+async function subscribe(filter, params, localFunc, table_rules, localParams) {
+    try {
+        // if (this.is_view) throw "Cannot subscribe to a view";
+        if (this.t) {
+            throw "subscribe not allowed within transactions";
+        }
+        if (!localParams && !localFunc) {
+            throw " missing data. provide -> localFunc | localParams { socket } ";
+        }
+        if (localParams?.socket && localFunc) {
+            console.error({ localParams, localFunc });
+            throw " Cannot have localFunc AND socket ";
+        }
+        const { filterFields, forcedFilter } = table_rules?.select || {}, filterOpts = await this.prepareWhere({ filter, forcedFilter, addKeywords: false, filterFields, tableAlias: undefined, localParams, tableRule: table_rules }), condition = filterOpts.where, throttle = params?.throttle || 0, selectParams = (0, PubSubManager_1.omitKeys)(params || {}, ["throttle"]);
+        /** app_triggers condition field has an index which limits it's value.
+         * TODO: use condition md5 hash
+         * */
+        const filterSize = JSON.stringify(filter || {}).length;
+        if (filterSize * 4 > 2704) {
+            throw "filter too big. Might exceed the btree version 4 maximum 2704. Use a primary key or a $rowhash filter instead";
+        }
+        if (!localFunc) {
+            if (!this.dboBuilder.prostgles.isSuperUser) {
+                throw "Subscribe not possible. Must be superuser to add triggers 1856";
+            }
+            return await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams)
+                .then(async (_isValid) => {
+                let viewOptions = undefined;
+                if (this.is_view) {
+                    const viewName = this.name;
+                    const viewNameEscaped = this.escapedName;
+                    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 }));
+                    def = def.trim();
+                    if (def.endsWith(";")) {
+                        def = def.slice(0, -1);
+                    }
+                    if (!def || typeof def !== "string") {
+                        throw (0, DboBuilder_1.makeErr)("Could get view definition");
+                    }
+                    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 = Array.from(new Set(tableColumns.map(tc => tc.tableID.toString())));
+                    viewOptions = {
+                        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;
+                        if (tableCols.length) {
+                            const tableNameEscaped = tableSchema === current_schema ? table.relname : [tableSchema, tableName].map(v => JSON.stringify(v)).join(".");
+                            const fullCondition = `EXISTS (
+                  SELECT 1
+                  FROM ${viewNameEscaped}
+                  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(`
+                    WITH ${(0, prostgles_types_1.asName)(tableName)} AS (
+                      SELECT * 
+                      FROM ${(0, prostgles_types_1.asName)(tableName)}
+                      LIMIT 0
+                    )
+
+                    SELECT *
+                    FROM (
+                      ${def}
+                    ) prostgles_view_ref_table_test
+                  `);
+                                const relatedTableSubscription = {
+                                    tableName: tableName,
+                                    tableNameEscaped,
+                                    condition: fullCondition,
+                                };
+                                if (count.toString() === '0') {
+                                    return relatedTableSubscription;
+                                }
+                            }
+                            catch (e) {
+                                (0, PubSubManager_1.log)(`Could not not override subscribed view (${this.name}) table (${tableName}). Will not check condition`, e);
+                            }
+                        }
+                        return {
+                            tableName: tableName,
+                            tableNameEscaped: JSON.stringify(tableName),
+                            condition: "TRUE"
+                        };
+                    }));
+                    /** Get list of remaining used inner tables */
+                    const allUsedTables = 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));
+                    viewOptions.relatedTables = [
+                        ...viewOptions.relatedTables,
+                        ...remainingInnerTables.map(t => ({
+                            tableName: t.table_name,
+                            tableNameEscaped: [t.table_name, t.table_schema].map(v => JSON.stringify(v)).join("."),
+                            condition: "TRUE"
+                        }))
+                    ];
+                    if (!viewOptions.relatedTables.length) {
+                        throw "Could not subscribe to this view: no related tables found";
+                    }
+                }
+                const { socket } = localParams ?? {};
+                const pubSubManager = await this.dboBuilder.getPubSubManager();
+                return pubSubManager.addSub({
+                    table_info: this.tableOrViewInfo,
+                    socket,
+                    table_rules,
+                    table_name: this.name,
+                    condition: condition,
+                    viewOptions,
+                    func: undefined,
+                    filter: { ...filter },
+                    params: { ...selectParams },
+                    socket_id: socket?.id,
+                    throttle,
+                    last_throttled: 0,
+                }).then(channelName => ({ channelName }));
+            });
+        }
+        else {
+            const pubSubManager = await this.dboBuilder.getPubSubManager();
+            pubSubManager.addSub({
+                table_info: this.tableOrViewInfo,
+                socket: undefined,
+                table_rules,
+                condition,
+                func: localFunc,
+                filter: { ...filter },
+                params: { ...selectParams },
+                socket_id: undefined,
+                table_name: this.name,
+                throttle,
+                last_throttled: 0,
+            }).then(channelName => ({ channelName }));
+            const unsubscribe = async () => {
+                const pubSubManager = await this.dboBuilder.getPubSubManager();
+                pubSubManager.removeLocalSub(this.name, condition, localFunc);
+            };
+            let res = Object.freeze({ unsubscribe });
+            return res;
+        }
+    }
+    catch (e) {
+        if (localParams && localParams.testRule)
+            throw e;
+        throw (0, DboBuilder_1.parseError)(e, `dbo.${this.name}.subscribe()`);
+    }
+}
+exports.subscribe = subscribe;
+async function _subscribe(localFunc, table_rules, localParams) {
+    if (localFunc && !localParams) {
+        return {
+            unsubscribe: () => { }
+        };
+    }
+    if (localParams) {
+        return "";
+    }
+    return {
+        unsubscribe: () => { }
+    };
+}
+const d = async () => {
+    const res = await _subscribe(() => { });
+    const res2 = await _subscribe(undefined, {}, {});
+};