@fidt/saul-server 0.1.5 → 1.1.0

package/dist/index.d.ts

@@ -1,9 +1,13 @@
+import { Hono } from 'hono';
 export * from 'hono';
 export { Hono as WebServer } from 'hono';
 export { cors } from 'hono/cors';
 export { serve } from '@hono/node-server';
+export * from 'socket.io';
+export { createAdapter } from '@socket.io/redis-adapter';
 import * as zod from 'zod';
 export { zod as Zod };
+import { Readable, Writable } from 'stream';
 export * from 'zod-validation-error';
 
 declare class File {
@@ -30,4 +34,431 @@ declare class File {
     write(buffer: ArrayBuffer): void;
 }
 
-export { File };
+/**
+ * FILE DẠNG STREAM — cho file mà cả nội dung KHÔNG được phép nằm trong RAM.
+ *
+ * Khác `File` (buffered, giữ base64 trong bộ nhớ, trần vài chục MB), `FileStream` chỉ giữ
+ * metadata + một hàm mở nguồn. Byte chỉ chảy khi có người đọc, nên RAM là hằng số bất kể
+ * file 8MB hay 8GB.
+ *
+ * Dùng được ở CẢ HAI vị trí trong definition:
+ * - param      → chiều lên: multipart upload, gateway/downstream đưa `Readable` vào đây.
+ * - returnType → chiều xuống: handler trả về, runtime pipe thẳng ra browser.
+ *
+ * Khai kiểu nào là chọn hợp đồng đó. Transport KHÔNG được đánh tráo `File` thành
+ * `FileStream` hay ngược lại — một param có shape phụ thuộc transport là thứ tuyệt đối
+ * không được xảy ra.
+ */
+/** Brand để nhận diện qua ranh giới package — xem `FileStream.is`. */
+declare const FILE_STREAM_BRAND: unique symbol;
+interface FileStreamMetadata {
+    name: string;
+    /** Kích thước KHAI BÁO. `0` = không biết trước (dữ liệu sinh on-the-fly). */
+    size: number;
+    type: string;
+}
+declare class FileStream {
+    /** @internal Đánh dấu instance để `is()` nhận ra qua nhiều bản copy của package. */
+    readonly [FILE_STREAM_BRAND]: true;
+    readonly metadata: FileStreamMetadata;
+    private readonly source;
+    private consumed;
+    constructor(metadata: FileStreamMetadata, source: () => Readable);
+    /**
+     * Mở nguồn và trả về `Readable`.
+     *
+     * Gọi lần thứ hai sẽ NÉM. Một stream không phải là value: đọc hai lần thì lần thứ hai
+     * hoặc rỗng, hoặc mở lại nguồn và trả về dữ liệu đã cũ — cả hai đều là bug im lặng.
+     * Cần đọc nhiều lần thì `buffer()` một lần rồi tự giữ.
+     */
+    stream(): Readable;
+    /** Đã có ai đọc chưa — cho runtime biết có phải drain trước khi trả response không. */
+    get isConsumed(): boolean;
+    /** Đẩy toàn bộ nội dung vào một `Writable`, chờ tới khi xong. */
+    pipeTo(destination: Writable): Promise<void>;
+    /**
+     * Đọc hết vào một `Buffer`.
+     *
+     * `maxBytes` là BẮT BUỘC, không có mặc định: đây là escape hatch duy nhất ra khỏi mô hình
+     * streaming, và người dùng nó phải tự nói ra trần mình chấp nhận. Một `buffer()` không
+     * trần đặt giữa đường xử lý file 3GB sẽ giết process — mà chỉ giết trong production, với
+     * file lớn, chứ không bao giờ trong test.
+     */
+    buffer(maxBytes: number): Promise<Buffer>;
+    /**
+     * Có phải `FileStream` không.
+     *
+     * Dùng brand chứ KHÔNG dùng `instanceof`: gateway và downstream có thể resolve hai bản
+     * copy khác nhau của `@fidt/saul-server` (dual-package hazard), lúc đó `instanceof` trả
+     * `false` cho một object hoàn toàn hợp lệ — và nó hỏng theo kiểu chỉ lộ ra khi deploy
+     * thật, không bao giờ trong monorepo.
+     */
+    static is(value: unknown): value is FileStream;
+    /** Dựng từ một `Buffer` sẵn có — tiện cho test và cho handler trả dữ liệu nhỏ. */
+    static fromBuffer(metadata: Omit<FileStreamMetadata, 'size'> & {
+        size?: number;
+    }, data: Buffer): FileStream;
+}
+
+/**
+ * SaulException — lỗi NGHIỆP VỤ mà handler chủ động ném để từ chối một lời gọi.
+ *
+ * Khác `Error` trần ở đúng hai điểm, và cả hai đều là lý do nó tồn tại:
+ *
+ *  1. **Có `code`** đi qua được dây. Envelope lỗi của downstream mang cả `message` lẫn
+ *     `code`, gateway map sang ack `{ ok:false, error, code }`, client dựng lại thành
+ *     `SaulException` — nên client bắt được lỗi theo mã chứ không phải so khớp chuỗi tiếng
+ *     Việt. `Error` trần chỉ còn lại `message` sau chuyến đi.
+ *  2. **Là ý ĐỊNH từ chối, không phải sự cố.** Gateway log `Error` lạ như một lỗi server,
+ *     còn `SaulException` là câu trả lời hợp lệ ("bạn không được sub chat của người khác")
+ *     nên không cần ồn ào trong log.
+ *
+ * Chỗ dùng chính là validator của subscription: controller `sub<Model>` ném `SaulException`
+ * để từ chối, và cái ném đó nổi lên đúng chỗ client đang `catch` quanh vòng `for await`.
+ */
+declare class SaulException extends Error {
+    /** Mã ổn định để client rẽ nhánh. Mặc định là mã chung của một từ chối nghiệp vụ. */
+    readonly code: string;
+    constructor(message: string, code?: string);
+    /**
+     * Nhận diện KHÔNG dùng `instanceof`.
+     *
+     * Gateway, downstream và SDK có thể resolve ba bản copy vật lý khác nhau của package
+     * này (pnpm workspace + code sinh ra được copy vào từng service), nên `instanceof` sẽ
+     * trả false cho một SaulException hoàn toàn thật. Cùng lý do với `FileStream.is`.
+     */
+    static is(value: unknown): value is SaulException;
+}
+
+/**
+ * PREDICATE — điều kiện lọc mà client khai khi mở một subscription.
+ *
+ * File này CHỈ có kiểu, không có runtime: việc đánh giá predicate xảy ra ở GATEWAY (nó giữ
+ * socket và biết ai đang nghe gì), không ở downstream. Downstream chỉ cần đọc và thu hẹp
+ * predicate trong validator `sub<Model>` rồi trả về.
+ *
+ * Cú pháp `$`-prefix, cố ý KHÁC filter authz kiểu Directus (`_eq`, `_or`) ở
+ * `Permission.filter`. Hai thứ trả lời hai câu hỏi khác nhau — filter authz nói "được thấy
+ * BẢN GHI nào" và được forward xuống query storage; predicate nói "muốn nhận EVENT nào" và
+ * được Saul tự đánh giá in-memory. Trộn cú pháp sẽ khiến người đọc tưởng chúng thay nhau được.
+ */
+/** So sánh trên một field. Nhiều toán tử trong cùng object thì AND với nhau. */
+interface PredicateComparison<V> {
+    $eq?: V;
+    $ne?: V;
+    $gt?: V;
+    $gte?: V;
+    $lt?: V;
+    $lte?: V;
+    $in?: V[];
+    $nin?: V[];
+    /** Field có mặt trong payload hay không — nói về SỰ CÓ MẶT, không phải giá trị. */
+    $exists?: boolean;
+}
+/**
+ * Predicate trên một Model.
+ *
+ * Giá trị trần là shorthand của `$eq`: `{ chatId: 12 }` ≡ `{ chatId: { $eq: 12 } }`.
+ * Các key cùng cấp AND với nhau, nên `{}` khớp TẤT CẢ — đó là lý do validator `sub<Model>`
+ * mặc định TỪ CHỐI, và là lý do nên thu hẹp predicate thay vì chỉ kiểm rồi trả nguyên.
+ *
+ * KHÔNG có `$regex`: nó là đường ReDoS do client tự khai, chạy ở đường nóng của mọi lần push.
+ */
+type Predicate<T> = {
+    [K in keyof T]?: T[K] | PredicateComparison<T[K]>;
+} & {
+    $and?: Predicate<T>[];
+    $or?: Predicate<T>[];
+    $not?: Predicate<T>;
+};
+/**
+ * Một subscription đang mở, nhìn từ phía server.
+ *
+ * `id` do gateway sinh TRƯỚC khi gọi validator và truyền xuống qua `ctx.subId`, nên
+ * validator lưu lại được để về sau `sub<Model>.unsub(id)` thu hồi (vd user bị mời khỏi
+ * phòng chat trong lúc đang nghe).
+ */
+interface Sub<T> {
+    id: string;
+    predicate: Predicate<T>;
+}
+/**
+ * Gộp nhiều predicate bằng AND — cách chuẩn để validator THU HẸP thứ client xin.
+ *
+ * ```ts
+ * return narrow(predicate, { userId: { $eq: ctx.principal.sub } })
+ * ```
+ *
+ * Dùng `$and` thay vì trải phẳng bằng spread: spread sẽ để điều kiện sau GHI ĐÈ điều kiện
+ * trước trên cùng một field, tức là client khai `{ userId: { $eq: 'ai-đó' } }` rồi ràng
+ * buộc bảo mật ghi đè lên — đúng ý. Nhưng ở chiều ngược lại (`{...cứng, ...client}`) thì
+ * client ghi đè ràng buộc bảo mật. `$and` không có chiều nào để nhầm: mọi nhánh đều phải thoả.
+ */
+declare const narrow: <T>(...predicates: (Predicate<T> | null | undefined)[]) => Predicate<T>;
+
+/**
+ * LỖI CỦA CHUNK STORE, có mã máy-đọc-được.
+ *
+ * Cùng kiểu với `BinaryStreamError` của đường WebSocket: mỗi tình huống một `code`, và mã
+ * đó — chứ không phải chuỗi message — là thứ tầng trên map sang HTTP status. Một bảng map
+ * duy nhất, không handler nào tự viết status.
+ */
+type UploadErrorCode = 'UPLOAD_NOT_FOUND' | 'UPLOAD_EXISTS' | 'UPLOAD_EXPIRED' | 'UPLOAD_COMPLETED'
+/** Đang complete dở — một lời gọi complete khác đã chiếm chỗ. */
+ | 'UPLOAD_BUSY' | 'PART_OUT_OF_RANGE' | 'PART_IN_FLIGHT' | 'PART_TOO_LARGE' | 'PART_MISSING' | 'SIZE_MISMATCH' | 'CHECKSUM_MISMATCH' | 'DISK_BUDGET' | 'FORBIDDEN';
+declare class UploadError extends Error {
+    readonly code: UploadErrorCode;
+    constructor(code: UploadErrorCode, message: string);
+    static is(value: unknown): value is UploadError;
+}
+/**
+ * MÃ LỖI → HTTP STATUS. Bảng DUY NHẤT, và nó phải phủ hết `UploadErrorCode`.
+ *
+ * `Record<UploadErrorCode, number>` cố ý không optional: thêm một mã mới mà quên map thì
+ * TypeScript báo ngay, thay vì lặng lẽ trả 500 cho một lỗi vốn có nghĩa rõ ràng.
+ */
+declare const UPLOAD_ERROR_STATUS: Record<UploadErrorCode, number>;
+declare const uploadErrorStatus: (code: UploadErrorCode) => number;
+
+interface WritePartResult {
+    size: number;
+    /** sha256 hex của part — client dùng để retry có kiểm chứng. */
+    etag: string;
+}
+interface PartInfo {
+    partNumber: number;
+    size: number;
+}
+interface PartDiskStoreOptions {
+    /** Thư mục gốc. Mỗi upload một thư mục con. */
+    rootDir: string;
+    /** fsync mỗi part trước khi rename. Tắt = đổi durability-khi-crash lấy throughput. */
+    fsync?: boolean;
+}
+declare class PartDiskStore {
+    private readonly rootDir;
+    private readonly fsync;
+    constructor(options: PartDiskStoreOptions);
+    /**
+     * Thư mục của một upload.
+     *
+     * `assertSafeUploadId` chạy TRƯỚC `join` — đây là bề mặt path-traversal duy nhất của
+     * cả tính năng, và `join('/tmp', '../../etc')` là một đường dẫn hoàn toàn hợp lệ.
+     */
+    dirFor(uploadId: string): string;
+    private pathFor;
+    ensureDir(uploadId: string): Promise<void>;
+    /**
+     * Ghi một part. Trả về số byte thật và sha256.
+     *
+     * Bốn bước, thứ tự bắt buộc:
+     *   1. `open(tmp, 'wx')` — hai PUT cùng part cùng lúc thì một cái thua ngay, thay vì
+     *      hai writer xen kẽ vào cùng một file.
+     *   2. pipeline có đếm byte + hash — vượt trần là abort GIỮA CHỪNG, không đọc hết rồi
+     *      mới than.
+     *   3. fsync (nếu bật) rồi `rename` — rename trong cùng filesystem là atomic, nên
+     *      file `.part` xuất hiện là đã hoàn chỉnh, không có trạng thái nửa vời.
+     *   4. Chỉ khi rename xong mới coi như part tồn tại.
+     */
+    writePart(uploadId: string, partNumber: number, body: Readable, opts: {
+        maxBytes: number;
+        partCount: number;
+        declaredLength?: number;
+        expectedSha256?: string;
+    }): Promise<WritePartResult>;
+    /** Mở một part để đọc. Dùng bởi `concatParts`. */
+    createPartStream(uploadId: string, partNumber: number, partCount: number): Readable;
+    /** Các part ĐANG CÓ THẬT trên đĩa (không tính `.tmp`). */
+    listParts(uploadId: string): Promise<PartInfo[]>;
+    /** Xoá cả thư mục upload. Trả về số byte giải phóng. Idempotent. */
+    removeUpload(uploadId: string): Promise<number>;
+    /** Thư mục cũ hơn `olderThanMs` — ứng viên dọn rác. Xem `UploadSweeper`. */
+    listStaleDirs(olderThanMs: number, now?: number): Promise<string[]>;
+    /** Tổng byte đang chiếm — để đối chiếu lại counter, vốn trôi sau mỗi lần crash. */
+    totalBytes(): Promise<number>;
+}
+/**
+ * `uploadId` phải là UUID. Kiểm TRƯỚC mọi thao tác đường dẫn.
+ *
+ * Không dùng blacklist (`..`, `/`): danh sách cấm luôn thiếu một dạng nào đó
+ * (`%2e%2e`, null byte, tên dài quá giới hạn OS). Whitelist một hình dạng đã biết thì không.
+ */
+declare function assertSafeUploadId(uploadId: string): void;
+/** `partNumber` phải là số nguyên trong `1..partCount`. */
+declare function assertSafePartNumber(partNumber: number, partCount: number): void;
+
+type UploadState = 'open' | 'completing' | 'completed';
+interface UploadRecord {
+    uploadId: string;
+    module: string;
+    function: string;
+    /** Tên param kiểu FileStream của function đích. */
+    param: string;
+    /** Các param KHÔNG phải file của cùng lời gọi. */
+    params: Record<string, unknown>;
+    file: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    chunkSize: number;
+    partCount: number;
+    /** Deadline TUYỆT ĐỐI do gateway quyết, không bao giờ gia hạn. */
+    hardExpiresAt: number;
+    /** Deadline TRƯỢT, gia hạn mỗi lần nhận được part. */
+    expiresAt: number;
+    idleTimeoutMs: number;
+    state: UploadState;
+    createdAt: number;
+}
+interface UploadRegistryOptions {
+    store: PartDiskStore;
+    /** Ngân sách đĩa của MÁY NÀY. Vượt thì từ chối init. */
+    maxDiskBytes: number;
+}
+declare class UploadRegistry {
+    private readonly records;
+    private readonly store;
+    private readonly maxDiskBytes;
+    /**
+     * Byte đang chiếm, đếm tăng dần. Đây là con số ƯỚC LƯỢNG — nó trôi sau mỗi lần crash,
+     * nên `UploadSweeper` định kỳ tính lại bằng `du` thật. Counter trôi mà không ai sửa thì
+     * ngân sách âm thầm khoá mọi upload, và không có gì trong log nói tại sao.
+     */
+    private usedBytes;
+    constructor(options: UploadRegistryOptions);
+    get diskUsedBytes(): number;
+    /** Đặt lại bộ đếm sau khi đối chiếu với đĩa thật. Xem `UploadSweeper`. */
+    setDiskUsedBytes(bytes: number): void;
+    init(record: Omit<UploadRecord, 'state' | 'createdAt' | 'expiresAt'>): Promise<UploadRecord>;
+    /**
+     * Record của một upload đang MỞ được.
+     *
+     * Hết hạn thì ném `UPLOAD_EXPIRED` chứ không `UPLOAD_NOT_FOUND`: hai thứ đó nói với
+     * client hai điều khác nhau — "id sai, đừng thử nữa" và "chậm quá, làm lại từ init".
+     */
+    get(uploadId: string, allowed?: UploadState[]): UploadRecord;
+    /** Có record nào không, bất kể trạng thái — cho abort idempotent và cho sweeper. */
+    peek(uploadId: string): UploadRecord | undefined;
+    list(): UploadRecord[];
+    /**
+     * Gia hạn deadline sau khi nhận được một part, và cộng chênh lệch byte vào bộ đếm.
+     *
+     * `delta` chứ không phải `size`: PUT lại một part là GHI ĐÈ, nên phần tăng thêm chỉ là
+     * hiệu số. Cộng nguyên `size` mỗi lần retry sẽ thổi phồng bộ đếm cho tới khi ngân sách
+     * khoá cả những upload hoàn toàn bình thường.
+     */
+    touch(uploadId: string, deltaBytes: number): void;
+    /**
+     * Chuyển sang `completing`, một lần duy nhất.
+     *
+     * Đây là chốt chống complete đồng thời: hai request cùng lúc thì cái thứ hai thấy state
+     * đã đổi và nhận `UPLOAD_BUSY`, thay vì cả hai cùng ghép file và cùng gọi handler.
+     */
+    beginComplete(uploadId: string): UploadRecord;
+    /** Quay lại `open` khi complete thất bại — cho client retry mà không mất part đã gửi. */
+    rollbackComplete(uploadId: string): void;
+    /** Xoá record + part trên đĩa. Idempotent. */
+    remove(uploadId: string): Promise<void>;
+    /**
+     * Ghi `meta.json` cạnh part.
+     *
+     * Ghi tmp rồi rename để không bao giờ có một `meta.json` cụt: sweeper đọc phải file cụt
+     * sẽ coi thư mục là rác và xoá một upload đang chạy dở.
+     */
+    private persist;
+    /** Đọc `meta.json` của một thư mục — cho sweeper phân biệt upload sống với rác. */
+    readPersisted(uploadId: string): Promise<UploadRecord | undefined>;
+}
+
+/**
+ * DỌN RÁC ĐỊNH KỲ cho chunk store.
+ *
+ * Ba việc, và việc thứ hai/thứ ba mới là lý do tồn tại của nó: một `setTimeout` per-upload
+ * (kiểu `BinaryStreamBuffer` đang dùng cho WS) chỉ dọn được thứ nó biết. Process chết giữa
+ * chừng thì timer chết theo, còn file thì ở lại đĩa mãi mãi.
+ *
+ *   1. Upload quá hạn        → xoá record + part.
+ *   2. Thư mục KHÔNG có record trong RAM và đã cũ → rác của một process đã chết, xoá.
+ *   3. Định kỳ đối chiếu bộ đếm byte với đĩa thật → counter trôi sau crash, mà counter trôi
+ *      thì ngân sách âm thầm khoá mọi upload và không có gì trong log nói tại sao.
+ */
+interface UploadSweeperOptions {
+    registry: UploadRegistry;
+    store: PartDiskStore;
+    intervalMs?: number;
+    /** Thư mục mồ côi phải cũ hơn ngần này mới xoá. Mặc định 2× idle timeout dài nhất. */
+    orphanGraceMs?: number;
+    /** Bao nhiêu tick thì đối chiếu lại bộ đếm với đĩa (quét `du` không rẻ). */
+    reconcileEvery?: number;
+}
+interface SweepResult {
+    expired: number;
+    orphans: number;
+    reconciledBytes?: number;
+}
+declare class UploadSweeper {
+    private readonly registry;
+    private readonly store;
+    private readonly intervalMs;
+    private readonly orphanGraceMs;
+    private readonly reconcileEvery;
+    private timer?;
+    private ticks;
+    constructor(options: UploadSweeperOptions);
+    /** Bắt đầu quét. `unref()` để timer dọn dẹp không giữ process sống. */
+    start(): void;
+    stop(): void;
+    sweep(now?: number): Promise<SweepResult>;
+}
+
+/**
+ * NỐI CÁC PART thành MỘT `Readable`, không buffer.
+ *
+ * `Readable.from(async generator)` cho backpressure đúng miễn phí: generator chỉ chạy tiếp
+ * khi consumer kéo, nên tốc độ đọc đĩa tự khớp tốc độ ghi ra downstream. Và vì generator
+ * chỉ mở part khi tới lượt, ở mọi thời điểm chỉ có **một** fd đang mở — RAM là
+ * `highWaterMark`, không phụ thuộc file 8MB hay 8GB.
+ *
+ * `finally { rs.destroy() }` không phải cho đường thành công (stream tự đóng khi hết) mà cho
+ * đường HUỶ: consumer `destroy()` giữa chừng sẽ ném vào generator, và không có `finally` thì
+ * part đang đọc dở giữ fd tới tận lúc GC.
+ */
+declare function concatParts(store: PartDiskStore, uploadId: string, partNumbers: number[], partCount: number): Readable;
+
+/**
+ * SUB-ROUTER `/saul/upload/*` — phía DOWNSTREAM của multipart upload.
+ *
+ * Gateway không lưu byte nào; nó bơm thẳng từng part sang đây. Nên đây mới là nơi part nằm
+ * trên đĩa và được ghép lại lúc complete.
+ *
+ * Router này KHÔNG tự gác quyền. Nó tin gateway, đúng như `POST /saul` đang tin — quyền đã
+ * được chốt ở `/upload/init` của gateway, trước byte đầu tiên. Đặt thêm một tầng authz ở đây
+ * mà không có token của user thì cũng chỉ là kiểm lại chính mình.
+ *
+ * Chỉ ba biến env, và cả ba đều nói về TÀI NGUYÊN CỦA MÁY NÀY. Mọi thứ thuộc về chính sách
+ * (deadline, chunk size, partCount) do gateway truyền xuống trong lời gọi init.
+ */
+interface UploadRouterOptions {
+    /** Gọi hàm đích sau khi đã ghép file. Runtime truyền `dispatch` của nó vào đây. */
+    dispatch: (body: {
+        module: string;
+        function: string;
+        params: Record<string, unknown>;
+    }) => Promise<unknown>;
+    rootDir?: string;
+    maxDiskBytes?: number;
+    fsync?: boolean;
+    /** Trần cứng một part. Gateway cũng gác, nhưng ở đây mới đếm byte THẬT. */
+    maxPartBytes?: number;
+    sweepIntervalMs?: number;
+}
+interface UploadSubsystem {
+    router: Hono;
+    registry: UploadRegistry;
+    store: PartDiskStore;
+    sweeper: UploadSweeper;
+}
+declare function createUploadSubsystem(options: UploadRouterOptions): UploadSubsystem;
+
+export { File, FileStream, type FileStreamMetadata, PartDiskStore, type PartDiskStoreOptions, type PartInfo, type Predicate, type PredicateComparison, SaulException, type Sub, type SweepResult, UPLOAD_ERROR_STATUS, UploadError, type UploadErrorCode, type UploadRecord, UploadRegistry, type UploadRegistryOptions, type UploadRouterOptions, type UploadState, type UploadSubsystem, UploadSweeper, type UploadSweeperOptions, type WritePartResult, assertSafePartNumber, assertSafeUploadId, concatParts, createUploadSubsystem, narrow, uploadErrorStatus };

package/dist/index.js

@@ -1,3 +1,3 @@
-export*from'hono';export{Hono as WebServer}from'hono';export{cors}from'hono/cors';export{serve}from'@hono/node-server';import*as zod from'zod';export{zod as Zod };export*from'zod-validation-error';// @fidt/saul-server - A server library for the Saul framework
-var n=class{content;metadata;constructor(r){this.metadata=r||{name:"",size:0,type:""},this.content="";}encodeBase64(r){return Buffer.from(r).toString("base64")}decodeBase64(r){let e=Buffer.from(r,"base64"),t=new Uint8Array(e.length);return e.copy(t),t.buffer}read(){if(!this.content)throw new Error("File content is not set");return this.decodeBase64(this.content)}write(r){this.content=this.encodeBase64(r);}};export{n as File};//# sourceMappingURL=index.js.map
+import {Hono}from'hono';export*from'hono';export{Hono as WebServer}from'hono';export{cors}from'hono/cors';export{serve}from'@hono/node-server';export*from'socket.io';export{createAdapter}from'@socket.io/redis-adapter';import*as zod from'zod';export{zod as Zod };import {Readable,Transform}from'stream';import {pipeline}from'stream/promises';import {createHash}from'crypto';import {createReadStream}from'fs';import {mkdir,open,unlink,rename,readdir,stat,rm,writeFile,readFile}from'fs/promises';import {join}from'path';import {tmpdir}from'os';export*from'zod-validation-error';// @fidt/saul-server - A server library for the Saul framework
+var R=class{content;metadata;constructor(e){this.metadata=e||{name:"",size:0,type:""},this.content="";}encodeBase64(e){return Buffer.from(e).toString("base64")}decodeBase64(e){let t=Buffer.from(e,"base64"),r=new Uint8Array(t.length);return t.copy(r),r.buffer}read(){if(!this.content)throw new Error("File content is not set");return this.decodeBase64(this.content)}write(e){this.content=this.encodeBase64(e);}};var _=Symbol.for("@fidt/saul.FileStream"),P=class s{[_]=true;metadata;source;consumed=false;constructor(e,t){this.metadata=e,this.source=t;}stream(){if(this.consumed)throw new Error(`FILE_STREAM_CONSUMED: '${this.metadata.name}' \u0111\xE3 \u0111\u01B0\u1EE3c \u0111\u1ECDc r\u1ED3i \u2014 m\u1ED9t FileStream ch\u1EC9 ti\xEAu th\u1EE5 \u0111\u01B0\u1EE3c m\u1ED9t l\u1EA7n`);return this.consumed=true,this.source()}get isConsumed(){return this.consumed}async pipeTo(e){await pipeline(this.stream(),e);}async buffer(e){let t=[],r=0;for await(let n of this.stream()){let a=Buffer.isBuffer(n)?n:Buffer.from(n);if(r+=a.length,r>e)throw new Error(`FILE_STREAM_TOO_LARGE: '${this.metadata.name}' v\u01B0\u1EE3t ${e} byte khi buffer()`);t.push(a);}return Buffer.concat(t,r)}static is(e){return typeof e=="object"&&e!==null&&e[_]===true}static fromBuffer(e,t){return new s({...e,size:e.size??t.length},()=>Readable.from(t))}};var I=class s extends Error{code;constructor(e,t="SAUL_EXCEPTION"){super(e),this.name="SaulException",this.code=t,Object.setPrototypeOf(this,new.target.prototype);}static is(e){return e instanceof s||e instanceof Error&&e.name==="SaulException"}};var pe=(...s)=>{let e=s.filter(t=>!!t&&Object.keys(t).length>0);return e.length===0?{}:e.length===1?e[0]:{$and:e}};var c=class s extends Error{constructor(t,r){super(r);this.code=t;this.name="UploadError";}code;static is(t){return t instanceof s}},$={UPLOAD_NOT_FOUND:404,UPLOAD_EXISTS:409,UPLOAD_EXPIRED:410,UPLOAD_COMPLETED:409,UPLOAD_BUSY:409,PART_OUT_OF_RANGE:416,PART_IN_FLIGHT:409,PART_TOO_LARGE:413,PART_MISSING:422,SIZE_MISMATCH:422,CHECKSUM_MISMATCH:422,DISK_BUDGET:503,FORBIDDEN:403},O=s=>$[s]??500;var W=1024*1024,x=class{rootDir;fsync;constructor(e){this.rootDir=e.rootDir,this.fsync=e.fsync??true;}dirFor(e){return X(e),join(this.rootDir,e)}pathFor(e,t,r){return V(t,r),join(this.dirFor(e),`${String(t).padStart(6,"0")}.part`)}async ensureDir(e){await mkdir(this.dirFor(e),{recursive:true});}async writePart(e,t,r,n){let a=this.pathFor(e,t,n.partCount),o=`${a}.tmp`;await this.ensureDir(e);let i;try{i=await open(o,"wx");}catch(u){throw u?.code==="EEXIST"?new c("PART_IN_FLIGHT",`Part ${t} c\u1EE7a '${e}' \u0111ang \u0111\u01B0\u1EE3c ghi b\u1EDFi m\u1ED9t request kh\xE1c`):u}let p=createHash("sha256"),d=0,m=n.declaredLength!==void 0?Math.min(n.maxBytes,n.declaredLength):n.maxBytes,y=new Transform({transform(u,b,S){if(d+=u.length,d>m){S(new c("PART_TOO_LARGE",`Part ${t} v\u01B0\u1EE3t ${m} byte`));return}p.update(u),S(null,u);}});try{await pipeline(r,y,i.createWriteStream()),this.fsync&&await i.sync();}catch(u){throw await i.close().catch(()=>{}),await unlink(o).catch(()=>{}),u}if(await i.close(),n.declaredLength!==void 0&&d!==n.declaredLength)throw await unlink(o).catch(()=>{}),new c("SIZE_MISMATCH",`Part ${t}: nh\u1EADn ${d} byte, content-length khai ${n.declaredLength}`);let l=p.digest("hex");if(n.expectedSha256&&n.expectedSha256!==l)throw await unlink(o).catch(()=>{}),new c("CHECKSUM_MISMATCH",`Part ${t}: sha256 kh\xF4ng kh\u1EDBp (khai ${n.expectedSha256}, th\u1EADt ${l})`);return await rename(o,a),{size:d,etag:l}}createPartStream(e,t,r){return createReadStream(this.pathFor(e,t,r),{highWaterMark:W})}async listParts(e){let t;try{t=await readdir(this.dirFor(e));}catch(n){if(n?.code==="ENOENT")return [];throw n}let r=[];for(let n of t){let a=/^(\d{6})\.part$/.exec(n);if(!a)continue;let o=await stat(join(this.dirFor(e),n));r.push({partNumber:Number.parseInt(a[1],10),size:o.size});}return r.sort((n,a)=>n.partNumber-a.partNumber)}async removeUpload(e){let t=this.dirFor(e),r=0;try{for(let n of await readdir(t)){let a=await stat(join(t,n)).catch(()=>{});a&&(r+=a.size);}}catch(n){if(n?.code==="ENOENT")return 0;throw n}return await rm(t,{recursive:true,force:true}),r}async listStaleDirs(e,t=Date.now()){let r;try{r=await readdir(this.rootDir);}catch(a){if(a?.code==="ENOENT")return [];throw a}let n=[];for(let a of r){let o=await stat(join(this.rootDir,a)).catch(()=>{});o?.isDirectory()&&t-o.mtimeMs>e&&n.push(a);}return n}async totalBytes(){let e;try{e=await readdir(this.rootDir);}catch(r){if(r?.code==="ENOENT")return 0;throw r}let t=0;for(let r of e){let n=join(this.rootDir,r);if((await stat(n).catch(()=>{}))?.isDirectory())for(let o of await readdir(n).catch(()=>[])){let i=await stat(join(n,o)).catch(()=>{});i?.isFile()&&(t+=i.size);}}return t}};function X(s){if(!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(s))throw new c("FORBIDDEN",`uploadId kh\xF4ng h\u1EE3p l\u1EC7: '${s}'`)}function V(s,e){if(!Number.isSafeInteger(s)||s<1||s>e)throw new c("PART_OUT_OF_RANGE",`partNumber ${s} ngo\xE0i d\u1EA3i 1..${e}`)}var T="meta.json",D=class{records=new Map;store;maxDiskBytes;usedBytes=0;constructor(e){this.store=e.store,this.maxDiskBytes=e.maxDiskBytes;}get diskUsedBytes(){return this.usedBytes}setDiskUsedBytes(e){this.usedBytes=Math.max(0,e);}async init(e){if(this.records.has(e.uploadId))throw new c("UPLOAD_EXISTS",`Upload '${e.uploadId}' \u0111\xE3 t\u1ED3n t\u1EA1i`);if(this.usedBytes+e.file.size>this.maxDiskBytes)throw new c("DISK_BUDGET",`H\u1EBFt ng\xE2n s\xE1ch \u0111\u0129a (${this.usedBytes}/${this.maxDiskBytes} byte) \u2014 th\u1EED l\u1EA1i sau`);let t=Date.now(),r={...e,state:"open",createdAt:t,expiresAt:Math.min(t+e.idleTimeoutMs,e.hardExpiresAt)};return this.records.set(r.uploadId,r),await this.store.ensureDir(r.uploadId),await this.persist(r),r}get(e,t=["open"]){let r=this.records.get(e);if(!r)throw new c("UPLOAD_NOT_FOUND",`Upload '${e}' kh\xF4ng t\u1ED3n t\u1EA1i`);if(Date.now()>r.hardExpiresAt||Date.now()>r.expiresAt)throw new c("UPLOAD_EXPIRED",`Upload '${e}' \u0111\xE3 h\u1EBFt h\u1EA1n`);if(!t.includes(r.state))throw new c(r.state==="completed"?"UPLOAD_COMPLETED":"UPLOAD_BUSY",`Upload '${e}' \u0111ang \u1EDF tr\u1EA1ng th\xE1i '${r.state}'`);return r}peek(e){return this.records.get(e)}list(){return [...this.records.values()]}touch(e,t){let r=this.records.get(e);r&&(r.expiresAt=Math.min(Date.now()+r.idleTimeoutMs,r.hardExpiresAt),this.usedBytes=Math.max(0,this.usedBytes+t));}beginComplete(e){let t=this.get(e,["open"]);return t.state="completing",t}rollbackComplete(e){let t=this.records.get(e);t?.state==="completing"&&(t.state="open");}async remove(e){this.records.delete(e);let t=await this.store.removeUpload(e);this.usedBytes=Math.max(0,this.usedBytes-t);}async persist(e){let t=this.store.dirFor(e.uploadId),r=join(t,`${T}.tmp`);await writeFile(r,JSON.stringify(e),"utf-8"),await rename(r,join(t,T));}async readPersisted(e){try{let t=await readFile(join(this.store.dirFor(e),T),"utf-8");return JSON.parse(t)}catch{return}}};var U=class{registry;store;intervalMs;orphanGraceMs;reconcileEvery;timer;ticks=0;constructor(e){this.registry=e.registry,this.store=e.store,this.intervalMs=e.intervalMs??6e4,this.orphanGraceMs=e.orphanGraceMs??20*6e4,this.reconcileEvery=e.reconcileEvery??10;}start(){this.timer||(this.timer=setInterval(()=>{this.sweep().catch(e=>console.error("[saul][upload] sweep l\u1ED7i:",e));},this.intervalMs),typeof this.timer.unref=="function"&&this.timer.unref());}stop(){this.timer&&(clearInterval(this.timer),this.timer=void 0);}async sweep(e=Date.now()){let t={expired:0,orphans:0};for(let r of this.registry.list())(e>r.hardExpiresAt||e>r.expiresAt)&&(await this.registry.remove(r.uploadId),t.expired+=1);for(let r of await this.store.listStaleDirs(this.orphanGraceMs,e))this.registry.peek(r)||(await this.store.removeUpload(r).catch(()=>{}),t.orphans+=1);if(this.ticks+=1,this.ticks%this.reconcileEvery===0){let r=await this.store.totalBytes();this.registry.setDiskUsedBytes(r),t.reconciledBytes=r;}return t}};function v(s,e,t,r){async function*n(){for(let a of t){let o=s.createPartStream(e,a,r);try{for await(let i of o)yield i;}finally{o.destroy();}}}return Readable.from(n())}var M=(s,e)=>{let t=process.env[s],r=t?Number.parseInt(t,10):NaN;return Number.isFinite(r)&&r>0?r:e},ne=(s,e)=>{let t=process.env[s];return t===void 0?e:t==="true"||t==="1"};function Fe(s){let e=new x({rootDir:s.rootDir??process.env.SAUL_UPLOAD_TMP_DIR??join(tmpdir(),"saul-uploads"),fsync:s.fsync??ne("SAUL_UPLOAD_FSYNC",true)}),t=new D({store:e,maxDiskBytes:s.maxDiskBytes??M("SAUL_UPLOAD_MAX_DISK_BYTES",20*1024*1024*1024)}),r=new U({registry:t,store:e,intervalMs:s.sweepIntervalMs}),n=s.maxPartBytes??M("SAUL_UPLOAD_MAX_PART_BYTES",32*1024*1024),a=new Hono;return a.onError((o,i)=>c.is(o)?i.json({error:o.message,code:o.code},O(o.code)):(console.error("[saul][upload] l\u1ED7i kh\xF4ng x\xE1c \u0111\u1ECBnh:",o),i.json({error:o instanceof Error?o.message:String(o)},500))),a.post("/init",async o=>{let i=await o.req.json(),p=await t.init(i);return o.json({uploadId:p.uploadId,expiresAt:p.expiresAt})}),a.put("/:uploadId/part/:partNumber",async o=>{let i=o.req.param("uploadId"),p=Number(o.req.param("partNumber")),d=t.get(i),m=o.req.header("content-length");if(!m)throw new c("SIZE_MISMATCH","Thi\u1EBFu content-length \u2014 part ph\u1EA3i khai \u0111\u1ED9 d\xE0i");let y=(await e.listParts(i)).find(b=>b.partNumber===p),l=o.req.raw.body;if(!l)throw new c("SIZE_MISMATCH","Request kh\xF4ng c\xF3 body");let u=await e.writePart(i,p,Readable.fromWeb(l),{maxBytes:n,partCount:d.partCount,declaredLength:Number(m),expectedSha256:o.req.header("x-saul-part-sha256")});return t.touch(i,u.size-(y?.size??0)),o.json({partNumber:p,size:u.size,etag:u.etag})}),a.get("/:uploadId",async o=>{let i=o.req.param("uploadId"),p=t.get(i,["open","completing"]),d=await e.listParts(i);return o.json({uploadId:i,size:p.file.size,chunkSize:p.chunkSize,partCount:p.partCount,received:d,expiresAt:p.expiresAt})}),a.post("/:uploadId/complete",async o=>{let i=o.req.param("uploadId"),{ctx:p}=await o.req.json().catch(()=>({})),d=t.beginComplete(i);try{let m=await e.listParts(i),y=new Set(m.map(f=>f.partNumber)),l=[];for(let f=1;f<=d.partCount;f+=1)y.has(f)||l.push(f);if(l.length>0)throw new c("PART_MISSING",`Thi\u1EBFu part: ${l.slice(0,10).join(", ")}${l.length>10?"\u2026":""}`);let u=m.reduce((f,k)=>f+k.size,0);if(d.file.size>0&&u!==d.file.size)throw new c("SIZE_MISMATCH",`Nh\u1EADn ${u} byte, khai b\xE1o ${d.file.size}`);let b=m.map(f=>f.partNumber),S=new P(d.file,()=>v(e,i,b,d.partCount)),B=await s.dispatch({module:d.module,function:d.function,params:{...d.params,[d.param]:S,ctx:p}});return o.json(B)}catch(m){throw t.rollbackComplete(i),m}finally{t.peek(i)?.state!=="open"&&await t.remove(i).catch(()=>{});}}),a.delete("/:uploadId",async o=>(await t.remove(o.req.param("uploadId")).catch(()=>{}),o.body(null,204))),{router:a,registry:t,store:e,sweeper:r}}export{R as File,P as FileStream,x as PartDiskStore,I as SaulException,$ as UPLOAD_ERROR_STATUS,c as UploadError,D as UploadRegistry,U as UploadSweeper,V as assertSafePartNumber,X as assertSafeUploadId,v as concatParts,Fe as createUploadSubsystem,pe as narrow,O as uploadErrorStatus};//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map