@valentinkolb/filegate 0.0.1

package/src/schemas.ts

@@ -0,0 +1,170 @@
+import { z } from "zod";
+
+// ============================================================================
+// Common
+// ============================================================================
+
+export const ErrorSchema = z.object({
+  error: z.string(),
+});
+
+export const FileTypeSchema = z.enum(["file", "directory"]);
+
+export const FileInfoSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: FileTypeSchema,
+  size: z.number(),
+  mtime: z.iso.datetime(),
+  isHidden: z.boolean(),
+  mimeType: z.string().optional(),
+});
+
+export const DirInfoSchema = FileInfoSchema.extend({
+  items: z.array(FileInfoSchema),
+  total: z.number(),
+});
+
+// ============================================================================
+// Query Params
+// ============================================================================
+
+export const PathQuerySchema = z.object({
+  path: z.string().min(1),
+});
+
+export const InfoQuerySchema = z.object({
+  path: z.string().min(1),
+  showHidden: z
+    .string()
+    .optional()
+    .transform((v) => v === "true"),
+});
+
+export const SearchQuerySchema = z.object({
+  paths: z.string().min(1),
+  pattern: z.string().min(1).max(500),
+  showHidden: z
+    .string()
+    .optional()
+    .transform((v) => v === "true"),
+  limit: z
+    .string()
+    .optional()
+    .transform((v) => (v ? parseInt(v, 10) : undefined)),
+});
+
+/** Count recursive wildcards (**) in a glob pattern */
+export const countRecursiveWildcards = (pattern: string): number => {
+  return (pattern.match(/\*\*/g) || []).length;
+};
+
+// ============================================================================
+// Request Bodies
+// ============================================================================
+
+export const MkdirBodySchema = z.object({
+  path: z.string().min(1),
+  ownerUid: z.number().int().optional(),
+  ownerGid: z.number().int().optional(),
+  mode: z
+    .string()
+    .regex(/^[0-7]{3,4}$/)
+    .optional(),
+});
+
+export const MoveBodySchema = z.object({
+  from: z.string().min(1),
+  to: z.string().min(1),
+});
+
+export const CopyBodySchema = z.object({
+  from: z.string().min(1),
+  to: z.string().min(1),
+});
+
+export const UploadStartBodySchema = z.object({
+  path: z.string().min(1),
+  filename: z.string().min(1),
+  size: z.number().int().positive(),
+  checksum: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+  chunkSize: z.number().int().positive(),
+  ownerUid: z.number().int().optional(),
+  ownerGid: z.number().int().optional(),
+  mode: z
+    .string()
+    .regex(/^[0-7]{3,4}$/)
+    .optional(),
+});
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+export const SearchResultSchema = z.object({
+  basePath: z.string(),
+  files: z.array(FileInfoSchema),
+  total: z.number(),
+  hasMore: z.boolean(),
+});
+
+export const SearchResponseSchema = z.object({
+  results: z.array(SearchResultSchema),
+  totalFiles: z.number(),
+});
+
+export const UploadStartResponseSchema = z.object({
+  uploadId: z.string().regex(/^[a-f0-9]{16}$/),
+  totalChunks: z.number(),
+  chunkSize: z.number(),
+  uploadedChunks: z.array(z.number()),
+  completed: z.literal(false),
+});
+
+export const UploadChunkProgressSchema = z.object({
+  chunkIndex: z.number(),
+  uploadedChunks: z.array(z.number()),
+  completed: z.literal(false),
+});
+
+export const UploadChunkCompleteSchema = z.object({
+  completed: z.literal(true),
+  file: FileInfoSchema.extend({ checksum: z.string() }),
+});
+
+export const UploadChunkResponseSchema = z.union([UploadChunkProgressSchema, UploadChunkCompleteSchema]);
+
+// ============================================================================
+// Header Schemas
+// ============================================================================
+
+export const UploadFileHeadersSchema = z.object({
+  "x-file-path": z.string().min(1),
+  "x-file-name": z.string().min(1),
+  "x-owner-uid": z.string().regex(/^\d+$/).transform(Number).optional(),
+  "x-owner-gid": z.string().regex(/^\d+$/).transform(Number).optional(),
+  "x-file-mode": z
+    .string()
+    .regex(/^[0-7]{3,4}$/)
+    .optional(),
+});
+
+export const UploadChunkHeadersSchema = z.object({
+  "x-upload-id": z.string().regex(/^[a-f0-9]{16}$/),
+  "x-chunk-index": z.string().regex(/^\d+$/).transform(Number),
+  "x-chunk-checksum": z
+    .string()
+    .regex(/^sha256:[a-f0-9]{64}$/)
+    .optional(),
+});
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type FileInfo = z.infer<typeof FileInfoSchema>;
+export type DirInfo = z.infer<typeof DirInfoSchema>;
+export type SearchResult = z.infer<typeof SearchResultSchema>;
+export type UploadStartBody = z.infer<typeof UploadStartBodySchema>;
+export type UploadFileHeaders = z.infer<typeof UploadFileHeadersSchema>;
+export type UploadChunkHeaders = z.infer<typeof UploadChunkHeadersSchema>;

