prostgles-server 4.2.625 → 4.2.627

package/lib/PublishParser/getFileVersionTableRules.spec.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { FileTableConfig } from "../ProstglesTypes";
+import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
+import type { PublishParser } from "./PublishParser";
+import { getFileVersionTableRules } from "./getFileVersionTableRules";
+
+void test("file version rules inherit fields and restrictive select options", async () => {
+  const fileColumns = ["id", "updated", "metadata"];
+  const versionColumns = ["id", "file_id", "created", "metadata"];
+  const getHandler = (columns: string[]) => ({
+    column_names: columns,
+    parseFieldFilter: (fields: any = "*") => parseFieldFilter(fields, true, columns),
+  });
+  const parser = {
+    dbo: {
+      files: getHandler(fileColumns),
+      files_versions: getHandler(versionColumns),
+    },
+    getTableRules: () => Promise.resolve({
+      select: {
+        fields: "*",
+        maxLimit: 5,
+        subscribeThrottle: 20,
+        disableMethods: { subscribe: 1 },
+      },
+    }),
+  } as unknown as PublishParser;
+
+  const rules = await getFileVersionTableRules.call(
+    parser,
+    { tableName: "files", versioning: {} } as FileTableConfig,
+    {
+      select: {
+        fields: "*",
+        maxLimit: 10,
+        subscribeThrottle: 10,
+        disableMethods: { sync: 1 },
+      },
+    },
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+  );
+
+  assert(rules?.select);
+  assert.deepEqual(rules.select.fields, {
+    id: 1,
+    file_id: 1,
+    created: 1,
+    metadata: 1,
+  });
+  assert.equal(rules.select.maxLimit, 5);
+  assert.equal(rules.select.subscribeThrottle, 20);
+  assert.deepEqual(rules.select.disableMethods, { subscribe: 1, sync: 1 });
+});

package/lib/PublishParser/getFileVersionTableRules.ts

