prostgles-server 4.2.183 → 4.2.184

package/lib/DboBuilder/ViewHandler/find.ts

@@ -1,7 +1,13 @@
-
 import { SelectParams, isObject } from "prostgles-types";
 import { TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import {
+  Filter,
+  LocalParams,
+  getClientErrorFromPGError,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  withUserRLS,
+} from "../DboBuilder";
 import { getNewQuery } from "../QueryBuilder/getNewQuery";
 import { getSelectQuery } from "../QueryBuilder/getSelectQuery";
 import { NewQuery } from "../QueryBuilder/QueryBuilder";
@@ -9,68 +15,104 @@ import { canRunSQL } from "../runSQL";
 import { TableHandler } from "../TableHandler/TableHandler";
 import { ViewHandler } from "./ViewHandler";
 
-export const find = async function(this: ViewHandler, filter?: Filter, selectParams?: SelectParams, _?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any[]> {
+export const find = async function (
+  this: ViewHandler,
+  filter?: Filter,
+  selectParams?: SelectParams,
+  _?: undefined,
+  tableRules?: TableRule,
+  localParams?: LocalParams,
+): Promise<any[]> {
   const start = Date.now();
-  const command = selectParams?.limit === 1 && selectParams?.returnType === "row"? "findOne" : "find";
+  const command =
+    selectParams?.limit === 1 && selectParams?.returnType === "row"
+      ? "findOne"
+      : "find";
   try {
     filter = filter || {};
-    const allowedReturnTypes = Object.keys({ 
-      row: 1, statement: 1, value: 1, values: 1, 
-      "statement-no-rls": 1, "statement-where": 1,
+    const allowedReturnTypes = Object.keys({
+      row: 1,
+      statement: 1,
+      value: 1,
+      values: 1,
+      "statement-no-rls": 1,
+      "statement-where": 1,
     } satisfies Record<Required<SelectParams>["returnType"], 1>);
 
     const { returnType } = selectParams || {};
     if (returnType && !allowedReturnTypes.includes(returnType)) {
-      throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`
+      throw `returnType (${returnType}) can only be ${allowedReturnTypes.join(" OR ")}`;
     }
 
     const { testRule = false } = localParams || {};
 
     if (testRule) return [];
     if (selectParams) {
-      const validParamNames = Object.keys({ 
-        "select": 1, "orderBy": 1, "offset": 1, "limit": 1, 
-        "returnType": 1, "groupBy": 1, "having": 1
+      const validParamNames = Object.keys({
+        select: 1,
+        orderBy: 1,
+        offset: 1,
+        limit: 1,
+        returnType: 1,
+        groupBy: 1,
+        having: 1,
       } satisfies Record<keyof SelectParams, 1>);
-      
-      const invalidParams = Object.keys(selectParams).filter(k => !validParamNames.includes(k as any));
-      if (invalidParams && invalidParams.length) throw "Invalid params: " + invalidParams.join(", ") + " \n Expecting: " + validParamNames.join(", ");
+
+      const invalidParams = Object.keys(selectParams).filter(
+        (k) => !validParamNames.includes(k as any),
+      );
+      if (invalidParams && invalidParams.length)
+        throw (
+          "Invalid params: " +
+          invalidParams.join(", ") +
+          " \n Expecting: " +
+          validParamNames.join(", ")
+        );
     }
 
     /* Validate publish */
-    if (tableRules) { 
-
+    if (tableRules) {
       if (!tableRules.select) throw "select rules missing for " + this.name;
-      const fields = tableRules.select.fields; 
+      const fields = tableRules.select.fields;
       const maxLimit = tableRules.select.maxLimit;
 
-      if (<any>tableRules.select !== "*" && typeof tableRules.select !== "boolean" && !isObject(tableRules.select)) {
+      if (
+        <any>tableRules.select !== "*" &&
+        typeof tableRules.select !== "boolean" &&
+        !isObject(tableRules.select)
+      ) {
         throw `\nInvalid publish.${this.name}.select\nExpecting any of: "*" | { fields: "*" } | true | false`;
       }
       if (!fields) {
         throw ` invalid ${this.name}.select rule -> fields (required) setting missing.\nExpecting any of: "*" | { col_name: false } | { col1: true, col2: true }`;
       }
       if (maxLimit && !Number.isInteger(maxLimit)) {
-        throw ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` + maxLimit;
+        throw (
+          ` invalid publish.${this.name}.select.maxLimit -> expecting integer but got ` +
+          maxLimit
+        );
       }
     }
 
-    const _selectParams = selectParams ?? {}
-    const selectParamsLimitCheck = localParams?.bypassLimit && !Number.isFinite(_selectParams.limit)? { ..._selectParams, limit: null } : { limit: 1000, ..._selectParams }
+    const _selectParams = selectParams ?? {};
+    const selectParamsLimitCheck =
+      localParams?.bypassLimit && !Number.isFinite(_selectParams.limit)
+        ? { ..._selectParams, limit: null }
+        : { limit: 1000, ..._selectParams };
     const newQuery = await getNewQuery(
-      this, 
-      filter, 
-      selectParamsLimitCheck, 
-      _, 
-      tableRules, 
-      localParams, 
+      this,
+      filter,
+      selectParamsLimitCheck,
+      _,
+      tableRules,
+      localParams,
     );
 
     const queryWithoutRLS = getSelectQuery(
-      this, 
-      newQuery, 
-      undefined, 
-      !!selectParamsLimitCheck?.groupBy
+      this,
+      newQuery,
+      undefined,
+      !!selectParamsLimitCheck?.groupBy,
     );
 
     const queryWithRLS = withUserRLS(localParams, queryWithoutRLS);
@@ -80,74 +122,117 @@ export const find = async function(this: ViewHandler, filter?: Filter, selectPar
         return [];
       } catch (e) {
         console.error(e);
-        throw `Internal error: publish config is not valid for publish.${this.name}.select `
+        throw `Internal error: publish config is not valid for publish.${this.name}.select `;
       }
     }
 
     /** Used for subscribe  */
-    if(localParams?.returnNewQuery) return (newQuery as unknown as any);
+    if (localParams?.returnNewQuery) return newQuery as unknown as any;
     if (localParams?.returnQuery) {
-      if(localParams?.returnQuery === "where-condition"){
+      if (localParams?.returnQuery === "where-condition") {
         return newQuery.whereOpts.condition as any;
       }
-      return ((localParams?.returnQuery === "noRLS"? queryWithoutRLS : queryWithRLS) as unknown as any[]);
+      return (localParams?.returnQuery === "noRLS"
+        ? queryWithoutRLS
+        : queryWithRLS) as unknown as any[];
     }
 
-    const result = await runQueryReturnType({ 
-      queryWithoutRLS, 
-      queryWithRLS, 
-      returnType, 
-      handler: this, 
+    const result = await runQueryReturnType({
+      queryWithoutRLS,
+      queryWithRLS,
+      returnType,
+      handler: this,
       localParams,
       newQuery,
     });
 
-    await this._log({ command, localParams, data: { filter, selectParams }, duration: Date.now() - start });
+    await this._log({
+      command,
+      localParams,
+      data: { filter, selectParams },
+      duration: Date.now() - start,
+    });
     return result;
   } catch (e) {
-    this._log({ command, localParams, data: { filter, selectParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    this._log({
+      command,
+      localParams,
+      data: { filter, selectParams },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-}
+};
 
 type RunQueryReturnTypeArgs = {
   queryWithRLS: string;
   queryWithoutRLS: string;
-  returnType: SelectParams["returnType"]; 
-  handler: ViewHandler | TableHandler; 
+  returnType: SelectParams["returnType"];
+  handler: ViewHandler | TableHandler;
   localParams: LocalParams | undefined;
   newQuery: NewQuery | undefined;
 };
 
-export const runQueryReturnType = async ({ newQuery, handler, localParams, queryWithRLS, queryWithoutRLS, returnType,}: RunQueryReturnTypeArgs) => {
-
+export const runQueryReturnType = async ({
+  newQuery,
+  handler,
+  localParams,
+  queryWithRLS,
+  queryWithoutRLS,
+  returnType,
+}: RunQueryReturnTypeArgs) => {
   const query = queryWithRLS;
-  const sqlTypes = ["statement", "statement-no-rls", "statement-where"] as const;
-  if(!returnType || returnType === "values"){
-
-    return handler.dbHandler.any(query).then(data => {
-      if (returnType === "values") {
-        return data.map(d => Object.values(d)[0]);
-      }
-      return data;
-    }).catch(err => getClientErrorFromPGError(err, { type: "tableMethod", localParams, view: handler, }));
-
-  } else if (sqlTypes.some(v => v === returnType)) {
+  const sqlTypes = [
+    "statement",
+    "statement-no-rls",
+    "statement-where",
+  ] as const;
+  if (!returnType || returnType === "values") {
+    return handler.dbHandler
+      .any(query)
+      .then((data) => {
+        if (returnType === "values") {
+          return data.map((d) => Object.values(d)[0]);
+        }
+        return data;
+      })
+      .catch((err) =>
+        getClientErrorFromPGError(err, {
+          type: "tableMethod",
+          localParams,
+          view: handler,
+        }),
+      );
+  } else if (sqlTypes.some((v) => v === returnType)) {
     if (!(await canRunSQL(handler.dboBuilder.prostgles, localParams))) {
-      throw `Not allowed:  { returnType: ${JSON.stringify(returnType)} } requires execute sql privileges `
+      throw `Not allowed:  { returnType: ${JSON.stringify(returnType)} } requires execute sql privileges `;
     }
-    if(returnType === "statement-no-rls"){
+    if (returnType === "statement-no-rls") {
       return queryWithoutRLS as any;
     }
-    if(returnType === "statement-where"){
-      if(!newQuery) throw `returnType ${returnType} not possible for this command type`;
+    if (returnType === "statement-where") {
+      if (!newQuery)
+        throw `returnType ${returnType} not possible for this command type`;
       return newQuery.whereOpts.condition as any;
     }
     return query as unknown as any[];
-
   } else if (["row", "value"].includes(returnType)) {
-    return handler.dbHandler.oneOrNone(query).then(data => {
-      return (data && returnType === "value") ? Object.values(data)[0] : data;
-    }).catch(err => getClientErrorFromPGError(err,  { type: "tableMethod", localParams, view: handler, }));
+    return handler.dbHandler
+      .oneOrNone(query)
+      .then((data) => {
+        return data && returnType === "value" ? Object.values(data)[0] : data;
+      })
+      .catch((err) =>
+        getClientErrorFromPGError(err, {
+          type: "tableMethod",
+          localParams,
+          view: handler,
+        }),
+      );
   }
-}
+};

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -1,22 +1,40 @@
-import { AnyObject, EXISTS_KEY, EXISTS_KEYS, FieldFilter, asName } from "prostgles-types";
+import {
+  AnyObject,
+  EXISTS_KEY,
+  EXISTS_KEYS,
+  FieldFilter,
+  asName,
+} from "prostgles-types";
 import { LocalParams, ExistsFilterConfig } from "../DboBuilder";
 import { ViewHandler } from "./ViewHandler";
 import { TableRule } from "../../PublishParser/PublishParser";
 import { TableHandler } from "../TableHandler/TableHandler";
 import { getTableJoinQuery } from "./getTableJoinQuery";
 
-
-export async function getExistsCondition(this: ViewHandler, eConfig: ExistsFilterConfig, localParams: LocalParams | undefined): Promise<string> {
-
+export async function getExistsCondition(
+  this: ViewHandler,
+  eConfig: ExistsFilterConfig,
+  localParams: LocalParams | undefined,
+): Promise<string> {
   const thisTable = this.name;
-  const isNotExists = ["$notExists", "$notExistsJoined"].includes(eConfig.existType);
+  const isNotExists = ["$notExists", "$notExistsJoined"].includes(
+    eConfig.existType,
+  );
 
   const { targetTableFilter } = eConfig;
 
   /* Nested $exists is not allowed */
-  if (targetTableFilter && Object.keys(targetTableFilter).find(fk => EXISTS_KEYS.includes(fk as EXISTS_KEY))) {
-    throw { stack: ["prepareExistCondition()"], message: "Nested exists dissallowed" };
-  } 
+  if (
+    targetTableFilter &&
+    Object.keys(targetTableFilter).find((fk) =>
+      EXISTS_KEYS.includes(fk as EXISTS_KEY),
+    )
+  ) {
+    throw {
+      stack: ["prepareExistCondition()"],
+      message: "Nested exists dissallowed",
+    };
+  }
 
   let t2Rules: TableRule | undefined = undefined,
     forcedFilter: AnyObject | undefined,
@@ -24,41 +42,51 @@ export async function getExistsCondition(this: ViewHandler, eConfig: ExistsFilte
     tableAlias;
 
   /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
-  if (localParams?.isRemoteRequest && !localParams?.socket && !localParams?.httpReq) {
+  if (
+    localParams?.isRemoteRequest &&
+    !localParams?.socket &&
+    !localParams?.httpReq
+  ) {
     throw "Unexpected: localParams isRemoteRequest and missing socket/httpReq: ";
   }
-  const targetTable = eConfig.isJoined?  eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
-  if ((localParams?.socket || localParams?.httpReq) && this.dboBuilder.publishParser) {
-
-    t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr({ 
-      tableName: targetTable, 
-      command: "find", 
-      localParams 
-    }) as TableRule;
+  const targetTable = eConfig.isJoined
+    ? eConfig.parsedPath.at(-1)!.table
+    : eConfig.targetTable;
+  if (
+    (localParams?.socket || localParams?.httpReq) &&
+    this.dboBuilder.publishParser
+  ) {
+    t2Rules = (await this.dboBuilder.publishParser.getValidatedRequestRuleWusr({
+      tableName: targetTable,
+      command: "find",
+      localParams,
+    })) as TableRule;
 
     if (!t2Rules || !t2Rules.select) throw "Dissallowed";
     ({ forcedFilter, filterFields } = t2Rules.select);
   }
 
-  const tableHandler = this.dboBuilder.dbo[targetTable] as TableHandler
-  const finalWhere = (await tableHandler.prepareWhere({
-    select: undefined,
-    filter: targetTableFilter,
-    forcedFilter,
-    filterFields,
-    addWhere: false,
-    tableAlias,
-    localParams,
-    tableRule: t2Rules
-  })).where
+  const tableHandler = this.dboBuilder.dbo[targetTable] as TableHandler;
+  const finalWhere = (
+    await tableHandler.prepareWhere({
+      select: undefined,
+      filter: targetTableFilter,
+      forcedFilter,
+      filterFields,
+      addWhere: false,
+      tableAlias,
+      localParams,
+      tableRule: t2Rules,
+    })
+  ).where;
 
   let innerQuery = [
     `SELECT 1`,
     `FROM ${asName(targetTable)}`,
-    `${finalWhere ? `WHERE ${finalWhere}` : ""}`
+    `${finalWhere ? `WHERE ${finalWhere}` : ""}`,
   ].join("\n");
 
-  if(eConfig.isJoined){
+  if (eConfig.isJoined) {
     const { query } = getTableJoinQuery({
       path: eConfig.parsedPath,
       rootTableAlias: thisTable,
@@ -69,5 +97,4 @@ export async function getExistsCondition(this: ViewHandler, eConfig: ExistsFilte
   }
 
   return `${isNotExists ? " NOT " : " "} EXISTS ( \n${innerQuery} \n) `;
-
-}
+}

package/lib/DboBuilder/ViewHandler/getExistsFilters.ts

@@ -3,46 +3,53 @@ import { ExistsFilterConfig } from "../DboBuilder";
 import { ViewHandler } from "./ViewHandler";
 import { parseJoinPath } from "./parseJoinPath";
 
-export const getExistsFilters = (filter: any, viewHandler: ViewHandler): ExistsFilterConfig[] => {
-
+export const getExistsFilters = (
+  filter: any,
+  viewHandler: ViewHandler,
+): ExistsFilterConfig[] => {
   /* Exists join filter */
-  const ERR = "Invalid exists filter. \nExpecting something like: \n | { $exists: { tableName.tableName2: Filter } } \n  | { $exists: { \"**.tableName3\": Filter } }\n | { path: string[]; filter: AnyObject }"
+  const ERR =
+    'Invalid exists filter. \nExpecting something like: \n | { $exists: { tableName.tableName2: Filter } } \n  | { $exists: { "**.tableName3": Filter } }\n | { path: string[]; filter: AnyObject }';
   const existsConfigs: ExistsFilterConfig[] = getKeys(filter)
-    .filter((k ): k is typeof EXISTS_KEYS[number] => EXISTS_KEYS.includes(k as EXISTS_KEY) && !!Object.keys(filter[k] ?? {}).length)
-    .map(key => {
-
+    .filter(
+      (k): k is (typeof EXISTS_KEYS)[number] =>
+        EXISTS_KEYS.includes(k as EXISTS_KEY) &&
+        !!Object.keys(filter[k] ?? {}).length,
+    )
+    .map((key) => {
       const isJoined = key.toLowerCase().includes("join");
       const filterValue = filter[key];
 
-
       /**
-       * type ExistsJoined = 
+       * type ExistsJoined =
        *   | { "table1.table2": { column: filterValue }  }
        *   | { path: string[]; filter: AnyObject }
        */
       const dataKeys = Object.keys(filterValue);
-      const isDetailed = dataKeys.length === 2 && dataKeys.every(key => ["path", "filter"].includes(key));
+      const isDetailed =
+        dataKeys.length === 2 &&
+        dataKeys.every((key) => ["path", "filter"].includes(key));
 
       const firstKey = dataKeys[0]!;
 
       /**
        * Non joined exists are never detailed
        */
-      if(!isJoined){
-        const format = `Expecting single table in exists filter. Example: { $exists: { tableName: Filter } }`
-        if(isDetailed){
-          throw `Exists filters cannot be detailed. ${format}`
+      if (!isJoined) {
+        const format = `Expecting single table in exists filter. Example: { $exists: { tableName: Filter } }`;
+        if (isDetailed) {
+          throw `Exists filters cannot be detailed. ${format}`;
         }
         const targetTable = firstKey;
         if (!viewHandler.dboBuilder.dbo[targetTable]) {
-          throw `Table ${JSON.stringify(targetTable)} not found. ${format}`
+          throw `Table ${JSON.stringify(targetTable)} not found. ${format}`;
         }
         const res: ExistsFilterConfig = {
           isJoined: false,
           existType: key as EXISTS_KEY,
           targetTableFilter: filterValue[firstKey],
           targetTable: firstKey,
-        }
+        };
         return res;
       }
 
@@ -50,12 +57,17 @@ export const getExistsFilters = (filter: any, viewHandler: ViewHandler): ExistsF
        * Prevent some errors with table names that contain "."
        */
       const firstKeyIsATable = !!viewHandler.dboBuilder.dbo[firstKey];
-      const [path, targetTableFilter] = isDetailed? [filterValue.path, filterValue.filter] : [(firstKeyIsATable? [firstKey] : firstKey.split(".")), filterValue[firstKey]];
+      const [path, targetTableFilter] = isDetailed
+        ? [filterValue.path, filterValue.filter]
+        : [
+            firstKeyIsATable ? [firstKey] : firstKey.split("."),
+            filterValue[firstKey],
+          ];
 
       if (!path.length) {
         throw ERR + "\nBut got: " + JSON.stringify(filterValue);
       }
-      
+
       return {
         isJoined: true,
         existType: key as EXISTS_KEY,
@@ -67,8 +79,8 @@ export const getExistsFilters = (filter: any, viewHandler: ViewHandler): ExistsF
           allowMultiOrJoin: true,
         }),
         targetTableFilter,
-      }
+      };
     });
 
   return existsConfigs;
-}
+};

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -1,37 +1,68 @@
-import {
-  TableInfo as TInfo
-} from "prostgles-types/dist";
+import { TableInfo as TInfo } from "prostgles-types/dist";
 import { TableRule } from "../../PublishParser/PublishParser";
 import { LocalParams } from "../DboBuilder";
 import { ViewHandler } from "./ViewHandler";
 
-export async function getInfo(this: ViewHandler, lang?: string, param2?: any, param3?: any, tableRules?: TableRule, localParams?: LocalParams): Promise<TInfo> {
+export async function getInfo(
+  this: ViewHandler,
+  lang?: string,
+  param2?: any,
+  param3?: any,
+  tableRules?: TableRule,
+  localParams?: LocalParams,
+): Promise<TInfo> {
   const p = this.getValidatedRules(tableRules, localParams);
   if (!p.getInfo) {
-    await this._log({ command: "getInfo", localParams, data: { lang }, duration: 0, error: "Not allowed" });
+    await this._log({
+      command: "getInfo",
+      localParams,
+      data: { lang },
+      duration: 0,
+      error: "Not allowed",
+    });
     throw "Not allowed";
   }
 
   const fileTableName = this.dboBuilder.prostgles?.opts?.fileTable?.tableName;
 
-  await this._log({ command: "getInfo", localParams, data: { lang }, duration: 0 });
-  const allowedFieldsToSelect = this.parseFieldFilter(tableRules?.select?.fields);
+  await this._log({
+    command: "getInfo",
+    localParams,
+    data: { lang },
+    duration: 0,
+  });
+  const allowedFieldsToSelect = this.parseFieldFilter(
+    tableRules?.select?.fields,
+  );
   return {
     oid: this.tableOrViewInfo.oid,
     comment: this.tableOrViewInfo.comment,
-    info: this.dboBuilder.prostgles?.tableConfigurator?.getTableInfo({ tableName: this.name, lang }),
-    isFileTable: !this.is_media? undefined : {
-      allowedNestedInserts: tableRules?.insert?.allowedNestedInserts
-    },
+    info: this.dboBuilder.prostgles?.tableConfigurator?.getTableInfo({
+      tableName: this.name,
+      lang,
+    }),
+    isFileTable: !this.is_media
+      ? undefined
+      : {
+          allowedNestedInserts: tableRules?.insert?.allowedNestedInserts,
+        },
     isView: this.is_view,
-    hasFiles: Boolean(!this.is_media && fileTableName && this.columns.some(c => c.references?.some(r => r.ftable === fileTableName))),
+    hasFiles: Boolean(
+      !this.is_media &&
+        fileTableName &&
+        this.columns.some((c) =>
+          c.references?.some((r) => r.ftable === fileTableName),
+        ),
+    ),
     fileTableName,
     dynamicRules: {
-      update: Boolean(tableRules?.update?.dynamicFields?.length)
+      update: Boolean(tableRules?.update?.dynamicFields?.length),
     },
     /**
      * Only show column groups that are fully allowed to be selected by the user
      */
-    uniqueColumnGroups: this.tableOrViewInfo.uniqueColumnGroups?.filter(g => !localParams || g.every(c => allowedFieldsToSelect.includes(c))),
-  }
-}
+    uniqueColumnGroups: this.tableOrViewInfo.uniqueColumnGroups?.filter(
+      (g) => !localParams || g.every((c) => allowedFieldsToSelect.includes(c)),
+    ),
+  };
+}