package/src/utils.ts

@@ -0,0 +1,282 @@
+// ============================================================================
+// Filegate Utils - Browser-compatible utilities for chunked uploads
+// ============================================================================
+
+// ============================================================================
+// Type Declarations
+// ============================================================================
+
+// Blob.slice() is standard but missing from TypeScript's lib.dom.d.ts
+declare global {
+  interface Blob {
+    slice(start?: number, end?: number, contentType?: string): Blob;
+  }
+}
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ChunkInfo {
+  index: number;
+  data: Blob;
+  total: number;
+}
+
+export interface UploadState {
+  uploaded: number;
+  total: number;
+  percent: number;
+  status: "pending" | "uploading" | "completed" | "error";
+}
+
+export type StateSubscriber = (state: UploadState) => void;
+
+export interface PrepareOptions {
+  file: Blob | File;
+  chunkSize?: number;
+}
+
+export interface SendOptions {
+  index: number;
+  retries?: number;
+  fn: (chunk: { index: number; data: Blob }) => Promise<void>;
+}
+
+export interface SendAllOptions {
+  skip?: number[];
+  retries?: number;
+  concurrency?: number;
+  fn: (chunk: { index: number; data: Blob }) => Promise<void>;
+}
+
+// ============================================================================
+// ChunkedUpload Class
+// ============================================================================
+
+export class ChunkedUpload {
+  readonly file: Blob | File;
+  readonly fileSize: number;
+  readonly chunkSize: number;
+  readonly totalChunks: number;
+  readonly checksum: string;
+
+  private _state: UploadState;
+  private _subscribers: Set<StateSubscriber> = new Set();
+  private _completedChunks: Set<number> = new Set();
+
+  constructor(opts: { file: Blob | File; fileSize: number; chunkSize: number; totalChunks: number; checksum: string }) {
+    this.file = opts.file;
+    this.fileSize = opts.fileSize;
+    this.chunkSize = opts.chunkSize;
+    this.totalChunks = opts.totalChunks;
+    this.checksum = opts.checksum;
+    this._state = {
+      uploaded: 0,
+      total: opts.totalChunks,
+      percent: 0,
+      status: "pending",
+    };
+  }
+
+  // ==========================================================================
+  // State Management
+  // ==========================================================================
+
+  get state(): UploadState {
+    return { ...this._state };
+  }
+
+  subscribe(fn: StateSubscriber): () => void {
+    this._subscribers.add(fn);
+    // Emit current state immediately
+    fn(this.state);
+    return () => {
+      this._subscribers.delete(fn);
+    };
+  }
+
+  private _updateState(partial: Partial<UploadState>): void {
+    this._state = { ...this._state, ...partial };
+    for (const fn of this._subscribers) {
+      fn(this.state);
+    }
+  }
+
+  complete(opts: { index: number }): void {
+    if (this._completedChunks.has(opts.index)) return;
+
+    this._completedChunks.add(opts.index);
+    const uploaded = this._completedChunks.size;
+    const percent = Math.round((uploaded / this.totalChunks) * 100);
+    const status = uploaded === this.totalChunks ? "completed" : "uploading";
+
+    this._updateState({ uploaded, percent, status });
+  }
+
+  reset(): void {
+    this._completedChunks.clear();
+    this._updateState({
+      uploaded: 0,
+      percent: 0,
+      status: "pending",
+    });
+  }
+
+  // ==========================================================================
+  // Chunk Access
+  // ==========================================================================
+
+  get(opts: { index: number }): Blob {
+    const start = opts.index * this.chunkSize;
+    const end = Math.min(start + this.chunkSize, this.fileSize);
+    // Blob.prototype.slice is standard but TypeScript's lib.dom.d.ts doesn't include it
+    // We use a type-safe wrapper that preserves the Blob type
+    return (this.file as Blob).slice(start, end);
+  }
+
+  async hash(opts: { data: Blob | ArrayBuffer }): Promise<string> {
+    const buffer = opts.data instanceof Blob ? await opts.data.arrayBuffer() : opts.data;
+    const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+    const hashArray = new Uint8Array(hashBuffer);
+    return `sha256:${Array.from(hashArray)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("")}`;
+  }
+
+  // ==========================================================================
+  // Upload Helpers
+  // ==========================================================================
+
+  async send(opts: SendOptions): Promise<void> {
+    const { index, retries = 0, fn } = opts;
+    const data = this.get({ index });
+
+    let lastError: Error | null = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        await fn({ index, data });
+        this.complete({ index });
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < retries) {
+          // Exponential backoff: 100ms, 200ms, 400ms, ...
+          await new Promise((r) => setTimeout(r, 100 * Math.pow(2, attempt)));
+        }
+      }
+    }
+
+    this._updateState({ status: "error" });
+    throw lastError;
+  }
+
+  async sendAll(opts: SendAllOptions): Promise<void> {
+    const { skip = [], retries = 0, concurrency = 1, fn } = opts;
+    const skipSet = new Set(skip);
+
+    // Mark skipped chunks as completed
+    for (const index of skip) {
+      this.complete({ index });
+    }
+
+    this._updateState({ status: "uploading" });
+
+    // Get indices that need to be uploaded
+    const toUpload: number[] = [];
+    for (let i = 0; i < this.totalChunks; i++) {
+      if (!skipSet.has(i) && !this._completedChunks.has(i)) {
+        toUpload.push(i);
+      }
+    }
+
+    if (concurrency === 1) {
+      // Sequential upload
+      for (const index of toUpload) {
+        await this.send({ index, retries, fn });
+      }
+    } else {
+      // Concurrent upload with limited parallelism
+      const queue = [...toUpload];
+      const inFlight: Promise<void>[] = [];
+
+      while (queue.length > 0 || inFlight.length > 0) {
+        // Start new uploads up to concurrency limit
+        while (queue.length > 0 && inFlight.length < concurrency) {
+          const index = queue.shift()!;
+          const promise = this.send({ index, retries, fn }).then(() => {
+            inFlight.splice(inFlight.indexOf(promise), 1);
+          });
+          inFlight.push(promise);
+        }
+
+        // Wait for at least one to complete
+        if (inFlight.length > 0) {
+          await Promise.race(inFlight);
+        }
+      }
+    }
+
+    this._updateState({ status: "completed" });
+  }
+
+  // ==========================================================================
+  // Async Iterator
+  // ==========================================================================
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<ChunkInfo> {
+    for (let index = 0; index < this.totalChunks; index++) {
+      yield {
+        index,
+        data: this.get({ index }),
+        total: this.totalChunks,
+      };
+    }
+  }
+}
+
+// ============================================================================
+// chunks namespace
+// ============================================================================
+
+async function prepare(opts: PrepareOptions): Promise<ChunkedUpload> {
+  const { file, chunkSize = 5 * 1024 * 1024 } = opts;
+  const fileSize = file.size;
+  const totalChunks = Math.ceil(fileSize / chunkSize);
+
+  // Calculate checksum using WebCrypto
+  const buffer = await file.arrayBuffer();
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  const hashArray = new Uint8Array(hashBuffer);
+  const checksum = `sha256:${Array.from(hashArray)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("")}`;
+
+  return new ChunkedUpload({
+    file,
+    fileSize,
+    chunkSize,
+    totalChunks,
+    checksum,
+  });
+}
+
+export const chunks = {
+  prepare,
+};
+
+// ============================================================================
+// formatBytes
+// ============================================================================
+
+export function formatBytes(opts: { bytes: number; decimals?: number }): string {
+  const { bytes, decimals = 2 } = opts;
+
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}