@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/json-rpc/server/safe_json_rpc_server.js

@@ -0,0 +1,570 @@
+import cors from '@koa/cors';
+import http from 'http';
+import { default as Koa } from 'koa';
+import bodyParser from 'koa-bodyparser';
+import compress from 'koa-compress';
+import Router from 'koa-router';
+import { format, inspect } from 'util';
+import { ZodError } from 'zod';
+import { createLogger } from '../../log/index.js';
+import { promiseWithResolvers } from '../../promise/utils.js';
+import { getSchemaParameters, parseWithOptionals, schemaHasMethod } from '../../schemas/index.js';
+import { Timer } from '../../timer/index.js';
+import { jsonStringify } from '../convert.js';
+import { assert } from '../js_utils.js';
+const defaultServerConfig = {
+    http200OnError: false,
+    maxBatchSize: 100,
+    maxBodySizeBytes: '1mb',
+    corsAllowedOrigins: [],
+    corsAllowedHeaders: []
+};
+function normalizeCorsOrigin(origin) {
+    if (origin === '*') {
+        return origin;
+    }
+    const url = new URL(origin);
+    if (![
+        'http:',
+        'https:'
+    ].includes(url.protocol)) {
+        throw new Error(`Invalid CORS origin protocol: ${origin}`);
+    }
+    if (url.username || url.password || url.pathname !== '' && url.pathname !== '/' || url.search || url.hash) {
+        throw new Error(`CORS allowed origin must not include credentials, a path, query parameters, or a fragment: ${origin}`);
+    }
+    return url.origin;
+}
+export class SafeJsonRpcServer {
+    proxy;
+    healthCheck;
+    extraMiddlewares;
+    diagnosticsMiddleware;
+    log;
+    /**
+   * The HTTP server accepting remote requests.
+   * This member field is initialized when the server is started.
+   */ httpServer;
+    config;
+    constructor(/** The proxy object to delegate requests to */ proxy, config = {}, /** Health check function */ healthCheck = ()=>true, /** Additional Koa middlewares */ extraMiddlewares = [], /** Additional per-request diagnostics middlewares */ diagnosticsMiddleware, /** Logger */ log = createLogger('json-rpc:server')){
+        this.proxy = proxy;
+        this.healthCheck = healthCheck;
+        this.extraMiddlewares = extraMiddlewares;
+        this.diagnosticsMiddleware = diagnosticsMiddleware;
+        this.log = log;
+        this.config = {
+            ...defaultServerConfig,
+            ...config
+        };
+        this.config.corsAllowedOrigins = this.config.corsAllowedOrigins.map(normalizeCorsOrigin);
+        // handle empty string
+        if (!this.config.maxBodySizeBytes) {
+            this.config.maxBodySizeBytes = defaultServerConfig.maxBodySizeBytes;
+        }
+    }
+    /** Returns the status of this server, including per-component health when the health check reports it. */ getStatus() {
+        return Promise.resolve(this.healthCheck()).then((result)=>{
+            const { healthy, details } = normalizeStatusCheckResult(result);
+            return {
+                ok: healthy,
+                ...details
+            };
+        });
+    }
+    isHealthy() {
+        return this.getStatus().then((status)=>status.ok);
+    }
+    /**
+   * Get an express app object.
+   * @param prefix - Our server prefix.
+   * @returns The app object.
+   */ getApp(prefix = '') {
+        const router = this.getRouter(prefix);
+        const exceptionHandler = async (ctx, next)=>{
+            try {
+                await next();
+            } catch (err) {
+                const method = ctx.request.body?.method ?? 'unknown';
+                this.log.warn(`Uncaught error in JSON RPC server call ${method}: ${inspect(err)}`);
+                if (err && 'name' in err && err.name === 'BadRequestError') {
+                    ctx.status = 400;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32000,
+                            message: `Bad request: ${err.message}`
+                        }
+                    };
+                } else if (err && err instanceof SyntaxError) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32700,
+                            message: `Parse error: ${err.message}`
+                        }
+                    };
+                } else {
+                    ctx.status = 500;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        id: null,
+                        error: {
+                            code: -32603,
+                            message: err.message ?? 'Internal error'
+                        }
+                    };
+                }
+            }
+        };
+        const jsonResponse = async (ctx, next)=>{
+            try {
+                await next();
+                if (ctx.body && typeof ctx.body === 'object') {
+                    ctx.body = jsonStringify(ctx.body);
+                }
+            } catch (err) {
+                ctx.status = 500;
+                ctx.body = {
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32700,
+                        message: `Unable to serialize response: ${err.message}`
+                    }
+                };
+            }
+        };
+        const app = new Koa();
+        app.on('error', (error)=>{
+            this.log.error(`Error on API handler: ${error}`);
+        });
+        app.use(compress({
+            br: false
+        }));
+        app.use(jsonResponse);
+        const corsAllowedHeaders = this.config.corsAllowedHeaders.length > 0 ? {
+            allowHeaders: this.config.corsAllowedHeaders
+        } : {};
+        if (this.config.corsAllowedOrigins.length === 0) {
+            app.use(cors(corsAllowedHeaders));
+        } else {
+            const allowedOrigins = new Set(this.config.corsAllowedOrigins);
+            const allowAnyOrigin = allowedOrigins.has('*');
+            app.use(cors({
+                origin: (ctx)=>{
+                    const origin = ctx.get('Origin');
+                    if (!origin) {
+                        return '';
+                    }
+                    if (allowAnyOrigin) {
+                        return origin;
+                    }
+                    if (allowedOrigins.has(origin)) {
+                        return origin;
+                    }
+                    return '';
+                },
+                credentials: true,
+                ...corsAllowedHeaders
+            }));
+        }
+        for (const middleware of this.extraMiddlewares){
+            app.use(middleware);
+        }
+        app.use(exceptionHandler);
+        app.use(bodyParser({
+            jsonLimit: this.config.maxBodySizeBytes,
+            enableTypes: [
+                'json'
+            ]
+        }));
+        app.use(router.routes());
+        app.use(router.allowedMethods());
+        return app;
+    }
+    /**
+   * Get a router object wrapping our RPC class.
+   * @param prefix - The server prefix.
+   * @returns The router object.
+   */ getRouter(prefix) {
+        const router = new Router({
+            prefix
+        });
+        // "JSON RPC mode" where a single endpoint is used and the method is given in the request body
+        router.post('/', async (ctx)=>{
+            if (Array.isArray(ctx.request.body)) {
+                if (ctx.request.body.length > this.config.maxBatchSize) {
+                    ctx.status = this.config.http200OnError ? 200 : 400;
+                    ctx.body = {
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32600,
+                            message: `Batch request exceeds maximum allowed size of ${this.config.maxBatchSize}`
+                        },
+                        id: null
+                    };
+                    return;
+                }
+                const resp = await this.processBatch(ctx.request.body, ctx.request.headers);
+                if (Array.isArray(resp)) {
+                    ctx.status = 200;
+                    ctx.body = resp;
+                } else {
+                    ctx.status = this.config.http200OnError ? 200 : 400;
+                    ctx.body = resp;
+                }
+            } else {
+                const resp = await this.processRequest(ctx.request.body, ctx.request.headers);
+                if ('error' in resp) {
+                    ctx.status = this.config.http200OnError ? 200 : 400;
+                }
+                ctx.body = resp;
+            }
+        });
+        return router;
+    }
+    async processBatch(requests, headers = {}) {
+        if (requests.length === 0) {
+            return {
+                jsonrpc: '2.0',
+                error: {
+                    code: -32600,
+                    message: 'Invalid Request'
+                },
+                id: null
+            };
+        }
+        const results = await Promise.allSettled(requests.map((req)=>this.processRequest(req, headers)));
+        return results.map((res)=>{
+            if (res.status === 'fulfilled') {
+                return res.value;
+            }
+            this.log.warn(`Uncaught error executing request in batch: ${res.reason}.`);
+            return {
+                jsonrpc: '2.0',
+                error: {
+                    code: -32603,
+                    message: 'Internal error'
+                },
+                id: null
+            };
+        });
+    }
+    async processRequest(request, headers = {}) {
+        if (!request || typeof request !== 'object') {
+            return {
+                jsonrpc: '2.0',
+                error: {
+                    code: -32600,
+                    message: 'Invalid Request'
+                },
+                id: null
+            };
+        }
+        const { params = [], jsonrpc = '2.0', id, method } = request;
+        if (typeof method !== 'string' || !method) {
+            return {
+                jsonrpc: '2.0',
+                id,
+                error: {
+                    code: -32600,
+                    message: `Invalid request`
+                }
+            };
+        }
+        // Fail if not a registered function in the proxy
+        if (typeof method !== 'string' || method === 'constructor' || !this.proxy.hasMethod(method)) {
+            return {
+                jsonrpc,
+                id,
+                error: {
+                    code: -32601,
+                    message: `Method not found: ${method}`
+                }
+            };
+        } else {
+            try {
+                let result;
+                if (this.diagnosticsMiddleware) {
+                    const diagnosticsData = {
+                        id: id ?? null,
+                        method,
+                        params,
+                        headers
+                    };
+                    await this.diagnosticsMiddleware(diagnosticsData, async ()=>{
+                        result = await this.proxy.call(method, params, (durationMs, succeeded)=>{
+                            diagnosticsData.requestValidationDurationMs = durationMs;
+                            diagnosticsData.requestValidationSucceeded = succeeded;
+                        });
+                    });
+                } else {
+                    result = await this.proxy.call(method, params);
+                }
+                // Coerce an undefined return value to null so the response always carries a `result` key.
+                // JSON.stringify drops undefined-valued keys, which would otherwise produce a JSON-RPC
+                // response with neither `result` nor `error` — a spec violation that leaves callers unable
+                // to distinguish "not found" from a malformed response.
+                return {
+                    jsonrpc,
+                    id,
+                    result: result ?? null
+                };
+            } catch (err) {
+                if (err && err instanceof ZodError) {
+                    const message = err.issues.map((e)=>`${e.message} (${e.path.join('.')})`).join('. ') || 'Validation error';
+                    return {
+                        jsonrpc: '2.0',
+                        id,
+                        error: {
+                            code: -32701,
+                            message
+                        }
+                    };
+                } else if (err) {
+                    return {
+                        jsonrpc,
+                        id,
+                        error: {
+                            code: -32702,
+                            data: err.data,
+                            message: err.message
+                        }
+                    };
+                } else {
+                    return {
+                        jsonrpc,
+                        id,
+                        error: {
+                            code: -32702,
+                            message: 'Error executing request'
+                        }
+                    };
+                }
+            }
+        }
+    }
+    /**
+   * Start this server with koa.
+   * @param port - Port number.
+   * @param prefix - Prefix string.
+   */ start(port, prefix = '') {
+        if (this.httpServer) {
+            throw new Error('Server is already listening');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this.httpServer = http.createServer(this.getApp(prefix).callback());
+        this.httpServer.listen(port);
+    }
+    /**
+   * Stops the HTTP server
+   */ stop() {
+        if (!this.httpServer) {
+            return Promise.resolve();
+        }
+        const { promise, resolve, reject } = promiseWithResolvers();
+        this.httpServer.close((err)=>{
+            if (err) {
+                reject(err);
+            } else {
+                resolve();
+            }
+        });
+        return promise;
+    }
+    /**
+   * Explicitly calls an RPC method.
+   * @param methodName - The RPC method.
+   * @param jsonParams - The RPC parameters.
+   * @returns The remote result.
+   */ async call(methodName, jsonParams = []) {
+        return await this.proxy.call(methodName, jsonParams);
+    }
+}
+function normalizeStatusCheckResult(result) {
+    return typeof result === 'boolean' ? {
+        healthy: result
+    } : result;
+}
+/**
+ * Forwards calls to a handler. Relies on a schema definition to validate and convert inputs
+ * before forwarding calls, and then converts outputs into JSON using default conversions.
+ */ export class SafeJsonProxy {
+    handler;
+    log;
+    schema;
+    constructor(handler, schema){
+        this.handler = handler;
+        this.log = createLogger('json-rpc:proxy');
+        this.schema = schema;
+    }
+    /**
+   * Call an RPC method.
+   * @param methodName - The RPC method.
+   * @param jsonParams - The RPC parameters.
+   * @returns The remote result.
+   */ async call(methodName, jsonParams = [], onRequestValidated) {
+        this.log.debug(format(`request`, methodName, jsonParams));
+        assert(schemaHasMethod(this.schema, methodName), `Method ${methodName} not found in schema`);
+        const method = this.handler[methodName];
+        assert(typeof method === 'function', `Method ${methodName} is not a function`);
+        const validationTimer = new Timer();
+        let args;
+        try {
+            assert(Array.isArray(jsonParams), `Params to ${methodName} is not an array: ${jsonParams}`);
+            args = await parseWithOptionals(jsonParams, getSchemaParameters(this.schema[methodName]));
+            onRequestValidated?.(validationTimer.ms(), true);
+        } catch (error) {
+            onRequestValidated?.(validationTimer.ms(), false);
+            throw error;
+        }
+        const ret = await method.apply(this.handler, args);
+        this.log.debug(format('response', methodName, ret));
+        return ret;
+    }
+    hasMethod(methodName) {
+        return schemaHasMethod(this.schema, methodName) && typeof this.handler[methodName] === 'function';
+    }
+}
+class NamespacedSafeJsonProxy {
+    proxies = {};
+    constructor(handlers){
+        for (const [namespace, [handler, schema]] of Object.entries(handlers)){
+            this.proxies[namespace] = new SafeJsonProxy(handler, schema);
+        }
+    }
+    call(namespacedMethodName, jsonParams = [], onRequestValidated) {
+        const [namespace, methodName] = namespacedMethodName.split('_', 2);
+        assert(namespace && methodName, `Invalid namespaced method name: ${namespacedMethodName}`);
+        const handler = this.proxies[namespace];
+        assert(handler, `Namespace not found: ${namespace}`);
+        return handler.call(methodName, jsonParams, onRequestValidated);
+    }
+    hasMethod(namespacedMethodName) {
+        const [namespace, methodName] = namespacedMethodName.split('_', 2);
+        const handler = this.proxies[namespace];
+        return handler?.hasMethod(methodName);
+    }
+}
+export function makeHandler(handler, schema) {
+    return [
+        handler,
+        schema
+    ];
+}
+function makeAggregateHealthcheck(namedHandlers, log) {
+    return async ()=>{
+        try {
+            const entries = await Promise.all(Object.entries(namedHandlers).map(async ([name, [, , healthCheck]])=>{
+                const { healthy, details } = normalizeStatusCheckResult(healthCheck ? await healthCheck() : true);
+                return [
+                    name,
+                    {
+                        healthy,
+                        ...details
+                    }
+                ];
+            }));
+            const components = Object.fromEntries(entries);
+            const failed = entries.filter(([, status])=>!status.healthy).map(([name])=>name);
+            if (failed.length > 0) {
+                log?.warn(`Health check failed for ${failed.join(', ')}`, {
+                    components
+                });
+            }
+            return {
+                healthy: failed.length === 0,
+                details: {
+                    components
+                }
+            };
+        } catch (err) {
+            log?.error(`Error during health check`, err);
+            return {
+                healthy: false
+            };
+        }
+    };
+}
+/**
+ * Creates a single SafeJsonRpcServer from multiple handlers.
+ * @param servers - List of handlers to be combined.
+ * @returns A single JsonRpcServer with namespaced methods.
+ */ export function createNamespacedSafeJsonRpcServer(handlers, options = {}) {
+    const { diagnostic, middlewares, log } = options;
+    const proxy = new NamespacedSafeJsonProxy(handlers);
+    const healthCheck = makeAggregateHealthcheck(handlers, log);
+    return new SafeJsonRpcServer(proxy, options, healthCheck, middlewares, diagnostic, log);
+}
+export function createSafeJsonRpcServer(handler, schema, options = {}) {
+    const { diagnostic, log, healthCheck, middlewares: extraMiddlewares } = options;
+    const proxy = new SafeJsonProxy(handler, schema);
+    return new SafeJsonRpcServer(proxy, options, healthCheck, extraMiddlewares, diagnostic, log);
+}
+/**
+ * Creates a router for handling a status request that returns a 200 status code when healthy and a 500 otherwise,
+ * along with the reported status as a JSON body.
+ * @param getCurrentStatus - Function returning the current status of the server.
+ * @param apiPrefix - The prefix to use for all api requests
+ * @returns - The router for handling status requests.
+ */ export function createStatusRouter(getCurrentStatus, apiPrefix = '') {
+    const router = new Router({
+        prefix: `${apiPrefix}`
+    });
+    router.get('/status', async (ctx)=>{
+        let status;
+        try {
+            status = await getCurrentStatus();
+        } catch  {
+            status = {
+                ok: false
+            };
+        }
+        ctx.status = status.ok === true ? 200 : 500;
+        ctx.type = 'application/json';
+        ctx.body = status;
+    });
+    return router;
+}
+/**
+ * Wraps a JsonRpcServer in a nodejs http server and starts it.
+ * Installs a status router that reports the status of the server, using its getStatus method when available so that
+ * per-component health is included, and falling back to isHealthy otherwise.
+ * Returns once starts listening unless noWait is set.
+ * @returns A running http server.
+ */ export async function startHttpRpcServer(rpcServer, options = {}) {
+    const app = rpcServer.getApp(options.apiPrefix);
+    const getStatus = rpcServer.getStatus ? rpcServer.getStatus.bind(rpcServer) : async ()=>({
+            ok: await rpcServer.isHealthy() === true
+        });
+    const statusRouter = createStatusRouter(getStatus, options.apiPrefix);
+    app.use(statusRouter.routes()).use(statusRouter.allowedMethods());
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    const httpServer = http.createServer(app.callback());
+    if (options.timeoutMs) {
+        httpServer.timeout = options.timeoutMs;
+    }
+    if (options.keepAliveTimeoutMs !== undefined) {
+        httpServer.keepAliveTimeout = options.keepAliveTimeoutMs;
+    }
+    if (options.headersTimeoutMs !== undefined) {
+        httpServer.headersTimeout = options.headersTimeoutMs;
+    }
+    const { promise, resolve } = promiseWithResolvers();
+    const listenPort = options.port ? typeof options.port === 'string' ? parseInt(options.port) : options.port : 0;
+    httpServer.listen({
+        host: options.host,
+        port: listenPort,
+        reuseAddress: true
+    }, ()=>resolve());
+    // Wait until listen callback is called
+    if (!options.noWait) {
+        await promise;
+    }
+    const port = httpServer.address().port;
+    return Object.assign(httpServer, {
+        port
+    });
+}

