prostgles-server 4.2.625 → 4.2.627

package/lib/DboBuilder/QueryBuilder/getNewQuery.ts

@@ -1,7 +1,13 @@
 import type { SelectParams } from "prostgles-types";
-import { asName, isEmpty, omitKeys } from "prostgles-types";
+import { asName, isEmpty, isObject, omitKeys } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { Filter, LocalParams, PGIdentifier, ValidatedTableRules } from "../DboBuilder";
+import {
+  prepareOrderByQuery,
+  type Filter,
+  type LocalParams,
+  type PGIdentifier,
+  type ValidatedTableRules,
+} from "../DboBuilder";
 import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { parseJoinPath } from "../ViewHandler/parseJoinPath";
 import { prepareSortItems } from "../ViewHandler/prepareSortItems";
@@ -21,22 +27,31 @@ export const getNewQuery = async (
 ): Promise<NewQuery> => {
   const { columns } = viewHandler;
 
-  if (localParams?.isRemoteRequest && !tableRules?.select?.fields) {
+  const selectRule = tableRules?.select;
+  if (tableRules && !selectRule?.fields) {
     throw `INTERNAL ERROR: publish.${viewHandler.name}.select.fields rule missing`;
   }
 
+  /** Only missing tableRules means this is an unrestricted local query */
   const allowedOrderByFields =
-    !tableRules ?
+    !selectRule ?
       viewHandler.column_names.slice(0)
-    : viewHandler.parseFieldFilter(tableRules.select?.orderByFields ?? tableRules.select?.fields);
+    : viewHandler.parseFieldFilter(selectRule.orderByFields);
   const allowedSelectFields =
-    !tableRules ?
+    !selectRule ?
       viewHandler.column_names.slice(0)
-    : viewHandler.parseFieldFilter(tableRules.select?.fields);
+    : viewHandler.parseFieldFilter(selectRule.fields);
+  const allowedFilterFields =
+    !selectRule ?
+      viewHandler.column_names.slice(0)
+    : viewHandler.parseFieldFilter(selectRule.filterFields);
 
   const joinQueries: NewQueryJoin[] = [];
 
   const { select: userSelect = "*" } = selectParams;
+  const aggregateTableAlias =
+    selectParams.joinExpressionAlias ??
+    ({ raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS } satisfies PGIdentifier);
 
   const selectItemBuilder = new SelectItemBuilder({
     allowedFields: allowedSelectFields,
@@ -46,6 +61,39 @@ export const getNewQuery = async (
     functions: FUNCTIONS,
     allFields: viewHandler.column_names.slice(0),
     columns,
+    parseAggregateOptions: async ({ $filter, $orderBy }) => {
+      if ($filter !== undefined && !isObject($filter)) {
+        throw `Invalid aggregate $filter. Expecting an object`;
+      }
+      const filterInfo =
+        $filter === undefined ? undefined : (
+          await prepareWhere(viewHandler, {
+            filter: $filter,
+            select: undefined,
+            filterFields: allowedFilterFields,
+            tableAlias: aggregateTableAlias,
+            localParams,
+            addWhere: false,
+            tableRule: tableRules,
+          })
+        );
+      const orderByItems = prepareSortItems(
+        $orderBy,
+        allowedOrderByFields,
+        aggregateTableAlias,
+        [],
+        [],
+      );
+      return {
+        filter: filterInfo?.condition,
+        orderBy: prepareOrderByQuery(orderByItems, aggregateTableAlias.raw)[0],
+        dependencyFields: [
+          ...(filterInfo?.columnsUsed ?? []),
+          ...orderByItems.map(({ key }) => key),
+        ],
+        dependencyExists: filterInfo?.exists ?? [],
+      };
+    },
   });
 
   await selectItemBuilder.parseUserSelectWithJoins(
@@ -151,9 +199,9 @@ export const getNewQuery = async (
         ...omitKeys(commonWhereParams, ["forcedFilter", "selectParams"]),
         filter: selectParams.having,
         tableAlias:
-          selectParams.joinExpressionAlias ? source.alias : (
-            { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS }
-          ),
+          selectParams.joinExpressionAlias ?
+            source.alias
+          : { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS },
         isHaving: true,
       })
     );

package/lib/DboBuilder/QueryBuilder/parseJoinSelect.ts

@@ -5,18 +5,7 @@ import type {
   RawJoinPath,
   SimpleJoinSelect,
 } from "prostgles-types";
-import { getKeys, includes } from "prostgles-types";
-
-const JOIN_KEYS = ["$innerJoin", "$leftJoin"] as const;
-const JOIN_PARAM_KEYS = getKeys({
-  $condition: 1,
-  filter: 1,
-  having: 1,
-  limit: 1,
-  offset: 1,
-  orderBy: 1,
-  select: 1,
-} satisfies Record<keyof Omit<DetailedJoinSelect, (typeof JOIN_KEYS)[number]>, 1>);
+import { getKeys, includes, JOIN_KEYS, JOIN_PARAMS } from "prostgles-types";
 
 export type ParsedJoin =
   | {
@@ -47,7 +36,7 @@ export const parseJoinSelect = (joinParams: JoinSelect): ParsedJoin | string =>
   } else if (joinKey) {
     /* Full option join  { field_name: db.innerJoin.table_name(filter, select)  } */
     const invalidParams = Object.keys(joinParams).filter(
-      (k) => !includes([...JOIN_PARAM_KEYS, ...JOIN_KEYS], k),
+      (k) => !includes([...JOIN_PARAMS, ...JOIN_KEYS], k),
     );
     if (invalidParams.length) {
       throw "Invalid join params: " + invalidParams.join(", ");

package/lib/DboBuilder/TableHandler/onDeleteFromFileTable.ts

@@ -4,6 +4,11 @@ import { asName } from "prostgles-types";
 import type { FileTableConfig } from "../../ProstglesTypes";
 import type { OnCommit } from "../../PublishParser/publishTypesAndUtils";
 import { deleteUnreferencedFile } from "../../StorageClient/deleteUnreferencedFile";
+import {
+  getFileRevisionsTableHandler,
+  getFileTableHandler,
+} from "../../StorageClient/fileVersionUtils";
+import type { TableHandlers } from "../DboBuilder";
 
 type OnDeleteFromFileTableArgs = {
   returningQuery: undefined | string;
@@ -12,12 +17,14 @@ type OnDeleteFromFileTableArgs = {
     filter: AnyObject;
   };
   t: pgPromise.ITask<{}>;
+  dbx: TableHandlers;
   onCommit: OnCommit;
   isOneOrNone: boolean;
 };
+
 export const onDeleteFromFileTable = async (
   config: FileTableConfig,
-  { onCommit, t, returningQuery, filterOpts, isOneOrNone }: OnDeleteFromFileTableArgs,
+  { onCommit, t, dbx, returningQuery, filterOpts, isOneOrNone }: OnDeleteFromFileTableArgs,
 ) => {
   const { tableName } = config;
   if (config.delayedDelete) {
@@ -27,15 +34,35 @@ export const onDeleteFromFileTable = async (
     return (isOneOrNone ? result[0] : result) as undefined | AnyObject[];
   }
 
-  const files = await t.any<Record<string, unknown> & { _prostgles_storage_key: string }>(
+  const fileIds =
+    config.versioning ?
+      await getFileTableHandler(dbx, config).find(filterOpts.filter, {
+        select: { id: 1 },
+        limit: null,
+      })
+    : [];
+  const versionFiles =
+    fileIds.length ?
+      await getFileRevisionsTableHandler(dbx, config).find(
+        { file_id: { $in: fileIds.map(({ id }) => id) } },
+        { select: { storage_key: 1 }, limit: null },
+      )
+    : [];
+
+  const KEY = "_prostgles_storage_key" as const;
+  const files = await t.any<Record<string, unknown> & { [KEY]: string }>(
     `DELETE FROM ${asName(tableName)} ${filterOpts.where}
      ${returningQuery ? `${returningQuery},` : "RETURNING"}
-     COALESCE(storage_key, id) AS _prostgles_storage_key`,
+     COALESCE(storage_key, id) AS ${KEY}`,
   );
-  const result = files.map(({ _prostgles_storage_key, ...row }) => {
-    onCommit(({ db }) => deleteUnreferencedFile(db, config, _prostgles_storage_key));
-    return row;
-  });
+  const storageKeys = new Set([
+    ...versionFiles.map(({ storage_key }) => storage_key),
+    ...files.map((row) => row[KEY]),
+  ]);
+  for (const storageKey of storageKeys) {
+    onCommit(({ db }) => deleteUnreferencedFile(db, config, storageKey));
+  }
+  const result = files.map(({ [KEY]: _, ...row }) => row);
   if (!returningQuery) return undefined;
   return (isOneOrNone ? result[0] : result) as AnyObject[] | undefined;
 };

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -33,6 +33,7 @@ export const updateFile = async (
     data,
     localParams,
     mediaId: existingFile.id,
+    version: Number(existingFile.version ?? 1) + 1,
     original_last_modified,
   });
   return { newData: omitKeys(newFile, ["id"]) };

package/lib/DboBuilder/TableHandler/uploadFile.ts

@@ -44,6 +44,7 @@ export type UploadFileArgs = TransactionCallbacks & {
    * Used to update an existing file
    */
   mediaId: string | undefined;
+  version?: number;
 };
 
 export const uploadFile = async (
@@ -54,6 +55,7 @@ export const uploadFile = async (
     original_last_modified,
     localParams,
     mediaId,
+    version,
     onCommit,
     onRollback,
   }: UploadFileArgs,
@@ -115,6 +117,7 @@ export const uploadFile = async (
     url: [fileServeRoute, coreInfo.id].join("/"),
     content_length: String(contentLength),
     data: Buffer.from([0x01]),
+    ...(config.versioning ? { version: version ?? 1 } : {}),
   };
 
   const isInsert = !mediaId;

package/lib/DboBuilder/ViewHandler/find.ts

@@ -11,6 +11,7 @@ import {
 import { getNewQuery } from "../QueryBuilder/getNewQuery";
 import { getSelectQuery } from "../QueryBuilder/getSelectQuery";
 import { getReturnTypeQuery } from "./getReturnTypeQuery";
+import { validateSelectParams } from "./validateSelectParams";
 import type { ViewHandler } from "./ViewHandler";
 
 export type Param3 = {
@@ -30,44 +31,13 @@ export const find = async function (
 
   const command = limit === 1 && returnType === "row" ? "findOne" : "find";
   try {
-    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>);
+    validateSelectParams(selectParams);
 
     const { returnType } = selectParams || {};
-    if (returnType && !allowedReturnTypes.includes(returnType)) {
-      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,
-        abortSignal: 1,
-      } satisfies Record<keyof SelectParams, 1>);
-
-      const invalidParams = Object.keys(selectParams).filter((k) => !validParamNames.includes(k));
-      if (invalidParams.length)
-        throw (
-          "Invalid params: " +
-          invalidParams.join(", ") +
-          " \n Expecting: " +
-          validParamNames.join(", ")
-        );
-    }
 
     /* Validate publish */
     if (tableRules) {

package/lib/DboBuilder/ViewHandler/getRawInfo.ts

@@ -2,6 +2,7 @@ import { type TableInfo as TInfo } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { LocalParams } from "../DboBuilder";
 import type { ViewHandler } from "./ViewHandler";
+import { isFileVersionTable } from "../../StorageClient/fileVersionUtils";
 
 /** Table metadata before client schema customisation. */
 export function getRawInfo(
@@ -11,7 +12,9 @@ export function getRawInfo(
   localParams?: LocalParams,
 ): TInfo {
   const validatedTableRules = this.getValidatedRules(tableRules, localParams);
-  const fileTableName = this.dboBuilder.prostgles.opts.fileTable?.tableName;
+  const fileTableConfig = this.dboBuilder.prostgles.opts.fileTable;
+  const fileTableName = fileTableConfig?.tableName;
+  const isVersionTable = isFileVersionTable(fileTableConfig, this.name);
   const allowedFieldsToSelect = this.parseFieldFilter(tableRules?.select?.fields);
   const { requiredNestedInserts, allowedNestedInserts } = tableRules?.insert ?? {};
   const label = this.dboBuilder.prostgles.tableConfigurator?.getTableLabel({
@@ -32,10 +35,11 @@ export function getRawInfo(
     isView: this.isView,
     hasFiles: Boolean(
       !this.is_media &&
+      !isVersionTable &&
       fileTableName &&
       this.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
     ),
-    fileTableName,
+    fileTableName: isVersionTable ? undefined : fileTableName,
     dynamicRules: {
       update: Boolean(tableRules?.update?.dynamicFields?.length),
     },

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -34,6 +34,8 @@ export const parseComplexFilter = ({
   allowed_colnames,
   columns,
 }: Args) => {
+  const columnsUsed: string[] = [];
+
   /**
    * { $funcName: [arg1, arg2] }
    * { $column: "column_name" }
@@ -45,8 +47,9 @@ export const parseComplexFilter = ({
         throw `expecting: \n  { $column: "column_name" } received:\n ${JSON.stringify(funcData)}`;
       }
       if (!allowed_colnames.includes(column)) {
-        throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
+        throw `Disallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
       }
+      columnsUsed.push(column);
       return asNameAlias(column, tableAliasRaw);
     }
     const { funcName, args } = parseFunctionObject(funcData);
@@ -56,6 +59,8 @@ export const parseComplexFilter = ({
       functions: FUNCTIONS,
       allowedFields: allowed_colnames,
     });
+    const fields = funcDef.getFields(args);
+    columnsUsed.push(...(fields === "*" ? allowed_colnames : fields));
     return funcDef.getQuery({
       args,
       tableAliasRaw,
@@ -108,5 +113,8 @@ export const parseComplexFilter = ({
     result += ` ${sqlOperand} ${rightVal}`;
   }
 
-  return result;
+  return {
+    condition: result,
+    columnsUsed: Array.from(new Set(columnsUsed)),
+  };
 };

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -77,9 +77,16 @@ async function subscribe(
       newQuery,
     });
 
-    const [firstField, ...otherFields] = newQuery.select
-      .filter((s) => s.selected)
-      .flatMap((c) => c.fields);
+    const [firstField, ...otherFields] = Array.from(
+      new Set([
+        ...newQuery.select
+          .filter((s) => s.selected)
+          .flatMap((item) => [...item.fields, ...(item.dependencyFields ?? [])]),
+        ...newQuery.orderByItems
+          .map(({ key }) => key)
+          .filter((key) => this.column_names.includes(key)),
+      ]),
+    );
 
     const commonSubOpts = {
       table_info: this.tableOrViewInfo,

package/lib/DboBuilder/ViewHandler/validateSelectParams.ts

@@ -0,0 +1,51 @@
+import { getJSONBObjectSchemaValidationError, getKeys, type SelectParams } from "prostgles-types";
+
+export const validateSelectParams = (
+  selectParams: any,
+): selectParams is SelectParams | undefined => {
+  if (selectParams === undefined) {
+    return true;
+  }
+  const allowedReturnTypes = getKeys({
+    row: 1,
+    statement: 1,
+    value: 1,
+    values: 1,
+    "statement-no-rls": 1,
+    "statement-where": 1,
+  } satisfies Record<Required<SelectParams>["returnType"], 1>);
+
+  const selectParamsValidation = getJSONBObjectSchemaValidationError(
+    {
+      select: {
+        oneOf: [{ enum: ["*", ""] as const }, { record: { values: "any" } }, "string[]"],
+        optional: true,
+      },
+      orderBy: {
+        oneOf: [
+          { record: { values: "any" } },
+          { arrayOf: { record: { values: "any" } } },
+          "string[]",
+          "string",
+        ],
+        optional: true,
+      },
+      offset: { type: "integer", optional: true },
+      limit: { type: "integer", nullable: true, optional: true },
+      returnType: {
+        enum: allowedReturnTypes,
+        optional: true,
+      },
+      groupBy: { type: "boolean", optional: true },
+      having: { record: { values: "any" }, optional: true },
+      abortSignal: { type: "any", optional: true },
+    },
+    selectParams,
+    "selectParams",
+  );
+  if (selectParamsValidation.error !== undefined) {
+    throw `selectParams validation error: ${JSON.stringify(selectParamsValidation.error)}`;
+  }
+  selectParamsValidation.data satisfies SelectParams;
+  return true;
+};

package/lib/DboBuilder/getColumns.ts

@@ -6,6 +6,7 @@ import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./DboBuil
 import type { TableHandler } from "./TableHandler/TableHandler";
 import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getRawInfo } from "./ViewHandler/getRawInfo";
+import { isFileVersionTable } from "../StorageClient/fileVersionUtils";
 
 export const isTableHandler = (v: any): v is TableHandler => "parseUpdateRules" in v;
 
@@ -173,6 +174,7 @@ const getFileColumnInfo = (args: {
   if (!fileTableConfig) return undefined;
   const { colName, tableHandler } = args;
   const tableName = tableHandler.name;
+  if (isFileVersionTable(fileTableConfig, tableName)) return undefined;
   const tableConfig = fileTableConfig.referencedTables?.[tableName];
   const isReferencingFileTable = tableHandler.columns.some(
     (c) =>

package/lib/DboBuilder/getCondition.ts

@@ -44,6 +44,11 @@ export async function getCondition(
   const filter = { ...rawFilter };
 
   const existsConfigs = getExistsFilters(filter, this);
+  const dependencyColumns = existsConfigs.flatMap((existsConfig) =>
+    existsConfig.isJoined ?
+      (existsConfig.parsedPath[0]?.on.flatMap((columnPair) => Object.keys(columnPair)) ?? [])
+    : [],
+  );
 
   const functionConditions: string[] = [];
   const funcFilter = FILTER_FUNCS.filter((f) => f.name in filter);
@@ -59,6 +64,7 @@ export async function getCondition(
     if (disallowedCols.length) {
       throw `Invalid/disallowed columns found in function filter: ${disallowedCols}`;
     }
+    dependencyColumns.push(...fields);
     functionConditions.push(
       f.getQuery({
         args: funcArgs,
@@ -89,6 +95,7 @@ export async function getCondition(
     const compCol = computedFields.find((cf) => cf.name === key);
     if (compCol) {
       if (!p.select) throw new Error("Computed column filter requires p.select.fields");
+      dependencyColumns.push(...p.select.fields);
       computedColConditions.push(
         compCol.getQuery({
           tableAliasRaw: tableAlias?.raw,
@@ -157,14 +164,15 @@ export async function getCondition(
   const complexFilters: string[] = [];
   const complexFilterKey = "$filter";
   if (complexFilterKey in filter) {
-    const complexFilterCondition = parseComplexFilter({
+    const complexFilter = parseComplexFilter({
       filter,
       complexFilterKey,
       tableAliasRaw: tableAlias?.raw,
       allowed_colnames,
       columns: this.columns,
     });
-    complexFilters.push(complexFilterCondition);
+    complexFilters.push(complexFilter.condition);
+    dependencyColumns.push(...complexFilter.columnsUsed);
   }
 
   /* Parse join filters
@@ -238,7 +246,7 @@ export async function getCondition(
 
   /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
   return {
-    columnsUsed: q?.columnsUsed ?? [],
+    columnsUsed: Array.from(new Set([...(q?.columnsUsed ?? []), ...dependencyColumns])),
     exists: existsConfigs,
     condition: templates.sort().join(" AND \n"),
   };

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -1,5 +1,5 @@
 import type { AnyObject, ParsedJoinPath, SubscribeParams } from "prostgles-types";
-import { asName, isDefined, isEmpty, reverseParsedPath } from "prostgles-types";
+import { asName, isEmpty, reverseParsedPath } from "prostgles-types";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
 import type { ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
 import type { Filter, LocalParams } from "./DboBuilder";
@@ -36,6 +36,9 @@ export async function getSubscribeRelatedTables(
       relatedTables: [],
     };
 
+    const dependencyExists = newQuery.select
+      .filter((item) => item.selected)
+      .flatMap((item) => item.dependencyExists ?? []);
     const nonExistsFilter = newQuery.whereOpts.exists.length ? {} : filter;
     const pushRelatedTable = async (
       relatedTableName: string,
@@ -112,11 +115,15 @@ export async function getSubscribeRelatedTables(
       await pushRelatedTable(
         j.table.raw,
         j.joinPath,
-        j.select.map((s) => (s.selected ? s.columnName : undefined)).filter(isDefined),
+        j.select
+          .filter((item) => item.selected)
+          .flatMap((item) => [...item.fields, ...(item.dependencyFields ?? [])]),
         {},
       );
     }
-    for (const existsFilter of newQuery.whereOpts.exists.filter((e) => e.isJoined)) {
+    for (const existsFilter of [...newQuery.whereOpts.exists, ...dependencyExists].filter(
+      (existsFilter) => existsFilter.isJoined,
+    )) {
       for (const [index, pathItem] of existsFilter.parsedPath.entries()) {
         const isLast = index === existsFilter.parsedPath.length - 1;
         await pushRelatedTable(

package/lib/ProstglesTypes.ts

@@ -70,6 +70,17 @@ export type FileTableConfig = {
     checkIntervalHours?: number;
   };
 
+  /**
+   * Keeps immutable metadata records for every uploaded file revision.
+   * Existing file IDs and URLs continue to resolve to the latest version.
+   */
+  versioning?: {
+    /** Defaults to `${tableName}_versions`. */
+    tableName?: string;
+    /** Maximum versions kept per file. Undefined keeps every version. */
+    maxVersions?: number;
+  };
+
   /**
    * Specifying referencedTables with referenceColumns allows restricting the
    * allowed file types that can be inserted and referenced in the specified tables.

package/lib/PubSubManager/PubSubManager.ts

@@ -200,7 +200,7 @@ export class PubSubManager {
 
   subs: Subscription[] = [];
   syncs: SyncParams[] = [];
-  readonly socketChannelPreffix = CHANNELS._preffix;
+  readonly socketChannelPrefix = CHANNELS._preffix;
   postgresNotifListenManager?: PostgresNotifListenManager;
 
   private constructor(dboBuilder: DboBuilder) {

package/lib/PubSubManager/addSub.ts

@@ -45,7 +45,7 @@ export async function addSub(
     throw "addSub: cannot have socket AND func";
   }
 
-  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(selectParams)}.m.sub`;
+  const channel_name = `${this.socketChannelPrefix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(selectParams)}.m.sub`;
   const mainTrigger = {
     table_name: table_name,
     condition: parseCondition(condition),

package/lib/PublishParser/PublishParser.ts

@@ -17,6 +17,8 @@ import type {
   UnrestrictedFunctionContext,
 } from "./defineServerFunction";
 import { getFileTableRules } from "./getFileTableRules";
+import { getFileVersionTableRules } from "./getFileVersionTableRules";
+import { isFileVersionTable } from "../StorageClient/fileVersionUtils";
 import { getPublishedObjectFromResult } from "./getPublishedObjectFromResult";
 import { getSchemaFromPublish } from "./getSchemaFromPublish";
 import { getParsedPublishTable } from "./getParsedPublishTable";
@@ -313,13 +315,12 @@ export class PublishParser {
       (isAuditTable && clientReq ?
         await this.getPublishObjectForUser(clientReq, clientInfo)
       : undefined);
-    const publishRulesExcludingInferredTables =
-      await this.getParsedPublishTable({
-        clientReq,
-        tableName,
-        clientInfo,
-        resolvedPublishObject,
-      });
+    const publishRulesExcludingInferredTables = await this.getParsedPublishTable({
+      clientReq,
+      tableName,
+      clientInfo,
+      resolvedPublishObject,
+    });
     if (audit && isAuditTable) {
       const auditTableRules = await getAuditTableRules.bind(this)(
         audit,
@@ -336,6 +337,23 @@ export class PublishParser {
         scope,
       );
     }
+    const fileConfig = this.prostgles.opts.fileTable;
+    if (isFileVersionTable(fileConfig, tableName)) {
+      const versionRules = await getFileVersionTableRules.bind(this)(
+        fileConfig,
+        publishRulesExcludingInferredTables,
+        clientReq,
+        clientInfo,
+        scope,
+        overriddenPublish,
+      );
+      return applyScopeToTableRules(
+        tableName,
+        tableHandler,
+        parsePublishTableRule(versionRules),
+        scope,
+      );
+    }
     if (this.dbo[tableName]?.is_media) {
       const { rules: fileTableRules } = await getFileTableRules.bind(this)(
         tableName,

package/lib/PublishParser/getFileTableRules.ts

@@ -5,6 +5,7 @@ import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import type { PublishParser } from "./PublishParser";
 import type { ParsedPublishTable, PublishObject, UpdateRule } from "./publishTypesAndUtils";
 import type { LocalParams } from "../DboBuilder/DboBuilder";
+import { isFileVersionTable } from "../StorageClient/fileVersionUtils";
 
 /**
  * Permissions for referencedTables columns are propagated to the file table (even if file table has no permissions)
@@ -28,7 +29,12 @@ export async function getFileTableRules(
   const forcedUpdateFilters: FullFilter<AnyObject, void>[] = [];
   const allowedNestedInserts: { table: string; column: string }[] = [];
   const referencedColumns = this.prostgles.dboBuilder.tablesOrViews
-    ?.filter((t) => !t.is_view && t.name !== fileTableName)
+    ?.filter(
+      (t) =>
+        !t.is_view &&
+        t.name !== fileTableName &&
+        !isFileVersionTable(this.prostgles.opts.fileTable, t.name),
+    )
     .map((t) => {
       const refCols = t.columns.filter((c) =>
         c.references?.some((r) => r.ftable === fileTableName),