fastify-txstate 3.6.6 → 3.6.8

package/lib/filestorage.d.ts

@@ -0,0 +1,31 @@
+import { type Readable } from 'stream';
+export interface FileHandler {
+    init: () => Promise<void>;
+    put: (stream: Readable) => Promise<{
+        checksum: string;
+        size: number;
+    }>;
+    get: (checksum: string) => Readable;
+    remove: (checksum: string) => Promise<void>;
+}
+export declare class FileSystemHandler implements FileHandler {
+    #private;
+    options: {
+        tmpdir: string;
+        permdir: string;
+    };
+    constructor(options?: {
+        tmpdir?: string;
+        permdir?: string;
+    });
+    init(): Promise<void>;
+    get(checksum: string): import("fs").ReadStream;
+    exists(checksum: string): Promise<boolean>;
+    fileSize(checksum: string): Promise<number>;
+    put(stream: Readable): Promise<{
+        checksum: string;
+        size: number;
+    }>;
+    remove(checksum: string): Promise<void>;
+}
+export declare const fileHandler: FileSystemHandler;

package/lib/filestorage.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileHandler = exports.FileSystemHandler = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const promises_2 = require("stream/promises");
+const txstate_utils_1 = require("txstate-utils");
+class FileSystemHandler {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            tmpdir: options.tmpdir ?? '/files/tmp/',
+            permdir: options.permdir ?? '/files/storage/'
+        };
+        if (!this.options.tmpdir.endsWith('/'))
+            this.options.tmpdir += '/';
+        if (!this.options.permdir.endsWith('/'))
+            this.options.permdir += '/';
+    }
+    #getTmpLocation() {
+        return `${this.options.tmpdir}${(0, txstate_utils_1.randomid)(12)}`;
+    }
+    #getFileLocation(checksum) {
+        return `${this.options.permdir}${checksum.slice(0, 1)}/${checksum.slice(1, 2)}/${checksum.slice(2)}`;
+    }
+    async #moveToPerm(tmp, checksum) {
+        const checksumpath = this.#getFileLocation(checksum);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(checksumpath), { recursive: true });
+        await (0, promises_1.rename)(tmp, checksumpath);
+    }
+    async init() {
+        await (0, promises_1.mkdir)(this.options.tmpdir, { recursive: true });
+        await (0, promises_1.mkdir)(this.options.permdir, { recursive: true });
+    }
+    get(checksum) {
+        const filepath = this.#getFileLocation(checksum);
+        const stream = (0, fs_1.createReadStream)(filepath);
+        return stream;
+    }
+    async exists(checksum) {
+        const filepath = this.#getFileLocation(checksum);
+        return (await (0, txstate_utils_1.rescue)((0, promises_1.access)(filepath, promises_1.constants.R_OK), false)) ?? true;
+    }
+    async fileSize(checksum) {
+        const filepath = this.#getFileLocation(checksum);
+        const info = await (0, promises_1.stat)(filepath);
+        return info.size;
+    }
+    async put(stream) {
+        const tmp = this.#getTmpLocation();
+        const hash = (0, crypto_1.createHash)('sha256');
+        let size = 0;
+        stream.on('data', (data) => { hash.update(data); size += data.length; });
+        try {
+            const out = (0, fs_1.createWriteStream)(tmp);
+            const flushedPromise = new Promise((resolve, reject) => {
+                out.on('close', resolve);
+                out.on('error', reject);
+            });
+            await (0, promises_2.pipeline)(stream, out);
+            await flushedPromise;
+            const checksum = hash.digest('base64url');
+            const rereadhash = (0, crypto_1.createHash)('sha256');
+            const read = (0, fs_1.createReadStream)(tmp);
+            for await (const chunk of read) {
+                rereadhash.update(chunk);
+            }
+            const rereadsum = rereadhash.digest('base64url');
+            if (rereadsum !== checksum)
+                throw new Error('File did not write to disk correctly. Please try uploading again.');
+            await this.#moveToPerm(tmp, checksum);
+            return { checksum, size };
+        }
+        catch (e) {
+            await (0, txstate_utils_1.rescue)((0, promises_1.unlink)(tmp));
+            throw e;
+        }
+    }
+    async remove(checksum) {
+        const filepath = this.#getFileLocation(checksum);
+        try {
+            await (0, promises_1.unlink)(filepath);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                console.warn('Tried to delete file with checksum', checksum, 'but it did not exist.');
+            else
+                console.warn(e);
+        }
+    }
+}
+exports.FileSystemHandler = FileSystemHandler;
+exports.fileHandler = new FileSystemHandler();

package/lib/index.d.ts

@@ -189,4 +189,6 @@ export default class Server {
 }
 export * from './analytics';
 export * from './error';
+export * from './filestorage';
 export * from './unified-auth';
+export * from './postformdata';

package/lib/index.js

@@ -417,4 +417,6 @@ this is log into this application and use dev tools to pull your token from the
 exports.default = Server;
 __exportStar(require("./analytics"), exports);
 __exportStar(require("./error"), exports);
+__exportStar(require("./filestorage"), exports);
 __exportStar(require("./unified-auth"), exports);