package/dest/json-rpc/test/index.d.ts

@@ -0,0 +1,2 @@
+export { createJsonRpcTestSetup, type JsonRpcTestContext } from './integration.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9qc29uLXJwYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sa0JBQWtCLENBQUMifQ==

package/dest/json-rpc/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}

package/dest/json-rpc/test/index.js

@@ -0,0 +1 @@
+export { createJsonRpcTestSetup } from './integration.js';

package/dest/json-rpc/test/integration.d.ts

@@ -0,0 +1,14 @@
+import type http from 'http';
+import type { ApiSchemaFor } from '../../schemas/api.js';
+import { type SafeJsonRpcClientOptions } from '../client/safe_json_rpc_client.js';
+import { type SafeJsonRpcServer, type SafeJsonRpcServerOptions } from '../server/safe_json_rpc_server.js';
+export type JsonRpcTestContext<T extends object> = {
+    server: SafeJsonRpcServer;
+    client: T;
+    httpServer: http.Server & {
+        port: number;
+    };
+    url: string;
+};
+export declare function createJsonRpcTestSetup<T extends object>(handler: T, schema: ApiSchemaFor<T>, serverOptions?: SafeJsonRpcServerOptions, clientOptions?: SafeJsonRpcClientOptions): Promise<JsonRpcTestContext<T>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWdyYXRpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9qc29uLXJwYy90ZXN0L2ludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXpELE9BQU8sRUFBRSxLQUFLLHdCQUF3QixFQUEyQixNQUFNLG1DQUFtQyxDQUFDO0FBQzNHLE9BQU8sRUFDTCxLQUFLLGlCQUFpQixFQUN0QixLQUFLLHdCQUF3QixFQUc5QixNQUFNLG1DQUFtQyxDQUFDO0FBRTNDLE1BQU0sTUFBTSxrQkFBa0IsQ0FBQyxDQUFDLFNBQVMsTUFBTSxJQUFJO0lBQ2pELE1BQU0sRUFBRSxpQkFBaUIsQ0FBQztJQUMxQixNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ1YsVUFBVSxFQUFFLElBQUksQ0FBQyxNQUFNLEdBQUc7UUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFBO0tBQUUsQ0FBQztJQUMzQyxHQUFHLEVBQUUsTUFBTSxDQUFDO0NBQ2IsQ0FBQztBQUVGLHdCQUFzQixzQkFBc0IsQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUMzRCxPQUFPLEVBQUUsQ0FBQyxFQUNWLE1BQU0sRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFDLEVBQ3ZCLGFBQWEsR0FBRSx3QkFBNkIsRUFDNUMsYUFBYSxHQUFFLHdCQUE2QixHQUMzQyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FVaEMifQ==

