prostgles-server 4.2.624 → 4.2.626

package/lib/DboBuilder/TableHandler/update.ts

@@ -9,6 +9,7 @@ import { getReferenceColumnInserts } from "./insert/getReferenceColumnInserts";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 import { lockFileForUpdate } from "./updateFile";
 import type { TableHandler } from "./TableHandler";
+import { prepareWhere } from "../ViewHandler/prepareWhere";
 
 export async function update(
   this: TableHandler,
@@ -66,7 +67,7 @@ export async function update(
         );
     }
 
-    const updateFilter = await this.prepareWhere({
+    const updateFilter = await prepareWhere(this, {
       select: undefined,
       filter,
       forcedFilter,

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/ViewHandler.ts

@@ -13,26 +13,25 @@ import type { TableEvent } from "../../Logging";
 import type { DB } from "../../Prostgles";
 import type { Join } from "../../ProstglesTypes";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { Graph } from "../joins/shortestPath";
+import type { VoidFunction } from "../../SchemaWatch/SchemaWatch";
+import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
+import type { TableHooksDefinition } from "../../TableHooks/TableHooks";
+import { escapeTSNames } from "../../utils/utils";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
 import { getSerializedClientErrorFromPGError } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
 import { getValidatedTableRules } from "../TableRules/getValidatedTableRules";
 import { getColumns } from "../getColumns";
+import type { Graph } from "../joins/shortestPath";
 import { count } from "./count";
 import { find, type Param3 } from "./find";
+import { getDbHandlerWithAbort } from "./getDbHandlerWithAbort";
 import { getInfo } from "./getInfo";
 import { parseFieldFilter } from "./parseFieldFilter";
-import { prepareWhere } from "./prepareWhere";
 import { size } from "./size";
 import type { OnData } from "./subscribe";
 import { subscribe } from "./subscribe";
 import { validateViewRules } from "./validateViewRules";
-import { escapeTSNames } from "../../utils/utils";
-import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
-import { getDbHandlerWithAbort } from "./getDbHandlerWithAbort";
-import type { VoidFunction } from "../../SchemaWatch/SchemaWatch";
-import type { TableHooksDefinition } from "../../TableHooks/TableHooks";
 
 export type JoinPaths = {
   t1: string;
@@ -338,11 +337,6 @@ export class ViewHandler {
     return col_names;
   }
 
-  /**
-   * Parses group or simple filter
-   */
-  prepareWhere = prepareWhere.bind(this);
-
   intersectColumns(
     allowedFields: FieldFilter,
     disallowedFields: FieldFilter,

package/lib/DboBuilder/ViewHandler/find.ts

@@ -101,7 +101,6 @@ export const find = async function (
       this,
       filter,
       selectParamsLimitCheck,
-      undefined,
       tableRules,
       localParams,
     );

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -1,10 +1,11 @@
-import type { AnyObject, EXISTS_KEY, FieldFilter } from "prostgles-types";
-import { EXISTS_KEYS, asName } from "prostgles-types";
-import type { LocalParams, ExistsFilterConfig } from "../DboBuilder";
-import type { ViewHandler } from "./ViewHandler";
+import type { EXISTS_KEY } from "prostgles-types";
+import { EXISTS_KEYS } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { TableHandler } from "../TableHandler/TableHandler";
-import { getTableJoinQuery } from "./getTableJoinQuery";
+import type { ExistsFilterConfig, LocalParams } from "../DboBuilder";
+import { getQuerySourceSQL } from "../QueryBuilder/getQuerySource";
+import { getTableJoinAlias, getTableJoinQuery } from "./getTableJoinQuery";
+import type { ViewHandler } from "./ViewHandler";
+import { prepareWhere } from "./prepareWhere";
 
 export async function getExistsCondition(
   this: ViewHandler,
@@ -25,17 +26,22 @@ export async function getExistsCondition(
     };
   }
 
-  let t2Rules: ParsedTableRule | undefined = undefined,
-    forcedFilter: AnyObject | undefined,
-    filterFields: FieldFilter | undefined;
-
   /* Check if allowed to view data - forcedFilters will bypass this check through isForcedFilterBypass */
   if (localParams?.isRemoteRequest && !localParams.clientReq) {
     throw "Unexpected: localParams isRemoteRequest and missing clientReq";
   }
+
+  let targetTableRules: ParsedTableRule | undefined = undefined;
   const targetTable = eConfig.isJoined ? eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
-  if (localParams?.clientReq && this.dboBuilder.publishParser) {
-    t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
+  const tableHandler = this.dboBuilder.dboMap.get(targetTable);
+  if (!tableHandler) {
+    throw `Table handler for ${targetTable} not found`;
+  }
+  if (localParams?.clientReq) {
+    if (!this.dboBuilder.publishParser) {
+      throw "Unexpected: missing publishParser";
+    }
+    targetTableRules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
       {
         tableName: targetTable,
         command: "find",
@@ -44,27 +50,27 @@ export async function getExistsCondition(
       localParams.scope,
     );
 
-    if (!t2Rules.select) throw "Disallowed";
-    ({ forcedFilter, filterFields } = t2Rules.select);
+    if (!targetTableRules.select) throw "Disallowed";
   }
 
-  const tableHandler = this.dboBuilder.dbo[targetTable] as TableHandler;
-  const finalWhere = (
-    await tableHandler.prepareWhere({
-      select: undefined,
-      filter: targetTableFilter,
-      forcedFilter,
-      filterFields,
-      addWhere: false,
-      tableAlias: undefined,
-      localParams,
-      tableRule: t2Rules,
-    })
-  ).where;
+  const targetAlias =
+    eConfig.isJoined ? getTableJoinAlias(targetTable, eConfig.parsedPath.length - 1) : undefined;
+  const whereOpts = await prepareWhere(tableHandler, {
+    select: undefined,
+    selectParams: {},
+    filter: targetTableFilter,
+    forcedFilter: targetTableRules?.select?.forcedFilter,
+    filterFields: targetTableRules?.select?.filterFields,
+    tableRule: targetTableRules,
+    addWhere: false,
+    tableAlias: targetAlias,
+    localParams,
+  });
+  const { source: targetSource, where: finalWhere } = whereOpts;
 
   let innerQuery = [
     `SELECT 1`,
-    `FROM ${asName(targetTable)}`,
+    `FROM ${getQuerySourceSQL(targetSource)}`,
     `${finalWhere ? `WHERE ${finalWhere}` : ""}`,
   ].join("\n");
 
@@ -74,6 +80,7 @@ export async function getExistsCondition(
       rootTableAlias: rootTableAlias ?? rootTable,
       type: "EXISTS",
       finalWhere,
+      finalTableExpression: targetSource.expression,
     });
     innerQuery = query;
   }

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/getTableJoinQuery.ts

@@ -1,10 +1,12 @@
 import { asName } from "prostgles-types";
+import type { PGIdentifier } from "../DboBuilder";
 import type { ParsedJoinPath } from "./parseJoinPath";
 
 type getTableJoinsArgs = {
   rootTableAlias: string;
   type: "INNER" | "LEFT" | "EXISTS";
   finalWhere?: string;
+  finalTableExpression?: string;
   path: ParsedJoinPath[];
 };
 export const getTableJoinQuery = ({
@@ -12,14 +14,14 @@ export const getTableJoinQuery = ({
   type,
   rootTableAlias,
   finalWhere,
+  finalTableExpression,
 }: getTableJoinsArgs): { targetAlias: string; query: string } => {
   const [firstPath] = path;
   if (!firstPath) {
     throw `Cannot create join query for empty path`;
   }
-  const aliasSufix = "jd";
   const getTableAlias = (table: string, pathIndex: number) =>
-    asName(`${aliasSufix}_${pathIndex}_${table}`);
+    getTableJoinAlias(table, pathIndex).escaped;
 
   const query = path
     .map(({ table, on }, i) => {
@@ -45,19 +47,19 @@ export const getTableJoinQuery = ({
        */
       const whereJoinCondition =
         isLast && isExists ?
-          `WHERE (${getJoinOnCondition({
-            on: firstPath.on,
-            leftAlias: rootTableAlias,
-            rightAlias: getTableAlias(firstPath.table, 0),
-          })})`
+          `WHERE (${[
+            getJoinOnCondition({
+              on: firstPath.on,
+              leftAlias: rootTableAlias,
+              rightAlias: getTableAlias(firstPath.table, 0),
+            }),
+            finalWhere,
+          ]
+            .filter(Boolean)
+            .join(") AND (")})`
         : "";
 
-      const tableSelect =
-        isExists && isLast ?
-          [`(`, ` SELECT *`, ` FROM ${tableName}`, finalWhere ? `  WHERE ${finalWhere}` : "", `)`]
-            .filter((v) => v)
-            .join("\n")
-        : tableName;
+      const tableSelect = isLast ? (finalTableExpression ?? tableName) : tableName;
       if (isExists && isFirst) {
         return [`SELECT 1`, `FROM ${tableSelect} ${tableAlias}`, whereJoinCondition]
           .filter((v) => v)
@@ -76,6 +78,12 @@ export const getTableJoinQuery = ({
   };
 };
 
+export const getTableJoinAlias = (table: string, pathIndex: number): PGIdentifier => {
+  const prefix = "jd";
+  const raw = `${prefix}_${pathIndex}_${table}`;
+  return { raw, escaped: asName(raw) };
+};
+
 type GetJoinOnConditionArgs = {
   on: Record<string, string>[];
   leftAlias: string;
@@ -95,7 +103,7 @@ export const getJoinOnConditions = ({
       .map(([leftCol, rightCol]) => {
         return `${leftAlias}.${getLeftColName(leftCol)} = ${rightAlias}.${getRightColName(rightCol)}`;
       })
-      .join(" AND ")
+      .join(" AND "),
   );
 };
 

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,9 +1,10 @@
-import type { AnyObject, FieldFilter } from "prostgles-types/dist";
+import type { AnyObject, FieldFilter, SelectParams } from "prostgles-types/dist";
 import { getKeys, isDefined, isObject } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { ExistsFilterConfig, Filter, LocalParams, PGIdentifier } from "../DboBuilder";
 import { getCondition } from "../getCondition";
 import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
+import { getQuerySource, type QuerySource } from "../QueryBuilder/getQuerySource";
 import type { ViewHandler } from "./ViewHandler";
 
 export type PrepareWhereParams = {
@@ -16,46 +17,61 @@ export type PrepareWhereParams = {
   localParams: LocalParams | undefined;
   tableRule: ParsedTableRule | undefined;
   isHaving?: boolean;
+  selectParams?: SelectParams;
 };
 
-export async function prepareWhere(
-  this: ViewHandler,
-  params: PrepareWhereParams,
-): Promise<{
+export type WhereOptions = {
   columnsUsed: string[];
   condition: string;
   where: string;
   filter: AnyObject;
   exists: ExistsFilterConfig[];
-}> {
-  const {
+  source: QuerySource;
+};
+
+export const prepareWhere = async (
+  viewHandler: ViewHandler,
+  {
     filter,
     select,
     forcedFilter,
-    filterFields: ff,
     addWhere: addKeywords = true,
     tableAlias,
     localParams,
     tableRule,
-  } = params;
-  const { $and: $and_key, $or: $or_key } = this.dboBuilder.prostgles.keywords;
+    /* Local update allow all. TODO: tidy all calls */
+    filterFields = !tableRule ? "*" : undefined,
+    isHaving,
+    selectParams,
+  }: PrepareWhereParams,
+): Promise<WhereOptions> => {
+  const { $and: $and_key, $or: $or_key } = viewHandler.dboBuilder.prostgles.keywords;
+
+  if (localParams?.isRemoteRequest && !tableRule) {
+    throw "Unexpected: localParams isRemoteRequest and missing tableRule";
+  }
 
-  let filterFields = ff;
-  /* Local update allow all. TODO -> FIX THIS */
-  if (!ff && !tableRule) filterFields = "*";
+  const source = await getQuerySource(
+    viewHandler,
+    selectParams ? tableRule : undefined,
+    filter ?? {},
+    selectParams ?? {},
+    tableAlias,
+  );
 
   const exists: ExistsFilterConfig[] = [];
 
   type FilterItemResult = { condition: string; columnsUsed: string[] };
   const parseFullFilter = async (
-    f: any,
+    fullFilter: any,
     parentFilter: AnyObject | null = null,
     isForcedFilterBypass: boolean,
   ): Promise<FilterItemResult | undefined> => {
-    if (!f) throw "Invalid/missing group filter provided";
-    if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
+    if (!fullFilter) throw "Invalid/missing group filter provided";
+    if (!isObject(fullFilter))
+      throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(fullFilter);
 
-    const keys = getKeys(f);
+    const keys = getKeys(fullFilter);
     if (!keys.length) {
       return;
     }
@@ -66,8 +82,8 @@ export async function prepareWhere(
         throw "group filter ($and/$or) can only be placed at the root or within another group filter";
     }
 
-    const { [$and_key]: $and, [$or_key]: $or } = f,
-      group: AnyObject[] | undefined = $and || $or;
+    const { [$and_key]: $and, [$or_key]: $or } = fullFilter;
+    const group = ($and || $or) as AnyObject[] | undefined;
 
     if (group && group.length) {
       const operand = $and ? " AND " : " OR ";
@@ -82,20 +98,24 @@ export async function prepareWhere(
       if (conditionItems.length) {
         const conditions = conditionItems.map((c) => c.condition);
         const columnsUsed = conditionItems.map((c) => c.columnsUsed).flat();
-        if (conditions.length === 1) return { columnsUsed, condition: conditions.join(operand) };
-        else return { columnsUsed, condition: ` ( ${conditions.sort().join(operand)} ) ` };
+        if (conditions.length === 1) {
+          return { columnsUsed, condition: conditions.join(operand) };
+        }
+        return { columnsUsed, condition: ` ( ${conditions.sort().join(operand)} ) ` };
       }
     } else if (!group) {
       /** forcedFilters do not get checked against publish and are treated as server-side requests */
-      const itemInfo = await getCondition.bind(this)({
-        filter: { ...f },
+      const itemInfo = await getCondition.bind(viewHandler)({
+        filter: { ...fullFilter },
         select,
         allowed_colnames:
-          isForcedFilterBypass ? this.column_names.slice(0) : this.parseFieldFilter(filterFields),
-        tableAlias,
+          isForcedFilterBypass ?
+            viewHandler.column_names.slice(0)
+          : viewHandler.parseFieldFilter(filterFields),
+        tableAlias: source.alias,
         localParams: isForcedFilterBypass ? undefined : localParams,
         tableRules: isForcedFilterBypass ? undefined : tableRule,
-        isHaving: params.isHaving,
+        isHaving,
       });
       exists.push(...itemInfo.exists);
       return {
@@ -135,5 +155,6 @@ export async function prepareWhere(
     where: combinedConditions || "",
     filter: finalFilter,
     exists,
+    source,
   };
-}
+};

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

@@ -1,4 +1,4 @@
-import { pickKeys } from "prostgles-types";
+import { pickKeys, type AnyObject } from "prostgles-types";
 import { parseFilterItem } from "../Filtering/Filtering";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
 import type { ExistsFilterConfig, LocalParams, PGIdentifier } from "./DboBuilder";
@@ -9,6 +9,7 @@ import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getExistsCondition } from "./ViewHandler/getExistsCondition";
 import { getExistsFilters } from "./ViewHandler/getExistsFilters";
 import { parseComplexFilter } from "./ViewHandler/parseComplexFilter";
+import { isArray } from "../utils/utils";
 
 const FILTER_FUNCS = FUNCTIONS.filter((f) => f.canBeUsedForFilter);
 
@@ -21,7 +22,7 @@ const FILTER_FUNCS = FUNCTIONS.filter((f) => f.canBeUsedForFilter);
 export async function getCondition(
   this: ViewHandler,
   params: {
-    filter: any;
+    filter: AnyObject;
     select: SelectItemValidated[] | undefined;
     allowed_colnames: string[];
     tableAlias?: PGIdentifier;
@@ -44,21 +45,21 @@ export async function getCondition(
 
   const existsConfigs = getExistsFilters(filter, this);
 
-  const funcConds: string[] = [];
+  const functionConditions: string[] = [];
   const funcFilter = FILTER_FUNCS.filter((f) => f.name in filter);
 
   funcFilter.map((f) => {
     const funcArgs = filter[f.name];
-    if (!Array.isArray(funcArgs)) {
+    if (!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 dissallowedCols = fields.filter((fname) => !allowed_colnames.includes(fname));
-    if (dissallowedCols.length) {
-      throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`;
+    const disallowedCols = fields.filter((fname) => !allowed_colnames.includes(fname));
+    if (disallowedCols.length) {
+      throw `Invalid/disallowed columns found in function filter: ${disallowedCols}`;
     }
-    funcConds.push(
+    functionConditions.push(
       f.getQuery({
         args: funcArgs,
         allColumns: this.columns,
@@ -84,7 +85,7 @@ export async function getCondition(
   const p = this.getValidatedRules(tableRules, localParams);
   const computedFields = p.allColumns.filter((c) => c.type === "computed");
   const computedColConditions: string[] = [];
-  Object.keys(filter || {}).map((key) => {
+  Object.keys(filter).map((key) => {
     const compCol = computedFields.find((cf) => cf.name === key);
     if (compCol) {
       if (!p.select) throw new Error("Computed column filter requires p.select.fields");
@@ -231,7 +232,7 @@ export async function getCondition(
   let templates: string[] = q?.condition ? [q.condition] : [];
 
   if (existsCond) templates.push(existsCond);
-  templates = templates.concat(funcConds);
+  templates = templates.concat(functionConditions);
   templates = templates.concat(computedColConditions);
   templates = templates.concat(complexFilters);
 

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -8,6 +8,7 @@ import type { TableHandler } from "./TableHandler/TableHandler";
 import type { ViewHandler } from "./ViewHandler/ViewHandler";
 import { getViewRelatedTables } from "./ViewRelatedTables/getViewRelatedTables";
 import type { AddTriggerParams } from "../PubSubManager/addTrigger";
+import { prepareWhere } from "./ViewHandler/prepareWhere";
 
 type Args = {
   selectParams: Omit<SubscribeParams, "throttle">;
@@ -66,9 +67,9 @@ export async function getSubscribeRelatedTables(
         isEmpty(targetTableFilter) ? reversedJoinFilter : (
           { $and: [targetTableFilter, reversedJoinFilter] }
         );
-      const joinConditionInfo = await relatedTableOrViewHandler.prepareWhere({
-        select: undefined,
+      const joinConditionInfo = await prepareWhere(relatedTableOrViewHandler, {
         filter,
+        select: undefined,
         addWhere: false,
         localParams: undefined,
         tableRule: undefined,

package/lib/DboBuilder/parseUpdateRules.ts

@@ -9,6 +9,7 @@ import { type ParsedTableRule } from "../PublishParser/PublishParser";
 import type { Filter, LocalParams } from "./DboBuilder";
 import { prepareNewData } from "./TableHandler/DataValidator";
 import type { TableHandler } from "./TableHandler/TableHandler";
+import { prepareWhere } from "./ViewHandler/prepareWhere";
 
 /**
  * 1) Check if publish is valid
@@ -57,7 +58,7 @@ export async function parseUpdateRules(
       throw ` Invalid update rule fo r ${this.name}. fields missing `;
     }
     finalUpdateFilter = (
-      await this.prepareWhere({
+      await prepareWhere(this, {
         select: undefined,
         filter,
         forcedFilter,
@@ -77,7 +78,7 @@ export async function parseUpdateRules(
           /**
            * Validated filter and fields
            */
-          const condition = await this.prepareWhere({
+          const condition = await prepareWhere(this, {
             select: undefined,
             filterFields: this.column_names,
             filter: dfRule.filter,

package/lib/Prostgles.ts

@@ -320,6 +320,7 @@ export class Prostgles {
       this.dboBuilder = await DboBuilder.create(this);
     }
     this.dbo = this.dboBuilder.dbo;
+    if (this.publishParser) this.initPublishParser();
     await this.opts.onLog?.({
       type: "debug",
       command: "refreshDBO.end",

package/lib/ProstglesContext.spec.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import type { DboBuilder } from "./DboBuilder/DboBuilder";
 import { Prostgles } from "./Prostgles";
+import type { PublishParser } from "./PublishParser/PublishParser";
 
 void describe("Prostgles context", async () => {
   await test("recreates context and runs cleanups in reverse order", async () => {
@@ -47,6 +48,35 @@ void describe("Prostgles context", async () => {
     assert.equal(prostgles.context, undefined);
   });
 
+  await test("recreates the publish parser with the rebuilt DBO", async () => {
+    const prostgles = new Prostgles({
+      dbConnection: "postgres://unused",
+      onReady: () => {},
+    });
+    prostgles.db = {} as typeof prostgles.db;
+    const rebuiltDbo = {};
+    const dboBuilder = {
+      build: () => {
+        dboBuilder.dbo = rebuiltDbo;
+        return Promise.resolve();
+      },
+      dbo: {},
+      sql: {},
+      tables: [],
+    };
+    prostgles.dboBuilder = dboBuilder as unknown as DboBuilder;
+
+    // PublishParser captures the DBO on construction, so it must be recreated after a rebuild.
+    const initialPublishParser = {} as PublishParser;
+    prostgles.publishParser = initialPublishParser;
+
+    await prostgles.rebuildDBO();
+
+    assert.equal(prostgles.dbo, rebuiltDbo);
+    assert.notEqual(prostgles.publishParser, initialPublishParser);
+    assert.equal(prostgles.publishParser.dbo, prostgles.dbo);
+  });
+
   await test("cleans partially-created context after an error", async () => {
     const events: string[] = [];
     const prostgles = new Prostgles({

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.