fastify-txstate 3.6.9 → 4.0.1

package/lib/error.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationErrors = exports.ValidationError = exports.FailedValidationError = exports.HttpError = void 0;
-exports.fstValidationToMessage = fstValidationToMessage;
-const http_status_codes_1 = require("http-status-codes");
-class HttpError extends Error {
+import { getReasonPhrase } from 'http-status-codes';
+export class HttpError extends Error {
     statusCode;
     constructor(statusCode, message) {
         if (!message) {
@@ -12,28 +8,13 @@ class HttpError extends Error {
             else if (statusCode === 403)
                 message = 'You are not authorized for that.';
             else
-                message = (0, http_status_codes_1.getReasonPhrase)(statusCode);
+                message = getReasonPhrase(statusCode);
         }
         super(message);
         this.statusCode = statusCode;
     }
 }
-exports.HttpError = HttpError;
-/**
- * @deprecated This response format is less flexible than the one based on the ValidationMessage
- * interface. Use ValidationError or ValidationErrors instead, and adjust the client to expect
- * the new format.
- */
-class FailedValidationError extends HttpError {
-    errors;
-    constructor(errors) {
-        super(422, 'Validation failure.');
-        this.errors = errors;
-        this.errors = errors;
-    }
-}
-exports.FailedValidationError = FailedValidationError;
-class ValidationError extends HttpError {
+export class ValidationError extends HttpError {
     path;
     type;
     constructor(message, path, type) {
@@ -42,16 +23,14 @@ class ValidationError extends HttpError {
         this.type = type;
     }
 }
-exports.ValidationError = ValidationError;
-class ValidationErrors extends HttpError {
+export class ValidationErrors extends HttpError {
     errors;
     constructor(errors) {
         super(422, errors[0]?.message);
         this.errors = errors;
     }
 }
-exports.ValidationErrors = ValidationErrors;
-function fstValidationToMessage(v) {
+export function fstValidationToMessage(v) {
     const instancePath = v.keyword === 'required' ? v.instancePath + '/' + v.params.missingProperty : v.instancePath;
-    return { message: v.message, path: instancePath.substring(1).replace(/\//g, '.'), type: 'error' };
+    return { message: v.message, path: instancePath.substring(1).replace(/\//gv, '.'), type: 'error' };
 }

package/lib/filestorage.d.ts

@@ -1,4 +1,4 @@
-import { type Readable } from 'stream';
+import type { Readable } from 'node:stream';
 export interface FileHandler {
     init: () => Promise<void>;
     put: (stream: Readable) => Promise<{

package/lib/filestorage.js

@@ -1,13 +1,10 @@
-"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 {
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { access, constants, mkdir, rename, unlink, stat } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { rescue, randomid } from 'txstate-utils';
+export class FileSystemHandler {
     options;
     constructor(options = {}) {
         this.options = {
@@ -20,50 +17,50 @@ class FileSystemHandler {
             this.options.permdir += '/';
     }
     #getTmpLocation() {
-        return `${this.options.tmpdir}${(0, txstate_utils_1.randomid)(12)}`;
+        return `${this.options.tmpdir}${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);
+        await mkdir(dirname(checksumpath), { recursive: true });
+        await 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 });
+        await mkdir(this.options.tmpdir, { recursive: true });
+        await mkdir(this.options.permdir, { recursive: true });
     }
     get(checksum) {
         const filepath = this.#getFileLocation(checksum);
-        const stream = (0, fs_1.createReadStream)(filepath);
+        const stream = 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;
+        return (await rescue(access(filepath, constants.R_OK), false)) !== false;
     }
     async fileSize(checksum) {
         const filepath = this.#getFileLocation(checksum);
-        const info = await (0, promises_1.stat)(filepath);
+        const info = await stat(filepath);
         return info.size;
     }
     async put(stream) {
         const tmp = this.#getTmpLocation();
-        const hash = (0, crypto_1.createHash)('sha256');
+        const hash = createHash('sha256');
         let size = 0;
         stream.on('data', (data) => { hash.update(data); size += data.length; });
         try {
-            const out = (0, fs_1.createWriteStream)(tmp);
+            const out = createWriteStream(tmp);
             const flushedPromise = new Promise((resolve, reject) => {
                 out.on('close', resolve);
                 out.on('error', reject);
             });
-            await (0, promises_2.pipeline)(stream, out);
+            await pipeline(stream, out);
             await flushedPromise;
             const checksum = hash.digest('base64url');
-            const rereadhash = (0, crypto_1.createHash)('sha256');
-            const read = (0, fs_1.createReadStream)(tmp);
+            const rereadhash = createHash('sha256');
+            const read = createReadStream(tmp);
             for await (const chunk of read) {
                 rereadhash.update(chunk);
             }
@@ -74,22 +71,21 @@ class FileSystemHandler {
             return { checksum, size };
         }
         catch (e) {
-            await (0, txstate_utils_1.rescue)((0, promises_1.unlink)(tmp));
+            await rescue(unlink(tmp));
             throw e;
         }
     }
     async remove(checksum) {
         const filepath = this.#getFileLocation(checksum);
         try {
-            await (0, promises_1.unlink)(filepath);
+            await 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);
+            const err = e;
+            if (err.code === 'ENOENT')
+                return; // file already gone, nothing to do
+            throw e;
         }
     }
 }
-exports.FileSystemHandler = FileSystemHandler;
-exports.fileHandler = new FileSystemHandler();
+export const fileHandler = new FileSystemHandler();

package/lib/index.d.ts

@@ -1,194 +1,9 @@
-import { type FastifyDynamicSwaggerOptions } from '@fastify/swagger';
-import { type FastifySwaggerUiOptions } from '@fastify/swagger-ui';
-import type { JsonSchemaToTsProvider } from '@fastify/type-provider-json-schema-to-ts';
-import { type FastifyInstance, type FastifyRequest, type FastifyReply, type FastifyServerOptions, type FastifyLoggerOptions, type FastifyBaseLogger, type RawServerDefault } from 'fastify';
-import http from 'node:http';
-import type http2 from 'node:http2';
-type ErrorHandler = (error: Error, req: FastifyRequest, res: FastifyReply) => Promise<void>;
-export interface FastifyTxStateAuthInfo {
-    /**
-     * The primary identifier for the user that is making the request, after processing
-     * their session token / JWT.
-     */
-    username: string;
-    /**
-     * This should be an identifier for the particular session, so that the same user
-     * on different devices/browsers/tabs can be distinguished from one another.
-     *
-     * It should NOT be usable as a cookie or bearer token, as it will appear in logs. If you
-     * use JSON Web Tokens, an easy thing is to combine the username with the `iat` issued
-     * date to create something unique but not useful to attackers.
-     *
-     * For lookup tokens, you can do the same `${username}-${createdAt}` after looking up
-     * the session in your database.
-     *
-     * If all else fails, you can sha256 the session token with a salt.
-     */
-    sessionId: string;
-    /**
-     * The date that the session was created, if available. This is useful for considering
-     * tokens before a certain date as invalid. For instance, if you want a logout action
-     * to invalidate all tokens created until that point, you can compare this field against
-     * the last time they logged out.
-     */
-    sessionCreatedAt?: Date;
-    /**
-     * Some authentication systems allow administrators to impersonate regular users, so that
-     * they can see what that user sees and troubleshoot issues. We still want to log the administrator
-     * with any actions they take while impersonating someone, for auditing purposes, so you should
-     * fill this field when applicable.
-     *
-     * This will also be available at `req.auth.impersonatedBy`, so it is possible for your API
-     * to implement complicated authorization rules based on whether a user is being impersonated.
-     * It sort of defeats the purpose of impersonation, but used sparingly it could prevent administrators
-     * from making mistakes.
-     */
-    impersonatedBy?: string;
-    /**
-     * If your API may be accessed by a different client application, such that the user is actually logged
-     * into that application instead of yours, but you accept that application's session tokens, filling
-     * this field can help log requests that are authenticated with the other application's token.
-     */
-    clientId?: string;
-    /**
-     * A string that designates the current session as one that has limited authorization. The application will
-     * be responsible for checking this field and restricting appropriately.
-     *
-     * For example, a user who authenticated via non-standard mechanism might be given a scope of 'altlogin' and
-     * only a portion of the application's functionality would be available to them.
-     */
-    scope?: string;
-    /**
-     * The token or key that was used to authenticate the request. This is useful for
-     * making sub-requests to other APIs that can authenticate with the same token.
-     */
-    token: string;
-    /**
-     * The issuer configuration for the token, if applicable. This helps you generate
-     * a proper logout url in multi-issuer environments.
-     */
-    issuerConfig?: IssuerConfig;
-}
-export interface IssuerConfig {
-    iss: string;
-    url?: string;
-    publicKey?: string;
-    secret?: string;
-    validateUrl?: URL;
-    logoutUrl?: URL;
-}
-export interface FastifyTxStateOptions extends Partial<FastifyServerOptions> {
-    https?: http2.SecureServerOptions;
-    validOrigins?: string[];
-    validOriginHosts?: string[];
-    validOriginSuffixes?: string[];
-    skipOriginCheck?: boolean;
-    checkOrigin?: (req: FastifyRequest) => boolean;
-    /**
-     * Run an asynchronous function to check the health of the service.
-     *
-     * Return a non-empty error message to trigger unhealthy status.
-     *
-     * Setting a health message with setUnhealthy will override this and prevent it from being executed.
-     */
-    checkHealth?: () => Promise<string | {
-        status?: number;
-        message?: string;
-    } | undefined>;
-    /**
-     * Run an async function to get authentication information out of the request
-     * object. Should return an object with at least a username and sessionid (see FastifyTxStateAuthInfo
-     * for further detail).
-     *
-     * The return object will be added to the request object as `req.auth` for later
-     * use in your route handlers. It will also be added to the logs in production.
-     *
-     * IMPORTANT: It is not advisable to return excessive amounts of data here, nor anything
-     * particularly sensitive, since it will all be included in every log entry.
-     *
-     * If this function throws, the client will receive a 401 response.
-     */
-    authenticate?: (req: FastifyRequest) => Promise<FastifyTxStateAuthInfo | undefined>;
-}
-declare module 'fastify' {
-    interface FastifyRequest {
-        auth?: FastifyTxStateAuthInfo;
-        /**
-         * @deprecated Use `req.auth.token` instead. Just trying to keep everything contained.
-         * This will be removed in the next major version.
-         */
-        token?: string;
-    }
-    interface FastifyReply {
-        extraLogInfo: any;
-    }
-}
-export declare const devLogger: {
-    level: string;
-    info: (msg: any) => void;
-    error: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    debug: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    fatal: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    warn: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    trace: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    silent: (msg: any) => void;
-    child(bindings: any, options?: any): /*elided*/ any;
-};
-export declare const prodLogger: FastifyLoggerOptions;
-export type FastifyInstanceTyped = FastifyInstance<RawServerDefault, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, FastifyBaseLogger, JsonSchemaToTsProvider>;
-export type TxServer = Server;
-export default class Server {
-    protected config: FastifyTxStateOptions & {
-        http2?: true;
-    };
-    protected https: boolean;
-    protected errorHandlers: ErrorHandler[];
-    protected healthMessage?: string;
-    protected healthCallback?: () => Promise<string | {
-        status?: number;
-        message?: string;
-    } | undefined>;
-    protected shuttingDown: boolean;
-    protected sigHandler: (signal: any) => void;
-    protected validOrigins: Record<string, boolean>;
-    protected validOriginHosts: Record<string, boolean>;
-    protected validOriginSuffixes: Set<string>;
-    protected swaggerEndpoint: string | undefined;
-    app: FastifyInstanceTyped;
-    constructor(config?: FastifyTxStateOptions & {
-        http2?: true;
-    });
-    start(port?: number): Promise<void>;
-    addErrorHandler(handler: ErrorHandler): void;
-    setUnhealthy(message: string): void;
-    setHealthy(): void;
-    setValidOrigins(origins: string[]): void;
-    setValidOriginHosts(hosts: string[]): void;
-    setValidOriginSuffixes(suffixes: string[]): void;
-    swagger(opts?: {
-        path?: string;
-        openapi?: FastifyDynamicSwaggerOptions['openapi'];
-        ui?: FastifySwaggerUiOptions;
-    }): Promise<void>;
-    close(softSeconds?: number): Promise<void>;
-}
-export * from './analytics';
-export * from './error';
-export * from './filestorage';
-export * from './unified-auth';
-export * from './postformdata';
+export { default } from './server.ts';
+export * from './server.ts';
+export * from './analytics.ts';
+export * from './error.ts';
+export * from './filestorage.ts';
+export * from './jwt-auth.ts';
+export * from './unified-auth.ts';
+export * from './oauth.ts';
+export * from './postformdata.ts';