yedra 0.9.0 → 0.9.2

package/dist/routing/app.d.ts

@@ -0,0 +1,50 @@
+import { type Context } from './listen';
+import type { Path } from './path';
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
+type HttpReq = {
+    method: string;
+    url: string;
+    query: Record<string, string | undefined>;
+    headers: Record<string, string | undefined>;
+    body: Uint8Array;
+};
+type HttpRes = {
+    status: number;
+    body: Uint8Array;
+    headers: Record<string, string>;
+};
+export type Endpoint = {
+    method: Method;
+    path: Path;
+    handle: (req: HttpReq, params: Record<string, string>) => Promise<HttpRes>;
+    documentation: () => object;
+};
+export declare class App {
+    private endpoints;
+    constructor(endpoints: Endpoint[]);
+    /**
+     * Handle an HTTP request.
+     * @param req - The HTTP request.
+     * @returns The HTTP response.
+     */
+    handle(req: HttpReq): Promise<HttpRes>;
+    /**
+     * Generate OpenAPI documentation for the app.
+     */
+    docs(options: {
+        info: {
+            title: string;
+            description: string;
+            version: string;
+        };
+        servers: {
+            description: string;
+            url: string;
+        }[];
+    }): object;
+    listen(port: number): Context;
+    private static errorResponse;
+    private matchEndpoint;
+}
+export declare const app: (routes: string) => Promise<App>;
+export {};

package/dist/routing/app.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = exports.App = void 0;
+const glob_1 = require("glob");
+const errors_1 = require("./errors");
+const listen_1 = require("./listen");
+class App {
+    constructor(endpoints) {
+        this.endpoints = endpoints;
+    }
+    /**
+     * Handle an HTTP request.
+     * @param req - The HTTP request.
+     * @returns The HTTP response.
+     */
+    handle(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (req.method !== 'GET' &&
+                req.method !== 'POST' &&
+                req.method !== 'PUT' &&
+                req.method !== 'DELETE') {
+                return App.errorResponse(405, `Method '${req.method}' not allowed.`);
+            }
+            const match = this.matchEndpoint(req.url, req.method);
+            if (!match.result) {
+                if (match.invalidMethod) {
+                    return App.errorResponse(405, `Method '${req.method}' not allowed for path '${req.url}'.`);
+                }
+                return App.errorResponse(404, `Path '${req.url}' not found.`);
+            }
+            try {
+                return yield match.result.endpoint.handle(req, match.result.params);
+            }
+            catch (error) {
+                if (error instanceof errors_1.HttpError) {
+                    return App.errorResponse(error.status, error.message);
+                }
+                console.error(error);
+                return App.errorResponse(500, 'Internal Server Error.');
+            }
+        });
+    }
+    /**
+     * Generate OpenAPI documentation for the app.
+     */
+    docs(options) {
+        var _a;
+        const paths = {};
+        for (const endpoint of this.endpoints) {
+            const path = endpoint.path.toString();
+            const methods = (_a = paths[path]) !== null && _a !== void 0 ? _a : {};
+            methods[endpoint.method.toLowerCase()] = endpoint.documentation();
+            paths[path] = methods;
+        }
+        return {
+            openapi: '3.0.2',
+            info: options.info,
+            servers: options.servers,
+            paths,
+        };
+    }
+    listen(port) {
+        return (0, listen_1.listen)(this, port);
+    }
+    static errorResponse(status, errorMessage) {
+        return {
+            status,
+            body: Buffer.from(JSON.stringify({
+                status,
+                errorMessage,
+            })),
+            headers: {
+                'content-type': 'application/json',
+            },
+        };
+    }
+    matchEndpoint(url, method) {
+        let invalidMethod = false;
+        let result = undefined;
+        for (const endpoint of this.endpoints) {
+            const params = endpoint.path.match(url);
+            if (!params) {
+                continue;
+            }
+            if (endpoint.method !== method) {
+                invalidMethod = true;
+                continue;
+            }
+            const score = Object.keys(params).length;
+            const previous = result === null || result === void 0 ? void 0 : result.score;
+            if (previous === undefined || score < previous) {
+                // if there was no previous match or this one is better, use it
+                result = { endpoint, params, score };
+            }
+        }
+        return { invalidMethod, result };
+    }
+}
+exports.App = App;
+const shouldIgnore = (path) => {
+    const extensions = [
+        '.test.ts',
+        '.schema.ts',
+        '.util.ts',
+        '.d.ts',
+        '.test.js',
+        '.schema.js',
+        '.util.js',
+    ];
+    for (const extension of extensions) {
+        if (path.endsWith(extension)) {
+            return true;
+        }
+    }
+    return false;
+};
+const app = (routes) => __awaiter(void 0, void 0, void 0, function* () {
+    const endpoints = [];
+    const files = yield (0, glob_1.glob)([`${routes}/**/*.ts`, `${routes}/**/*.js`], {
+        absolute: true,
+    });
+    for (const file of files) {
+        if (shouldIgnore(file)) {
+            continue;
+        }
+        const endpoint = yield Promise.resolve(`${file}`).then(s => require(s));
+        endpoints.push(endpoint.default);
+    }
+    return new App(endpoints);
+});
+exports.app = app;

