feat: implement chunked storage for Telegram file uploads and retrieval

src/db/file-parts.ts

@@ -0,0 +1,97 @@
+import { sql } from 'drizzle-orm';
+import { db } from './index';
+
+export type CompressionAlgorithm = 'gzip' | null;
+
+export interface FilePart {
+  id: number;
+  fileId: string;
+  partNumber: number;
+  telegramFileId: string;
+  telegramFileUniqueId: string;
+  storageChatId: number;
+  storageMessageId: number;
+  sizeBytes: number;
+  storedSizeBytes: number;
+  compressionAlgorithm: CompressionAlgorithm;
+  etag: string;
+  createdAt: Date;
+}
+
+export type NewFilePartInput = Omit<FilePart, 'id' | 'createdAt'>;
+
+const toNumber = (value: unknown): number => Number(value ?? 0);
+
+const mapRowToFilePart = (row: Record<string, unknown>): FilePart => ({
+  id: toNumber(row.id),
+  fileId: row.file_id as string,
+  partNumber: toNumber(row.part_number),
+  telegramFileId: row.telegram_file_id as string,
+  telegramFileUniqueId: row.telegram_file_unique_id as string,
+  storageChatId: toNumber(row.storage_chat_id),
+  storageMessageId: toNumber(row.storage_message_id),
+  sizeBytes: toNumber(row.size_bytes),
+  storedSizeBytes: toNumber(row.stored_size_bytes),
+  compressionAlgorithm: (row.compression_algorithm as CompressionAlgorithm) || null,
+  etag: row.etag as string,
+  createdAt: new Date(row.created_at as string),
+});
+
+export const insertFileParts = async (parts: NewFilePartInput[]): Promise<void> => {
+  for (const part of parts) {
+    await db.execute(
+      sql`INSERT INTO file_parts (
+        file_id,
+        part_number,
+        telegram_file_id,
+        telegram_file_unique_id,
+        storage_chat_id,
+        storage_message_id,
+        size_bytes,
+        stored_size_bytes,
+        compression_algorithm,
+        etag
+      ) VALUES (
+        ${part.fileId}::uuid,
+        ${part.partNumber},
+        ${part.telegramFileId},
+        ${part.telegramFileUniqueId},
+        ${part.storageChatId},
+        ${part.storageMessageId},
+        ${part.sizeBytes},
+        ${part.storedSizeBytes},
+        ${part.compressionAlgorithm},
+        ${part.etag}
+      )`,
+    );
+  }
+};
+
+export const listFileParts = async (fileId: string): Promise<FilePart[]> => {
+  const result = (await db.execute(
+    sql`SELECT id,
+      file_id,
+      part_number,
+      telegram_file_id,
+      telegram_file_unique_id,
+      storage_chat_id,
+      storage_message_id,
+      size_bytes,
+      stored_size_bytes,
+      compression_algorithm,
+      etag,
+      created_at
+    FROM file_parts
+    WHERE file_id = ${fileId}::uuid
+    ORDER BY part_number`,
+  )) as unknown as Record<string, unknown>[];
+
+  return result.map(mapRowToFilePart);
+};
+
+export const countFileParts = async (fileId: string): Promise<number> => {
+  const result = (await db.execute(
+    sql`SELECT COUNT(*) AS count FROM file_parts WHERE file_id = ${fileId}::uuid`,
+  )) as unknown as Record<string, unknown>[];
+  return toNumber(result[0]?.count);
+};

src/db/files-ext.ts

@@ -51,6 +51,8 @@ const mapDbRowToS3Record = (row: Record<string, unknown>): S3FileRecord => {
     storageBackend: (row.storage_backend as string) || 'telegram',
     isDeleted: row.is_deleted as boolean,
     multipartUploadId: row.multipart_upload_id as string | null,
+    partCount:
+      row.part_count === null || row.part_count === undefined ? null : toNumber(row.part_count),
     createdAt: new Date(row.created_at as string),
     updatedAt: new Date(row.updated_at as string),
   };

src/db/index.ts

@@ -1,6 +1,6 @@
 import { drizzle } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
-import { files } from './schema';
+import { fileParts, files } from './schema';
 
 const client = postgres(process.env.DATABASE_URL!, {
   max: 10,
@@ -8,6 +8,6 @@ const client = postgres(process.env.DATABASE_URL!, {
   connect_timeout: 10,
 });
 
-export const db = drizzle(client, { schema: { files } });
-export { files };
+export const db = drizzle(client, { schema: { fileParts, files } });
+export { fileParts, files };
 export default db;

src/db/schema.ts

@@ -1,5 +1,14 @@
 import type { InferInsertModel, InferSelectModel } from 'drizzle-orm';
-import { bigint, boolean, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import {
+  bigint,
+  boolean,
+  integer,
+  pgTable,
+  serial,
+  text,
+  timestamp,
+  uuid,
+} from 'drizzle-orm/pg-core';
 
 export const files = pgTable('files', {
   id: uuid('id').primaryKey().defaultRandom(),
@@ -25,9 +34,27 @@ export const files = pgTable('files', {
   storageBackend: text('storage_backend').default('telegram'),
   isDeleted: boolean('is_deleted').default(false),
   multipartUploadId: text('multipart_upload_id'),
+  partCount: integer('part_count'),
   createdAt: timestamp('created_at').defaultNow().notNull(),
   updatedAt: timestamp('updated_at').defaultNow().notNull(),
 });
 
+export const fileParts = pgTable('file_parts', {
+  id: serial('id').primaryKey(),
+  fileId: uuid('file_id').notNull(),
+  partNumber: integer('part_number').notNull(),
+  telegramFileId: text('telegram_file_id').notNull(),
+  telegramFileUniqueId: text('telegram_file_unique_id').notNull(),
+  storageChatId: bigint('storage_chat_id', { mode: 'number' }).notNull(),
+  storageMessageId: bigint('storage_message_id', { mode: 'number' }).notNull(),
+  sizeBytes: bigint('size_bytes', { mode: 'number' }).notNull(),
+  storedSizeBytes: bigint('stored_size_bytes', { mode: 'number' }).notNull(),
+  compressionAlgorithm: text('compression_algorithm'),
+  etag: text('etag').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+});
+
 export type File = InferSelectModel<typeof files>;
 export type NewFile = InferInsertModel<typeof files>;
+export type FilePart = InferSelectModel<typeof fileParts>;
+export type NewFilePart = InferInsertModel<typeof fileParts>;