package/dest/json-rpc/test/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/test/integration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAE,KAAK,wBAAwB,EAA2B,MAAM,mCAAmC,CAAC;AAC3G,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAG9B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI;IACjD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,CAAC,CAAC;IACV,UAAU,EAAE,IAAI,CAAC,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,wBAAsB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EAC3D,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,aAAa,GAAE,wBAA6B,EAC5C,aAAa,GAAE,wBAA6B,GAC3C,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAUhC"}

package/dest/json-rpc/test/integration.js

@@ -0,0 +1,21 @@
+import { makeFetch } from '../client/fetch.js';
+import { createSafeJsonRpcClient } from '../client/safe_json_rpc_client.js';
+import { createSafeJsonRpcServer, startHttpRpcServer } from '../server/safe_json_rpc_server.js';
+export async function createJsonRpcTestSetup(handler, schema, serverOptions = {}, clientOptions = {}) {
+    const server = createSafeJsonRpcServer(handler, schema, serverOptions);
+    const httpServer = await startHttpRpcServer(server, {
+        host: '127.0.0.1'
+    });
+    const noRetryFetch = makeFetch([], true);
+    const url = `http://127.0.0.1:${httpServer.port}`;
+    const client = createSafeJsonRpcClient(url, schema, {
+        fetch: noRetryFetch,
+        ...clientOptions
+    });
+    return {
+        server,
+        client,
+        httpServer,
+        url
+    };
+}

