@adonisjs/http-server 5.12.0 → 6.0.1-0

package/build/src/response.js

@@ -0,0 +1,587 @@
+import etag from 'etag';
+import vary from 'vary';
+import fresh from 'fresh';
+import mime from 'mime-types';
+import destroy from 'destroy';
+import { extname } from 'node:path';
+import onFinished from 'on-finished';
+import { promisify } from 'node:util';
+import json from '@poppinss/utils/json';
+import { Macroable } from '@poppinss/macroable';
+import { createReadStream, stat } from 'node:fs';
+import { RuntimeException } from '@poppinss/utils';
+import contentDisposition from 'content-disposition';
+import { Redirect } from './redirect.js';
+import { CookieSerializer } from './cookies/serializer.js';
+import { AbortException } from './exceptions/abort_exception.js';
+const statFn = promisify(stat);
+const CACHEABLE_HTTP_METHODS = ['GET', 'HEAD'];
+export class Response extends Macroable {
+    request;
+    response;
+    #qs;
+    #headers = {};
+    #hasExplicitStatus = false;
+    #cookieSerializer;
+    #router;
+    #config;
+    get hasLazyBody() {
+        return !!(this.lazyBody.content || this.lazyBody.fileToStream || this.lazyBody.stream);
+    }
+    get isStreamResponse() {
+        return !!(this.lazyBody.stream || this.lazyBody.fileToStream);
+    }
+    lazyBody = {};
+    ctx;
+    constructor(request, response, encryption, config, router, qs) {
+        super();
+        this.request = request;
+        this.response = response;
+        this.#qs = qs;
+        this.#config = config;
+        this.#router = router;
+        this.#cookieSerializer = new CookieSerializer(encryption);
+    }
+    get finished() {
+        return this.response.writableFinished;
+    }
+    get headersSent() {
+        return this.response.headersSent;
+    }
+    get isPending() {
+        return !this.headersSent && !this.finished;
+    }
+    #castHeaderValue(value) {
+        return Array.isArray(value) ? value.map(String) : String(value);
+    }
+    #endResponse(body, statusCode) {
+        this.flushHeaders(statusCode);
+        const res = this.response;
+        res.end(body, null, null);
+    }
+    #getDataType(content) {
+        if (Buffer.isBuffer(content)) {
+            return 'buffer';
+        }
+        if (content instanceof Date) {
+            return 'date';
+        }
+        if (content instanceof RegExp) {
+            return 'regexp';
+        }
+        const dataType = typeof content;
+        if (dataType === 'number' ||
+            dataType === 'boolean' ||
+            dataType === 'string' ||
+            dataType === 'bigint') {
+            return dataType;
+        }
+        if (dataType === 'object') {
+            return 'object';
+        }
+        throw new RuntimeException(`Cannot serialize "${dataType}" to HTTP response`);
+    }
+    writeBody(content, generateEtag, jsonpCallbackName) {
+        const hasEmptyBody = content === null || content === undefined || content === '';
+        if (hasEmptyBody) {
+            this.safeStatus(204);
+        }
+        const statusCode = this.response.statusCode;
+        if (statusCode && (statusCode < 200 || statusCode === 204 || statusCode === 304)) {
+            this.removeHeader('Content-Type');
+            this.removeHeader('Content-Length');
+            this.removeHeader('Transfer-Encoding');
+            this.#endResponse();
+            return;
+        }
+        if (hasEmptyBody) {
+            this.removeHeader('Content-Length');
+            this.#endResponse();
+            return;
+        }
+        const dataType = this.#getDataType(content);
+        if (dataType === 'object') {
+            content = json.safeStringify(content);
+        }
+        else if (dataType === 'number' ||
+            dataType === 'boolean' ||
+            dataType === 'bigint' ||
+            dataType === 'regexp') {
+            content = String(content);
+        }
+        else if (dataType === 'date') {
+            content = content.toISOString();
+        }
+        if (jsonpCallbackName) {
+            content = content.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+            content = `/**/ typeof ${jsonpCallbackName} === 'function' && ${jsonpCallbackName}(${content});`;
+        }
+        if (generateEtag) {
+            this.setEtag(content);
+        }
+        if (generateEtag && this.fresh()) {
+            this.removeHeader('Content-Type');
+            this.removeHeader('Content-Length');
+            this.removeHeader('Transfer-Encoding');
+            this.#endResponse(null, 304);
+            return;
+        }
+        this.header('Content-Length', Buffer.byteLength(content));
+        if (jsonpCallbackName) {
+            this.header('X-Content-Type-Options', 'nosniff');
+            this.safeHeader('Content-Type', 'text/javascript; charset=utf-8');
+        }
+        else {
+            switch (dataType) {
+                case 'string':
+                    const type = /^\s*</.test(content) ? 'text/html' : 'text/plain';
+                    this.safeHeader('Content-Type', `${type}; charset=utf-8`);
+                    break;
+                case 'number':
+                case 'boolean':
+                case 'date':
+                case 'bigint':
+                case 'regexp':
+                    this.safeHeader('Content-Type', 'text/plain; charset=utf-8');
+                    break;
+                case 'buffer':
+                    this.safeHeader('Content-Type', 'application/octet-stream; charset=utf-8');
+                    break;
+                case 'object':
+                    this.safeHeader('Content-Type', 'application/json; charset=utf-8');
+                    break;
+            }
+        }
+        this.#endResponse(content);
+    }
+    streamBody(body, errorCallback) {
+        return new Promise((resolve) => {
+            let finished = false;
+            body.on('error', (error) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                destroy(body);
+                this.type('text');
+                if (typeof errorCallback === 'function') {
+                    this.#endResponse(...errorCallback(error));
+                }
+                else {
+                    this.#endResponse(error.code === 'ENOENT' ? 'File not found' : 'Cannot process file', error.code === 'ENOENT' ? 404 : 500);
+                    resolve();
+                }
+            });
+            body.on('end', resolve);
+            onFinished(this.response, () => {
+                finished = true;
+                destroy(body);
+            });
+            this.flushHeaders();
+            body.pipe(this.response);
+        });
+    }
+    async streamFileForDownload(filePath, generateEtag, errorCallback) {
+        try {
+            const stats = await statFn(filePath);
+            if (!stats || !stats.isFile()) {
+                throw new TypeError('response.download only accepts path to a file');
+            }
+            this.header('Last-Modified', stats.mtime.toUTCString());
+            this.type(extname(filePath));
+            if (generateEtag) {
+                this.setEtag(stats, true);
+            }
+            if (this.request.method === 'HEAD') {
+                this.#endResponse(null, generateEtag && this.fresh() ? 304 : 200);
+                return;
+            }
+            if (generateEtag && this.fresh()) {
+                this.#endResponse(null, 304);
+                return;
+            }
+            this.header('Content-length', stats.size);
+            return this.streamBody(createReadStream(filePath), errorCallback);
+        }
+        catch (error) {
+            this.type('text');
+            this.removeHeader('Etag');
+            if (typeof errorCallback === 'function') {
+                this.#endResponse(...errorCallback(error));
+            }
+            else {
+                this.#endResponse(error.code === 'ENOENT' ? 'File not found' : 'Cannot process file', error.code === 'ENOENT' ? 404 : 500);
+            }
+        }
+    }
+    flushHeaders(statusCode) {
+        this.response.writeHead(statusCode || this.response.statusCode, this.#headers);
+        return this;
+    }
+    getHeader(key) {
+        const value = this.#headers[key.toLowerCase()];
+        return value === undefined ? this.response.getHeader(key) : value;
+    }
+    getHeaders() {
+        return {
+            ...this.response.getHeaders(),
+            ...this.#headers,
+        };
+    }
+    header(key, value) {
+        if (value === null || value === undefined) {
+            return this;
+        }
+        this.#headers[key.toLowerCase()] = this.#castHeaderValue(value);
+        return this;
+    }
+    append(key, value) {
+        if (value === null || value === undefined) {
+            return this;
+        }
+        key = key.toLowerCase();
+        let existingHeader = this.getHeader(key);
+        let casted = this.#castHeaderValue(value);
+        if (!existingHeader) {
+            this.#headers[key] = casted;
+            return this;
+        }
+        existingHeader = this.#castHeaderValue(existingHeader);
+        casted = Array.isArray(existingHeader)
+            ? existingHeader.concat(casted)
+            : [existingHeader].concat(casted);
+        this.#headers[key] = casted;
+        return this;
+    }
+    safeHeader(key, value) {
+        if (!this.getHeader(key)) {
+            this.header(key, value);
+        }
+        return this;
+    }
+    removeHeader(key) {
+        key = key.toLowerCase();
+        if (this.#headers[key]) {
+            delete this.#headers[key.toLowerCase()];
+        }
+        return this;
+    }
+    getStatus() {
+        return this.response.statusCode;
+    }
+    status(code) {
+        this.#hasExplicitStatus = true;
+        this.response.statusCode = code;
+        return this;
+    }
+    safeStatus(code) {
+        if (this.#hasExplicitStatus) {
+            return this;
+        }
+        this.response.statusCode = code;
+        return this;
+    }
+    type(type, charset) {
+        type = charset ? `${type}; charset=${charset}` : type;
+        this.header('Content-Type', mime.contentType(type));
+        return this;
+    }
+    vary(field) {
+        vary(this.response, field);
+        return this;
+    }
+    setEtag(body, weak = false) {
+        this.header('Etag', etag(body, { weak }));
+        return this;
+    }
+    fresh() {
+        if (this.request.method && !CACHEABLE_HTTP_METHODS.includes(this.request.method)) {
+            return false;
+        }
+        const status = this.response.statusCode;
+        if ((status >= 200 && status < 300) || status === 304) {
+            return fresh(this.request.headers, this.#headers);
+        }
+        return false;
+    }
+    getBody() {
+        if (this.lazyBody.content) {
+            return this.lazyBody.content[0];
+        }
+        return null;
+    }
+    send(body, generateEtag = this.#config.etag) {
+        this.lazyBody.content = [body, generateEtag];
+    }
+    json(body, generateEtag = this.#config.etag) {
+        return this.send(body, generateEtag);
+    }
+    jsonp(body, callbackName = this.#config.jsonpCallbackName, generateEtag = this.#config.etag) {
+        this.lazyBody.content = [body, generateEtag, callbackName];
+    }
+    stream(body, errorCallback) {
+        if (typeof body.pipe !== 'function' || !body.readable || typeof body.read !== 'function') {
+            throw new TypeError('response.stream accepts a readable stream only');
+        }
+        this.lazyBody.stream = [body, errorCallback];
+    }
+    download(filePath, generateEtag = this.#config.etag, errorCallback) {
+        this.lazyBody.fileToStream = [filePath, generateEtag, errorCallback];
+    }
+    attachment(filePath, name, disposition, generateEtag, errorCallback) {
+        name = name || filePath;
+        this.header('Content-Disposition', contentDisposition(name, { type: disposition }));
+        return this.download(filePath, generateEtag, errorCallback);
+    }
+    location(url) {
+        this.header('Location', url);
+        return this;
+    }
+    redirect(path, forwardQueryString = false, statusCode = 302) {
+        const handler = new Redirect(this.request, this, this.#router, this.#qs);
+        if (forwardQueryString) {
+            handler.withQs();
+        }
+        if (path === 'back') {
+            return handler.status(statusCode).back();
+        }
+        if (path) {
+            return handler.status(statusCode).toPath(path);
+        }
+        return handler;
+    }
+    abort(body, status) {
+        throw AbortException.invoke(body, status || 400);
+    }
+    abortIf(condition, body, status) {
+        if (condition) {
+            this.abort(body, status);
+        }
+    }
+    abortUnless(condition, body, status) {
+        if (!condition) {
+            this.abort(body, status);
+        }
+    }
+    cookie(key, value, options) {
+        options = Object.assign({}, this.#config.cookie, options);
+        const serialized = this.#cookieSerializer.sign(key, value, options);
+        if (!serialized) {
+            return this;
+        }
+        this.append('set-cookie', serialized);
+        return this;
+    }
+    encryptedCookie(key, value, options) {
+        options = Object.assign({}, this.#config.cookie, options);
+        const serialized = this.#cookieSerializer.encrypt(key, value, options);
+        if (!serialized) {
+            return this;
+        }
+        this.append('set-cookie', serialized);
+        return this;
+    }
+    plainCookie(key, value, options) {
+        options = Object.assign({}, this.#config.cookie, options);
+        const serialized = this.#cookieSerializer.encode(key, value, options);
+        if (!serialized) {
+            return this;
+        }
+        this.append('set-cookie', serialized);
+        return this;
+    }
+    clearCookie(key, options) {
+        options = Object.assign({}, this.#config.cookie, options);
+        options.expires = new Date(1);
+        options.maxAge = -1;
+        const serialized = this.#cookieSerializer.encode(key, '', { ...options, encode: false });
+        this.append('set-cookie', serialized);
+        return this;
+    }
+    finish() {
+        if (!this.isPending) {
+            return;
+        }
+        if (this.lazyBody.content) {
+            this.writeBody(...this.lazyBody.content);
+            return;
+        }
+        if (this.lazyBody.stream) {
+            this.streamBody(...this.lazyBody.stream);
+            return;
+        }
+        if (this.lazyBody.fileToStream) {
+            this.streamFileForDownload(...this.lazyBody.fileToStream);
+            return;
+        }
+        this.#endResponse();
+    }
+    continue() {
+        this.status(100);
+        return this.send(null, false);
+    }
+    switchingProtocols() {
+        this.status(101);
+        return this.send(null, false);
+    }
+    ok(body, generateEtag) {
+        this.status(200);
+        return this.send(body, generateEtag);
+    }
+    created(body, generateEtag) {
+        this.status(201);
+        return this.send(body, generateEtag);
+    }
+    accepted(body, generateEtag) {
+        this.status(202);
+        return this.send(body, generateEtag);
+    }
+    nonAuthoritativeInformation(body, generateEtag) {
+        this.status(203);
+        return this.send(body, generateEtag);
+    }
+    noContent() {
+        this.status(204);
+        return this.send(null, false);
+    }
+    resetContent() {
+        this.status(205);
+        return this.send(null, false);
+    }
+    partialContent(body, generateEtag) {
+        this.status(206);
+        return this.send(body, generateEtag);
+    }
+    multipleChoices(body, generateEtag) {
+        this.status(300);
+        return this.send(body, generateEtag);
+    }
+    movedPermanently(body, generateEtag) {
+        this.status(301);
+        return this.send(body, generateEtag);
+    }
+    movedTemporarily(body, generateEtag) {
+        this.status(302);
+        return this.send(body, generateEtag);
+    }
+    seeOther(body, generateEtag) {
+        this.status(303);
+        return this.send(body, generateEtag);
+    }
+    notModified(body, generateEtag) {
+        this.status(304);
+        return this.send(body, generateEtag);
+    }
+    useProxy(body, generateEtag) {
+        this.status(305);
+        return this.send(body, generateEtag);
+    }
+    temporaryRedirect(body, generateEtag) {
+        this.status(307);
+        return this.send(body, generateEtag);
+    }
+    badRequest(body, generateEtag) {
+        this.status(400);
+        return this.send(body, generateEtag);
+    }
+    unauthorized(body, generateEtag) {
+        this.status(401);
+        return this.send(body, generateEtag);
+    }
+    paymentRequired(body, generateEtag) {
+        this.status(402);
+        return this.send(body, generateEtag);
+    }
+    forbidden(body, generateEtag) {
+        this.status(403);
+        return this.send(body, generateEtag);
+    }
+    notFound(body, generateEtag) {
+        this.status(404);
+        return this.send(body, generateEtag);
+    }
+    methodNotAllowed(body, generateEtag) {
+        this.status(405);
+        return this.send(body, generateEtag);
+    }
+    notAcceptable(body, generateEtag) {
+        this.status(406);
+        return this.send(body, generateEtag);
+    }
+    proxyAuthenticationRequired(body, generateEtag) {
+        this.status(407);
+        return this.send(body, generateEtag);
+    }
+    requestTimeout(body, generateEtag) {
+        this.status(408);
+        return this.send(body, generateEtag);
+    }
+    conflict(body, generateEtag) {
+        this.status(409);
+        return this.send(body, generateEtag);
+    }
+    gone(body, generateEtag) {
+        this.status(410);
+        return this.send(body, generateEtag);
+    }
+    lengthRequired(body, generateEtag) {
+        this.status(411);
+        return this.send(body, generateEtag);
+    }
+    preconditionFailed(body, generateEtag) {
+        this.status(412);
+        return this.send(body, generateEtag);
+    }
+    requestEntityTooLarge(body, generateEtag) {
+        this.status(413);
+        return this.send(body, generateEtag);
+    }
+    requestUriTooLong(body, generateEtag) {
+        this.status(414);
+        return this.send(body, generateEtag);
+    }
+    unsupportedMediaType(body, generateEtag) {
+        this.status(415);
+        return this.send(body, generateEtag);
+    }
+    requestedRangeNotSatisfiable(body, generateEtag) {
+        this.status(416);
+        return this.send(body, generateEtag);
+    }
+    expectationFailed(body, generateEtag) {
+        this.status(417);
+        return this.send(body, generateEtag);
+    }
+    unprocessableEntity(body, generateEtag) {
+        this.status(422);
+        return this.send(body, generateEtag);
+    }
+    tooManyRequests(body, generateEtag) {
+        this.status(429);
+        return this.send(body, generateEtag);
+    }
+    internalServerError(body, generateEtag) {
+        this.status(500);
+        return this.send(body, generateEtag);
+    }
+    notImplemented(body, generateEtag) {
+        this.status(501);
+        return this.send(body, generateEtag);
+    }
+    badGateway(body, generateEtag) {
+        this.status(502);
+        return this.send(body, generateEtag);
+    }
+    serviceUnavailable(body, generateEtag) {
+        this.status(503);
+        return this.send(body, generateEtag);
+    }
+    gatewayTimeout(body, generateEtag) {
+        this.status(504);
+        return this.send(body, generateEtag);
+    }
+    httpVersionNotSupported(body, generateEtag) {
+        this.status(505);
+        return this.send(body, generateEtag);
+    }
+}

package/build/src/router/brisk.d.ts

@@ -0,0 +1,18 @@
+import { Macroable } from '@poppinss/macroable';
+import type { Application } from '@adonisjs/application';
+import { Route } from './route.js';
+import type { LazyImport } from '../types/base.js';
+import type { MiddlewareStore } from '../middleware/store.js';
+import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/route.js';
+export declare class BriskRoute<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+    #private;
+    route: null | Route<NamedMiddleware>;
+    constructor(app: Application<any, any, any>, middlewareStore: MiddlewareStore<NamedMiddleware>, options: {
+        pattern: string;
+        globalMatchers: RouteMatchers;
+    });
+    setHandler(handler: RouteFn): Route;
+    redirect(identifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): Route;
+    redirectToPath(url: string): Route;
+}

package/build/src/router/brisk.js

@@ -0,0 +1,35 @@
+import { Macroable } from '@poppinss/macroable';
+import { Route } from './route.js';
+export class BriskRoute extends Macroable {
+    #pattern;
+    #globalMatchers;
+    #app;
+    #middlewareStore;
+    route = null;
+    constructor(app, middlewareStore, options) {
+        super();
+        this.#app = app;
+        this.#middlewareStore = middlewareStore;
+        this.#pattern = options.pattern;
+        this.#globalMatchers = options.globalMatchers;
+    }
+    setHandler(handler) {
+        this.route = new Route(this.#app, this.#middlewareStore, {
+            pattern: this.#pattern,
+            globalMatchers: this.#globalMatchers,
+            methods: ['GET', 'HEAD'],
+            handler: handler,
+        });
+        return this.route;
+    }
+    redirect(identifier, params, options) {
+        return this.setHandler(async (ctx) => {
+            return ctx.response.redirect().toRoute(identifier, params || ctx.params, options);
+        });
+    }
+    redirectToPath(url) {
+        return this.setHandler(async (ctx) => {
+            return ctx.response.redirect().toPath(url);
+        });
+    }
+}

package/build/src/router/executor.d.ts

@@ -0,0 +1,4 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { StoreRouteNode } from '../types/route.js';
+import type { HttpContext } from '../http_context/main.js';
+export declare function execute(route: StoreRouteNode, resolver: ContainerResolver<any>, ctx: HttpContext): Promise<void>;

package/build/src/router/executor.js

@@ -0,0 +1,16 @@
+export function execute(route, resolver, ctx) {
+    return route.middleware
+        .runner()
+        .finalHandler(() => {
+        if (typeof route.handler === 'function') {
+            return route.handler(ctx);
+        }
+        return route.handler.handle(resolver, ctx);
+    })
+        .run((middleware, next) => {
+        if (typeof middleware === 'function') {
+            return middleware(ctx, next);
+        }
+        return middleware.handle(resolver, ctx, next, middleware.args);
+    });
+}

package/build/src/router/group.d.ts

@@ -0,0 +1,19 @@
+import { Macroable } from '@poppinss/macroable';
+import type { MiddlewareStore } from '../middleware/store.js';
+import type { LazyImport, UnWrapLazyImport } from '../types/base.js';
+import type { RouteMatcher } from '../types/route.js';
+import type { GetMiddlewareArgs, MiddlewareAsClass, MiddlewareFn } from '../types/middleware.js';
+import { Route } from './route.js';
+import { BriskRoute } from './brisk.js';
+import { RouteResource } from './resource.js';
+export declare class RouteGroup<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+    #private;
+    routes: (Route | RouteGroup | RouteResource | BriskRoute)[];
+    constructor(routes: (Route | RouteGroup | RouteResource | BriskRoute)[], middlewareStore: MiddlewareStore<NamedMiddleware>);
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    prefix(prefix: string): this;
+    domain(domain: string): this;
+    as(name: string): this;
+    middleware<Name extends keyof NamedMiddleware>(middleware: Name, ...args: GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>): this;
+    middleware(middleware: MiddlewareFn): this;
+}