+__exportStar(require("./postformdata"), exports);

package/lib/postformdata.d.ts

@@ -0,0 +1,15 @@
+import { Readable } from 'node:stream';
+import { ReadableStream } from 'node:stream/web';
+export interface FormDataTextField {
+    name: string;
+    value: string;
+}
+export interface FormDataFileField {
+    name: string;
+    value: ReadableStream | Readable;
+    filename?: string;
+    filetype?: string;
+    filesize?: number;
+}
+export type FormDataField = FormDataTextField | FormDataFileField;
+export declare function postFormData(url: string, fields: FormDataField[], headers?: Record<string, any>): Promise<Response>;

package/lib/postformdata.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postFormData = postFormData;
+const node_stream_1 = require("node:stream");
+const web_1 = require("node:stream/web");
+async function postFormData(url, fields, headers = {}) {
+    const encoder = new TextEncoder();
+    const boundary = `${Math.random().toString(36).substring(2, 15)}${Math.random().toString(36).substring(2, 15)}`;
+    const footer = `--${boundary}--\r\n`;
+    const chunks = fields.map(field => new FormDataChunk(boundary, encoder, field));
+    const totalSize = chunks.some(chunk => chunk.contentsize == null) ? undefined : chunks.reduce((sum, chunk) => sum + chunk.extrasize + chunk.contentsize, 0);
+    headers = {
+        ...headers,
+        'Content-Type': `multipart/form-data; boundary=${boundary}`
+    };
+    if (totalSize) {
+        headers['Content-Length'] = totalSize.toString();
+    }
+    let i = 0;
+    let part = 'header';
+    const stream = new web_1.ReadableStream({
+        async pull(controller) {
+            if (i === chunks.length) {
+                controller.enqueue(encoder.encode(footer));
+                controller.close();
+            }
+            else {
+                const chunk = chunks[i];
+                if (part === 'header') {
+                    controller.enqueue(encoder.encode(chunk.header));
+                    part = 'content';
+                }
+                else if (part === 'content') {
+                    const { value, done } = await chunk.contentReader.read();
+                    if (done)
+                        part = 'footer';
+                    else
+                        controller.enqueue(value);
+                }
+                else if (part === 'footer') {
+                    controller.enqueue(encoder.encode(chunk.footer));
+                    i++;
+                    part = 'header';
+                }
+            }
+        },
+        cancel() {
+            for (const chunk of chunks) {
+                if (chunk.contentReader.cancel) {
+                    chunk.contentReader.cancel();
+                }
+            }
+        }
+    });
+    return await fetch(url, {
+        method: 'POST',
+        headers,
+        duplex: 'half',
+        body: stream
+    });
+}
+function isFileField(field) {
+    return 'filename' in field || 'filetype' in field || 'filesize' in field || (typeof field.value === 'object' && 'getReader' in field.value);
+}
+class FormDataChunk {
+    header;
+    footer;
+    extrasize;
+    contentsize;
+    contentReader;
+    constructor(boundary, encoder, field) {
+        this.header = `--${boundary}\r\nContent-Disposition: form-data; name="${field.name}"`;
+        this.footer = '\r\n';
+        if (isFileField(field)) {
+            this.header += `; filename="${field.filename ?? field.name}"\r\nContent-Type: ${field.filetype ?? 'application/octet-stream'}`;
+            this.contentsize = field.filesize;
+            this.contentReader = (field.value instanceof node_stream_1.Readable ? web_1.ReadableStream.from(field.value) : field.value).getReader();
+        }
+        else {
+            const encoded = encoder.encode(field.value);
+            this.contentsize = encoded.length;
+            this.contentReader = new web_1.ReadableStream({
+                start: controller => {
+                    controller.enqueue(encoded);
+                    controller.close();
+                }
+            }).getReader();
+        }
+        this.header += '\r\n\r\n';
+        this.extrasize = Buffer.byteLength(this.header) + Buffer.byteLength(this.footer);
+    }
+}

package/lib-esm/index.js

@@ -13,4 +13,8 @@ export const analyticsPlugin = ftxst.analyticsPlugin
 export const AnalyticsClient = ftxst.AnalyticsClient
 export const LoggingAnalyticsClient = ftxst.LoggingAnalyticsClient
 export const ElasticAnalyticsClient = ftxst.ElasticAnalyticsClient
+export const postFormData = ftxst.postFormData
+export const readableToWebReadable = ftxst.readableToWebReadable
+export const FileSystemHandler = ftxst.FileSystemHandler
+export const fileHandler = ftxst.fileHandler
 export default ftxst.default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-txstate",
-  "version": "3.6.6",
+  "version": "3.6.8",
   "description": "A small wrapper for fastify providing a set of common conventions & utility functions we use.",
   "exports": {
     ".": {
@@ -34,9 +34,10 @@
     "ua-parser-js": "^1.0.37"
   },
   "devDependencies": {
+    "@fastify/multipart": "^8.0.0",
     "@types/chai": "^4.2.14",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^22.0.0",
+    "@types/node": "^24.0.0",
     "axios": "^1.6.8",
     "chai": "^4.2.0",
     "eslint-config-standard-with-typescript": "^43.0.0",