yedra 0.9.2 → 0.9.4

package/dist/routing/errors.js

@@ -1,73 +1,63 @@
-"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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export 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 {
+export class ConflictError extends HttpError {
     constructor(message) {
         super(409, message);
     }
 }
-exports.ConflictError = ConflictError;

package/dist/routing/http.d.ts

@@ -1,4 +1,4 @@
-import type { Log, Schema, Typeof } from '../lib';
+import type { Log, Schema, Typeof } from '../lib.js';
 /**
  * Indicates that the HTTP request failed. This can be
  * due to a network error or a response that indicates

package/dist/routing/http.js

@@ -1,33 +1,20 @@
-"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.Http = exports.HttpResponse = exports.HttpRequestError = void 0;
-const types_1 = require("node:util/types");
+import { isUint8Array } from 'node:util/types';
 /**
  * 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.
  */
-class HttpRequestError extends Error {
+export class HttpRequestError extends Error {
     constructor(message, response) {
         super(message);
         this.response = response;
     }
 }
-exports.HttpRequestError = HttpRequestError;
 /**
  * The response to an HTTP request.
  */
-class HttpResponse {
+export class HttpResponse {
     /**
      * Creates a new HTTP response.
      * @param status - The status code.
@@ -65,11 +52,10 @@ class HttpResponse {
         return parsed;
     }
 }
-exports.HttpResponse = HttpResponse;
 /**
  * A class for performing HTTP requests.
  */
-class Http {
+export class Http {
     constructor(log) {
         this.log = log;
     }
@@ -101,42 +87,37 @@ class Http {
      * @param headers - The HTTP headers.
      * @returns The response.
      */
-    request(method, url, body, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isBuffer = (0, types_1.isUint8Array)(body);
-            const requestBody = isBuffer ? body : JSON.stringify(body);
-            const actualHeaders = isBuffer
-                ? headers
-                : Object.assign({ 'content-type': 'application/json' }, headers);
-            const response = yield this.getResponse(method, url, requestBody, actualHeaders);
-            if (response.status < 200 || response.status >= 300) {
-                throw new HttpRequestError(`HTTP request returned status code ${response.status}`, response);
-            }
-            return response;
-        });
+    async request(method, url, body, headers) {
+        const isBuffer = isUint8Array(body);
+        const requestBody = isBuffer ? body : JSON.stringify(body);
+        const actualHeaders = isBuffer
+            ? headers
+            : { 'content-type': 'application/json', ...headers };
+        const response = await this.getResponse(method, url, requestBody, actualHeaders);
+        if (response.status < 200 || response.status >= 300) {
+            throw new HttpRequestError(`HTTP request returned status code ${response.status}`, response);
+        }
+        return response;
     }
-    getResponse(method, url, body, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const response = yield fetch(url, {
-                    method,
-                    headers,
-                    body,
-                });
-                const buffer = Buffer.from(yield response.arrayBuffer());
-                const responseHeaders = {};
-                response.headers.forEach((value, key) => {
-                    responseHeaders[key] = value;
-                });
-                return new HttpResponse(response.status, responseHeaders, buffer);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new HttpRequestError(error.message);
-                }
-                throw error;
+    async getResponse(method, url, body, headers) {
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body,
+            });
+            const buffer = Buffer.from(await response.arrayBuffer());
+            const responseHeaders = {};
+            response.headers.forEach((value, key) => {
+                responseHeaders[key] = value;
+            });
+            return new HttpResponse(response.status, responseHeaders, buffer);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new HttpRequestError(error.message);
             }
-        });
+            throw error;
+        }
     }
 }
-exports.Http = Http;

package/dist/routing/listen.d.ts

@@ -1,4 +1,4 @@
-import type { App } from './app';
+import type { App } from './app.js';
 export interface Context {
     stop(): Promise<void>;
 }

package/dist/routing/listen.js

