@keetanetwork/anchor 0.0.5 → 0.0.6

package/services/fx/server.js

@@ -1,15 +1,10 @@
 import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
-import * as http from 'http';
+import * as KeetaAnchorHTTPServer from '../../lib/http-server.js';
 import KeetaNet from '@keetanetwork/keetanet-client';
 import { createAssert } from 'typia';
 import { KeetaAnchorUserError } from '../../lib/error.js';
 import { acceptSwapRequest } from './common.js';
 import * as Signing from '../../lib/utils/signing.js';
-import { Log } from '../../lib/log/index.js';
-/**
- * The maximum size of a request (128KiB)
- */
-const MAX_REQUEST_SIZE = 1024 * 128;
 const assertConversionInputCanonical = (() => { const _io0 = input => "string" === typeof input.from && (RegExp(/^keeta_am(.*)/).test(input.from) || RegExp(/^keeta_an(.*)/).test(input.from) || RegExp(/^keeta_ao(.*)/).test(input.from) || RegExp(/^keeta_ap(.*)/).test(input.from) || RegExp(/^tyblocks_am(.*)/).test(input.from) || RegExp(/^tyblocks_an(.*)/).test(input.from) || RegExp(/^tyblocks_ao(.*)/).test(input.from) || RegExp(/^tyblocks_ap(.*)/).test(input.from)) && ("string" === typeof input.to && (RegExp(/^keeta_am(.*)/).test(input.to) || RegExp(/^keeta_an(.*)/).test(input.to) || RegExp(/^keeta_ao(.*)/).test(input.to) || RegExp(/^keeta_ap(.*)/).test(input.to) || RegExp(/^tyblocks_am(.*)/).test(input.to) || RegExp(/^tyblocks_an(.*)/).test(input.to) || RegExp(/^tyblocks_ao(.*)/).test(input.to) || RegExp(/^tyblocks_ap(.*)/).test(input.to))) && "string" === typeof input.amount && ("from" === input.affinity || "to" === input.affinity); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.from && (RegExp(/^keeta_am(.*)/).test(input.from) || RegExp(/^keeta_an(.*)/).test(input.from) || RegExp(/^keeta_ao(.*)/).test(input.from) || RegExp(/^keeta_ap(.*)/).test(input.from) || RegExp(/^tyblocks_am(.*)/).test(input.from) || RegExp(/^tyblocks_an(.*)/).test(input.from) || RegExp(/^tyblocks_ao(.*)/).test(input.from) || RegExp(/^tyblocks_ap(.*)/).test(input.from)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "createAssert",
     path: _path + ".from",
@@ -149,38 +144,6 @@ const assertConversionQuote = (() => { const _io0 = input => "object" === typeof
     }
     return input;
 }; })();
-const assertErrorData = (() => { const _io0 = input => "string" === typeof input.error && (undefined === input.statusCode || "number" === typeof input.statusCode) && (undefined === input.contentType || "string" === typeof input.contentType); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".error",
-    expected: "string",
-    value: input.error
-}, _errorFactory)) && (undefined === input.statusCode || "number" === typeof input.statusCode || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".statusCode",
-    expected: "(number | undefined)",
-    value: input.statusCode
-}, _errorFactory)) && (undefined === input.contentType || "string" === typeof input.contentType || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-    method: "createAssert",
-    path: _path + ".contentType",
-    expected: "(string | undefined)",
-    value: input.contentType
-}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
-    if (false === __is(input)) {
-        _errorFactory = errorFactory;
-        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
-            method: "createAssert",
-            path: _path + "",
-            expected: "__type",
-            value: input
-        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
-            method: "createAssert",
-            path: _path + "",
-            expected: "__type",
-            value: input
-        }, _errorFactory))(input, "$input", true);
-    }
-    return input;
-}; })();
 ;
 async function formatQuoteSignable(unsignedQuote) {
     const retval = [
@@ -218,476 +181,169 @@ async function requestToAccounts(config, request) {
         account: account.assertAccount()
     });
 }