@@ -0,0 +1,106 @@
+import { fromEntries } from "prostgles-types";
+import type { AuthClientRequest, AuthResultWithSID } from "../Auth/AuthTypes";
+import type { LocalParams } from "../DboBuilder/DboBuilder";
+import type { FileTableConfig } from "../ProstglesTypes";
+import type { PublishParser } from "./PublishParser";
+import type { ParsedPublishTable, PublishObject } from "./publishTypesAndUtils";
+import { getFileVersionTableName } from "../StorageClient/fileVersionUtils";
+import type { FileTableRow, FileVersionTableRow } from "../StorageClient/fileTableDefinitions";
+
+export const getFileVersionTableRules = async function (
+  this: PublishParser,
+  config: FileTableConfig,
+  explicitRules: ParsedPublishTable | undefined,
+  clientReq: AuthClientRequest | undefined,
+  clientInfo: AuthResultWithSID | undefined,
+  scope: LocalParams["scope"] | undefined,
+  resolvedPublishObject: PublishObject | undefined,
+): Promise<ParsedPublishTable | undefined> {
+  const versionTableName = getFileVersionTableName(config);
+  if (
+    resolvedPublishObject &&
+    Object.hasOwn(resolvedPublishObject, versionTableName) &&
+    !explicitRules?.select
+  ) {
+    return;
+  }
+
+  const fileRules = await this.getTableRules({
+    tableName: config.tableName,
+    clientReq,
+    clientInfo,
+    scope,
+    resolvedPublishObject,
+  });
+  if (!fileRules?.select) return;
+
+  const versionHandler = this.dbo[versionTableName];
+  if (!versionHandler) throw new Error(`File version table not found: ${versionTableName}`);
+  const fileHandler = this.dbo[config.tableName];
+  if (!fileHandler) throw new Error(`File table not found: ${config.tableName}`);
+  const select = explicitRules?.select;
+  const requestedFields = versionHandler.parseFieldFilter(select?.fields ?? "*");
+  const fileSelectFields = fileHandler.parseFieldFilter(fileRules.select.fields);
+  const fields = (versionHandler.column_names as (keyof FileVersionTableRow)[]).filter(
+    (field) =>
+      requestedFields.includes(field) &&
+      fileSelectFields.includes(getFileVersionSourceField(field)) &&
+      (fileHandler.column_names as (keyof FileTableRow)[]).includes(
+        getFileVersionSourceField(field),
+      ),
+  );
+  const requestedFilterFields = versionHandler.parseFieldFilter(select?.filterFields ?? fields);
+  const requestedOrderByFields = versionHandler.parseFieldFilter(select?.orderByFields ?? fields);
+  const inheritedFilter = {
+    $existsJoined: {
+      path: [{ table: config.tableName, on: [{ file_id: "id" }] }],
+      filter: fileRules.select.forcedFilter ?? {},
+    },
+  };
+
+  return {
+    select: {
+      ...fileRules.select,
+      ...select,
+      fields: fromEntries(fields.map((field) => [field, 1 as const] as const)),
+      filterFields: fromEntries(
+        fields
+          .filter((field) => requestedFilterFields.includes(field))
+          .map((field) => [field, 1 as const] as const),
+      ),
+      orderByFields: fromEntries(
+        fields
+          .filter((field) => requestedOrderByFields.includes(field))
+          .map((field) => [field, 1 as const] as const),
+      ),
+      forcedFilter:
+        select?.forcedFilter ? { $and: [inheritedFilter, select.forcedFilter] } : inheritedFilter,
+      maxLimit: getMostRestrictiveLimit(fileRules.select.maxLimit, select?.maxLimit),
+      subscribeThrottle: Math.max(
+        fileRules.select.subscribeThrottle ?? 0,
+        select?.subscribeThrottle ?? 0,
+      ),
+      disableMethods: {
+        ...fileRules.select.disableMethods,
+        ...select?.disableMethods,
+      },
+    },
+  };
+};
+
+const getFileVersionSourceField = (field: keyof FileVersionTableRow): keyof FileTableRow => {
+  if (field === "file_id") return "id";
+  if (field === "created") return "updated";
+  return field;
+};
+
+const getMostRestrictiveLimit = (
+  inheritedLimit: number | null | undefined,
+  explicitLimit: number | null | undefined,
+) => {
+  const limits = [inheritedLimit, explicitLimit].filter(
+    (limit): limit is number => typeof limit === "number",
+  );
+  if (limits.length) return Math.min(...limits);
+  return inheritedLimit === null || explicitLimit === null ? null : undefined;
+};

package/lib/PublishParser/getPublishedTableNames.ts

@@ -1,6 +1,7 @@
 import { isObject } from "prostgles-types";
 import type { PublishParser } from "./PublishParser";
 import { type PublishObject } from "./PublishParser";
