@enbox/dwn-server 0.0.1

package/dist/esm/src/dwn-server.js

@@ -0,0 +1,130 @@
+import log from 'loglevel';
+import prefix from 'loglevel-plugin-prefix';
+import { config as defaultConfig } from './config.js';
+import { getDwnConfig } from './storage.js';
+import { HttpServerShutdownHandler } from './lib/http-server-shutdown-handler.js';
+import { HttpApi } from './http-api.js';
+import { PluginLoader } from './plugin-loader.js';
+import { RegistrationManager } from './registration/registration-manager.js';
+import { WsApi } from './ws-api.js';
+import { Dwn, EventEmitterStream } from '@enbox/dwn-sdk-js';
+import { removeProcessHandlers, setProcessHandlers } from './process-handlers.js';
+/**
+ * State of the DwnServer, either Stopped or Started, to help short-circuit start and stop logic.
+ */
+var DwnServerState;
+(function (DwnServerState) {
+    DwnServerState[DwnServerState["Stopped"] = 0] = "Stopped";
+    DwnServerState[DwnServerState["Started"] = 1] = "Started";
+})(DwnServerState || (DwnServerState = {}));
+export class DwnServer {
+    serverState = DwnServerState.Stopped;
+    processHandlers;
+    /**
+     * A custom DID resolver to use in the DWN.
+     * Mainly for testing purposes. Ignored if `dwn` is provided.
+     */
+    didResolver;
+    dwn;
+    config;
+    #httpServerShutdownHandler;
+    #httpApi;
+    #wsApi;
+    /**
+     * @param options.dwn - Dwn instance to use as an override. Registration endpoint will not be enabled if this is provided.
+     */
+    constructor(options = {}) {
+        this.config = options.config ?? defaultConfig;
+        this.didResolver = options.didResolver;
+        this.dwn = options.dwn;
+        log.setLevel(this.config.logLevel);
+        prefix.reg(log);
+        prefix.apply(log);
+    }
+    /**
+     * Starts the DWN server.
+     */
+    async start() {
+        if (this.serverState === DwnServerState.Started) {
+            return;
+        }
+        await this.#setupServer();
+        this.processHandlers = setProcessHandlers(this);
+        this.serverState = DwnServerState.Started;
+    }
+    /**
+     * Function to setup the servers (HTTP and WebSocket)
+     * The DWN creation is secondary and only happens if it hasn't already been done.
+     */
+    async #setupServer() {
+        let registrationManager;
+        if (!this.dwn) {
+            // undefined registrationStoreUrl is used as a signal that there is no need for tenant registration, DWN is open for all.
+            registrationManager = await RegistrationManager.create({
+                registrationStoreUrl: this.config.registrationStoreUrl,
+                termsOfServiceFilePath: this.config.termsOfServiceFilePath,
+                proofOfWorkChallengeNonceSeed: this.config.registrationProofOfWorkSeed,
+                proofOfWorkInitialMaximumAllowedHash: this.config.registrationProofOfWorkInitialMaxHash,
+            });
+            let eventStream;
+            if (this.config.webSocketSupport) {
+                // If Even Stream plugin is not specified, use `EventEmitterStream` implementation as default.
+                if (this.config.eventStreamPluginPath === undefined || this.config.eventStreamPluginPath === '') {
+                    eventStream = new EventEmitterStream();
+                }
+                else {
+                    eventStream = await PluginLoader.loadPlugin(this.config.eventStreamPluginPath);
+                }
+            }
+            const dwnConfig = await getDwnConfig(this.config, {
+                didResolver: this.didResolver,
+                tenantGate: registrationManager,
+                eventStream,
+            });
+            this.dwn = await Dwn.create(dwnConfig);
+        }
+        this.#httpApi = await HttpApi.create(this.config, this.dwn, registrationManager);
+        await this.#httpApi.start(this.config.port);
+        log.info(`HttpServer listening on port ${this.config.port}`);
+        this.#httpServerShutdownHandler = new HttpServerShutdownHandler(this.#httpApi.server);
+        if (this.config.webSocketSupport) {
+            this.#wsApi = new WsApi(this.#httpApi.server, this.dwn);
+            this.#wsApi.start();
+            log.info('WebSocketServer ready...');
+        }
+    }
+    /**
+     * Stops the DWN server.
+     */
+    async stop() {
+        if (this.serverState === DwnServerState.Stopped) {
+            return;
+        }
+        await this.dwn.close();
+        await this.#httpApi.close();
+        // close WebSocket server if it was initialized
+        if (this.#wsApi !== undefined) {
+            await this.#wsApi.close();
+        }
+        await new Promise((resolve) => {
+            this.#httpServerShutdownHandler.stop(() => {
+                resolve();
+            });
+        });
+        removeProcessHandlers(this.processHandlers);
+        this.serverState = DwnServerState.Stopped;
+    }
+    get httpServer() {
+        return this.#httpApi.server;
+    }
+    get wsServer() {
+        return this.#wsApi?.server;
+    }
+    /**
+     * Gets the RegistrationManager for testing purposes.
+     */
+    get registrationManager() {
+        return this.#httpApi.registrationManager;
+    }
+}
+//# sourceMappingURL=dwn-server.js.map