package/dist/routing/endpoint.d.ts

@@ -0,0 +1,35 @@
+import type { BodyType, Typeof } from '../validation/body';
+import type { Schema } from '../validation/schema';
+import type { Endpoint } from './app';
+import { Http } from './http';
+import { Log } from './log';
+export type EndpointRequest<Query, Headers, Req> = {
+    log: Log;
+    http: Http;
+    url: string;
+    params: Record<string, string>;
+    query: Query;
+    headers: Headers;
+    body: Req;
+};
+export type EndpointResponse<Res> = Promise<{
+    status?: number;
+    body: Res;
+    headers?: Record<string, string>;
+}> | {
+    status?: number;
+    body: Res;
+    headers?: Record<string, string>;
+};
+export type EndpointOptions<Query extends Schema<unknown>, Headers extends Schema<unknown>, Req extends BodyType<unknown>, Res extends BodyType<unknown>, Ext> = {
+    summary: string;
+    description?: string;
+    category?: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    query: Query;
+    headers: Headers;
+    req: Req;
+    res: Res;
+    do: (req: EndpointRequest<Typeof<Query>, Typeof<Headers>, Typeof<Req>> & Ext) => EndpointResponse<Typeof<Res>>;
+};
+export declare const endpoint: <Query extends Schema<unknown>, Headers extends Schema<unknown>, Req extends BodyType<unknown>, Res extends BodyType<unknown>>(path: string, options: EndpointOptions<Query, Headers, Req, Res, object>) => Endpoint;

package/dist/routing/endpoint.js