+import { getFileVersionTableName, isFileVersionTable } from "../StorageClient/fileVersionUtils";
 
 export const getPublishedTableNames = (
   publishParserInstance: PublishParser,
@@ -24,19 +25,27 @@ export const getPublishedTableNames = (
     publishParserInstance.dbo[fileTableName]?.is_media &&
     !tableNames.includes(fileTableName)
   ) {
-    const isReferenced = publishParserInstance.prostgles.dboBuilder.tablesOrViews?.some((t) =>
-      t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
+    const isReferenced = publishParserInstance.prostgles.dboBuilder.tablesOrViews?.some(
+      (t) =>
+        !isFileVersionTable(publishParserInstance.prostgles.opts.fileTable, t.name) &&
+        t.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
     );
     if (isReferenced) {
       tableNames.unshift(fileTableName);
     }
   }
 
+  const fileConfig = publishParserInstance.prostgles.opts.fileTable;
+  if (fileConfig?.versioning && tableNames.includes(fileConfig.tableName)) {
+    const versionTableName = getFileVersionTableName(fileConfig);
+    if (!tableNames.includes(versionTableName)) {
+      tableNames.unshift(versionTableName);
+    }
+  }
+
   const audit = publishParserInstance.prostgles.resolvedAuditConfig;
   const publishedFileTableName =
-    fileTableName && tableNames.includes(fileTableName) ?
-      fileTableName
-    : undefined;
+    fileTableName && tableNames.includes(fileTableName) ? fileTableName : undefined;
   if (
     audit &&
     !tableNames.includes(audit.tableName) &&

package/lib/StorageClient/deleteUnreferencedFile.ts

@@ -1,5 +1,6 @@
 import type { DB } from "../Prostgles";
 import type { FileTableConfig } from "../ProstglesTypes";
+import { getFileVersionTableName } from "./fileVersionUtils";
 
 export const deleteUnreferencedFile = async (
   db: DB,
@@ -11,8 +12,25 @@ export const deleteUnreferencedFile = async (
   const referenced = await db.tx(async (tx) => {
     await tx.none("SET LOCAL row_security = off");
     return tx.oneOrNone<{ found: number }>(
-      "SELECT 1 FROM ${table:name} WHERE storage_key = ${key}::uuid OR (storage_key IS NULL AND id = ${key}::uuid) LIMIT 1",
-      { table: config.tableName, key: storageKey },
+      `SELECT 1 AS found
+       WHERE EXISTS (
+         SELECT 1 FROM \${fileTable:name}
+         WHERE storage_key = \${key}::uuid OR (storage_key IS NULL AND id = \${key}::uuid)
+       )
+       ${
+         config.versioning ?
+           `OR EXISTS (
+             SELECT 1 FROM \${versionTable:name}
+             WHERE storage_key = \${key}::uuid
+           )`
+         : ""
+       }
+       LIMIT 1`,
+      {
+        fileTable: config.tableName,
+        versionTable: getFileVersionTableName(config),
+        key: storageKey,
+      },
     );
   });
   if (!referenced) await config.storageClient.delete(storageKey);

package/lib/StorageClient/fileTableDefinitions.ts

@@ -0,0 +1,52 @@
+import { omitKeys } from "prostgles-types";
+import type { TableRowFromColumnDefinitions } from "../TableConfig/TableRowFromColumnDefinitions";
+
+export const FILE_TABLE_COLUMN_DEFINITIONS = {
+  id: `UUID PRIMARY KEY DEFAULT gen_random_uuid()`,
+  /**
+   * NULL for legacy objects stored under their file ID.
+   * */
+  storage_key: `UUID UNIQUE`,
+  extension: `TEXT NOT NULL DEFAULT ''`,
+  content_type: `TEXT NOT NULL DEFAULT ''`,
+  content_length: `BIGINT NOT NULL DEFAULT 0`,
+  etag: `TEXT NOT NULL DEFAULT ''`,
+  original_name: `TEXT NOT NULL`,
+  original_last_modified: `TIMESTAMPTZ`,
+  description: `TEXT`,
+  url: `TEXT NOT NULL DEFAULT ''`,
+  cloud_url: `TEXT`,
+  signed_url: `TEXT`,
+  signed_url_expires: `BIGINT`,
+  added: `TIMESTAMP NOT NULL DEFAULT NOW()`,
+  updated: `TIMESTAMP NOT NULL DEFAULT NOW()`,
+  deleted: `TIMESTAMPTZ`,
+  deleted_from_storage: `TIMESTAMPTZ`,
+  data: `BYTEA NOT NULL CHECK (data = decode('01', 'hex'))`, // Used as a placeholder to ensure insert types are correct. Actual data is uploaded to storageClient and not stored in the DB
+} as const;
+
+export const FILE_TABLE_VERSION_COLUMN_DEFINITIONS = {
+  version: `INTEGER NOT NULL DEFAULT 1`,
+} as const;
+
+export const FILE_VERSION_TABLE_COLUMN_DEFINITIONS = {
+  ...omitKeys(FILE_TABLE_COLUMN_DEFINITIONS, ["data"]),
+  storage_key: `UUID NOT NULL`,
+  file_id: `UUID NOT NULL`, // FK constraint is added later on
+  version: `INTEGER NOT NULL`,
+  created: `TIMESTAMP NOT NULL DEFAULT NOW()`,
+} as const;
+
+export type FileTableInsertRow = TableRowFromColumnDefinitions<
+  typeof FILE_TABLE_COLUMN_DEFINITIONS
+> &
+  Partial<TableRowFromColumnDefinitions<typeof FILE_TABLE_VERSION_COLUMN_DEFINITIONS>>;
+export type FileTableRow = Required<
+  TableRowFromColumnDefinitions<typeof FILE_TABLE_COLUMN_DEFINITIONS>
+> &
+  Partial<Required<TableRowFromColumnDefinitions<typeof FILE_TABLE_VERSION_COLUMN_DEFINITIONS>>>;
+
+export type FileVersionTableInsertRow = TableRowFromColumnDefinitions<
+  typeof FILE_VERSION_TABLE_COLUMN_DEFINITIONS
+>;
+export type FileVersionTableRow = Required<FileVersionTableInsertRow>;

package/lib/StorageClient/fileVersionUtils.ts

@@ -0,0 +1,37 @@
+import type { TableHandler } from "prostgles-types";
+import type { TableHandlers } from "../DboBuilder/DboBuilder";
+import type { FileTableConfig } from "../ProstglesTypes";
+import type {
+  FileTableRow,
+  FileVersionTableInsertRow,
+  FileVersionTableRow,
+} from "./fileTableDefinitions";
+
+type FileVersionTableSchema = {
+  fileVersions: {
+    columns: FileVersionTableRow;
+    insertColumns: FileVersionTableInsertRow;
+  };
+};
+
+export const getFileVersionTableName = (config: FileTableConfig) =>
+  config.versioning?.tableName ?? `${config.tableName}_versions`;
+
+export const isFileVersionTable = (
+  config: FileTableConfig | undefined,
+  tableName: string,
+): config is FileTableConfig & { versioning: NonNullable<FileTableConfig["versioning"]> } =>
+  Boolean(config?.versioning && getFileVersionTableName(config) === tableName);
+
+export const getFileTableHandler = (dbo: TableHandlers, config: FileTableConfig) => {
+  const handler = dbo[config.tableName] as TableHandler<FileTableRow> | undefined;
+  if (!handler) throw new Error(`File table not found: ${config.tableName}`);
+  return handler;
+};
+
+export const getFileRevisionsTableHandler = (dbo: TableHandlers, config: FileTableConfig) => {
+  const handler = dbo[getFileVersionTableName(config)] as
+    TableHandler<FileVersionTableRow, FileVersionTableSchema, "fileVersions"> | undefined;
+  if (!handler) throw new Error(`File table not found: ${config.tableName}`);
+  return handler;
+};

package/lib/StorageClient/getFileStorageKey.ts

@@ -1,5 +1,14 @@
 import type { FileTableRow } from "./getFileTableConfig";
 
 /** Legacy files are stored under their logical ID. */
-export const getFileStorageKey = (file: Pick<FileTableRow, "id" | "storage_key">) =>
-  file.storage_key ?? file.id;
+export const getFileStorageKey = (
+  file: Pick<FileTableRow, "id" | "storage_key"> | { storage_key: string },
+) => {
+  const { storage_key } = file;
+  const id = "id" in file ? file.id : undefined;
+  const key = storage_key ?? id;
+  if (!key) {
+    throw new Error("Unable to determine file storage key");
+  }
+  return key;
+};

package/lib/StorageClient/getFileTableConfig.spec.ts

@@ -5,7 +5,10 @@ import { getFileTableConfig } from "./getFileTableConfig";
 
 void test("managed files preserve hooks on other tables and append file hooks", () => {
   const guard = { afterEach: [{ commands: { insert: 1 }, validate: async () => {} }] };
-  const fileGuard = { beforeEach: [{ commands: { insert: 1 }, validate: async () => {} }] };
+  const fileGuard = {
+    beforeEach: [{ commands: { insert: 1 }, validate: async () => {} }],
+    afterEach: [{ commands: { insert: 1 }, validate: async () => {} }],
+  };
   const prostgles = {
     opts: {
       fileTable: { tableName: "files", storageClient: {}, expressApp: {} },
@@ -16,4 +19,6 @@ void test("managed files preserve hooks on other tables and append file hooks",
   assert.equal(result.tableHooks?.documents, guard);
   assert.equal(result.tableHooks.files?.beforeEach?.length, 2);
   assert.equal(result.tableHooks.files.beforeEach[1], fileGuard.beforeEach[0]);
+  assert.equal(result.tableHooks.files.afterEach?.length, 2);
+  assert.equal(result.tableHooks.files.afterEach[0], fileGuard.afterEach[0]);
 });

package/lib/StorageClient/getFileTableConfig.ts

@@ -1,37 +1,27 @@
-import { omitKeys } from "prostgles-types";
+import { asName, omitKeys } from "prostgles-types";
+import { md5 } from "prostgles-types/dist/md5";
 import { onDeleteFromFileTable } from "../DboBuilder/TableHandler/onDeleteFromFileTable";
 import { updateFile } from "../DboBuilder/TableHandler/updateFile";
 import { assertFileObjectValid, uploadFile } from "../DboBuilder/TableHandler/uploadFile";
 import type { Prostgles } from "../Prostgles";
-import type { BeforeEachTsTrigger } from "../PublishParser/publishTypesAndUtils";
+import type {
+  AfterEachTsTrigger,
+  BeforeEachTsTrigger,
+} from "../PublishParser/publishTypesAndUtils";
 import type { TableConfig } from "../TableConfig/TableConfigTypes";
-import type { TableRowFromColumnDefinitions } from "../TableConfig/TableRowFromColumnDefinitions";
 import type { TableHooks } from "../TableHooks/TableHooks";
 import { setupFileServeHandler } from "./setupFileServeHandler";
 import type { TableHandlers } from "../DboBuilder/DboBuilder";
+import { getFileTableHandler, getFileVersionTableName } from "./fileVersionUtils";
+import { backfillFileVersions, saveFileVersion } from "./saveFileVersion";
+import {
+  FILE_TABLE_COLUMN_DEFINITIONS,
+  FILE_TABLE_VERSION_COLUMN_DEFINITIONS,
+  FILE_VERSION_TABLE_COLUMN_DEFINITIONS,
+  type FileTableRow,
+} from "./fileTableDefinitions";
 
-const FILE_TABLE_COLUMN_DEFINITIONS = {
-  id: `UUID PRIMARY KEY DEFAULT gen_random_uuid()`,
-  storage_key: `UUID UNIQUE`, // NULL for legacy objects stored under their file ID.
-  extension: `TEXT NOT NULL DEFAULT ''`,
-  content_type: `TEXT NOT NULL DEFAULT ''`,
-  content_length: `BIGINT NOT NULL DEFAULT 0`,
-  etag: `TEXT NOT NULL DEFAULT ''`,
-  original_name: `TEXT NOT NULL`,
-  original_last_modified: `TIMESTAMPTZ`,
-  description: `TEXT`,
-  url: `TEXT NOT NULL DEFAULT ''`,
-  cloud_url: `TEXT`,
-  signed_url: `TEXT`,
-  signed_url_expires: `BIGINT`,
-  added: `TIMESTAMP NOT NULL DEFAULT NOW()`,
-  updated: `TIMESTAMP NOT NULL DEFAULT NOW()`,
-  deleted: `TIMESTAMPTZ`,
-  deleted_from_storage: `TIMESTAMPTZ`,
-  data: `BYTEA NOT NULL CHECK (data = decode('01', 'hex'))`, // Used as a placeholder to ensure insert types are correct. Actual data is uploaded to storageClient and not stored in the DB
-} as const;
-
-export type FileTableRow = TableRowFromColumnDefinitions<typeof FILE_TABLE_COLUMN_DEFINITIONS>;
+export type { FileTableInsertRow, FileTableRow } from "./fileTableDefinitions";
 
 export const getFileTableConfig = (
   prg: Prostgles,
@@ -44,7 +34,30 @@ export const getFileTableConfig = (
   const { expressApp } = fileTable;
 
   const { tableName: fileTableName, storageClient } = fileTable;
+  const versionTableName = getFileVersionTableName(fileTable);
+  const versionConstraintName = `prostgles_file_version_${md5(JSON.stringify([versionTableName, fileTableName]))}`;
+  const versionIndexName = `prostgles_file_version_${md5(versionTableName)}_key`;
+  if (fileTable.versioning) {
+    if (versionTableName === fileTableName) {
+      throw new Error("File version table name must differ from the file table name");
+    }
+    if (
+      fileTable.versioning.maxVersions !== undefined &&
+      (!Number.isInteger(fileTable.versioning.maxVersions) || fileTable.versioning.maxVersions < 1)
+    ) {
+      throw new Error("fileTable.versioning.maxVersions must be a positive integer");
+    }
+    if (tableConfig?.[versionTableName]) {
+      throw new Error(
+        `File version table name (${versionTableName}) is managed and cannot be configured in tableConfig`,
+      );
+    }
+  }
 
+  const fileColumnDefinitions = {
+    ...FILE_TABLE_COLUMN_DEFINITIONS,
+    ...(fileTable.versioning && FILE_TABLE_VERSION_COLUMN_DEFINITIONS),
+  };
   const userFileTableConfig = tableConfig?.[fileTableName];
   if (userFileTableConfig) {
     if ("isLookupTable" in userFileTableConfig) {
@@ -59,12 +72,21 @@ export const getFileTableConfig = (
     }
     if ("columns" in userFileTableConfig && userFileTableConfig.columns) {
       const userCols = new Set(Object.keys(userFileTableConfig.columns));
-      const clashingColumns = Object.keys(FILE_TABLE_COLUMN_DEFINITIONS).filter((col) =>
+      const clashingFileColumns = Object.keys(fileColumnDefinitions).filter((col) =>
         userCols.has(col),
       );
-      if (clashingColumns.length) {
+      if (clashingFileColumns.length) {
+        throw new Error(
+          `FileManager table name (${fileTableName}) has clashing column names in tableConfig: ${clashingFileColumns}`,
+        );
+      }
+
+      const clashingFileRevisionColumns = Object.keys(FILE_VERSION_TABLE_COLUMN_DEFINITIONS).filter(
+        (col) => userCols.has(col),
+      );
+      if (clashingFileRevisionColumns.length) {
         throw new Error(
-          `FileManager table name (${fileTableName}) has clashing column names in tableConfig: ${clashingColumns}`,
+          `FileManager table name (${fileTableName}) has clashing column names with file revision table in tableConfig: ${clashingFileRevisionColumns}`,
         );
       }
     }
@@ -74,7 +96,7 @@ export const getFileTableConfig = (
     [fileTableName]: {
       ...userFileTableConfig,
       columns: {
-        ...FILE_TABLE_COLUMN_DEFINITIONS,
+        ...fileColumnDefinitions,
         ...userFileTableConfig?.columns,
       },
       onMount: ({ _db }) => {
@@ -89,6 +111,24 @@ export const getFileTableConfig = (
         };
       },
     },
+    ...(fileTable.versioning && {
+      [versionTableName]: {
+        /** Mirror user columns in the file revision table */
+        columns: { ...FILE_VERSION_TABLE_COLUMN_DEFINITIONS, ...userFileTableConfig?.columns },
+        constraints: {
+          [versionConstraintName]: `FOREIGN KEY (file_id) REFERENCES ${asName(fileTableName)}(id) ON DELETE CASCADE`,
+        },
+        indexes: {
+          [versionIndexName]: {
+            unique: true,
+            columns: "file_id, version",
+          },
+        },
+        onMount: async ({ dbo }) => {
+          await backfillFileVersions(dbo, fileTable);
+        },
+      },
+    }),
     ...omitKeys(tableConfig ?? {}, [fileTableName]),
   };
 
@@ -156,9 +196,24 @@ export const getFileTableConfig = (
         } satisfies BeforeEachTsTrigger<FileTableRow, TableHandlers>,
         ...(userFileTableHooks?.beforeEach || []),
       ],
-      onInsteadOfDelete: async ({ onCommit, tx, returningQuery, isOneOrNone, filterOpts }) => {
+      afterEach: [
+        ...(userFileTableHooks?.afterEach || []),
+        {
+          commands: { insert: 1, update: 1 },
+          validate: async ({ row, dbx, onCommit }) => {
+            const fileRow = await getFileTableHandler(dbx, fileTable).findOne({ id: row.id });
+            if (!fileRow) throw new Error(`File not found after write: ${row.id}`);
+            await saveFileVersion(fileTable, fileRow, dbx, onCommit);
+          },
+        } satisfies AfterEachTsTrigger<FileTableRow, TableHandlers> as AfterEachTsTrigger<
+          any,
+          TableHandlers
+        >,
+      ],
+      onInsteadOfDelete: async ({ onCommit, dbx, tx, returningQuery, isOneOrNone, filterOpts }) => {
         return onDeleteFromFileTable(fileTable, {
           onCommit,
+          dbx,
           t: tx,
           returningQuery,
           isOneOrNone,

package/lib/StorageClient/saveFileVersion.ts

@@ -0,0 +1,82 @@
+import { pickKeys } from "prostgles-types";
+import type { TableHandlers } from "../DboBuilder/DboBuilder";
+import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
+import type { FileTableConfig } from "../ProstglesTypes";
+import type { OnCommit } from "../PublishParser/publishTypesAndUtils";
+import { deleteUnreferencedFile } from "./deleteUnreferencedFile";
+import type { FileTableRow, FileVersionTableInsertRow } from "./fileTableDefinitions";
+import { getFileRevisionsTableHandler, getFileTableHandler } from "./fileVersionUtils";
+import { getFileStorageKey } from "./getFileStorageKey";
+
+export const saveFileVersion = async (
+  config: FileTableConfig,
+  row: FileTableRow,
+  dbx: TableHandlers,
+  onCommit: OnCommit,
+) => {
+  if (!config.versioning) return;
+  const version = Number(row.version);
+  if (!Number.isInteger(version) || version < 1) {
+    throw new Error(`Invalid file version: ${row.version}`);
+  }
+
+  const versions = getFileRevisionsTableHandler(dbx, config);
+  const versionColumns = (versions as TableHandler).column_names;
+  await versions.insert(getFileVersionRow(row, versionColumns), {
+    onConflict: {
+      action: "DoNothing",
+      conflictColumns: ["file_id", "version"],
+    },
+  });
+
+  const { maxVersions } = config.versioning;
+  if (maxVersions === undefined) return;
+  const removed = (await versions.find(
+    { file_id: row.id },
+    {
+      select: { id: 1, storage_key: 1 },
+      orderBy: { version: -1 },
+      offset: maxVersions,
+      limit: null,
+    },
+  )) as { id: string; storage_key: string }[];
+  if (!removed.length) return;
+
+  await versions.delete({ id: { $in: removed.map(({ id }) => id) } });
+  for (const storageKey of new Set(removed.map(({ storage_key }) => storage_key))) {
+    onCommit(({ db }) => deleteUnreferencedFile(db, config, storageKey));
+  }
+};
+
+export const backfillFileVersions = async (dbo: TableHandlers, config: FileTableConfig) => {
+  if (!config.versioning) return;
+  const files = getFileTableHandler(dbo, config);
+  const fileRows = await files.find({}, { limit: null });
+  if (!fileRows.length) return;
+  console.log(`Backfilling file versions for ${fileRows.length} files`);
+  const fileRevisionsTableHandler = getFileRevisionsTableHandler(dbo, config);
+  const fileRevisionColumns = (fileRevisionsTableHandler as TableHandler).column_names;
+  await fileRevisionsTableHandler.insertMany(
+    fileRows.map((fileRow) => getFileVersionRow(fileRow, fileRevisionColumns)),
+    {
+      onConflict: {
+        action: "DoNothing",
+        conflictColumns: ["file_id", "version"],
+      },
+    },
+  );
+};
+
+/** Must ensure we copy over any columns that might have been created by the user */
+const getFileVersionRow = (row: FileTableRow, cols: string[]): FileVersionTableInsertRow => {
+  const { id, ...insertRow } = pickKeys(row, cols as (keyof FileTableRow)[]);
+  const version = Number(row.version ?? 1);
+  return {
+    ...insertRow,
+    file_id: id,
+    version,
+    storage_key: getFileStorageKey(row),
+    url: `${row.url}?version=${version}`,
+    created: row.updated,
+  };
+};