package/dist/esm/src/dwn-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dwn-server.js","sourceRoot":"","sources":["../../../src/dwn-server.ts"],"names":[],"mappings":"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"}

package/dist/esm/src/http-api.d.ts

@@ -0,0 +1,26 @@
+import { type Dwn } from '@enbox/dwn-sdk-js';
+import type { Express } from 'express';
+import http from 'http';
+import type { DwnServerConfig } from './config.js';
+import type { RegistrationManager } from './registration/registration-manager.js';
+import { Web5ConnectServer } from './web5-connect/web5-connect-server.js';
+export declare class HttpApi {
+    #private;
+    web5ConnectServer: Web5ConnectServer;
+    registrationManager: RegistrationManager;
+    dwn: Dwn;
+    private constructor();
+    static create(config: DwnServerConfig, dwn: Dwn, registrationManager?: RegistrationManager): Promise<HttpApi>;
+    get server(): http.Server;
+    get api(): Express;
+    /**
+     * Starts the HTTP API endpoint on the given port.
+     * @returns The HTTP server instance.
+     */
+    start(port: number): Promise<void>;
+    /**
+     * Stops the HTTP API endpoint.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=http-api.d.ts.map

package/dist/esm/src/http-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-api.d.ts","sourceRoot":"","sources":["../../../src/http-api.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAuD,MAAM,mBAAmB,CAAC;AAGlG,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AAG1D,OAAO,IAAI,MAAM,MAAM,CAAC;AASxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAGlF,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAM1E,qBAAa,OAAO;;IAKlB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,GAAG,EAAE,GAAG,CAAC;IAET,OAAO;WAEa,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,EAAE,GAAG,EAAE,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAuC1H,IAAI,MAAM,IAAI,IAAI,CAAC,MAAM,CAExB;IAED,IAAI,GAAG,IAAI,OAAO,CAEjB;IA2aD;;;OAGG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAc7B"}

package/dist/esm/src/http-api.js

@@ -0,0 +1,474 @@
+import { DateSort, RecordsRead, RecordsQuery, ProtocolsQuery } from '@enbox/dwn-sdk-js';
+import cors from 'cors';
+import express from 'express';
+import { readFileSync } from 'fs';
+import http from 'http';
+import log from 'loglevel';
+import { register } from 'prom-client';
+import responseTime from 'response-time';
+import { v4 as uuidv4 } from 'uuid';
+import { config } from './config.js';
+import { jsonRpcRouter } from './json-rpc-api.js';
+import { Web5ConnectServer } from './web5-connect/web5-connect-server.js';
+import { createJsonRpcErrorResponse, JsonRpcErrorCodes } from './lib/json-rpc.js';
+import { requestCounter, responseHistogram } from './metrics.js';
+import { Convert } from '@enbox/common';
+export class HttpApi {
+    #config;
+    #packageInfo;
+    #api;
+    #server;
+    web5ConnectServer;
+    registrationManager;
+    dwn;
+    constructor() { }
+    static async create(config, dwn, registrationManager) {
+        const httpApi = new HttpApi();
+        log.info(config);
+        httpApi.#packageInfo = {
+            server: config.serverName,
+        };
+        try {
+            // We populate the `version` and `sdkVersion` properties from the `package.json` file.
+            const packageJson = JSON.parse(readFileSync(config.packageJsonPath).toString());
+            httpApi.#packageInfo.version = packageJson.version;
+            httpApi.#packageInfo.sdkVersion = packageJson.dependencies ? packageJson.dependencies['@enbox/dwn-sdk-js'] : undefined;
+        }
+        catch (error) {
+            log.info('could not read `package.json` for version info', error);
+        }
+        httpApi.#config = config;
+        httpApi.#api = express();
+        httpApi.#server = http.createServer(httpApi.#api);
+        httpApi.dwn = dwn;
+        if (registrationManager !== undefined) {
+            httpApi.registrationManager = registrationManager;
+        }
+        // create the Web5 Connect Server
+        httpApi.web5ConnectServer = await Web5ConnectServer.create({
+            baseUrl: config.baseUrl,
+            sqlTtlCacheUrl: config.ttlCacheUrl,
+        });
+        httpApi.#setupMiddleware();
+        httpApi.#setupRoutes();
+        return httpApi;
+    }
+    get server() {
+        return this.#server;
+    }
+    get api() {
+        return this.#api;
+    }
+    #setupMiddleware() {
+        this.#api.use(cors({ exposedHeaders: 'dwn-response' }));
+        this.#api.use(express.json());
+        // We enable the formData middleware to handle multipart/form-data requests.
+        // This is necessary for the endpoints used by the Web5 Connect Server/OIDC flow.
+        this.#api.use(express.urlencoded({ extended: true }));
+        this.#api.use(responseTime((req, res, time) => {
+            const url = req.url === '/' ? '/jsonrpc' : req.url;
+            const route = (req.method + url)
+                .toLowerCase()
+                .replace(/[:.]/g, '')
+                .replace(/\//g, '_');
+            const statusCode = res.statusCode.toString();
+            responseHistogram.labels(route, statusCode).observe(time);
+            log.info(req.method, decodeURI(req.url), res.statusCode);
+        }));
+    }
+    /**
+     * Configures the HTTP server's request handlers.
+     */
+    #setupRoutes() {
+        const leadTailSlashRegex = /^\/|\/$/;
+        function readReplyHandler(res, reply) {
+            if (reply.status.code === 200) {
+                if (reply?.entry?.data) {
+                    const stream = reply.entry.data;
+                    res.setHeader('content-type', reply.entry.recordsWrite.descriptor.dataFormat);
+                    res.setHeader('dwn-response', JSON.stringify(reply));
+                    return stream.pipe(res);
+                }
+                else {
+                    return res.sendStatus(400);
+                }
+            }
+            else if (reply.status.code === 401) {
+                return res.sendStatus(404);
+            }
+            else {
+                return res.status(reply.status.code).send(reply);
+            }
+        }
+        this.#api.get('/health', (_req, res) => {
+            // return 200 ok
+            return res.json({ ok: true });
+        });
+        this.#api.get('/metrics', async (req, res) => {
+            try {
+                res.set('Content-Type', register.contentType);
+                res.end(await register.metrics());
+            }
+            catch (e) {
+                res.status(500).end(e);
+            }
+        });
+        // Returns the data for the most recently published record under a given protocol path collection, if one is present
+        this.#api.get('/:did/read/protocols/:protocol/*', async (req, res) => {
+            if (!req.params[0]) {
+                return res.status(400).send('protocol path is required');
+            }
+            // wrap request in a try-catch block to handle any unexpected errors
+            try {
+                const queryOptions = { filter: {} };
+                for (const param in req.query) {
+                    const keys = param.split('.');
+                    const lastKey = keys.pop();
+                    const lastLevelObject = keys.reduce((obj, key) => obj[key] = obj[key] || {}, queryOptions);
+                    lastLevelObject[lastKey] = req.query[param];
+                }
+                // the protocol path segment is base64url encoded, as the actual protocol is a URL
+                // we decode it here in order to filter for the correct protocol
+                const protocol = Convert.base64Url(req.params.protocol).toString();
+                queryOptions.filter.protocol = protocol;
+                queryOptions.filter.protocolPath = req.params[0].replace(leadTailSlashRegex, '');
+                const query = await RecordsQuery.create({
+                    filter: queryOptions.filter,
+                    pagination: { limit: 1 },
+                    dateSort: DateSort.PublishedDescending
+                });
+                const { entries, status } = await this.dwn.processMessage(req.params.did, query.message);
+                if (status.code === 200) {
+                    if (entries[0]) {
+                        const record = await RecordsRead.create({
+                            filter: { recordId: entries[0].recordId },
+                        });
+                        const reply = await this.dwn.processMessage(req.params.did, record.toJSON());
+                        return readReplyHandler(res, reply);
+                    }
+                    else {
+                        return res.sendStatus(404);
+                    }
+                }
+                else if (status.code === 401) {
+                    return res.sendStatus(404);
+                }
+                else {
+                    return res.sendStatus(status.code);
+                }
+            }
+            catch (error) {
+                log.error(`Error processing request: ${decodeURI(req.url)}`, error);
+                return res.sendStatus(400);
+            }
+        });
+        this.#api.get('/:did/read/protocols/:protocol', async (req, res) => {
+            // wrap request in a try-catch block to handle any unexpected errors
+            try {
+                // the protocol segment is base64url encoded, as the actual protocol is a URL
+                // we decode it here in order to filter for the correct protocol
+                const protocol = Convert.base64Url(req.params.protocol).toString();
+                const query = await ProtocolsQuery.create({
+                    filter: { protocol }
+                });
+                const { entries, status } = await this.dwn.processMessage(req.params.did, query.message);
+                if (status.code === 200) {
+                    if (entries.length) {
+                        res.status(status.code);
+                        res.json(entries[0]);
+                    }
+                    else {
+                        return res.sendStatus(404);
+                    }
+                }
+                else if (status.code === 401) {
+                    return res.sendStatus(404);
+                }
+                else {
+                    return res.sendStatus(status.code);
+                }
+            }
+            catch (error) {
+                log.error(`Error processing request: ${decodeURI(req.url)}`, error);
+                return res.sendStatus(400);
+            }
+        });
+        const recordsReadHandler = async (req, res) => {
+            const record = await RecordsRead.create({
+                filter: { recordId: req.params.id },
+            });
+            const reply = await this.dwn.processMessage(req.params.did, record.message);
+            return readReplyHandler(res, reply);
+        };
+        this.#api.get('/:did/read/records/:id', recordsReadHandler);
+        this.#api.get('/:did/records/:id', recordsReadHandler);
+        this.#api.get('/:did/query/protocols', async (req, res) => {
+            const query = await ProtocolsQuery.create({});
+            const { entries, status } = await this.dwn.processMessage(req.params.did, query.message);
+            if (status.code === 200) {
+                res.status(status.code);
+                res.json(entries);
+            }
+            else if (status.code === 401) {
+                return res.sendStatus(404);
+            }
+            else {
+                return res.sendStatus(status.code);
+            }
+        });
+        this.#api.get('/:did/query', async (req, res) => {
+            try {
+                // builds a nested object from flat keys with dot notation which may share the same parent path
+                // e.g. "did:dht:123/query?filter.protocol=foo&filter.protocolPath=bar" becomes
+                // {
+                //   filter: {
+                //     protocol: 'foo',
+                //     protocolPath: 'bar'
+                //   }
+                // }
+                const recordsQueryOptions = {};
+                for (const param in req.query) {
+                    const keys = param.split('.');
+                    const lastKey = keys.pop();
+                    const lastLevelObject = keys.reduce((obj, key) => obj[key] = obj[key] || {}, recordsQueryOptions);
+                    lastLevelObject[lastKey] = req.query[param];
+                }
+                const recordsQuery = await RecordsQuery.create({
+                    filter: recordsQueryOptions.filter,
+                    pagination: recordsQueryOptions.pagination,
+                    dateSort: recordsQueryOptions.dateSort,
+                });
+                // should always return a 200 status code with a JSON response
+                const reply = await this.dwn.processMessage(req.params.did, recordsQuery.message);
+                res.setHeader('content-type', 'application/json');
+                return res.json(reply);
+            }
+            catch (error) {
+                // error should only occur when we are unable to create the RecordsQuery message internally, making it a client error
+                return res.status(400).send(error);
+            }
+        });
+        this.#api.get('/', (_req, res) => {
+            // return a plain text string
+            res.setHeader('content-type', 'text/plain');
+            return res.send('please use a web5 client, for example: https://github.com/TBD54566975/web5-js ');
+        });
+        this.#api.post('/', async (req, res) => {
+            const dwnRpcRequestString = req.headers['dwn-request'];
+            if (!dwnRpcRequestString) {
+                const reply = createJsonRpcErrorResponse(uuidv4(), JsonRpcErrorCodes.BadRequest, 'request payload required.');
+                return res.status(400).json(reply);
+            }
+            let dwnRpcRequest;
+            try {
+                dwnRpcRequest = JSON.parse(dwnRpcRequestString);
+            }
+            catch (e) {
+                const reply = createJsonRpcErrorResponse(uuidv4(), JsonRpcErrorCodes.BadRequest, e.message);
+                return res.status(400).json(reply);
+            }
+            // Check whether data was provided in the request body
+            const contentLength = req.headers['content-length'];
+            const transferEncoding = req.headers['transfer-encoding'];
+            const requestDataStream = parseInt(contentLength) > 0 || transferEncoding !== undefined ? req : undefined;
+            const requestContext = {
+                dwn: this.dwn,
+                transport: 'http',
+                dataStream: requestDataStream,
+            };
+            const { jsonRpcResponse, dataStream: responseDataStream } = await jsonRpcRouter.handle(dwnRpcRequest, requestContext);
+            // If the handler catches a thrown exception and returns a JSON RPC InternalError, return the equivalent
+            // HTTP 500 Internal Server Error with the response.
+            if (jsonRpcResponse.error) {
+                requestCounter.inc({ method: dwnRpcRequest.method, error: 1 });
+                return res.status(500).json(jsonRpcResponse);
+            }
+            requestCounter.inc({
+                method: dwnRpcRequest.method,
+                status: jsonRpcResponse?.result?.reply?.status?.code || 0,
+            });
+            if (responseDataStream) {
+                res.setHeader('content-type', 'application/octet-stream');
+                res.setHeader('dwn-response', JSON.stringify(jsonRpcResponse));
+                return responseDataStream.pipe(res);
+            }
+            else {
+                return res.json(jsonRpcResponse);
+            }
+        });
+        this.#setupRegistrationRoutes();
+        this.#api.get('/info', (req, res) => {
+            res.setHeader('content-type', 'application/json');
+            const registrationRequirements = [];
+            if (config.registrationProofOfWorkEnabled) {
+                registrationRequirements.push('proof-of-work-sha256-v0');
+            }
+            if (config.termsOfServiceFilePath !== undefined) {
+                registrationRequirements.push('terms-of-service');
+            }
+            res.json({
+                url: config.baseUrl,
+                server: this.#packageInfo.server,
+                maxFileSize: config.maxRecordDataSize,
+                registrationRequirements: registrationRequirements,
+                version: this.#packageInfo.version,
+                sdkVersion: this.#packageInfo.sdkVersion,
+                webSocketSupport: config.webSocketSupport,
+            });
+        });
+        this.#setupWeb5ConnectServerRoutes();
+    }
+    #setupRegistrationRoutes() {
+        if (this.#config.registrationProofOfWorkEnabled) {
+            this.#api.get('/registration/proof-of-work', async (_req, res) => {
+                const proofOfWorkChallenge = this.registrationManager.getProofOfWorkChallenge();
+                res.json(proofOfWorkChallenge);
+            });
+        }
+        if (this.#config.termsOfServiceFilePath !== undefined) {
+            this.#api.get('/registration/terms-of-service', (_req, res) => res.send(this.registrationManager.getTermsOfService()));
+        }
+        if (this.#config.registrationStoreUrl !== undefined) {
+            this.#api.post('/registration', async (req, res) => {
+                const requestBody = req.body;
+                log.info('Registration request:', requestBody);
+                try {
+                    await this.registrationManager.handleRegistrationRequest(requestBody);
+                    res.status(200).json({ success: true });
+                }
+                catch (error) {
+                    const dwnServerError = error;
+                    if (dwnServerError.code !== undefined) {
+                        res.status(400).json(dwnServerError);
+                    }
+                    else {
+                        log.info('Error handling registration request:', error);
+                        res.status(500).json({ success: false });
+                    }
+                }
+            });
+        }
+    }
+    #setupWeb5ConnectServerRoutes() {
+        /**
+        * Endpoint allows a Client app (RP) to submit an Authorization Request.
+        * The Authorization Request is stored on the server, and a unique `request_uri` is returned to the Client app.
+        * The Client app can then provide this `request_uri` to the Provider app (wallet).
+        * The Provider app uses the `request_uri` to retrieve the stored Authorization Request.
+        */
+        this.#api.post('/connect/par', async (req, res) => {
+            log.info('Storing Pushed Authorization Request (PAR) request...');
+            // TODO: Add validation for request too large HTTP 413: https://github.com/TBD54566975/dwn-server/issues/146
+            // TODO: Add validation for too many requests HTTP 429: https://github.com/TBD54566975/dwn-server/issues/147
+            if (!req.body.request) {
+                return res.status(400).json({
+                    ok: false,
+                    status: {
+                        code: 400,
+                        message: "Bad Request: Missing 'request' parameter",
+                    },
+                });
+            }
+            // Validate that `request_uri` was NOT provided
+            if (req.body?.request?.request_uri) {
+                return res.status(400).json({
+                    ok: false,
+                    status: {
+                        code: 400,
+                        message: "Bad Request: 'request_uri' parameter is not allowed in PAR",
+                    },
+                });
+            }
+            const result = await this.web5ConnectServer.setWeb5ConnectRequest(req.body.request);
+            res.status(201).json(result);
+        });
+        /**
+        * Endpoint for the Provider to retrieve the Authorization Request from the request_uri
+        */
+        this.#api.get('/connect/authorize/:requestId.jwt', async (req, res) => {
+            log.info(`Retrieving Web5 Connect Request object of ID: ${req.params.requestId}...`);
+            // Look up the request object based on the requestId.
+            const requestObjectJwt = await this.web5ConnectServer.getWeb5ConnectRequest(req.params.requestId);
+            if (!requestObjectJwt) {
+                res.status(404).json({
+                    ok: false,
+                    status: { code: 404, message: 'Not Found' }
+                });
+            }
+            else {
+                res.set('Content-Type', 'application/jwt');
+                res.send(requestObjectJwt);
+            }
+        });
+        /**
+        * Endpoint that the Provider sends the Authorization Response to
+        */
+        this.#api.post('/connect/callback', async (req, res) => {
+            log.info('Storing Identity Provider (wallet) pushed response with ID token...');
+            // Store the ID token.
+            const idToken = req.body.id_token;
+            const state = req.body.state;
+            if (idToken !== undefined && state != undefined) {
+                await this.web5ConnectServer.setWeb5ConnectResponse(state, idToken);
+                res.status(201).json({
+                    ok: true,
+                    status: { code: 201, message: 'Created' }
+                });
+            }
+            else {
+                res.status(400).json({
+                    ok: false,
+                    status: { code: 400, message: 'Bad Request' }
+                });
+            }
+        });
+        /**
+        * Endpoint for the connecting Client to retrieve the Authorization Response
+        */
+        this.#api.get('/connect/token/:state.jwt', async (req, res) => {
+            log.info(`Retrieving ID token for state: ${req.params.state}...`);
+            // Look up the ID token.
+            const idToken = await this.web5ConnectServer.getWeb5ConnectResponse(req.params.state);
+            if (!idToken) {
+                res.status(404).json({
+                    ok: false,
+                    status: { code: 404, message: 'Not Found' }
+                });
+            }
+            else {
+                res.set('Content-Type', 'application/jwt');
+                res.send(idToken);
+            }
+        });
+    }
+    /**
+     * Starts the HTTP API endpoint on the given port.
+     * @returns The HTTP server instance.
+     */
+    async start(port) {
+        // promisify http.Server.listen() and await on it
+        await new Promise((resolve) => {
+            this.#server.listen(port, () => {
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stops the HTTP API endpoint.
+     */
+    async close() {
+        // promisify http.Server.close() and await on it
+        await new Promise((resolve, reject) => {
+            this.#server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        this.server.closeAllConnections();
+    }
+}
+//# sourceMappingURL=http-api.js.map