prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -34,7 +34,9 @@ export const getErrorAsObject = (rawError: any, includeStack = false) => {
     return { message: rawError };
   }
   if (rawError instanceof Error) {
-    const result = JSON.parse(JSON.stringify(rawError, Object.getOwnPropertyNames(rawError)));
+    const result = JSON.parse(
+      JSON.stringify(rawError, Object.getOwnPropertyNames(rawError)),
+    );
     if (!includeStack) {
       return omitKeys(result, ["stack"]);
     }
@@ -76,7 +78,7 @@ const otherKeys = [
 
 export function getSerializedClientErrorFromPGError(
   rawError: any,
-  args: GetSerializedClientErrorFromPGErrorArgs
+  args: GetSerializedClientErrorFromPGErrorArgs,
 ): AnyObject {
   const err = getErrorAsObject(rawError);
   if (err.code) {
@@ -89,7 +91,9 @@ export function getSerializedClientErrorFromPGError(
   const isServerSideRequest = !args.localParams;
   //TODO: add a rawSQL check for HTTP requests
   const showFullError =
-    isServerSideRequest || args.type === "sql" || args.localParams?.socket?.prostgles?.rawSQL;
+    isServerSideRequest ||
+    args.type === "sql" ||
+    args.localParams?.socket?.prostgles?.rawSQL;
   if (showFullError) {
     return err;
   }
@@ -102,15 +106,19 @@ export function getSerializedClientErrorFromPGError(
   ];
 
   const errObject = pickKeys(err, finalKeys);
-  if (view?.dboBuilder?.constraints && errObject.constraint && !errObject.column) {
+  if (
+    view?.dboBuilder?.constraints &&
+    errObject.constraint &&
+    !errObject.column
+  ) {
     const constraint = view.dboBuilder.constraints.find(
-      (c) => c.conname === errObject.constraint && c.relname === view.name
+      (c) => c.conname === errObject.constraint && c.relname === view.name,
     );
     if (constraint) {
       const cols = view.columns?.filter(
         (c) =>
           (!allowedKeys || allowedKeys.includes(c.name)) &&
-          constraint.conkey.includes(c.ordinal_position)
+          constraint.conkey.includes(c.ordinal_position),
       );
       const [firstCol] = cols ?? [];
       if (firstCol) {
@@ -123,7 +131,7 @@ export function getSerializedClientErrorFromPGError(
 }
 export function getClientErrorFromPGError(
   rawError: any,
-  args: GetSerializedClientErrorFromPGErrorArgs
+  args: GetSerializedClientErrorFromPGErrorArgs,
 ) {
   const errorObj = getSerializedClientErrorFromPGError(rawError, args);
   return Promise.reject(errorObj);
@@ -135,11 +143,16 @@ export function getClientErrorFromPGError(
 export function parseError(e: any, _caller: string): ProstglesError {
   const errorObject = isObject(e) ? e : undefined;
   const message =
-    typeof e === "string" ? e
-    : e instanceof Error ? e.message
-    : isObject(errorObject) ?
-      (errorObject.message ?? errorObject.txt ?? JSON.stringify(errorObject) ?? "")
-    : "";
+    typeof e === "string"
+      ? e
+      : e instanceof Error
+        ? e.message
+        : isObject(errorObject)
+          ? (errorObject.message ??
+            errorObject.txt ??
+            JSON.stringify(errorObject) ??
+            "")
+          : "";
 
   const result: ProstglesError = {
     ...errorObject,
@@ -175,7 +188,7 @@ export type PGConstraint = {
 
 export const getConstraints = async (
   db: DB,
-  schema: ProstglesInitOptions["schemaFilter"]
+  schema: ProstglesInitOptions["schemaFilter"],
 ): Promise<PGConstraint[]> => {
   const { sql, schemaNames } = getSchemaFilter(schema);
   return db.any(
@@ -188,7 +201,7 @@ export const getConstraints = async (
             ON nsp.oid = connamespace
     WHERE nsp.nspname ${sql}
   `,
-    { schemaNames }
+    { schemaNames },
   );
 };
 
@@ -200,7 +213,9 @@ export function isPlainObject(o: any): o is Record<string, any> {
   return Object(o) === o && Object.getPrototypeOf(o) === Object.prototype;
 }
 
-export function postgresToTsType(udt_data_type: PG_COLUMN_UDT_DATA_TYPE): keyof typeof TS_PG_Types {
+export function postgresToTsType(
+  udt_data_type: PG_COLUMN_UDT_DATA_TYPE,
+): keyof typeof TS_PG_Types {
   return (
     getKeys(TS_PG_Types).find((k) => {
       // @ts-ignore
@@ -209,14 +224,19 @@ export function postgresToTsType(udt_data_type: PG_COLUMN_UDT_DATA_TYPE): keyof
   );
 }
 
-export const prepareOrderByQuery = (items: SortItem[], tableAlias?: string): string[] => {
+export const prepareOrderByQuery = (
+  items: SortItem[],
+  tableAlias?: string,
+): string[] => {
   if (!items.length) return [];
   return [
     "ORDER BY " +
       items
         .map((d) => {
           const orderType = d.asc ? " ASC " : " DESC ";
-          const nullOrder = d.nulls ? ` NULLS ${d.nulls === "first" ? " FIRST " : " LAST "}` : "";
+          const nullOrder = d.nulls
+            ? ` NULLS ${d.nulls === "first" ? " FIRST " : " LAST "}`
+            : "";
           if (d.type === "query" && d.nested) {
             return d.fieldQuery;
           }
@@ -237,7 +257,10 @@ export const getCanExecute = async (db: DB) => {
   return false;
 };
 
-export const withUserRLS = (localParams: LocalParams | undefined, query: string) => {
+export const withUserRLS = (
+  localParams: LocalParams | undefined,
+  query: string,
+) => {
   const user = localParams?.isRemoteRequest?.user;
   const queryPrefix = `SET SESSION "prostgles.user" \nTO`;
   let firstQuery = `${queryPrefix} '';`;

package/lib/DboBuilder/getColumns.ts

@@ -15,7 +15,8 @@ import {
 import { TableHandler } from "./TableHandler/TableHandler";
 import { ViewHandler } from "./ViewHandler/ViewHandler";
 
-export const isTableHandler = (v: any): v is TableHandler => "parseUpdateRules" in v;
+export const isTableHandler = (v: any): v is TableHandler =>
+  "parseUpdateRules" in v;
 
 export async function getColumns(
   this: ViewHandler,
@@ -23,7 +24,7 @@ export async function getColumns(
   params?: { rule: "update"; filter: AnyObject },
   _param3?: undefined,
   tableRules?: TableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): Promise<ValidatedColumnInfo[]> {
   const start = Date.now();
   try {
@@ -34,7 +35,11 @@ export async function getColumns(
     let dynamicUpdateFields = this.column_names;
 
     if (params && tableRules && isTableHandler(this)) {
-      if (!isObject(params) || !isObject(params.filter) || params.rule !== "update") {
+      if (
+        !isObject(params) ||
+        !isObject(params.filter) ||
+        params.rule !== "update"
+      ) {
         throw (
           "params must be { rule: 'update', filter: object } but received: " +
           JSON.stringify(params)
@@ -45,7 +50,12 @@ export async function getColumns(
         dynamicUpdateFields = [];
       } else {
         const { filter } = params;
-        const updateRules = await this.parseUpdateRules(filter, undefined, tableRules, localParams);
+        const updateRules = await this.parseUpdateRules(
+          filter,
+          undefined,
+          tableRules,
+          localParams,
+        );
         dynamicUpdateFields = updateRules.fields;
       }
     }
@@ -79,11 +89,17 @@ export async function getColumns(
         });
 
         /** Do not allow updates to file table unless it's to delete fields */
-        if (prostgles.fileManager?.config && prostgles.fileManager.tableName === this.name) {
+        if (
+          prostgles.fileManager?.config &&
+          prostgles.fileManager.tableName === this.name
+        ) {
           update = false;
         }
 
-        const nonOrderableUD_Types: PG_COLUMN_UDT_DATA_TYPE[] = [..._PG_geometric, "xml" as any];
+        const nonOrderableUD_Types: PG_COLUMN_UDT_DATA_TYPE[] = [
+          ..._PG_geometric,
+          "xml" as any,
+        ];
 
         const result: ValidatedColumnInfo = {
           ...c,
@@ -97,7 +113,9 @@ export async function getColumns(
           select: select && Boolean(p.select?.fields?.includes(c.name)),
           orderBy:
             select &&
-            Boolean(p.select?.fields && p.select.orderByFields.includes(c.name)) &&
+            Boolean(
+              p.select?.fields && p.select.orderByFields.includes(c.name),
+            ) &&
             !nonOrderableUD_Types.includes(c.udt_name),
           filter: Boolean(p.select?.filterFields?.includes(c.name)),
           update:
@@ -108,9 +126,16 @@ export async function getColumns(
             dynamicUpdateFields.includes(c.name),
           delete:
             _delete &&
-            Boolean(p.delete && p.delete.filterFields && p.delete.filterFields.includes(c.name)),
-          ...(prostgles?.tableConfigurator?.getColInfo({ table: this.name, col: c.name, lang }) ||
-            {}),
+            Boolean(
+              p.delete &&
+                p.delete.filterFields &&
+                p.delete.filterFields.includes(c.name),
+            ),
+          ...(prostgles?.tableConfigurator?.getColInfo({
+            table: this.name,
+            col: c.name,
+            lang,
+          }) || {}),
           ...(fileConfig && { file: fileConfig }),
         };
 
@@ -133,14 +158,21 @@ export async function getColumns(
       duration: Date.now() - start,
       error: getErrorAsObject(e),
     });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
 }
 
 function replaceNonAlphaNumeric(string: string, replacement = "_"): string {
   return string.replace(/[\W_]+/g, replacement);
 }
-function capitalizeFirstLetter(string: string, nonalpha_replacement?: string): string {
+function capitalizeFirstLetter(
+  string: string,
+  nonalpha_replacement?: string,
+): string {
   const str = replaceNonAlphaNumeric(string, nonalpha_replacement);
   return str.charAt(0).toUpperCase() + str.slice(1);
 }

package/lib/DboBuilder/getCondition.ts

@@ -9,7 +9,7 @@ import { getExistsCondition } from "./ViewHandler/getExistsCondition";
 import { getExistsFilters } from "./ViewHandler/getExistsFilters";
 import { parseComplexFilter } from "./ViewHandler/parseComplexFilter";
 
-const FILTER_FUNCS = FUNCTIONS.filter(f => f.canBeUsedForFilter);
+const FILTER_FUNCS = FUNCTIONS.filter((f) => f.canBeUsedForFilter);
 
 /**
  * parses a single filter
@@ -18,52 +18,79 @@ const FILTER_FUNCS = FUNCTIONS.filter(f => f.canBeUsedForFilter);
  *  { fff: { $ilike: 'abc' } } => "fff" ilike 'abc'
  */
 export async function getCondition(
-  this: ViewHandler, 
-  params: { 
-    filter: any, 
-    select: SelectItem[] | undefined, 
-    allowed_colnames: string[], 
-    tableAlias?: string, 
-    localParams?: LocalParams, 
-    tableRules?: TableRule,
-    isHaving?: boolean,
+  this: ViewHandler,
+  params: {
+    filter: any;
+    select: SelectItem[] | undefined;
+    allowed_colnames: string[];
+    tableAlias?: string;
+    localParams?: LocalParams;
+    tableRules?: TableRule;
+    isHaving?: boolean;
   },
 ): Promise<{ exists: ExistsFilterConfig[]; condition: string }> {
-  const { filter: rawFilter, select, allowed_colnames, tableAlias, localParams, tableRules, isHaving } = params;
- 
-  const filter = { ... (rawFilter as any) } as any;
+  const {
+    filter: rawFilter,
+    select,
+    allowed_colnames,
+    tableAlias,
+    localParams,
+    tableRules,
+    isHaving,
+  } = params;
+
+  const filter = { ...(rawFilter as any) } as any;
 
   const existsConfigs = getExistsFilters(filter, this);
 
   const funcConds: string[] = [];
-  const funcFilter = FILTER_FUNCS.filter(f => f.name in filter);
+  const funcFilter = FILTER_FUNCS.filter((f) => f.name in filter);
 
-  funcFilter.map(f => {
+  funcFilter.map((f) => {
     const funcArgs = filter[f.name];
     if (!Array.isArray(funcArgs)) {
       throw `A function filter must contain an array. E.g: { $funcFilterName: ["col1"] } \n but got: ${JSON.stringify(pickKeys(filter, [f.name]))} `;
     }
-    const fields = this.parseFieldFilter(f.getFields(funcArgs), true, allowed_colnames);
+    const fields = this.parseFieldFilter(
+      f.getFields(funcArgs),
+      true,
+      allowed_colnames,
+    );
 
-    const dissallowedCols = fields.filter(fname => !allowed_colnames.includes(fname))
+    const dissallowedCols = fields.filter(
+      (fname) => !allowed_colnames.includes(fname),
+    );
     if (dissallowedCols.length) {
-      throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`
+      throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`;
     }
-    funcConds.push(f.getQuery({ args: funcArgs, allColumns: this.columns, allowedFields: allowed_colnames, tableAlias }));
+    funcConds.push(
+      f.getQuery({
+        args: funcArgs,
+        allColumns: this.columns,
+        allowedFields: allowed_colnames,
+        tableAlias,
+      }),
+    );
   });
 
-
   let existsCond = "";
   if (existsConfigs.length) {
-    existsCond = (await Promise.all(existsConfigs.map(async existsConfig => await getExistsCondition.bind(this)(existsConfig, localParams)))).join(" AND ");
+    existsCond = (
+      await Promise.all(
+        existsConfigs.map(
+          async (existsConfig) =>
+            await getExistsCondition.bind(this)(existsConfig, localParams),
+        ),
+      )
+    ).join(" AND ");
   }
 
   /* Computed field queries ($rowhash) */
   const p = this.getValidatedRules(tableRules, localParams);
-  const computedFields = p.allColumns.filter(c => c.type === "computed");
+  const computedFields = p.allColumns.filter((c) => c.type === "computed");
   const computedColConditions: string[] = [];
-  Object.keys(filter || {}).map(key => {
-    const compCol = computedFields.find(cf => cf.name === key);
+  Object.keys(filter || {}).map((key) => {
+    const compCol = computedFields.find((cf) => cf.name === key);
     if (compCol) {
       computedColConditions.push(
         compCol.getQuery({
@@ -75,7 +102,7 @@ export async function getCondition(
           // ctidField: this.is_view? undefined : "ctid"
 
           ctidField: undefined,
-        }) + ` = ${pgp.as.format("$1", [(filter as any)[key]])}`
+        }) + ` = ${pgp.as.format("$1", [(filter as any)[key]])}`,
       );
       delete (filter as any)[key];
     }
@@ -85,41 +112,48 @@ export async function getCondition(
   /* 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 => {
-      if (["function", "computed", "column"].includes(s.type) || isHaving && s.type === "aggregation") {
+    allowedSelect = select.filter((s) => {
+      if (
+        ["function", "computed", "column"].includes(s.type) ||
+        (isHaving && s.type === "aggregation")
+      ) {
         /** Selected computed cols are allowed for filtering without checking. Why not allow all?! */
         if (s.type !== "column" || allowed_colnames.includes(s.alias)) {
           return true;
         }
       }
       return false;
-    })
+    });
   }
 
   /* 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(
-    remainingNonSelectedColumns
-  );
+  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(remainingNonSelectedColumns);
   const complexFilters: string[] = [];
   const complexFilterKey = "$filter";
   if (complexFilterKey in filter) {
-
     const complexFilterCondition = parseComplexFilter({
       filter,
       complexFilterKey,
@@ -135,39 +169,43 @@ 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)
-    );
+  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 =>
-      c === fName ||
-      (
-        fName.startsWith(c) && (
-          fName.slice(c.length).includes("->") ||
-          fName.slice(c.length).includes(".")
-        )
-      )
-    ));
+  const validFieldNames = allowedSelect.map((s) => s.alias);
+  const invalidColumn = filterKeys.find(
+    (fName) =>
+      !validFieldNames.find(
+        (c) =>
+          c === fName ||
+          (fName.startsWith(c) &&
+            (fName.slice(c.length).includes("->") ||
+              fName.slice(c.length).includes("."))),
+      ),
+  );
 
   if (invalidColumn) {
-    const selItem = select?.find(s => s.alias === invalidColumn);
+    const selItem = select?.find((s) => s.alias === invalidColumn);
     let isComplexFilter = false;
-    if(selItem?.type === "aggregation"){
-      if(!params.isHaving){
-        throw new Error(`Filtering by ${invalidColumn} is not allowed. Aggregations cannot be filtered. Use HAVING clause instead.`);
+    if (selItem?.type === "aggregation") {
+      if (!params.isHaving) {
+        throw new Error(
+          `Filtering by ${invalidColumn} is not allowed. Aggregations cannot be filtered. Use HAVING clause instead.`,
+        );
       } else {
         isComplexFilter = true;
       }
     }
 
-    if(!isComplexFilter){
-      const allowedCols = allowedSelect.map(s => s.type === "column" ? s.getQuery() : s.alias).join(", ");
+    if (!isComplexFilter) {
+      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;
     }
@@ -182,10 +220,14 @@ export async function getCondition(
     filter: f,
     tableAlias,
     select: allowedSelect,
-    allowedColumnNames: !tableRules? this.column_names.slice(0) : this.parseFieldFilter(tableRules.select?.filterFields ?? tableRules.select?.fields),
+    allowedColumnNames: !tableRules
+      ? this.column_names.slice(0)
+      : this.parseFieldFilter(
+          tableRules.select?.filterFields ?? tableRules.select?.fields,
+        ),
   });
 
-  let templates: string[] = [q].filter(q => q);
+  let templates: string[] = [q].filter((q) => q);
 
   if (existsCond) templates.push(existsCond);
   templates = templates.concat(funcConds);
@@ -193,9 +235,8 @@ export async function getCondition(
   templates = templates.concat(complexFilters);
 
   /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
-  return { 
-    exists: existsConfigs, 
-    condition: templates.sort().join(" AND \n") 
+  return {
+    exists: existsConfigs,
+    condition: templates.sort().join(" AND \n"),
   };
-
-}
+}