@@ -0,0 +1,131 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = void 0;
+const types_1 = require("node:util/types");
+const error_1 = require("../validation/error");
+const errors_1 = require("./errors");
+const http_1 = require("./http");
+const log_1 = require("./log");
+const path_1 = require("./path");
+const endpoint = (path, options) => {
+    return {
+        method: options.method,
+        path: new path_1.Path(path),
+        handle(req, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d;
+                let body;
+                let query;
+                let headers;
+                try {
+                    body = options.req.deserialize(req.body, (_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : 'application/octet-stream');
+                    query = options.query.parse(req.query);
+                    headers = options.headers.parse(req.headers);
+                }
+                catch (error) {
+                    if (error instanceof SyntaxError) {
+                        throw new errors_1.BadRequestError(error.message);
+                    }
+                    if (error instanceof error_1.ValidationError) {
+                        throw new errors_1.BadRequestError(error.format());
+                    }
+                    throw error;
+                }
+                const log = new log_1.Log();
+                const http = new http_1.Http(log);
+                const response = yield options.do({
+                    log,
+                    http,
+                    url: req.url,
+                    params,
+                    query,
+                    headers,
+                    body,
+                });
+                if ((0, types_1.isUint8Array)(response.body)) {
+                    return {
+                        status: (_b = response.status) !== null && _b !== void 0 ? _b : 200,
+                        body: response.body,
+                        headers: (_c = response.headers) !== null && _c !== void 0 ? _c : {},
+                    };
+                }
+                return {
+                    status: (_d = response.status) !== null && _d !== void 0 ? _d : 200,
+                    body: Buffer.from(JSON.stringify(response.body)),
+                    headers: Object.assign({ 'content-type': 'application/json' }, response.headers),
+                };
+            });
+        },
+        documentation() {
+            var _a;
+            const parameters = [
+                ...paramDocs(options.query, 'query'),
+                ...paramDocs(options.headers, 'header'),
+            ];
+            return {
+                tags: [(_a = options.category) !== null && _a !== void 0 ? _a : path.split('/')[1]],
+                summary: options.summary,
+                description: options.description,
+                parameters,
+                requestBody: {
+                    required: true,
+                    content: options.req.bodyDocs(),
+                },
+                responses: {
+                    '200': {
+                        description: 'Success',
+                        content: options.res.bodyDocs(),
+                    },
+                    '400': {
+                        description: 'Bad Request',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        status: {
+                                            type: 'number',
+                                        },
+                                        error: {
+                                            type: 'string',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    };
+};
+exports.endpoint = endpoint;
+const paramDocs = (params, position) => {
+    var _a;
+    const result = [];
+    const docs = params.documentation();
+    if (!('properties' in docs) || !Array.isArray(docs.properties)) {
+        return result;
+    }
+    const required = 'required' in docs && Array.isArray(docs.required) ? docs.required : [];
+    for (const name in docs.properties) {
+        const property = docs.properties[name];
+        result.push({
+            name: name,
+            in: position,
+            description: 'description' in property ? property.description : undefined,
+            required: (_a = required.includes(name)) !== null && _a !== void 0 ? _a : false,
+            schema: property,
+        });
+    }
+    return result;
+};

package/dist/routing/env.d.ts

@@ -0,0 +1,3 @@
+import type { Typeof } from '../validation/body';
+import type { Schema } from '../validation/schema';
+export declare const parseEnv: <T extends Schema<unknown>>(schema: T) => Typeof<T>;

package/dist/routing/env.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnv = void 0;
+const error_1 = require("../validation/error");
+const parseEnv = (schema) => {
+    try {
+        return schema.parse(process.env);
+    }
+    catch (error) {
+        if (error instanceof error_1.ValidationError) {
+            console.error(`error: env validation failed: ${error.format()}`);
+        }
+        process.exit(1);
+    }
+};
+exports.parseEnv = parseEnv;

package/dist/routing/errors.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Base class for errors that will be handled as HTTP status codes.
+ */
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * Indicates a malformed request.
+ * Corresponds to HTTP status code 400 Bad Request.
+ */
+export declare class BadRequestError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Indicates missing or invalid credentials.
+ * Corresponds to HTTP status code 401 Unauthorized.
+ */
+export declare class UnauthorizedError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Indicates that some kind of payment is required.
+ * Corresponds to HTTP status code 402 Payment Required.
+ */
+export declare class PaymentRequiredError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Indicates that the user is not allowed to do something.
+ * Corresponds to HTTP status code 403 Forbidden.
+ */
+export declare class ForbiddenError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Indicates that the requested resource does not exist.
+ * Corresponds to HTTP status code 404 Not Found.
+ */
+export declare class NotFoundError extends HttpError {
+    constructor(message: string);
+}
+/**
+ * Indicates that the action conflicts with the current state.
+ * Corresponds to HTTP status code 409 Conflict.
+ */
+export declare class ConflictError extends HttpError {
+    constructor(message: string);
+}

package/dist/routing/errors.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.PaymentRequiredError = exports.UnauthorizedError = exports.BadRequestError = exports.HttpError = void 0;
+/**
+ * Base class for errors that will be handled as HTTP status codes.
+ */
+class HttpError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.HttpError = HttpError;
+/**
+ * Indicates a malformed request.
+ * Corresponds to HTTP status code 400 Bad Request.
+ */
+class BadRequestError extends HttpError {
+    constructor(message) {
+        super(400, message);
+    }
+}
+exports.BadRequestError = BadRequestError;
+/**
+ * Indicates missing or invalid credentials.
+ * Corresponds to HTTP status code 401 Unauthorized.
+ */
+class UnauthorizedError extends HttpError {
+    constructor(message) {
+        super(401, message);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * Indicates that some kind of payment is required.
+ * Corresponds to HTTP status code 402 Payment Required.
+ */
+class PaymentRequiredError extends HttpError {
+    constructor(message) {
+        super(402, message);
+    }
+}
+exports.PaymentRequiredError = PaymentRequiredError;
+/**
+ * Indicates that the user is not allowed to do something.
+ * Corresponds to HTTP status code 403 Forbidden.
+ */
+class ForbiddenError extends HttpError {
+    constructor(message) {
+        super(403, message);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+/**
+ * Indicates that the requested resource does not exist.
+ * Corresponds to HTTP status code 404 Not Found.
+ */
+class NotFoundError extends HttpError {
+    constructor(message) {
+        super(404, message);
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Indicates that the action conflicts with the current state.
+ * Corresponds to HTTP status code 409 Conflict.
+ */
+class ConflictError extends HttpError {
+    constructor(message) {
+        super(409, message);
+    }
+}
+exports.ConflictError = ConflictError;

package/dist/routing/http.d.ts

@@ -0,0 +1,83 @@
+import type { Log, Schema, Typeof } from '../lib';
+/**
+ * Indicates that the HTTP request failed. This can be
+ * due to a network error or a response that indicates
+ * failure. In the latter case, the response is part of
+ * this error.
+ */
+export declare class HttpRequestError extends Error {
+    readonly response?: HttpResponse;
+    constructor(message: string, response?: HttpResponse);
+}
+/**
+ * The response to an HTTP request.
+ */
+export declare class HttpResponse {
+    /**
+     * The HTTP status code.
+     */
+    readonly status: number;
+    /**
+     * The response headers.
+     */
+    readonly headers: Record<string, string>;
+    /**
+     * The raw response body.
+     */
+    private readonly response;
+    /**
+     * Creates a new HTTP response.
+     * @param status - The status code.
+     * @param headers - The response headers.
+     * @param response - The raw response data.
+     */
+    constructor(status: number, headers: Record<string, string>, response: Uint8Array);
+    /**
+     * @returns The raw response data.
+     */
+    buffer(): Buffer;
+    /**
+     * @returns The response as a UTF-8 encoded string.
+     */
+    text(): string;
+    /**
+     * Parses the response as JSON and according to the
+     * specified schema.
+     * @param schema - The schema. Default is y.unknown().
+     * @returns A JavaScript object.
+     */
+    json<T extends Schema<unknown>>(schema?: T): Typeof<T>;
+}
+/**
+ * A class for performing HTTP requests.
+ */
+export declare class Http {
+    private log;
+    constructor(log: Log);
+    /**
+     * Performs an HTTP GET request on the given URL.
+     * @param url - The URL.
+     * @param headers - The HTTP headers.
+     * @returns The response.
+     */
+    get(url: string, headers?: Record<string, string>): Promise<HttpResponse>;
+    /**
+     * Performs an HTTP POST request on the given URL. The body is converted
+     * to JSON.
+     * @param url - The URL.
+     * @param body - The body.
+     * @param headers - The HTTP headers.
+     * @returns The response.
+     */
+    post(url: string, body: unknown, headers?: Record<string, string>): Promise<HttpResponse>;
+    /**
+     * Performs an HTTP request on the given URL. The body is converted to JSON.
+     * @param method - The HTTP method.
+     * @param url - The URL.
+     * @param body - The body.
+     * @param headers - The HTTP headers.
+     * @returns The response.
+     */
+    request(method: 'GET' | 'POST', url: string, body: unknown, headers?: Record<string, string>): Promise<HttpResponse>;
+    private getResponse;
+}