-async function initRoutes(config) {
-    const routes = {};
-    /**
-     * If a homepage is provided, setup the route for it
-     */
-    if ('homepage' in config) {
-        routes['GET /'] = async function () {
-            let homepageData;
-            if (typeof config.homepage === 'string') {
-                homepageData = config.homepage;
-            }
-            else {
-                if (!config.homepage) {
-                    throw (new Error('internal error: No homepage function provided'));
-                }
-                homepageData = await config.homepage();
-            }
-            return ({
-                output: homepageData,
-                contentType: 'text/html'
-            });
-        };
-    }
-    /**
-     * Setup the request handler for an estimate request
-     */
-    routes['POST /api/getEstimate'] = async function (_ignore_params, postData) {
-        if (!postData || typeof postData !== 'object') {
-            throw (new Error('No POST data provided'));
-        }
-        if (!('request' in postData)) {
-            throw (new Error('POST data missing request'));
-        }
-        const conversion = assertConversionInputCanonical(postData.request);
-        const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
-        const estimateResponse = {
-            ok: true,
-            estimate: {
-                request: conversion,
-                convertedAmount: rateAndFee.convertedAmount,
-                expectedCost: {
-                    min: rateAndFee.cost.amount,
-                    max: rateAndFee.cost.amount,
-                    token: rateAndFee.cost.token
-                }
-            }
-        };
-        return ({
-            output: JSON.stringify(estimateResponse)
-        });
-    };
-    routes['POST /api/getQuote'] = async function (_ignore_params, postData) {
-        if (!postData || typeof postData !== 'object') {
-            throw (new Error('No POST data provided'));
-        }
-        if (!('request' in postData)) {
-            throw (new Error('POST data missing request'));
-        }
-        const conversion = assertConversionInputCanonical(postData.request);
-        const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
-        const unsignedQuote = {
-            request: conversion,
-            ...rateAndFee
-        };
-        const signedQuote = await generateSignedQuote(config.quoteSigner, unsignedQuote);
-        const quoteResponse = {
-            ok: true,
-            quote: signedQuote
-        };
-        return ({
-            output: JSON.stringify(quoteResponse)
-        });
-    };
-    routes['POST /api/createExchange'] = async function (_ignore_params, postData) {
-        if (!postData || typeof postData !== 'object') {
-            throw (new Error('No POST data provided'));
-        }
-        if (!('request' in postData)) {
-            throw (new Error('POST data missing request'));
-        }
-        const request = postData.request;
-        if (!request || typeof request !== 'object') {
-            throw (new Error('Request is not an object'));
-        }
-        if (!('quote' in request)) {
-            throw (new Error('Quote is missing from request'));
-        }
-        if (!('block' in request) || typeof request.block !== 'string') {
-            throw (new Error('Block was not provided in exchange request'));
-        }
-        const quote = assertConversionQuote(request.quote);
-        const isValidQuote = await verifySignedData(config.quoteSigner, quote);
-        if (!isValidQuote) {
-            throw (new Error('Invalid quote signature'));
-        }
-        const block = new KeetaNet.lib.Block(request.block);
-        let userClient;
-        if (KeetaNet.UserClient.isInstance(config.client)) {
-            userClient = config.client;
-        }
-        else {
-            const { account, signer } = await requestToAccounts(config, quote.request);
-            userClient = new KeetaNet.UserClient({
-                client: config.client.client,
-                network: config.client.network,
-                networkAlias: config.client.networkAlias,
-                account: account,
-                signer: signer
-            });
-        }
-        const expectedToken = KeetaNet.lib.Account.fromPublicKeyString(quote.request.from);
-        const expectedAmount = quote.request.affinity === 'from' ? quote.request.amount : quote.convertedAmount;
-        // eslint-disable-next-line @typescript-eslint/no-deprecated
-        const swapBlocks = await acceptSwapRequest(userClient, block, { token: expectedToken, amount: BigInt(expectedAmount) });
-        const publishResult = await userClient.client.transmit(swapBlocks);
-        if (!publishResult.publish) {
-            throw (new Error('Exchange Publish Failed'));
-        }
-        const exchangeResponse = {
-            ok: true,
-            exchangeID: block.hash.toString()
-        };
-        return ({
-            output: JSON.stringify(exchangeResponse)
-        });
-    };
-    routes['GET /api/getExchangeStatus/:id'] = async function (params) {
-        if (params === undefined || params === null) {
-            throw (new KeetaAnchorUserError('Expected params'));
-        }
-        const exchangeID = params.get('id');
-        if (typeof exchangeID !== 'string') {
-            throw (new Error('Missing exchangeID in params'));
-        }
-        const blockLookup = await config.client.client.getVoteStaple(exchangeID);
-        if (blockLookup === null) {
-            throw (new Error('Block Not Found'));
-        }
-        const exchangeResponse = {
-            ok: true,
-            exchangeID: exchangeID
-        };
-        return ({
-            output: JSON.stringify(exchangeResponse)
-        });
-    };
-    routes['ERROR'] = async function (_ignore_params, postData) {
-        const errorInfo = assertErrorData(postData);
-        const retval = {
-            output: errorInfo.error,
-            statusCode: errorInfo.statusCode ?? 400,
-            contentType: errorInfo.contentType ?? 'text/plain'
-        };
-        return (retval);
-    };
-    return (routes);
-}
-export class KeetaNetFXAnchorHTTPServer {
-    port;
+export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAnchorHTTPServer {
     homepage;
     client;
-    logger;
     account;
     signer;
     quoteSigner;
     fx;
-    #serverPromise;
-    #server;
     constructor(config) {
+        super(config);
         this.homepage = config.homepage ?? '';
-        this.port = config.port ?? 0;
         this.client = config.client;
         this.fx = config.fx;
         this.account = config.account;
         this.signer = config.signer ?? config.account;
         this.quoteSigner = config.quoteSigner;
-        this.logger = config.logger ?? new Log();
-    }
-    static routeMatch(requestURL, routeURL) {
-        const requestURLPaths = requestURL.pathname.split('/');
-        const routeURLPaths = routeURL.pathname.split('/');
-        if (requestURLPaths.length !== routeURLPaths.length) {
-            return ({ match: false });
-        }
-        const params = new Map();
-        for (let partIndex = 0; partIndex < requestURLPaths.length; partIndex++) {
-            const requestPath = requestURLPaths[partIndex];
-            const routePath = routeURLPaths[partIndex];
-            if (routePath === undefined || requestPath === undefined) {
-                return ({ match: false });
-            }
-            if (routePath.startsWith(':')) {
-                params.set(routePath.slice(1), requestPath);
-            }
-            else if (requestPath !== routePath) {
-                return ({ match: false });
-            }
-        }
-        return ({ match: true, params: params });
     }
-    static routeFind(method, requestURL, routes) {
-        for (const routeKey in routes) {
-            const route = routes[routeKey];
-            if (route === undefined) {
-                continue;
-            }
-            const [routeMethod, ...routePathParts] = routeKey.split(' ');
-            const routePath = `/${routePathParts.join(' ')}`.replace(/^\/+/, '/');
-            if (method !== routeMethod) {
-                continue;
-            }
-            const routeURL = new URL(routePath, 'http://localhost');
-            const matchResult = this.routeMatch(requestURL, routeURL);
-            if (matchResult.match) {
+    async initRoutes(config) {
+        const routes = {};
+        /**
+         * If a homepage is provided, setup the route for it
+         */
+        if ('homepage' in config) {
+            routes['GET /'] = async function () {
+                let homepageData;
+                if (typeof config.homepage === 'string') {
+                    homepageData = config.homepage;
+                }
+                else {
+                    if (!config.homepage) {
+                        throw (new Error('internal error: No homepage function provided'));
+                    }
+                    homepageData = await config.homepage();
+                }
                 return ({
-                    route: route,
-                    params: matchResult.params
+                    output: homepageData,
+                    contentType: 'text/html'
                 });
-            }
+            };
         }
-        return (null);
-    }
-    static addCORS(routes) {
-        const newRoutes = {};
-        const validMethods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD']);
-        const methodsByPath = {};
-        for (const routeKey in routes) {
-            const methodAndPath = routeKey.split(' ');
-            const method = methodAndPath[0];
-            const path = methodAndPath.slice(1).join(' ');
-            if (method === undefined || path === undefined) {
-                continue;
+        /**
+         * Setup the request handler for an estimate request
+         */
+        routes['POST /api/getEstimate'] = async function (_ignore_params, postData) {
+            if (!postData || typeof postData !== 'object') {
+                throw (new Error('No POST data provided'));
             }
-            if (!validMethods.has(method)) {
-                continue;
+            if (!('request' in postData)) {
+                throw (new Error('POST data missing request'));
             }
-            if (!(path in methodsByPath)) {
-                methodsByPath[path] = new Set();
+            const conversion = assertConversionInputCanonical(postData.request);
+            const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+            const estimateResponse = {
+                ok: true,
+                estimate: {
+                    request: conversion,
+                    convertedAmount: rateAndFee.convertedAmount,
+                    expectedCost: {
+                        min: rateAndFee.cost.amount,
+                        max: rateAndFee.cost.amount,
+                        token: rateAndFee.cost.token
+                    }
+                }
+            };
+            return ({
+                output: JSON.stringify(estimateResponse)
+            });
+        };
+        routes['POST /api/getQuote'] = async function (_ignore_params, postData) {
+            if (!postData || typeof postData !== 'object') {
+                throw (new Error('No POST data provided'));
             }
-            if (methodsByPath[path] === undefined) {
-                throw (new Error(`internal error: methodsByPath missing path for ${path}`));
+            if (!('request' in postData)) {
+                throw (new Error('POST data missing request'));
             }
-            methodsByPath[path].add(method);
-        }
-        const seenPaths = new Set();
-        for (const routeKey in routes) {
-            const methodAndPath = routeKey.split(' ');
-            const method = methodAndPath[0];
-            const path = methodAndPath.slice(1).join(' ');
-            const routeHandler = routes[routeKey];
-            if (routeHandler === undefined) {
-                throw (new Error(`internal error: routeHandler missing for routeKey ${routeKey}`));
+            const conversion = assertConversionInputCanonical(postData.request);
+            const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+            const unsignedQuote = {
+                request: conversion,
+                ...rateAndFee
+            };
+            const signedQuote = await generateSignedQuote(config.quoteSigner, unsignedQuote);
+            const quoteResponse = {
+                ok: true,
+                quote: signedQuote
+            };
+            return ({
+                output: JSON.stringify(quoteResponse)
+            });
+        };
+        routes['POST /api/createExchange'] = async function (_ignore_params, postData) {
+            if (!postData || typeof postData !== 'object') {
+                throw (new Error('No POST data provided'));
             }
-            if (method !== 'ERROR') {
-                if (method === undefined || path === undefined) {
-                    newRoutes[routeKey] = routeHandler;
-                    continue;
-                }
-                if (!validMethods.has(method)) {
-                    newRoutes[routeKey] = routeHandler;
-                    continue;
-                }
+            if (!('request' in postData)) {
+                throw (new Error('POST data missing request'));
             }
-            const validMethodsForPath = methodsByPath[path];
-            let validMethodsForPathParts = [];
-            if (validMethodsForPath !== undefined) {
-                validMethodsForPath.add('OPTIONS');
-                validMethodsForPathParts = Array.from(validMethodsForPath);
+            const request = postData.request;
+            if (!request || typeof request !== 'object') {
+                throw (new Error('Request is not an object'));
             }
-            else {
-                validMethodsForPathParts = [...Array.from(validMethods), 'OPTIONS'];
+            if (!('quote' in request)) {
+                throw (new Error('Quote is missing from request'));
             }
-            newRoutes[routeKey] = async function (...args) {
-                const retval = await routeHandler(...args);
-                /* Add CORS headers to the response for the original route handler */
-                if (retval.contentType === 'application/json' || retval.contentType === undefined) {
-                    if (!('headers' in retval) || retval.headers === undefined) {
-                        retval.headers = {};
-                    }
-                    retval.headers['Access-Control-Allow-Origin'] = '*';
-                }
-                return (retval);
-            };
-            if (!seenPaths.has(path) && path !== '' && path !== undefined) {
-                const corsRouteKey = `OPTIONS ${path}`;
-                newRoutes[corsRouteKey] = async function () {
-                    return ({
-                        output: '',
-                        statusCode: 204,
-                        contentType: 'text/plain',
-                        headers: {
-                            'Access-Control-Allow-Origin': '*',
-                            'Access-Control-Allow-Methods': validMethodsForPathParts.join(', '),
-                            'Access-Control-Allow-Headers': 'Content-Type',
-                            'Access-Control-Max-Age': '86400'
-                        }
-                    });
-                };
-                seenPaths.add(path);
+            if (!('block' in request) || typeof request.block !== 'string') {
+                throw (new Error('Block was not provided in exchange request'));
             }
-        }
-        return (newRoutes);
-    }
-    async main(onSetPort) {
-        this.logger?.debug('KeetaAnchorFX.Server', 'Starting HTTP server...');
-        const port = this.port;
-        const routes = KeetaNetFXAnchorHTTPServer.addCORS(await initRoutes(this));
-        const server = new http.Server(async (request, response) => {
-            const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
-            const method = request.method ?? 'GET';
-            /*
-             * Lookup the route based on the request
-             */
-            const requestedRouteAndParams = KeetaNetFXAnchorHTTPServer.routeFind(method, url, routes);
-            if (requestedRouteAndParams === null) {
-                response.statusCode = 404;
-                response.setHeader('Content-Type', 'text/plain');
-                response.write('Not Found');
-                response.end();
-                return;
+            const quote = assertConversionQuote(request.quote);
+            const isValidQuote = await verifySignedData(config.quoteSigner, quote);
+            if (!isValidQuote) {
+                throw (new Error('Invalid quote signature'));
             }
-            /*
-             * Extract the route handler and the parameters from
-             * the request
-             */
-            const { route, params } = requestedRouteAndParams;
-            /**
-             * Attempt to run the route, catch any errors
-             */
-            let result, generatedResult = false;
-            try {
-                /**
-                 * If POST'ing, read and parse the POST data
-                 */
-                let postData;
-                if (request.method === 'POST') {
-                    const data = await request.map(function (chunk) {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                        return (Buffer.from(chunk));
-                    }).reduce(function (prev, curr) {
-                        if (prev.length > MAX_REQUEST_SIZE) {
-                            throw (new Error('Request too large'));
-                        }
-                        if (!Buffer.isBuffer(curr)) {
-                            throw (new Error(`internal error: Current item is not a buffer -- ${typeof curr}`));
-                        }
-                        return (Buffer.concat([prev, curr]));
-                    }, Buffer.from(''));
-                    if (request.headers['content-type'] === 'application/json') {
-                        try {
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            postData = JSON.parse(data.toString('utf-8'));
-                        }
-                        catch {
-                            throw (new Error('Invalid JSON data'));
-                        }
-                    }
-                    else {
-                        throw (new KeetaAnchorUserError('Unsupported content type'));
-                    }
-                    /**
-                     * Call the route handler
-                     */
-                    result = await route(params, postData);
-                }
-                else {
-                    result = await route(params, undefined);
-                }
-                generatedResult = true;
-            }
-            catch (err) {
-                /**
-                 * If an error occurs, log it and return an error page
-                 */
-                this.logger?.error('KeetaAnchorFX.Server', err);
-                /**
-                 * If it is a user error, provide a user-friendly error page
-                 */
-                const errorHandlerRoute = routes['ERROR'];
-                if (errorHandlerRoute !== undefined) {
-                    if (KeetaAnchorUserError.isInstance(err)) {
-                        result = await errorHandlerRoute(new Map(), err.asErrorResponse('application/json'));
-                        generatedResult = true;
-                    }
-                    else {
-                        result = await errorHandlerRoute(new Map(), {
-                            error: JSON.stringify({ ok: false, error: 'Internal Server Error' }),
-                            statusCode: 500,
-                            contentType: 'application/json'
-                        });
-                        generatedResult = true;
-                    }
-                }
-                if (!generatedResult) {
-                    /**
-                     * Otherwise provide a generic error page
-                     */
-                    response.statusCode = 500;
-                    response.setHeader('Content-Type', 'text/plain');
-                    response.write('Internal Server Error');
-                    response.end();
-                    return;
-                }
+            const block = new KeetaNet.lib.Block(request.block);
+            let userClient;
+            if (KeetaNet.UserClient.isInstance(config.client)) {
+                userClient = config.client;
             }
-            if (result === undefined) {
-                throw (new Error('internal error: No result'));
+            else {
+                const { account, signer } = await requestToAccounts(config, quote.request);
+                userClient = new KeetaNet.UserClient({
+                    client: config.client.client,
+                    network: config.client.network,
+                    networkAlias: config.client.networkAlias,
+                    account: account,
+                    signer: signer
+                });
             }
-            /**
-             * Write the response to the client
-             */
-            response.statusCode = result.statusCode ?? 200;
-            for (const headerKey in result.headers ?? {}) {
-                const headerValue = result.headers?.[headerKey];
-                if (headerValue !== undefined) {
-                    response.setHeader(headerKey, headerValue);
-                }
+            const expectedToken = KeetaNet.lib.Account.fromPublicKeyString(quote.request.from);
+            const expectedAmount = quote.request.affinity === 'from' ? quote.request.amount : quote.convertedAmount;
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const swapBlocks = await acceptSwapRequest(userClient, block, { token: expectedToken, amount: BigInt(expectedAmount) });
+            const publishResult = await userClient.client.transmit(swapBlocks);
+            if (!publishResult.publish) {
+                throw (new Error('Exchange Publish Failed'));
             }
-            response.setHeader('Content-Type', result.contentType ?? 'application/json');
-            response.write(result.output);
-            response.end();
-        });
-        this.#server = server;
-        /**
-         * Create a promise to wait for the server to close
-         */
-        const waiter = new Promise((resolve) => {
-            server.on('close', () => {
-                this.logger?.debug('KeetaAnchorFX.Server', 'Server closed');
-                resolve();
+            const exchangeResponse = {
+                ok: true,
+                exchangeID: block.hash.toString()
+            };
+            return ({
+                output: JSON.stringify(exchangeResponse)
             });
-        });
-        /**
-         * Start listening on the port
-         */
-        server.listen(port, () => {
-            const address = server.address();
-            if (address !== null && typeof address === 'object') {
-                // @ts-ignore
-                this.port = address.port;
-                onSetPort?.(this.port);
+        };
+        routes['GET /api/getExchangeStatus/:id'] = async function (params) {
+            if (params === undefined || params === null) {
+                throw (new KeetaAnchorUserError('Expected params'));
             }
-            this.logger?.debug('KeetaAnchorFX.Server', 'Listening on port:', this.port);
-        });
-        /**
-         * Wait for the server to close
-         */
-        await waiter;
-    }
-    async start() {
-        await new Promise((resolve) => {
-            this.#serverPromise = this.main(function () {
-                resolve();
+            const exchangeID = params.get('id');
+            if (typeof exchangeID !== 'string') {
+                throw (new Error('Missing exchangeID in params'));
+            }
+            const blockLookup = await config.client.client.getVoteStaple(exchangeID);
+            if (blockLookup === null) {
+                throw (new Error('Block Not Found'));
+            }
+            const exchangeResponse = {
+                ok: true,
+                exchangeID: exchangeID
+            };
+            return ({
+                output: JSON.stringify(exchangeResponse)
             });
-        });
-    }
-    async wait() {
-        await this.#serverPromise;
-    }
-    async stop() {
-        this.#server?.close();
-        await this.wait();
-    }
-    get url() {
-        if (this.port === 0 || this.#server === undefined) {
-            throw (new Error('Server not started'));
-        }
-        return (`http://localhost:${this.port}`);
-    }
-    [Symbol.asyncDispose]() {
-        return (this.stop());
+        };
+        return (routes);
     }
 }
 //# sourceMappingURL=server.js.map