prostgles-server 4.2.624 → 4.2.626

package/lib/Audit/getAuditTableRules.ts

@@ -0,0 +1,292 @@
+import { as } from "pg-promise";
+import { asName, fromEntries, isDefined, isEmpty, isObject } from "prostgles-types";
+import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
+import type { Filter, LocalParams } from "../DboBuilder/DboBuilder";
+import type { ViewHandler } from "../DboBuilder/ViewHandler/ViewHandler";
+import { withTableExpression } from "../DboBuilder/QueryBuilder/getQuerySource";
+import type { PublishParser } from "../PublishParser/PublishParser";
+import type {
+  ParsedPublishTable,
+  PublishObject,
+  SelectRule,
+} from "../PublishParser/publishTypesAndUtils";
+import { AUDIT_TABLE_COLUMN_NAMES, type AuditTableRow } from "./AuditTable";
+import type { ResolvedAuditConfig } from "./AuditTypes";
+import { prepareWhere } from "../DboBuilder/ViewHandler/prepareWhere";
+
+export const getAuditTableRules = async function (
+  this: PublishParser,
+  audit: ResolvedAuditConfig,
+  auditTablePublishRules: ParsedPublishTable | undefined,
+  clientReq: AuthClientRequest | undefined,
+  clientInfo: AuthResultWithSID | undefined,
+  scope: LocalParams["scope"] | undefined,
+  resolvedPublishObject: PublishObject | undefined,
+): Promise<ParsedPublishTable | undefined> {
+  if (auditTablePublishRules?.select) {
+    return auditTablePublishRules;
+  }
+  if (resolvedPublishObject && Object.hasOwn(resolvedPublishObject, audit.tableName)) {
+    return auditTablePublishRules;
+  }
+
+  const auditedTableNames = Object.keys(audit.tables).filter(
+    (tableName) => canSelect(resolvedPublishObject?.[tableName]) || this.dbo[tableName]?.is_media,
+  );
+
+  const auditTableHandler = this.dbo[audit.tableName]!;
+
+  const auditedTableRules = (
+    await Promise.all(
+      auditedTableNames.map(async (tableName) => {
+        const tableHandler = this.dbo[tableName];
+        if (!tableHandler) return;
+
+        const rules = await this.getTableRules({
+          tableName,
+          clientReq,
+          clientInfo,
+          scope,
+          resolvedPublishObject,
+        });
+
+        if (!rules?.select) {
+          return;
+        }
+
+        return {
+          handler: tableHandler,
+          additionalForcedCondition: await getSourceAuditCondition(
+            tableHandler,
+            rules.select.forcedFilter,
+            audit.tables[tableName]!.excludeColumns,
+          ),
+          tableColumnOverrides: getAuditRowColumnOverrides(
+            tableHandler.parseFieldFilter(rules.select.fields),
+            audit.tables[tableName]!.idColumns,
+          ),
+        };
+      }),
+    )
+  ).filter(isDefined);
+
+  if (!auditedTableRules.length) {
+    return auditTablePublishRules;
+  }
+
+  const validateRequest = (filter: Filter) => {
+    const requiredTableNameFilterValue = getRequiredStringFilter(
+      filter,
+      [AUDIT_TABLE_COLUMN_NAMES.schema_name, AUDIT_TABLE_COLUMN_NAMES.table_name],
+      this.prostgles.keywords.$and,
+    );
+    if (!requiredTableNameFilterValue) {
+      throw new Error("Audit queries require an exact schema_name and table_name filter");
+    }
+    const { schema_name, table_name } = requiredTableNameFilterValue;
+    const [matchingAuditedTableRules, ...otherMatches] = auditedTableRules.filter(
+      ({ handler: { tableOrViewInfo } }) => {
+        const sourceName = tableOrViewInfo.qualifiedNameParts;
+        return sourceName.name === table_name && sourceName.schema === schema_name;
+      },
+    );
+    if (otherMatches.length) {
+      throw new Error("Invalid audit table filter: multiple matching rules found");
+    }
+    if (!matchingAuditedTableRules) {
+      throw new Error("Invalid audit table filter: no matching rules found");
+    }
+    const { additionalForcedCondition, tableColumnOverrides } = matchingAuditedTableRules;
+    const tableExpression = getTableExpression(
+      auditTableHandler,
+      tableColumnOverrides,
+      additionalForcedCondition,
+    );
+    return { tableExpression };
+  };
+
+  const select: SelectRule = withTableExpression(
+    {
+      fields: "*",
+      filterFields: "*",
+      orderByFields: "*",
+      disableMethods: { subscribe: 1, sync: 1 },
+    },
+    (request) => validateRequest(request.filter).tableExpression,
+  );
+
+  return { ...auditTablePublishRules, select };
+};
+
+const getAuditRowColumnOverrides = (allowedColumns: string[], idColumns: readonly string[]) => {
+  type SnapshotColumn =
+    | typeof AUDIT_TABLE_COLUMN_NAMES.old_id
+    | typeof AUDIT_TABLE_COLUMN_NAMES.new_id
+    | typeof AUDIT_TABLE_COLUMN_NAMES.old_row
+    | typeof AUDIT_TABLE_COLUMN_NAMES.new_row;
+  const getSnapshotExpression = (snapshotColumn: SnapshotColumn, columns: string[]) => {
+    const snapshot = asName(snapshotColumn);
+    const args = columns.flatMap((columnName) => [
+      as.text(columnName),
+      `${snapshot} -> ${as.text(columnName)}`,
+    ]);
+    return `CASE WHEN ${snapshot} IS NULL THEN NULL ELSE jsonb_build_object(${args.join(", ")}) END`;
+  };
+
+  return {
+    [AUDIT_TABLE_COLUMN_NAMES.old_id]: getSnapshotExpression(
+      AUDIT_TABLE_COLUMN_NAMES.old_id,
+      idColumns.filter((columnName) => allowedColumns.includes(columnName)),
+    ),
+    [AUDIT_TABLE_COLUMN_NAMES.new_id]: getSnapshotExpression(
+      AUDIT_TABLE_COLUMN_NAMES.new_id,
+      idColumns.filter((columnName) => allowedColumns.includes(columnName)),
+    ),
+    [AUDIT_TABLE_COLUMN_NAMES.old_row]: getSnapshotExpression(
+      AUDIT_TABLE_COLUMN_NAMES.old_row,
+      allowedColumns,
+    ),
+    [AUDIT_TABLE_COLUMN_NAMES.new_row]: getSnapshotExpression(
+      AUDIT_TABLE_COLUMN_NAMES.new_row,
+      allowedColumns,
+    ),
+  };
+};
+
+const getSourceAuditCondition = async (
+  sourceHandler: ViewHandler,
+  forcedFilter: Filter | undefined,
+  excludedColumns: readonly string[],
+) => {
+  const { schema, name } = sourceHandler.tableOrViewInfo.qualifiedNameParts;
+  const auditColumn = (columnName: keyof AuditTableRow) => asName(columnName);
+  const sourceCondition = [
+    `${auditColumn(AUDIT_TABLE_COLUMN_NAMES.schema_name)} = ${as.text(schema)}`,
+    `${auditColumn(AUDIT_TABLE_COLUMN_NAMES.table_name)} = ${as.text(name)}`,
+  ].join(" AND ");
+  if (!forcedFilter || !Object.keys(forcedFilter).length) {
+    return sourceCondition;
+  }
+
+  const getSnapshotCondition = async (
+    snapshotColumn:
+      typeof AUDIT_TABLE_COLUMN_NAMES.old_row | typeof AUDIT_TABLE_COLUMN_NAMES.new_row,
+  ) => {
+    const alias = `prostgles_audit_${snapshotColumn}`;
+    const snapshot = auditColumn(snapshotColumn);
+    const { condition } = await prepareWhere(sourceHandler, {
+      filter: forcedFilter,
+      select: undefined,
+      filterFields: sourceHandler.column_names.filter(
+        (columnName) => !excludedColumns.includes(columnName),
+      ),
+      addWhere: false,
+      tableAlias: { raw: alias, escaped: asName(alias) },
+      localParams: undefined,
+      tableRule: undefined,
+    });
+    if (!condition) return "TRUE";
+
+    const record = `NULL::${sourceHandler.escapedName}`;
+    return `(
+      ${snapshot} IS NULL OR EXISTS (
+        SELECT 1
+        FROM jsonb_populate_record(${record}, ${snapshot}) AS ${asName(alias)}
+        WHERE ${condition}
+      )
+    )`;
+  };
+
+  const [oldRowCondition, newRowCondition] = await Promise.all([
+    getSnapshotCondition(AUDIT_TABLE_COLUMN_NAMES.old_row),
+    getSnapshotCondition(AUDIT_TABLE_COLUMN_NAMES.new_row),
+  ]);
+  /** Prevent updates that cross a forcedFilter boundary from exposing either snapshot. */
+  return `(${sourceCondition}) AND ${oldRowCondition} AND ${newRowCondition}`;
+};
+
+const canSelect = (rule: PublishObject[string] | undefined) => {
+  return rule === "*" || rule === true || (isObject(rule) && Boolean(rule.select));
+};
+
+const getRequiredStringFilter = <Key extends keyof AuditTableRow>(
+  filter: Filter,
+  fieldNames: Key[],
+  andKey: string,
+): Record<Key, string> | undefined => {
+  const values = getExactStringFilters(filter, fieldNames, andKey);
+  if (fieldNames.some((fieldName) => !values[fieldName])) return;
+  return values as Record<Key, string>;
+};
+
+const getExactStringFilters = <Key extends keyof AuditTableRow>(
+  filter: Filter,
+  fieldNames: Key[],
+  andKey: string,
+): Partial<Record<Key, string>> => {
+  if (!isObject(filter)) return {};
+  const filterRecord = filter as Record<string, unknown>;
+  const result = fromEntries(
+    fieldNames
+      .map((fieldName) => {
+        const value = filterRecord[fieldName];
+        if (typeof value === "string") return [fieldName, value] as const;
+        if (!isObject(value)) return;
+
+        const entries = Object.entries(value);
+        const [operator, exactValue] = entries[0] ?? [];
+        if (
+          entries.length === 1 &&
+          operator &&
+          ["=", "$eq"].includes(operator) &&
+          typeof exactValue === "string"
+        ) {
+          return [fieldName, exactValue] as const;
+        }
+      })
+      .filter(isDefined),
+  ) as Partial<Record<Key, string>>;
+
+  const andFilters = filterRecord[andKey];
+  if (!Array.isArray(andFilters)) return result;
+
+  for (const andFilter of andFilters) {
+    const nestedValues = getExactStringFilters(andFilter as Filter, fieldNames, andKey);
+    for (const fieldName of fieldNames) {
+      const nestedValue = nestedValues[fieldName];
+      if (!nestedValue) continue;
+      const existingValue = result[fieldName];
+      if (existingValue && existingValue !== nestedValue) {
+        throw new Error(`Conflicting exact ${fieldName} filters`);
+      }
+      result[fieldName] = nestedValue;
+    }
+  }
+  return result;
+};
+
+const getTableExpression = (
+  auditTableHandler: ViewHandler,
+  columnOverrides: Record<string, string> | undefined,
+  additionalCondition: string | undefined,
+) => {
+  const overrides = columnOverrides && !isEmpty(columnOverrides) ? columnOverrides : undefined;
+  if (!overrides && !additionalCondition) return;
+
+  const invalidColumns = Object.keys(overrides ?? {}).filter(
+    (columnName) => !auditTableHandler.column_names.includes(columnName),
+  );
+  if (invalidColumns.length) {
+    throw new Error(`Invalid table column overrides: ${invalidColumns.join(", ")}`);
+  }
+
+  const columns =
+    overrides ?
+      auditTableHandler.column_names.map((columnName) => {
+        const override = overrides[columnName];
+        return override ? `${override} AS ${asName(columnName)}` : asName(columnName);
+      })
+    : ["*"];
+  const where = additionalCondition ? ` WHERE ${additionalCondition}` : "";
+  return `(SELECT ${columns.join(", ")} FROM ${auditTableHandler.escapedName}${where})`;
+};