package/dest/log/aws-logger-config.d.ts

@@ -0,0 +1,8 @@
+/** Pino configuration that adds OpenTelemetry severity fields understood by CloudWatch Logs. */
+export declare const AWSCloudLoggerConfig: {
+    messageKey: string;
+    formatters: {
+        level(label: string, level: number): object;
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLWxvZ2dlci1jb25maWcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2cvYXdzLWxvZ2dlci1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBdUJBLGdHQUFnRztBQUNoRyxlQUFPLE1BQU0sb0JBQW9COzs7OztDQU9ILENBQUMifQ==

package/dest/log/aws-logger-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-logger-config.d.ts","sourceRoot":"","sources":["../../src/log/aws-logger-config.ts"],"names":[],"mappings":"AAuBA,gGAAgG;AAChG,eAAO,MAAM,oBAAoB;;;;;CAOH,CAAC"}

package/dest/log/aws-logger-config.js

@@ -0,0 +1,55 @@
+function getSeverity(label) {
+    switch(label){
+        case 'trace':
+            return {
+                severityText: 'TRACE',
+                severityNumber: 1
+            };
+        case 'debug':
+            return {
+                severityText: 'DEBUG',
+                severityNumber: 5
+            };
+        case 'verbose':
+            return {
+                severityText: 'VERBOSE',
+                severityNumber: 7
+            };
+        case 'info':
+            return {
+                severityText: 'INFO',
+                severityNumber: 9
+            };
+        case 'warn':
+            return {
+                severityText: 'WARN',
+                severityNumber: 13
+            };
+        case 'error':
+            return {
+                severityText: 'ERROR',
+                severityNumber: 17
+            };
+        case 'fatal':
+            return {
+                severityText: 'FATAL',
+                severityNumber: 21
+            };
+        default:
+            return {
+                severityText: 'UNSPECIFIED',
+                severityNumber: 0
+            };
+    }
+}
+/** Pino configuration that adds OpenTelemetry severity fields understood by CloudWatch Logs. */ export const AWSCloudLoggerConfig = {
+    messageKey: 'msg',
+    formatters: {
+        level (label, level) {
+            return {
+                level,
+                ...getSeverity(label)
+            };
+        }
+    }
+};