@@ -1,16 +1,4 @@
-"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.listen = void 0;
-const node_http_1 = require("node:http");
+import { createServer } from 'node:http';
 const parseQuery = (url) => {
     const result = {};
     url.searchParams.forEach((value, key) => {
@@ -38,20 +26,18 @@ class ConcreteContext {
         this.activeConns = 0;
         this.server = server;
     }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                this.server.close((error) => {
-                    if (error !== undefined) {
-                        reject(error);
-                    }
-                    else if (this.activeConns === 0) {
-                        resolve();
-                    }
-                    else {
-                        this.resolve = resolve;
-                    }
-                });
+    async stop() {
+        return new Promise((resolve, reject) => {
+            this.server.close((error) => {
+                if (error !== undefined) {
+                    reject(error);
+                }
+                else if (this.activeConns === 0) {
+                    resolve();
+                }
+                else {
+                    this.resolve = resolve;
+                }
             });
         });
     }
@@ -68,26 +54,25 @@ class ConcreteContext {
         }
     }
 }
-const listen = (app, port) => {
+export const listen = (app, port) => {
     const addConn = () => {
         context.addConn();
     };
     const removeConn = () => {
         context.removeConn();
     };
-    const server = (0, node_http_1.createServer)((req, res) => {
+    const server = createServer((req, res) => {
         addConn();
         const chunks = [];
         req.on('data', (chunk) => {
             chunks.push(chunk);
         });
-        req.on('end', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a, _b;
+        req.on('end', async () => {
             const body = Buffer.concat(chunks);
-            const url = new URL((_a = req.url) !== null && _a !== void 0 ? _a : '', `http://${req.headers.host}`);
+            const url = new URL(req.url ?? '', `http://${req.headers.host}`);
             console.info(`[${new Date().toISOString()}] ${req.method} ${url.pathname} (${context.connectionCount()} connections)`);
-            const response = yield app.handle({
-                method: (_b = req.method) !== null && _b !== void 0 ? _b : 'GET',
+            const response = await app.handle({
+                method: req.method ?? 'GET',
                 url: url.pathname,
                 query: parseQuery(url),
                 headers: parseHeaders(req.headers),
@@ -96,7 +81,7 @@ const listen = (app, port) => {
             res.writeHead(response.status, response.headers);
             res.end(response.body);
             removeConn();
-        }));
+        });
     });
     const context = new ConcreteContext(server);
     server.listen(port, () => {
@@ -104,4 +89,3 @@ const listen = (app, port) => {
     });
     return context;
 };
-exports.listen = listen;

package/dist/routing/log.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Log = void 0;
-class Log {
+export class Log {
     /**
      * Output a debug message.
      * @param args - The message.
@@ -31,4 +28,3 @@ class Log {
         console.error(...args);
     }
 }
-exports.Log = Log;

package/dist/routing/path.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Path = void 0;
 /**
  * Represents an HTTP API path. Provides methods for concatenating paths and
  * extracting path parameters from strings.
  */
-class Path {
+export class Path {
     /**
      * Creates a new path. The path must start with `/`. Every part of the path
      * must match /^(:?[a-z0-9]+\??)|\*$/. It can either be a specific word, e.g.
@@ -92,4 +89,3 @@ class Path {
         return result;
     }
 }
-exports.Path = Path;

package/dist/routing/route.d.ts

@@ -1,10 +1,11 @@
-import { Http, Log } from '../lib';
-import type { BodyType, Typeof } from '../validation/body';
-import { type NoneBody } from '../validation/none';
-import { type ObjectSchema } from '../validation/object';
-import type { Schema } from '../validation/schema';
-import type { Endpoint } from './app';
-import { Path } from './path';
+import type { BodyType, Typeof } from '../validation/body.js';
+import { type NoneBody } from '../validation/none.js';
+import { type ObjectSchema } from '../validation/object.js';
+import type { Schema } from '../validation/schema.js';
+import type { Endpoint } from './app.js';
+import { Path } from './path.js';
+import { Log } from './log.js';
+import { Http } from './http.js';
 type ReqObject<Params, Query, Headers, Body> = {
     log: Log;
     http: Http;

package/dist/routing/route.js

@@ -1,28 +1,18 @@
-"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.route = void 0;
-const types_1 = require("node:util/types");
-const lib_1 = require("../lib");
-const none_1 = require("../validation/none");
-const object_1 = require("../validation/object");
-const errors_1 = require("./errors");
-const path_1 = require("./path");
+import { isUint8Array } from 'node:util/types';
+import { none } from '../validation/none.js';
+import { object } from '../validation/object.js';
+import { BadRequestError } from './errors.js';
+import { Path } from './path.js';
+import { Log } from './log.js';
+import { Http } from './http.js';
+import { ValidationError } from '../validation/error.js';
 class Route {
     constructor(path, params) {
         this.path = path;
         this.params = params;
     }
     get(options) {
-        return this.create(Object.assign({ req: (0, none_1.none)() }, options), 'GET');
+        return this.create({ req: none(), ...options }, 'GET');
     }
     post(options) {
         return this.create(options, 'POST');
@@ -31,72 +21,71 @@ class Route {
         return this.create(options, 'PUT');
     }
     delete(options) {
-        return this.create(Object.assign({ req: (0, none_1.none)() }, options), 'DELETE');
+        return this.create({ req: none(), ...options }, 'DELETE');
     }
     create(options, method) {
-        const querySchema = (0, object_1.object)(options.query);
-        const headersSchema = (0, object_1.object)(options.headers);
+        const querySchema = object(options.query);
+        const headersSchema = object(options.headers);
         const paramSchema = this.params;
         return {
             method,
             path: this.path,
-            handle(req, params) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b, _c, _d;
-                    let body;
-                    let query;
-                    let headers;
-                    const parsedParams = [];
-                    try {
-                        body = options.req.deserialize(req.body, (_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : 'application/octet-stream');
-                        query = querySchema.parse(req.query);
-                        headers = headersSchema.parse(req.headers);
-                        for (let i = 0; i < paramSchema.length; ++i) {
-                            parsedParams[i] = paramSchema[i].parse(params[i]);
-                        }
+            async handle(req, params) {
+                let body;
+                let query;
+                let headers;
+                const parsedParams = [];
+                try {
+                    body = options.req.deserialize(req.body, req.headers['content-type'] ?? 'application/octet-stream');
+                    query = querySchema.parse(req.query);
+                    headers = headersSchema.parse(req.headers);
+                    for (let i = 0; i < paramSchema.length; ++i) {
+                        parsedParams[i] = paramSchema[i].parse(params[i]);
                     }
-                    catch (error) {
-                        if (error instanceof SyntaxError) {
-                            throw new errors_1.BadRequestError(error.message);
-                        }
-                        if (error instanceof lib_1.ValidationError) {
-                            throw new errors_1.BadRequestError(error.format());
-                        }
-                        throw error;
+                }
+                catch (error) {
+                    if (error instanceof SyntaxError) {
+                        throw new BadRequestError(error.message);
                     }
-                    const log = new lib_1.Log();
-                    const http = new lib_1.Http(log);
-                    const response = yield options.do({
-                        log,
-                        http,
-                        url: req.url,
-                        params: parsedParams,
-                        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 : {},
-                        };
+                    if (error instanceof ValidationError) {
+                        throw new BadRequestError(error.format());
                     }
+                    throw error;
+                }
+                const log = new Log();
+                const http = new Http(log);
+                const response = await options.do({
+                    log,
+                    http,
+                    url: req.url,
+                    params: parsedParams,
+                    query,
+                    headers,
+                    body,
+                });
+                if (isUint8Array(response.body)) {
                     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),
+                        status: response.status ?? 200,
+                        body: response.body,
+                        headers: response.headers ?? {},
                     };
-                });
+                }
+                return {
+                    status: response.status ?? 200,
+                    body: Buffer.from(JSON.stringify(response.body)),
+                    headers: {
+                        '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 : this.path.toString().split('/')[1]],
+                    tags: [options.category ?? this.path.toString().split('/')[1]],
                     summary: options.summary,
                     description: options.description,
                     parameters,
@@ -133,7 +122,7 @@ class Route {
         };
     }
 }
-const route = (path, ...params) => {
+export const route = (path, ...params) => {
     let resultPath = '';
     const sections = path.length - 1;
     for (let i = 0; i < sections; ++i) {
@@ -141,9 +130,8 @@ const route = (path, ...params) => {
         resultPath += `:${i}`;
     }
     resultPath += path[sections];
-    return new Route(new path_1.Path(resultPath), params);
+    return new Route(new Path(resultPath), params);
 };
-exports.route = route;
 const paramDocs = (params, position) => {
     const result = [];
     for (const name in params) {

package/dist/routing/test.d.ts

@@ -1,5 +1,5 @@
-import { App } from './app';
-import { Http, HttpResponse } from './http';
+import { App } from './app.js';
+import { Http, HttpResponse } from './http.js';
 export declare class TestService {
     private target;
     private headers;