package/lib/Audit/getAuditTriggerConfig.ts

@@ -3,9 +3,22 @@ import { asName } from "prostgles-types";
 import type { TableConfig } from "../TableConfig/TableConfigTypes";
 import type { ResolvedAuditConfig } from "./AuditTypes";
 import { getAuditProtection, getAuditWriterName } from "./getAuditTableConfig";
+import { AUDIT_TABLE_COLUMN_NAMES } from "./AuditTable";
 
 export const getAuditTriggerConfig = (audit: ResolvedAuditConfig): TableConfig => {
   const result: TableConfig = {};
+  const columns = AUDIT_TABLE_COLUMN_NAMES;
+  const insertColumns = [
+    columns.schema_name,
+    columns.table_name,
+    columns.operation,
+    columns.old_id,
+    columns.new_id,
+    columns.old_row,
+    columns.new_row,
+    columns.actor,
+    columns.db_context,
+  ].map((columnName) => asName(columnName));
   for (const [name, options] of Object.entries(audit.tables)) {
     const { idColumns: ids, excludeColumns: excluded } = options;
     const functionName = getAuditWriterName(audit.tableName, name);
@@ -32,7 +45,7 @@ export const getAuditTriggerConfig = (audit: ResolvedAuditConfig): TableConfig =
               after_row := after_row - excluded;
             END IF;
             IF TG_OP = 'UPDATE' AND before_row IS NOT DISTINCT FROM after_row THEN RETURN NULL; END IF;
-            INSERT INTO ${asName(audit.tableName)} (schema_name, table_name, operation, old_id, new_id, old_row, new_row, actor, db_context)
+            INSERT INTO ${asName(audit.tableName)} (${insertColumns.join(", ")})
               VALUES (TG_TABLE_SCHEMA, TG_TABLE_NAME, TG_OP, before_id, after_id, before_row, after_row,
                 nullif(current_setting('prostgles.user', true), '')::jsonb,
                 jsonb_build_object(

package/lib/DBSchemaBuilder/getClientDBGeneratedSchemas.ts

@@ -86,6 +86,9 @@ export const getClientDBGeneratedSchemas = (
           `  ${JSON.stringify(table.name)}: ${tableType} & { insertColumns: ${input}; updateColumns: ${updateInput};${optionalTable} };`,
         ];
       });
+    if (!definitions.length) {
+      return `export type ${name} = Record<string, never>;`;
+    }
     return `export type ${name} = {\n${definitions.join("\n")}\n};`;
   };
 
@@ -105,9 +108,14 @@ const reservedNames = new Set(Object.values(DB_GENERATED_NAMES) as string[]);
 
 export const validateClientSchemaName = (name: string) => {
   // Requiring a Schema suffix also avoids TypeScript keywords and primitive type names.
-  if (!/^[A-Za-z_$][\w$]*Schema$/.test(name) || reservedNames.has(name)) {
+  if (!/^[A-Za-z_$][\w$]*Schema$/.test(name)) {
     throw new Error(
       `Invalid client schema name: ${JSON.stringify(name)}. Use a unique name ending in Schema.`,
     );
   }
+  if (reservedNames.has(name)) {
+    throw new Error(
+      `Invalid client schema name: ${JSON.stringify(name)}. Use a unique name ending in Schema that does not conflict with reserved names (${Array.from(reservedNames).join(", ")}).`,
+    );
+  }
 };

package/lib/DBSchemaBuilder/getDBGeneratedSchema.ts

@@ -1,5 +1,4 @@
-import { isDefined, isEmpty, type TableSchema } from "prostgles-types";
-import { fromEntries } from "../PublishParser/applyScopeToTableRules";
+import { fromEntries, isDefined, isEmpty, type TableSchema } from "prostgles-types";
 import type { TableConfig } from "../TableConfig/TableConfigTypes";
 import { escapeTSNames } from "../utils/utils";
 import { DB_GENERATED_NAMES } from "./constants";

package/lib/DboBuilder/QueryBuilder/QueryBuilder.ts

@@ -5,7 +5,6 @@
 
 import type {
   ColumnInfo,
-  JoinSelect,
   PG_COLUMN_UDT_DATA_TYPE,
   Select,
   ValidatedColumnInfo,
@@ -13,12 +12,15 @@ import type {
 import { getKeys, isEmpty, isObject, postgresToTsType } from "prostgles-types";
 import type { PGIdentifier, SortItem } from "../DboBuilder";
 
+import type { Awaitable } from "../../PublishParser/publishTypesAndUtils";
+import { asNameAlias } from "../../utils/asNameAlias";
 import type { ParsedJoinPath } from "../ViewHandler/parseJoinPath";
-import type { ViewHandler } from "../ViewHandler/ViewHandler";
-import type { FieldSpec, FunctionSpec } from "./Functions/Functions";
+import type { WhereOptions } from "../ViewHandler/prepareWhere";
 import { COMPUTED_FIELDS } from "./Functions/COMPUTED_FIELDS";
+import type { FieldSpec, FunctionSpec } from "./Functions/Functions";
 import { parseFunction } from "./Functions/parseFunction";
-import { asNameAlias } from "../../utils/asNameAlias";
+import { parseJoinSelect, type ParsedJoin } from "./parseJoinSelect";
+import type { QuerySource } from "./getQuerySource";
 
 export type SelectItem = {
   getFields: (args: any[]) => string[] | "*";
@@ -36,13 +38,9 @@ export type SelectItem = {
   | {
       type: "function" | "aggregation" | "joinedColumn" | "computed";
       columnName?: undefined;
-      // args: any[];
-      // getFields: (args: any[]) => string[] | "*";
-      // columnNames: string[];
     }
 );
 export type SelectItemValidated = Omit<SelectItem, "getFields"> & { fields: string[] };
-export type WhereOptions = Awaited<ReturnType<ViewHandler["prepareWhere"]>>;
 export type NewQueryRoot = {
   /**
    * All fields from the table will be in nested SELECT and GROUP BY to allow order/filter by fields not in select
@@ -55,6 +53,7 @@ export type NewQueryRoot = {
   select: SelectItemValidated[];
 
   table: PGIdentifier;
+  source: QuerySource;
   where: string;
   whereOpts: WhereOptions;
   orderByItems: SortItem[];
@@ -148,7 +147,7 @@ export class SelectItemBuilder {
     const allowedFields = isSelected ? allowedSelectedFields : allowedNonSelectedFields;
     if (!allowedFields.includes(f)) {
       throw (
-        "Field " + f + " is invalid or dissallowed. \nAllowed fields: " + allowedFields.join(", ")
+        "Field " + f + " is invalid or disallowed. \nAllowed fields: " + allowedFields.join(", ")
       );
     }
     return f;
@@ -193,7 +192,7 @@ export class SelectItemBuilder {
     });
   };
 
-  addColumn = (fieldName: string, selected: boolean) => {
+  private addColumn = (fieldName: string, selected: boolean) => {
     /* Check if computed col */
     if (selected) {
       const compCol = COMPUTED_FIELDS.find((cf) => cf.name === fieldName);
@@ -225,10 +224,19 @@ export class SelectItemBuilder {
     });
   };
 
-  parseUserSelect = async (
+  parse = async (
     userSelect: Select,
-    joinParse?: (key: string, val: JoinSelect, throwErr: (msg: string) => any) => any,
-  ) => {
+    joinParse?: (key: string, parsedJoin: ParsedJoin) => Awaitable<void>,
+  ): Promise<void> => {
+    if (userSelect === "") {
+      return;
+    }
+
+    if (userSelect === "*") {
+      this.allowedFields.map((key) => this.addColumn(key, true));
+      return;
+    }
+
     /* [col1, col2, col3] */
     if (Array.isArray(userSelect)) {
       if (userSelect.find((key) => typeof (key as unknown) !== "string")) {
@@ -236,90 +244,110 @@ export class SelectItemBuilder {
       }
 
       userSelect.map((key) => this.addColumn(key, true));
+      return;
+    }
 
-      /* Empty select */
-    } else if (userSelect === "") {
-      return [];
-    } else if (userSelect === "*") {
-      this.allowedFields.map((key) => this.addColumn(key, true));
-    } else if (isObject(userSelect) && !isEmpty(userSelect)) {
-      const selectKeys = Object.keys(userSelect),
-        selectValues = Object.values(userSelect);
-
-      /* Cannot include and exclude at the same time */
-      if (selectValues.filter((v) => [0, false].includes(v as number)).length) {
-        if (selectValues.filter((v) => ![0, false].includes(v as number)).length) {
-          throw "\nCannot include and exclude fields at the same time";
-        }
-
-        /* Exclude only */
-        this.allowedFields
-          .filter((f) => !selectKeys.includes(f))
-          .map((key) => this.addColumn(key, true));
-      } else {
-        await Promise.all(
-          selectKeys.map(async (key) => {
-            const val: unknown = userSelect[key as keyof typeof userSelect];
-            const throwErr = (extraErr = "") => {
-              console.trace(extraErr);
-              throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + extraErr;
-            };
-
-            /* Included fields */
-            if ([1, true].includes(val as number | boolean)) {
-              if (key === "*") {
-                this.allowedFields.map((key) => this.addColumn(key, true));
-              } else {
-                this.addColumn(key, true);
-              }
+    if (!isObject(userSelect)) {
+      throw "Unexpected select -> " + JSON.stringify(userSelect);
+    }
+
+    if (isEmpty(userSelect)) {
+      throw "Unexpected empty object select";
+    }
+
+    const selectKeys = Object.keys(userSelect),
+      selectValues = Object.values(userSelect);
+
+    /* Cannot include and exclude at the same time */
+    if (selectValues.filter((v) => [0, false].includes(v as number)).length) {
+      if (selectValues.filter((v) => ![0, false].includes(v as number)).length) {
+        throw "\nCannot include and exclude fields at the same time";
+      }
 
-              /* Aggs and functions */
-            } else if (typeof val === "string" || isObject(val)) {
-              /* Function shorthand notation
+      /* Exclude only */
+      this.allowedFields
+        .filter((f) => !selectKeys.includes(f))
+        .map((key) => this.addColumn(key, true));
+    } else {
+      await Promise.all(
+        selectKeys.map(async (key) => {
+          const val: unknown = userSelect[key as keyof typeof userSelect];
+          const throwErr: (message: string) => never = (message) => {
+            console.trace(message);
+            throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + message;
+          };
+
+          /* Included fields */
+          if ([1, true].includes(val as number | boolean)) {
+            if (key === "*") {
+              this.allowedFields.map((key) => this.addColumn(key, true));
+            } else {
+              this.addColumn(key, true);
+            }
+
+            /* Aggregations and functions */
+          } else if (typeof val === "string" || isObject(val)) {
+            /* Function shorthand notation
                 { id: "$max" } === { id: { $max: ["id"] } } === SELECT MAX(id) AS id 
-            */
-              if (
-                (typeof val === "string" && val !== "*") ||
-                (isObject(val) &&
-                  Object.keys(val).length === 1 &&
-                  Array.isArray(Object.values(val)[0]))
-              ) {
-                let funcName: string | undefined, args: any[] | undefined;
-                if (typeof val === "string") {
-                  /* Shorthand notation -> it is expected that the key is the column name used as the only argument */
-                  try {
-                    this.checkField(key, true);
-                  } catch {
-                    throwErr(
-                      ` Shorthand function notation error: the specifield column ( ${key} ) is invalid or dissallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `,
-                    );
-                  }
-                  funcName = val;
-                  args = [key];
-
-                  /** Function full notation { $funcName: ["colName", ...args] } */
-                } else {
-                  ({ funcName, args } = parseFunctionObject(val));
+              */
+            if (
+              (typeof val === "string" && val !== "*") ||
+              (isObject(val) &&
+                Object.keys(val).length === 1 &&
+                Array.isArray(Object.values(val)[0]))
+            ) {
+              let funcName: string | undefined, args: any[] | undefined;
+              if (typeof val === "string") {
+                /* Shorthand notation -> it is expected that the key is the column name used as the only argument */
+                try {
+                  this.checkField(key, true);
+                } catch {
+                  throwErr(
+                    ` Shorthand function notation error: the specified column ( ${key} ) is invalid or disallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `,
+                  );
                 }
+                funcName = val;
+                args = [key];
 
-                this.addFunction(funcName, args, key);
-
-                /* Join */
+                /** Function full notation { $funcName: ["colName", ...args] } */
               } else {
-                if (!joinParse) {
-                  throw "Joins disallowed";
-                }
-                await joinParse(key, val as JoinSelect, throwErr);
+                ({ funcName, args } = parseFunctionObject(val));
               }
-            } else throwErr();
-          }),
-        );
-      }
-    } else {
-      if (isEmpty(userSelect)) {
-        throw "Unexpected empty object select";
-      }
-      throw "Unexpected select -> " + JSON.stringify(userSelect);
+
+              this.addFunction(funcName, args, key);
+
+              /* Join */
+            } else {
+              if (!joinParse) {
+                throw "Joins disallowed";
+              }
+              const joinSelect = val;
+
+              const parsedJoin = parseJoinSelect(joinSelect);
+
+              if (typeof parsedJoin === "string") {
+                throwErr(parsedJoin);
+              }
+              await joinParse(key, parsedJoin);
+            }
+          } else throwErr("Invalid select value");
+        }),
+      );
     }
+
+    if (!joinParse) return;
+    /**
+     * Is this still needed?!!!
+     * Add non selected columns
+     * This ensures all fields are available for orderBy in case of nested select
+     * */
+    Array.from(new Set([...this.allowedFields, ...this.allowedOrderByFields])).map((columnName) => {
+      if (!this.select.find((s) => s.alias === columnName && s.type === "column")) {
+        this.addColumn(columnName, false);
+      }
+    });
   };
+
+  parseUserSelect = (userSelect: Select) => this.parse(userSelect);
+  parseUserSelectWithJoins = this.parse;
 }

package/lib/DboBuilder/QueryBuilder/getJoinQuery.ts

@@ -255,6 +255,7 @@ const getInnerJoinQuery = ({
 
     const isFirst = !i;
     if (isFirst) {
+      const tableExpression = isLast ? q2.source.expression : table.name;
       return [
         `SELECT `,
         `  /* Join fields + select */`,
@@ -262,13 +263,13 @@ const getInnerJoinQuery = ({
           rootSelectItems.map((s) => s.query),
           { appendCommas: true },
         ),
-        `FROM ${table.name} ${table.alias}`,
+        `FROM ${tableExpression} ${table.alias}`,
         ...targetQueryExtraQueries,
       ];
     }
 
     return [
-      `INNER JOIN ${table.name} ${table.alias}`,
+      `INNER JOIN ${isLast ? q2.source.expression : table.name} ${table.alias}`,
       `ON ${getJoinOnCondition({
         on: path.on,
         leftAlias: prevTable.alias,