prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,4 +1,10 @@
-import { AnyObject, FieldFilter, getKeys, isDefined, isObject } from "prostgles-types/dist";
+import {
+  AnyObject,
+  FieldFilter,
+  getKeys,
+  isDefined,
+  isObject,
+} from "prostgles-types/dist";
 import { ViewHandler } from "./ViewHandler";
 import { ExistsFilterConfig, Filter, LocalParams } from "../DboBuilder";
 import { SelectItem } from "../QueryBuilder/QueryBuilder";
@@ -11,14 +17,31 @@ export type PrepareWhereParams = {
   forcedFilter?: AnyObject;
   filterFields?: FieldFilter;
   addWhere?: boolean;
-  tableAlias?: string,
-  localParams: LocalParams | undefined,
-  tableRule: TableRule | undefined,
+  tableAlias?: string;
+  localParams: LocalParams | undefined;
+  tableRule: TableRule | undefined;
   isHaving?: boolean;
 };
 
-export async function prepareWhere(this: ViewHandler, params: PrepareWhereParams): Promise<{ condition: string; where: string; filter: AnyObject; exists: ExistsFilterConfig[]; }> {
-  const { filter, select, forcedFilter, filterFields: ff, addWhere: addKeywords = true, tableAlias, localParams, tableRule } = params;
+export async function prepareWhere(
+  this: ViewHandler,
+  params: PrepareWhereParams,
+): Promise<{
+  condition: string;
+  where: string;
+  filter: AnyObject;
+  exists: ExistsFilterConfig[];
+}> {
+  const {
+    filter,
+    select,
+    forcedFilter,
+    filterFields: ff,
+    addWhere: addKeywords = true,
+    tableAlias,
+    localParams,
+    tableRule,
+  } = params;
   const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
 
   let filterFields = ff;
@@ -27,17 +50,26 @@ export async function prepareWhere(this: ViewHandler, params: PrepareWhereParams
 
   const exists: ExistsFilterConfig[] = [];
 
-  const parseFullFilter = async (f: any, parentFilter: any = null, isForcedFilterBypass: boolean): Promise<string> => {
+  const parseFullFilter = async (
+    f: any,
+    parentFilter: any = null,
+    isForcedFilterBypass: boolean,
+  ): Promise<string> => {
     if (!f) throw "Invalid/missing group filter provided";
-    if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
+    if (!isObject(f))
+      throw (
+        "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f)
+      );
     let result = "";
     const keys = getKeys(f);
     if (!keys.length) {
       return result;
     }
-    if ((keys.includes($and_key) || keys.includes($or_key))) {
-      if (keys.length > 1) throw `\ngroup filter must contain only one array property. e.g.: { ${$and_key}: [...] } OR { ${$or_key}: [...] } `;
-      if (parentFilter && Object.keys(parentFilter).includes("")) throw "group filter ($and/$or) can only be placed at the root or within another group filter";
+    if (keys.includes($and_key) || keys.includes($or_key)) {
+      if (keys.length > 1)
+        throw `\ngroup filter must contain only one array property. e.g.: { ${$and_key}: [...] } OR { ${$or_key}: [...] } `;
+      if (parentFilter && Object.keys(parentFilter).includes(""))
+        throw "group filter ($and/$or) can only be placed at the root or within another group filter";
     }
 
     const { [$and_key]: $and, [$or_key]: $or } = f,
@@ -45,21 +77,27 @@ export async function prepareWhere(this: ViewHandler, params: PrepareWhereParams
 
     if (group && group.length) {
       const operand = $and ? " AND " : " OR ";
-      const conditions = (await Promise.all(
-          group.map(async gf => await parseFullFilter(gf, group, isForcedFilterBypass))
-        )).filter(c => c);
-        
+      const conditions = (
+        await Promise.all(
+          group.map(
+            async (gf) =>
+              await parseFullFilter(gf, group, isForcedFilterBypass),
+          ),
+        )
+      ).filter((c) => c);
+
       if (conditions?.length) {
         if (conditions.length === 1) return conditions.join(operand);
         else return ` ( ${conditions.sort().join(operand)} ) `;
       }
     } else if (!group) {
-
       /** forcedFilters do not get checked against publish and are treated as server-side requests */
       const cond = await getCondition.bind(this)({
         filter: { ...f },
         select,
-        allowed_colnames: isForcedFilterBypass ? this.column_names.slice(0) : this.parseFieldFilter(filterFields),
+        allowed_colnames: isForcedFilterBypass
+          ? this.column_names.slice(0)
+          : this.parseFieldFilter(filterFields),
         tableAlias,
         localParams: isForcedFilterBypass ? undefined : localParams,
         tableRules: isForcedFilterBypass ? undefined : tableRule,
@@ -69,22 +107,24 @@ export async function prepareWhere(this: ViewHandler, params: PrepareWhereParams
       exists.push(...cond.exists);
     }
     return result;
-  }
+  };
 
   /* A forced filter condition will not check if the existsJoined filter tables have been published */
-  const forcedFilterCond = forcedFilter ? await parseFullFilter(forcedFilter, null, true) : undefined;
+  const forcedFilterCond = forcedFilter
+    ? await parseFullFilter(forcedFilter, null, true)
+    : undefined;
   const filterCond = await parseFullFilter(filter, null, false);
-  let cond = [
-    forcedFilterCond, filterCond
-  ].filter(c => c).join(" AND ");
+  let cond = [forcedFilterCond, filterCond].filter((c) => c).join(" AND ");
 
-  const finalFilter = forcedFilter ? {
-    [$and_key]: [forcedFilter, filter].filter(isDefined)
-  } : { ...filter };
+  const finalFilter = forcedFilter
+    ? {
+        [$and_key]: [forcedFilter, filter].filter(isDefined),
+      }
+    : { ...filter };
 
   const condition = cond;
   if (cond && addKeywords) {
     cond = `WHERE ${cond}`;
   }
   return { condition, where: cond || "", filter: finalFilter, exists };
-}
+}

package/lib/DboBuilder/ViewHandler/size.ts

@@ -1,37 +1,71 @@
 import { SelectParams } from "prostgles-types";
 import { TableRule } from "../../PublishParser/publishTypesAndUtils";
 import { Filter, LocalParams } from "../DboBuilderTypes";
-import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../dboBuilderUtils";
+import {
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  withUserRLS,
+} from "../dboBuilderUtils";
 import { ViewHandler } from "./ViewHandler";
-export async function size(this: ViewHandler, _filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<string> {
+export async function size(
+  this: ViewHandler,
+  _filter?: Filter,
+  selectParams?: SelectParams,
+  param3_unused?: undefined,
+  table_rules?: TableRule,
+  localParams?: LocalParams,
+): Promise<string> {
   const filter = _filter || {};
   const start = Date.now();
   try {
-    const result = await this.find(filter, { ...selectParams, limit: 2 }, undefined, table_rules, localParams)
-      .then(async _allowed => {
-        
-        const q: string = await this.find(
-          filter, { ...selectParams, limit: selectParams?.limit ?? Number.MAX_SAFE_INTEGER },
-          undefined,
-          table_rules,
-          { ...localParams, returnQuery: "noRLS", bypassLimit: true }
-        ) as any;
-        const query = withUserRLS(
-          localParams,
-          `${withUserRLS(localParams, "")}
+    const result = await this.find(
+      filter,
+      { ...selectParams, limit: 2 },
+      undefined,
+      table_rules,
+      localParams,
+    ).then(async (_allowed) => {
+      const q: string = (await this.find(
+        filter,
+        {
+          ...selectParams,
+          limit: selectParams?.limit ?? Number.MAX_SAFE_INTEGER,
+        },
+        undefined,
+        table_rules,
+        { ...localParams, returnQuery: "noRLS", bypassLimit: true },
+      )) as any;
+      const query = withUserRLS(
+        localParams,
+        `${withUserRLS(localParams, "")}
             SELECT sum(pg_column_size((prgl_size_query.*))) as size 
             FROM (
               ${q}
             ) prgl_size_query
-          `
-        );
+          `,
+      );
 
-        return (this.tx?.t || this.db).one(query).then(({ size }) => size || '0');
-      });
-    await this._log({ command: "size", localParams, data: { filter, selectParams }, duration: Date.now() - start });
+      return (this.tx?.t || this.db).one(query).then(({ size }) => size || "0");
+    });
+    await this._log({
+      command: "size",
+      localParams,
+      data: { filter, selectParams },
+      duration: Date.now() - start,
+    });
     return result;
   } catch (e) {
-    await this._log({ command: "size", localParams, data: { filter, selectParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    await this._log({
+      command: "size",
+      localParams,
+      data: { filter, selectParams },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-}
+}

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -1,36 +1,80 @@
-import { AnyObject, SubscribeParams, SubscriptionChannels } from "prostgles-types";
+import {
+  AnyObject,
+  SubscribeParams,
+  SubscriptionChannels,
+} from "prostgles-types";
 import { TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, getSerializedClientErrorFromPGError } from "../DboBuilder";
+import {
+  Filter,
+  LocalParams,
+  getClientErrorFromPGError,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+} from "../DboBuilder";
 import { getSubscribeRelatedTables } from "../getSubscribeRelatedTables";
 import { NewQuery } from "../QueryBuilder/QueryBuilder";
 import { ViewHandler } from "./ViewHandler";
 
-type OnData = (items: AnyObject[]) => any; 
-export type LocalFuncs = {
-  onData: OnData
-  onError?: (error: any) => void;
-} | OnData;
+type OnData = (items: AnyObject[]) => any;
+export type LocalFuncs =
+  | {
+      onData: OnData;
+      onError?: (error: any) => void;
+    }
+  | OnData;
 
-export const getOnDataFunc = (localFuncs: LocalFuncs | undefined): OnData | undefined => {
-  return typeof localFuncs === "function"? localFuncs : localFuncs?.onData;
-}
-export const matchesLocalFuncs = (localFuncs1: LocalFuncs | undefined, localFuncs2: LocalFuncs | undefined) => {
-  return localFuncs1 && localFuncs2 && getOnDataFunc(localFuncs1) === getOnDataFunc(localFuncs2);
-}
-export const parseLocalFuncs = (localFuncs1: LocalFuncs | undefined): Extract<LocalFuncs, { onData: OnData }> | undefined=> {
-  return !localFuncs1? undefined : typeof localFuncs1 === "function"? {
-    onData: localFuncs1
-  } : localFuncs1;
-}
+export const getOnDataFunc = (
+  localFuncs: LocalFuncs | undefined,
+): OnData | undefined => {
+  return typeof localFuncs === "function" ? localFuncs : localFuncs?.onData;
+};
+export const matchesLocalFuncs = (
+  localFuncs1: LocalFuncs | undefined,
+  localFuncs2: LocalFuncs | undefined,
+) => {
+  return (
+    localFuncs1 &&
+    localFuncs2 &&
+    getOnDataFunc(localFuncs1) === getOnDataFunc(localFuncs2)
+  );
+};
+export const parseLocalFuncs = (
+  localFuncs1: LocalFuncs | undefined,
+): Extract<LocalFuncs, { onData: OnData }> | undefined => {
+  return !localFuncs1
+    ? undefined
+    : typeof localFuncs1 === "function"
+      ? {
+          onData: localFuncs1,
+        }
+      : localFuncs1;
+};
 
-async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs: LocalFuncs): Promise<{ unsubscribe: () => any }> 
-async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<SubscriptionChannels>
-async function subscribe(this: ViewHandler, filter: Filter, params: SubscribeParams, localFuncs?: LocalFuncs, table_rules?: TableRule, localParams?: LocalParams): Promise<{ unsubscribe: () => any } | SubscriptionChannels> 
-{
+async function subscribe(
+  this: ViewHandler,
+  filter: Filter,
+  params: SubscribeParams,
+  localFuncs: LocalFuncs,
+): Promise<{ unsubscribe: () => any }>;
+async function subscribe(
+  this: ViewHandler,
+  filter: Filter,
+  params: SubscribeParams,
+  localFuncs: undefined,
+  table_rules: TableRule | undefined,
+  localParams: LocalParams,
+): Promise<SubscriptionChannels>;
+async function subscribe(
+  this: ViewHandler,
+  filter: Filter,
+  params: SubscribeParams,
+  localFuncs?: LocalFuncs,
+  table_rules?: TableRule,
+  localParams?: LocalParams,
+): Promise<{ unsubscribe: () => any } | SubscriptionChannels> {
   const start = Date.now();
   try {
-
-    if(!this.dboBuilder.canSubscribe){
+    if (!this.dboBuilder.canSubscribe) {
       throw "Cannot subscribe. PubSubManager not initiated";
     }
 
@@ -41,25 +85,39 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
       throw " missing data. provide -> localFunc | localParams { socket } ";
     }
     if (localParams?.socket && localFuncs) {
-      console.error({ localParams, localFuncs })
+      console.error({ localParams, localFuncs });
       throw " Cannot have localFunc AND socket ";
     }
 
     const { throttle = 0, throttleOpts, ...selectParams } = params;
 
     /** Ensure request is valid */
-    await this.find(filter, { ...selectParams, limit: 0 }, undefined, table_rules, localParams);   
+    await this.find(
+      filter,
+      { ...selectParams, limit: 0 },
+      undefined,
+      table_rules,
+      localParams,
+    );
 
     // TODO: Implement comprehensive canSubscribe check
     // if (!this.dboBuilder.prostgles.isSuperUser) {
     //   throw "Subscribe not possible. Must be superuser";
     // }
 
-    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 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 = {
@@ -76,32 +134,40 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
     } as const;
 
     const pubSubManager = await this.dboBuilder.getPubSubManager();
-    if (!localFuncs) {    
-
+    if (!localFuncs) {
       const { socket } = localParams ?? {};
       const result = await pubSubManager.addSub({
         ...commonSubOpts,
-        socket, 
+        socket,
         localFuncs: undefined,
-        socket_id: socket?.id, 
+        socket_id: socket?.id,
       });
 
-      await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start });
+      await this._log({
+        command: "subscribe",
+        localParams,
+        data: { filter, params },
+        duration: Date.now() - start,
+      });
       return result;
     } else {
-
-      const { channelName, sendFirstData } = await pubSubManager.addSub({ 
+      const { channelName, sendFirstData } = await pubSubManager.addSub({
         ...commonSubOpts,
-        socket: undefined,  
-        localFuncs, 
-        socket_id: undefined, 
+        socket: undefined,
+        localFuncs,
+        socket_id: undefined,
       });
-      
+
       const unsubscribe = async () => {
         const pubSubManager = await this.dboBuilder.getPubSubManager();
-        pubSubManager.removeLocalSub(channelName, localFuncs)
+        pubSubManager.removeLocalSub(channelName, localFuncs);
       };
-      await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start });
+      await this._log({
+        command: "subscribe",
+        localParams,
+        data: { filter, params },
+        duration: Date.now() - start,
+      });
       const res: { unsubscribe: () => any } = Object.freeze({ unsubscribe });
       /** Send first data after subscription is initialised to prevent race conditions */
       setTimeout(() => {
@@ -110,8 +176,18 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
       return res;
     }
   } catch (e) {
-    await this._log({ command: "subscribe", localParams, data: { filter, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    await this._log({
+      command: "subscribe",
+      localParams,
+      data: { filter, params },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
 }
 

package/lib/DboBuilder/ViewHandler/validateViewRules.ts

@@ -5,13 +5,13 @@ import { ViewHandler } from "./ViewHandler";
 export async function validateViewRules(
   this: ViewHandler,
   args: {
-    fields?: FieldFilter,
-    filterFields?: FieldFilter,
-    returningFields?: FieldFilter,
-    forcedFilter?: AnyObject,
-    dynamicFields?: UpdateRule["dynamicFields"],
-    rule: "update" | "select" | "insert" | "delete"
-  }
+    fields?: FieldFilter;
+    filterFields?: FieldFilter;
+    returningFields?: FieldFilter;
+    forcedFilter?: AnyObject;
+    dynamicFields?: UpdateRule["dynamicFields"];
+    rule: "update" | "select" | "insert" | "delete";
+  },
 ) {
   const {
     fields,
@@ -27,31 +27,51 @@ export async function validateViewRules(
     try {
       const _fields = this.parseFieldFilter(fields);
       if (this.is_media && rule === "insert" && !_fields.includes("id")) {
-        throw "Must allow id insert for media table"
+        throw "Must allow id insert for media table";
       }
     } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.fields: \nVALUE: ` + JSON.stringify(fields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
+      throw (
+        ` issue with publish.${this.name}.${rule}.fields: \nVALUE: ` +
+        JSON.stringify(fields, null, 2) +
+        "\nERROR: " +
+        JSON.stringify(e, null, 2)
+      );
     }
   }
   if (filterFields) {
     try {
       this.parseFieldFilter(filterFields);
     } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.filterFields: \nVALUE: ` + JSON.stringify(filterFields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
+      throw (
+        ` issue with publish.${this.name}.${rule}.filterFields: \nVALUE: ` +
+        JSON.stringify(filterFields, null, 2) +
+        "\nERROR: " +
+        JSON.stringify(e, null, 2)
+      );
     }
   }
   if (returningFields) {
     try {
       this.parseFieldFilter(returningFields);
     } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.returningFields: \nVALUE: ` + JSON.stringify(returningFields, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
+      throw (
+        ` issue with publish.${this.name}.${rule}.returningFields: \nVALUE: ` +
+        JSON.stringify(returningFields, null, 2) +
+        "\nERROR: " +
+        JSON.stringify(e, null, 2)
+      );
     }
   }
   if (forcedFilter) {
     try {
       await this.find(forcedFilter, { limit: 0 });
     } catch (e) {
-      throw ` issue with publish.${this.name}.${rule}.forcedFilter: \nVALUE: ` + JSON.stringify(forcedFilter, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
+      throw (
+        ` issue with publish.${this.name}.${rule}.forcedFilter: \nVALUE: ` +
+        JSON.stringify(forcedFilter, null, 2) +
+        "\nERROR: " +
+        JSON.stringify(e, null, 2)
+      );
     }
   }
   if (dynamicFields) {
@@ -61,10 +81,15 @@ export async function validateViewRules(
         this.parseFieldFilter(fields);
         await this.find(filter, { limit: 0 });
       } catch (e) {
-        throw ` issue with publish.${this.name}.${rule}.dynamicFields: \nVALUE: ` + JSON.stringify(dfieldRule, null, 2) + "\nERROR: " + JSON.stringify(e, null, 2);
+        throw (
+          ` issue with publish.${this.name}.${rule}.dynamicFields: \nVALUE: ` +
+          JSON.stringify(dfieldRule, null, 2) +
+          "\nERROR: " +
+          JSON.stringify(e, null, 2)
+        );
       }
     }
   }
 
   return true;
-}
+}