@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@whatwg-node/server/esm/createServerAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServerAdapter.js","sources":["../../../../../node_modules/@whatwg-node/server/esm/createServerAdapter.js"],"sourcesContent":["import { chain, getInstrumented } from '@envelop/instrumentation';\nimport { AsyncDisposableStack, DisposableSymbols } from '@whatwg-node/disposablestack';\nimport * as DefaultFetchAPI from '@whatwg-node/fetch';\nimport { handleMaybePromise, unfakePromise } from '@whatwg-node/promise-helpers';\nimport { completeAssign, createCustomAbortControllerSignal, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, normalizeNodeRequest, sendNodeResponse, } from './utils.js';\nimport { fakePromise, getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './uwebsockets.js';\n// Required for envs like nextjs edge runtime\nfunction isRequestAccessible(serverContext) {\n    try {\n        return !!serverContext?.request;\n    }\n    catch {\n        return false;\n    }\n}\nconst EMPTY_OBJECT = {};\nfunction createServerAdapter(serverAdapterBaseObject, options) {\n    const useSingleWriteHead = options?.__useSingleWriteHead == null ? true : options.__useSingleWriteHead;\n    const fetchAPI = {\n        ...DefaultFetchAPI,\n        ...options?.fetchAPI,\n    };\n    const useCustomAbortCtrl = options?.__useCustomAbortCtrl == null\n        ? fetchAPI.Request !== globalThis.Request\n        : options.__useCustomAbortCtrl;\n    const givenHandleRequest = typeof serverAdapterBaseObject === 'function'\n        ? serverAdapterBaseObject\n        : serverAdapterBaseObject.handle;\n    const onRequestHooks = [];\n    const onResponseHooks = [];\n    let instrumentation;\n    const waitUntilPromises = new Set();\n    let _disposableStack;\n    function ensureDisposableStack() {\n        if (!_disposableStack) {\n            _disposableStack = new AsyncDisposableStack();\n            if (options?.disposeOnProcessTerminate) {\n                ensureDisposableStackRegisteredForTerminateEvents(_disposableStack);\n            }\n            _disposableStack.defer(() => {\n                if (waitUntilPromises.size > 0) {\n                    return Promise.allSettled(waitUntilPromises).then(() => {\n                        waitUntilPromises.clear();\n                    }, () => {\n                        waitUntilPromises.clear();\n                    });\n                }\n            });\n        }\n        return _disposableStack;\n    }\n    function waitUntil(maybePromise) {\n        // Ensure that the disposable stack is created\n        if (isPromise(maybePromise)) {\n            ensureDisposableStack();\n            waitUntilPromises.add(maybePromise);\n            maybePromise.then(() => {\n                waitUntilPromises.delete(maybePromise);\n            }, err => {\n                console.error(`Unexpected error while waiting: ${err.message || err}`);\n                waitUntilPromises.delete(maybePromise);\n            });\n        }\n    }\n    if (options?.plugins != null) {\n        for (const plugin of options.plugins) {\n            if (plugin.instrumentation) {\n                instrumentation = instrumentation\n                    ? chain(instrumentation, plugin.instrumentation)\n                    : plugin.instrumentation;\n            }\n            if (plugin.onRequest) {\n                onRequestHooks.push(plugin.onRequest);\n            }\n            if (plugin.onResponse) {\n                onResponseHooks.push(plugin.onResponse);\n            }\n            const disposeFn = plugin[DisposableSymbols.dispose];\n            if (disposeFn) {\n                ensureDisposableStack().defer(disposeFn);\n            }\n            const asyncDisposeFn = plugin[DisposableSymbols.asyncDispose];\n            if (asyncDisposeFn) {\n                ensureDisposableStack().defer(asyncDisposeFn);\n            }\n            if (plugin.onDispose) {\n                ensureDisposableStack().defer(plugin.onDispose);\n            }\n        }\n    }\n    let handleRequest = onRequestHooks.length > 0 || onResponseHooks.length > 0\n        ? function handleRequest(request, serverContext) {\n            let requestHandler = givenHandleRequest;\n            let response;\n            if (onRequestHooks.length === 0) {\n                return handleEarlyResponse();\n            }\n            let url = request['parsedUrl'] ||\n                new Proxy(EMPTY_OBJECT, {\n                    get(_target, prop, _receiver) {\n                        url = new fetchAPI.URL(request.url, 'http://localhost');\n                        return Reflect.get(url, prop, url);\n                    },\n                });\n            function handleResponse(response) {\n                if (onResponseHooks.length === 0) {\n                    return response;\n                }\n                return handleMaybePromise(() => iterateAsyncVoid(onResponseHooks, onResponseHook => onResponseHook({\n                    request,\n                    response,\n                    serverContext,\n                    setResponse(newResponse) {\n                        response = newResponse;\n                    },\n                    fetchAPI,\n                })), () => response);\n            }\n            function handleEarlyResponse() {\n                if (!response) {\n                    return handleMaybePromise(() => requestHandler(request, serverContext), handleResponse);\n                }\n                return handleResponse(response);\n            }\n            return handleMaybePromise(() => iterateAsyncVoid(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({\n                request,\n                setRequest(newRequest) {\n                    request = newRequest;\n                },\n                serverContext,\n                fetchAPI,\n                url,\n                requestHandler,\n                setRequestHandler(newRequestHandler) {\n                    requestHandler = newRequestHandler;\n                },\n                endResponse(newResponse) {\n                    response = newResponse;\n                    if (newResponse) {\n                        stopEarly();\n                    }\n                },\n            })), handleEarlyResponse);\n        }\n        : givenHandleRequest;\n    if (instrumentation?.request) {\n        const originalRequestHandler = handleRequest;\n        handleRequest = (request, initialContext) => {\n            return getInstrumented({ request }).asyncFn(instrumentation.request, originalRequestHandler)(request, initialContext);\n        };\n    }\n    // TODO: Remove this on the next major version\n    function handleNodeRequest(nodeRequest, ...ctx) {\n        const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};\n        // Ensure `waitUntil` is available in the server context\n        if (!serverContext.waitUntil) {\n            serverContext.waitUntil = waitUntil;\n        }\n        const request = normalizeNodeRequest(nodeRequest, fetchAPI, undefined, useCustomAbortCtrl);\n        return handleRequest(request, serverContext);\n    }\n    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {\n        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;\n        const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};\n        // Ensure `waitUntil` is available in the server context\n        if (!serverContext.waitUntil) {\n            serverContext.waitUntil = waitUntil;\n        }\n        const request = normalizeNodeRequest(nodeRequest, fetchAPI, nodeResponse, useCustomAbortCtrl);\n        return handleRequest(request, serverContext);\n    }\n    function requestListener(nodeRequest, nodeResponse, ...ctx) {\n        const defaultServerContext = {\n            req: nodeRequest,\n            res: nodeResponse,\n            waitUntil,\n        };\n        return unfakePromise(fakePromise()\n            .then(() => handleNodeRequestAndResponse(nodeRequest, nodeResponse, defaultServerContext, ...ctx))\n            .catch(err => handleErrorFromRequestHandler(err, fetchAPI.Response))\n            .then(response => sendNodeResponse(response, nodeResponse, nodeRequest, useSingleWriteHead))\n            .catch(err => console.error(`Unexpected error while handling request: ${err.message || err}`)));\n    }\n    function handleUWS(res, req, ...ctx) {\n        const defaultServerContext = {\n            res,\n            req,\n            waitUntil,\n        };\n        const filteredCtxParts = ctx.filter(partCtx => partCtx != null);\n        const serverContext = filteredCtxParts.length > 0\n            ? completeAssign(defaultServerContext, ...ctx)\n            : defaultServerContext;\n        const controller = useCustomAbortCtrl\n            ? createCustomAbortControllerSignal()\n            : new AbortController();\n        const originalResEnd = res.end.bind(res);\n        let resEnded = false;\n        res.end = function (data) {\n            resEnded = true;\n            return originalResEnd(data);\n        };\n        const originalOnAborted = res.onAborted.bind(res);\n        originalOnAborted(function () {\n            controller.abort();\n        });\n        res.onAborted = function (cb) {\n            controller.signal.addEventListener('abort', cb, { once: true });\n        };\n        const request = getRequestFromUWSRequest({\n            req,\n            res,\n            fetchAPI,\n            controller,\n        });\n        return handleMaybePromise(() => handleMaybePromise(() => handleRequest(request, serverContext), response => response, err => handleErrorFromRequestHandler(err, fetchAPI.Response)), response => {\n            if (!controller.signal.aborted && !resEnded) {\n                return handleMaybePromise(() => sendResponseToUwsOpts(res, response, controller, fetchAPI), r => r, err => {\n                    console.error(`Unexpected error while handling request: ${err.message || err}`);\n                });\n            }\n        });\n    }\n    function handleEvent(event, ...ctx) {\n        if (!event.respondWith || !event.request) {\n            throw new TypeError(`Expected FetchEvent, got ${event}`);\n        }\n        const filteredCtxParts = ctx.filter(partCtx => partCtx != null);\n        const serverContext = filteredCtxParts.length > 0\n            ? completeAssign({}, event, ...filteredCtxParts)\n            : isolateObject(event);\n        const response$ = handleRequest(event.request, serverContext);\n        event.respondWith(response$);\n    }\n    function handleRequestWithWaitUntil(request, ...ctx) {\n        const filteredCtxParts = ctx.filter(partCtx => partCtx != null);\n        const serverContext = filteredCtxParts.length > 1\n            ? completeAssign({}, ...filteredCtxParts)\n            : isolateObject(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null\n                ? waitUntil\n                : undefined);\n        return handleRequest(request, serverContext);\n    }\n    const fetchFn = (input, ...maybeCtx) => {\n        if (typeof input === 'string' || 'href' in input) {\n            const [initOrCtx, ...restOfCtx] = maybeCtx;\n            if (isRequestInit(initOrCtx)) {\n                const request = new fetchAPI.Request(input, initOrCtx);\n                const res$ = handleRequestWithWaitUntil(request, ...restOfCtx);\n                const signal = initOrCtx.signal;\n                if (signal) {\n                    return handleAbortSignalAndPromiseResponse(res$, signal);\n                }\n                return res$;\n            }\n            const request = new fetchAPI.Request(input);\n            return handleRequestWithWaitUntil(request, ...maybeCtx);\n        }\n        const res$ = handleRequestWithWaitUntil(input, ...maybeCtx);\n        return handleAbortSignalAndPromiseResponse(res$, input.signal);\n    };\n    const genericRequestHandler = (input, ...maybeCtx) => {\n        // If it is a Node request\n        const [initOrCtxOrRes, ...restOfCtx] = maybeCtx;\n        if (isNodeRequest(input)) {\n            if (!isServerResponse(initOrCtxOrRes)) {\n                throw new TypeError(`Expected ServerResponse, got ${initOrCtxOrRes}`);\n            }\n            return requestListener(input, initOrCtxOrRes, ...restOfCtx);\n        }\n        if (isUWSResponse(input)) {\n            return handleUWS(input, initOrCtxOrRes, ...restOfCtx);\n        }\n        if (isServerResponse(initOrCtxOrRes)) {\n            throw new TypeError('Got Node response without Node request');\n        }\n        // Is input a container object over Request?\n        if (isRequestAccessible(input)) {\n            // Is it FetchEvent?\n            if (isFetchEvent(input)) {\n                return handleEvent(input, ...maybeCtx);\n            }\n            // In this input is also the context\n            return handleRequestWithWaitUntil(input.request, input, ...maybeCtx);\n        }\n        // Or is it Request itself?\n        // Then ctx is present and it is the context\n        return fetchFn(input, ...maybeCtx);\n    };\n    const adapterObj = {\n        handleRequest: handleRequestWithWaitUntil,\n        fetch: fetchFn,\n        handleNodeRequest,\n        handleNodeRequestAndResponse,\n        requestListener,\n        handleEvent,\n        handleUWS,\n        handle: genericRequestHandler,\n        get disposableStack() {\n            return ensureDisposableStack();\n        },\n        [DisposableSymbols.asyncDispose]() {\n            if (_disposableStack && !_disposableStack.disposed) {\n                return _disposableStack.disposeAsync();\n            }\n            return fakePromise();\n        },\n        dispose() {\n            if (_disposableStack && !_disposableStack.disposed) {\n                return _disposableStack.disposeAsync();\n            }\n            return fakePromise();\n        },\n        waitUntil,\n    };\n    const serverAdapter = new Proxy(genericRequestHandler, {\n        // It should have all the attributes of the handler function and the server instance\n        has: (_, prop) => {\n            return (prop in adapterObj ||\n                prop in genericRequestHandler ||\n                (serverAdapterBaseObject && prop in serverAdapterBaseObject));\n        },\n        get: (_, prop) => {\n            // Somehow Deno and Node 24 don't like bound dispose functions\n            if (globalThis.Deno || prop === Symbol.asyncDispose || prop === Symbol.dispose) {\n                const adapterProp = Reflect.get(adapterObj, prop, adapterObj);\n                if (adapterProp) {\n                    return adapterProp;\n                }\n            }\n            const adapterProp = adapterObj[prop];\n            if (adapterProp) {\n                if (adapterProp.bind) {\n                    return adapterProp.bind(adapterObj);\n                }\n                return adapterProp;\n            }\n            const handleProp = genericRequestHandler[prop];\n            if (handleProp) {\n                if (handleProp.bind) {\n                    return handleProp.bind(genericRequestHandler);\n                }\n                return handleProp;\n            }\n            if (serverAdapterBaseObject) {\n                const serverAdapterBaseObjectProp = serverAdapterBaseObject[prop];\n                if (serverAdapterBaseObjectProp) {\n                    if (serverAdapterBaseObjectProp.bind) {\n                        return function (...args) {\n                            const returnedVal = serverAdapterBaseObject[prop](...args);\n                            if (returnedVal === serverAdapterBaseObject) {\n                                return serverAdapter;\n                            }\n                            return returnedVal;\n                        };\n                    }\n                    return serverAdapterBaseObjectProp;\n                }\n            }\n        },\n        apply(_, __, args) {\n            return genericRequestHandler(...args);\n        },\n    });\n    return serverAdapter;\n}\nexport { createServerAdapter };\n"],"names":["DefaultFetchAPI","handleRequest","response","iterateAsyncVoid","request","res$","adapterProp"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@whatwg-node/server/esm/plugins/useCors.js

@@ -0,0 +1,106 @@
+import { handleMaybePromise } from "../../../promise-helpers/esm/index.js";
+function getCORSHeadersByRequestAndOptions(request, corsOptions) {
+  const currentOrigin = request.headers.get("origin");
+  if (corsOptions === false || currentOrigin == null) {
+    return null;
+  }
+  const headers = {};
+  if (corsOptions.origin == null || corsOptions.origin.length === 0 || corsOptions.origin.includes("*")) {
+    headers["Access-Control-Allow-Origin"] = currentOrigin;
+    headers["Vary"] = "Origin";
+  } else if (typeof corsOptions.origin === "string") {
+    headers["Access-Control-Allow-Origin"] = corsOptions.origin;
+  } else if (Array.isArray(corsOptions.origin)) {
+    if (corsOptions.origin.length === 1) {
+      headers["Access-Control-Allow-Origin"] = corsOptions.origin[0];
+    } else if (corsOptions.origin.includes(currentOrigin)) {
+      headers["Access-Control-Allow-Origin"] = currentOrigin;
+      headers["Vary"] = "Origin";
+    } else {
+      headers["Access-Control-Allow-Origin"] = "null";
+    }
+  }
+  if (corsOptions.methods?.length) {
+    headers["Access-Control-Allow-Methods"] = corsOptions.methods.join(", ");
+  } else {
+    const requestMethod = request.headers.get("access-control-request-method");
+    if (requestMethod) {
+      headers["Access-Control-Allow-Methods"] = requestMethod;
+    }
+  }
+  if (corsOptions.allowedHeaders?.length) {
+    headers["Access-Control-Allow-Headers"] = corsOptions.allowedHeaders.join(", ");
+  } else {
+    const requestHeaders = request.headers.get("access-control-request-headers");
+    if (requestHeaders) {
+      headers["Access-Control-Allow-Headers"] = requestHeaders;
+      if (headers["Vary"]) {
+        headers["Vary"] += ", Access-Control-Request-Headers";
+      } else {
+        headers["Vary"] = "Access-Control-Request-Headers";
+      }
+    }
+  }
+  if (corsOptions.credentials != null) {
+    if (corsOptions.credentials === true) {
+      headers["Access-Control-Allow-Credentials"] = "true";
+    }
+  } else if (headers["Access-Control-Allow-Origin"] !== "*") {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  if (corsOptions.exposedHeaders) {
+    headers["Access-Control-Expose-Headers"] = corsOptions.exposedHeaders.join(", ");
+  }
+  if (corsOptions.maxAge) {
+    headers["Access-Control-Max-Age"] = corsOptions.maxAge.toString();
+  }
+  return headers;
+}
+function getCORSResponseHeaders(request, corsOptionsFactory, serverContext) {
+  return handleMaybePromise(() => corsOptionsFactory(request, serverContext), (corsOptions) => getCORSHeadersByRequestAndOptions(request, corsOptions));
+}
+function useCORS(options) {
+  let corsOptionsFactory = () => ({});
+  if (options != null) {
+    if (typeof options === "function") {
+      corsOptionsFactory = options;
+    } else if (typeof options === "object") {
+      const corsOptions = {
+        ...options
+      };
+      corsOptionsFactory = () => corsOptions;
+    } else if (options === false) {
+      corsOptionsFactory = () => false;
+    }
+  }
+  return {
+    onRequest({ request, fetchAPI, endResponse }) {
+      if (request.method.toUpperCase() === "OPTIONS") {
+        const response = new fetchAPI.Response(null, {
+          status: 204,
+          // Safari (and potentially other browsers) need content-length 0,
+          // for 204 or they just hang waiting for a body
+          // see: https://github.com/expressjs/cors/blob/master/lib/index.js#L176
+          headers: {
+            "Content-Length": "0"
+          }
+        });
+        endResponse(response);
+      }
+    },
+    onResponse({ request, serverContext, response }) {
+      return handleMaybePromise(() => getCORSResponseHeaders(request, corsOptionsFactory, serverContext), (headers) => {
+        if (headers != null) {
+          for (const headerName in headers) {
+            response.headers.set(headerName, headers[headerName]);
+          }
+        }
+      });
+    }
+  };
+}
+export {
+  getCORSHeadersByRequestAndOptions,
+  useCORS
+};
+//# sourceMappingURL=useCors.js.map

package/dist/node_modules/@whatwg-node/server/esm/plugins/useCors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCors.js","sources":["../../../../../../node_modules/@whatwg-node/server/esm/plugins/useCors.js"],"sourcesContent":["import { handleMaybePromise } from '@whatwg-node/promise-helpers';\nexport function getCORSHeadersByRequestAndOptions(request, corsOptions) {\n    const currentOrigin = request.headers.get('origin');\n    if (corsOptions === false || currentOrigin == null) {\n        return null;\n    }\n    const headers = {};\n    // If defined origins have '*' or undefined by any means, we should allow all origins\n    if (corsOptions.origin == null ||\n        corsOptions.origin.length === 0 ||\n        corsOptions.origin.includes('*')) {\n        headers['Access-Control-Allow-Origin'] = currentOrigin;\n        // Vary by origin because there are multiple origins\n        headers['Vary'] = 'Origin';\n    }\n    else if (typeof corsOptions.origin === 'string') {\n        // If there is one specific origin is specified, use it directly\n        headers['Access-Control-Allow-Origin'] = corsOptions.origin;\n    }\n    else if (Array.isArray(corsOptions.origin)) {\n        // If there is only one origin defined in the array, consider it as a single one\n        if (corsOptions.origin.length === 1) {\n            headers['Access-Control-Allow-Origin'] = corsOptions.origin[0];\n        }\n        else if (corsOptions.origin.includes(currentOrigin)) {\n            // If origin is available in the headers, use it\n            headers['Access-Control-Allow-Origin'] = currentOrigin;\n            // Vary by origin because there are multiple origins\n            headers['Vary'] = 'Origin';\n        }\n        else {\n            // There is no origin found in the headers, so we should return null\n            headers['Access-Control-Allow-Origin'] = 'null';\n        }\n    }\n    if (corsOptions.methods?.length) {\n        headers['Access-Control-Allow-Methods'] = corsOptions.methods.join(', ');\n    }\n    else {\n        const requestMethod = request.headers.get('access-control-request-method');\n        if (requestMethod) {\n            headers['Access-Control-Allow-Methods'] = requestMethod;\n        }\n    }\n    if (corsOptions.allowedHeaders?.length) {\n        headers['Access-Control-Allow-Headers'] = corsOptions.allowedHeaders.join(', ');\n    }\n    else {\n        const requestHeaders = request.headers.get('access-control-request-headers');\n        if (requestHeaders) {\n            headers['Access-Control-Allow-Headers'] = requestHeaders;\n            if (headers['Vary']) {\n                headers['Vary'] += ', Access-Control-Request-Headers';\n            }\n            else {\n                headers['Vary'] = 'Access-Control-Request-Headers';\n            }\n        }\n    }\n    if (corsOptions.credentials != null) {\n        if (corsOptions.credentials === true) {\n            headers['Access-Control-Allow-Credentials'] = 'true';\n        }\n    }\n    else if (headers['Access-Control-Allow-Origin'] !== '*') {\n        headers['Access-Control-Allow-Credentials'] = 'true';\n    }\n    if (corsOptions.exposedHeaders) {\n        headers['Access-Control-Expose-Headers'] = corsOptions.exposedHeaders.join(', ');\n    }\n    if (corsOptions.maxAge) {\n        headers['Access-Control-Max-Age'] = corsOptions.maxAge.toString();\n    }\n    return headers;\n}\nfunction getCORSResponseHeaders(request, corsOptionsFactory, serverContext) {\n    return handleMaybePromise(() => corsOptionsFactory(request, serverContext), corsOptions => getCORSHeadersByRequestAndOptions(request, corsOptions));\n}\nexport function useCORS(options) {\n    let corsOptionsFactory = () => ({});\n    if (options != null) {\n        if (typeof options === 'function') {\n            corsOptionsFactory = options;\n        }\n        else if (typeof options === 'object') {\n            const corsOptions = {\n                ...options,\n            };\n            corsOptionsFactory = () => corsOptions;\n        }\n        else if (options === false) {\n            corsOptionsFactory = () => false;\n        }\n    }\n    return {\n        onRequest({ request, fetchAPI, endResponse }) {\n            if (request.method.toUpperCase() === 'OPTIONS') {\n                const response = new fetchAPI.Response(null, {\n                    status: 204,\n                    // Safari (and potentially other browsers) need content-length 0,\n                    // for 204 or they just hang waiting for a body\n                    // see: https://github.com/expressjs/cors/blob/master/lib/index.js#L176\n                    headers: {\n                        'Content-Length': '0',\n                    },\n                });\n                endResponse(response);\n            }\n        },\n        onResponse({ request, serverContext, response }) {\n            return handleMaybePromise(() => getCORSResponseHeaders(request, corsOptionsFactory, serverContext), headers => {\n                if (headers != null) {\n                    for (const headerName in headers) {\n                        response.headers.set(headerName, headers[headerName]);\n                    }\n                }\n            });\n        },\n    };\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@whatwg-node/server/esm/utils.js

@@ -0,0 +1,476 @@
+import { handleMaybePromise, fakePromise, isPromise, createDeferredPromise } from "../../promise-helpers/esm/index.js";
+import { iterateAsyncVoid } from "../../promise-helpers/esm/index.js";
+function isAsyncIterable(body) {
+  return body != null && typeof body === "object" && typeof body[Symbol.asyncIterator] === "function";
+}
+function getPort(nodeRequest) {
+  if (nodeRequest.socket?.localPort) {
+    return nodeRequest.socket?.localPort;
+  }
+  const hostInHeader = nodeRequest.headers?.[":authority"] || nodeRequest.headers?.host;
+  const portInHeader = hostInHeader?.split(":")?.[1];
+  if (portInHeader) {
+    return portInHeader;
+  }
+  return 80;
+}
+function getHostnameWithPort(nodeRequest) {
+  if (nodeRequest.headers?.[":authority"]) {
+    return nodeRequest.headers?.[":authority"];
+  }
+  if (nodeRequest.headers?.host) {
+    return nodeRequest.headers?.host;
+  }
+  const port = getPort(nodeRequest);
+  if (nodeRequest.hostname) {
+    return nodeRequest.hostname + ":" + port;
+  }
+  const localIp = nodeRequest.socket?.localAddress;
+  if (localIp && !localIp?.includes("::") && !localIp?.includes("ffff")) {
+    return `${localIp}:${port}`;
+  }
+  return "localhost";
+}
+function buildFullUrl(nodeRequest) {
+  const hostnameWithPort = getHostnameWithPort(nodeRequest);
+  const protocol = nodeRequest.protocol || (nodeRequest.socket?.encrypted ? "https" : "http");
+  const endpoint = nodeRequest.originalUrl || nodeRequest.url || "/graphql";
+  return `${protocol}://${hostnameWithPort}${endpoint}`;
+}
+function isRequestBody(body) {
+  const stringTag = body[Symbol.toStringTag];
+  if (typeof body === "string" || stringTag === "Uint8Array" || stringTag === "Blob" || stringTag === "FormData" || stringTag === "URLSearchParams" || isAsyncIterable(body)) {
+    return true;
+  }
+  return false;
+}
+function normalizeNodeRequest(nodeRequest, fetchAPI, nodeResponse, __useCustomAbortCtrl) {
+  const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
+  let fullUrl = buildFullUrl(rawRequest);
+  if (nodeRequest.query) {
+    const url = new fetchAPI.URL(fullUrl);
+    for (const key in nodeRequest.query) {
+      url.searchParams.set(key, nodeRequest.query[key]);
+    }
+    fullUrl = url.toString();
+  }
+  let normalizedHeaders = nodeRequest.headers;
+  if (nodeRequest.headers?.[":method"]) {
+    normalizedHeaders = {};
+    for (const key in nodeRequest.headers) {
+      if (!key.startsWith(":")) {
+        normalizedHeaders[key] = nodeRequest.headers[key];
+      }
+    }
+  }
+  const controller = __useCustomAbortCtrl ? createCustomAbortControllerSignal() : new AbortController();
+  if (nodeResponse?.once) {
+    const closeEventListener = () => {
+      if (!controller.signal.aborted) {
+        Object.defineProperty(rawRequest, "aborted", { value: true });
+        controller.abort(nodeResponse.errored ?? void 0);
+      }
+    };
+    nodeResponse.once("error", closeEventListener);
+    nodeResponse.once("close", closeEventListener);
+    nodeResponse.once("finish", () => {
+      nodeResponse.removeListener("close", closeEventListener);
+    });
+  }
+  if (nodeRequest.method === "GET" || nodeRequest.method === "HEAD") {
+    return new fetchAPI.Request(fullUrl, {
+      method: nodeRequest.method,
+      headers: normalizedHeaders,
+      signal: controller.signal
+    });
+  }
+  const maybeParsedBody = nodeRequest.body;
+  if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
+    if (isRequestBody(maybeParsedBody)) {
+      return new fetchAPI.Request(fullUrl, {
+        method: nodeRequest.method || "GET",
+        headers: normalizedHeaders,
+        body: maybeParsedBody,
+        signal: controller.signal
+      });
+    }
+    const request = new fetchAPI.Request(fullUrl, {
+      method: nodeRequest.method || "GET",
+      headers: normalizedHeaders,
+      signal: controller.signal
+    });
+    if (!request.headers.get("content-type")?.includes("json")) {
+      request.headers.set("content-type", "application/json; charset=utf-8");
+    }
+    return new Proxy(request, {
+      get: (target, prop, receiver) => {
+        switch (prop) {
+          case "json":
+            return () => fakePromise(maybeParsedBody);
+          case "text":
+            return () => fakePromise(JSON.stringify(maybeParsedBody));
+          default:
+            if (globalThis.Bun) {
+              return Reflect.get(target, prop);
+            }
+            return Reflect.get(target, prop, receiver);
+        }
+      }
+    });
+  }
+  return new fetchAPI.Request(fullUrl, {
+    method: nodeRequest.method,
+    headers: normalizedHeaders,
+    signal: controller.signal,
+    // @ts-expect-error - AsyncIterable is supported as body
+    body: rawRequest,
+    duplex: "half"
+  });
+}
+function isReadable(stream) {
+  return stream.read != null;
+}
+function isNodeRequest(request) {
+  return isReadable(request);
+}
+function isServerResponse(stream) {
+  return stream != null && stream.setHeader != null && stream.end != null && stream.once != null && stream.write != null;
+}
+function isReadableStream(stream) {
+  return stream != null && stream.getReader != null;
+}
+function isFetchEvent(event) {
+  return event != null && event.request != null && event.respondWith != null;
+}
+function configureSocket(rawRequest) {
+  rawRequest?.socket?.setTimeout?.(0);
+  rawRequest?.socket?.setNoDelay?.(true);
+  rawRequest?.socket?.setKeepAlive?.(true);
+}
+function endResponse(serverResponse) {
+  serverResponse.end(null, null, null);
+}
+function sendAsyncIterable(serverResponse, asyncIterable) {
+  let closed = false;
+  const closeEventListener = () => {
+    closed = true;
+  };
+  serverResponse.once("error", closeEventListener);
+  serverResponse.once("close", closeEventListener);
+  serverResponse.once("finish", () => {
+    serverResponse.removeListener("close", closeEventListener);
+    serverResponse.removeListener("error", closeEventListener);
+  });
+  const iterator = asyncIterable[Symbol.asyncIterator]();
+  const pump = () => iterator.next().then(({ done, value }) => {
+    if (closed || done) {
+      return;
+    }
+    return handleMaybePromise(() => safeWrite(value, serverResponse), () => closed ? endResponse(serverResponse) : pump());
+  });
+  return pump();
+}
+function safeWrite(chunk, serverResponse) {
+  const result = serverResponse.write(chunk);
+  if (!result) {
+    return new Promise((resolve) => serverResponse.once("drain", resolve));
+  }
+}
+const isNode1x = globalThis.process?.versions?.node?.startsWith("1");
+function sendNodeResponse(fetchResponse, serverResponse, nodeRequest, __useSingleWriteHead) {
+  if (serverResponse.closed || serverResponse.destroyed || serverResponse.writableEnded) {
+    return;
+  }
+  if (!fetchResponse) {
+    serverResponse.statusCode = 404;
+    endResponse(serverResponse);
+    return;
+  }
+  if (__useSingleWriteHead && // @ts-expect-error - headersInit is a private property
+  fetchResponse.headers?.headersInit && // @ts-expect-error - headersInit is a private property
+  !Array.isArray(fetchResponse.headers.headersInit) && // @ts-expect-error - headersInit is a private property
+  !fetchResponse.headers.headersInit.get && // @ts-expect-error - map is a private property
+  !fetchResponse.headers._map && // @ts-expect-error - _setCookies is a private property
+  !fetchResponse.headers._setCookies?.length) {
+    serverResponse.writeHead(
+      fetchResponse.status,
+      fetchResponse.statusText,
+      // @ts-expect-error - headersInit is a private property
+      fetchResponse.headers.headersInit
+    );
+  } else {
+    if (serverResponse.setHeaders && !isNode1x) {
+      serverResponse.setHeaders(fetchResponse.headers);
+    } else {
+      let setCookiesSet = false;
+      fetchResponse.headers.forEach((value, key) => {
+        if (key === "set-cookie") {
+          if (setCookiesSet) {
+            return;
+          }
+          setCookiesSet = true;
+          const setCookies = fetchResponse.headers.getSetCookie?.();
+          if (setCookies) {
+            serverResponse.setHeader("set-cookie", setCookies);
+            return;
+          }
+        }
+        serverResponse.setHeader(key, value);
+      });
+    }
+    serverResponse.writeHead(fetchResponse.status, fetchResponse.statusText);
+  }
+  if (fetchResponse["bodyType"] === "String") {
+    return handleMaybePromise(
+      // @ts-expect-error - bodyInit is a private property
+      () => safeWrite(fetchResponse.bodyInit, serverResponse),
+      () => endResponse(serverResponse)
+    );
+  }
+  const bufOfRes = (
+    // @ts-expect-error - _buffer is a private property
+    fetchResponse._buffer
+  );
+  if (bufOfRes) {
+    return handleMaybePromise(() => safeWrite(bufOfRes, serverResponse), () => endResponse(serverResponse));
+  }
+  const fetchBody = fetchResponse.body;
+  if (fetchBody == null) {
+    endResponse(serverResponse);
+    return;
+  }
+  if (
+    // @ts-expect-error - Uint8Array is a valid body type
+    fetchBody[Symbol.toStringTag] === "Uint8Array"
+  ) {
+    return handleMaybePromise(() => safeWrite(fetchBody, serverResponse), () => endResponse(serverResponse));
+  }
+  configureSocket(nodeRequest);
+  if (isReadable(fetchBody)) {
+    serverResponse.once("close", () => {
+      fetchBody.destroy();
+    });
+    fetchBody.pipe(serverResponse, {
+      end: true
+    });
+    return;
+  }
+  if (isReadableStream(fetchBody)) {
+    return sendReadableStream(nodeRequest, serverResponse, fetchBody);
+  }
+  if (isAsyncIterable(fetchBody)) {
+    return sendAsyncIterable(serverResponse, fetchBody);
+  }
+}
+function sendReadableStream(nodeRequest, serverResponse, readableStream) {
+  const reader = readableStream.getReader();
+  nodeRequest?.once?.("error", (err) => {
+    reader.cancel(err);
+  });
+  function pump() {
+    return reader.read().then(({ done, value }) => done ? endResponse(serverResponse) : handleMaybePromise(() => safeWrite(value, serverResponse), pump));
+  }
+  return pump();
+}
+function isRequestInit(val) {
+  return val != null && typeof val === "object" && ("body" in val || "cache" in val || "credentials" in val || "headers" in val || "integrity" in val || "keepalive" in val || "method" in val || "mode" in val || "redirect" in val || "referrer" in val || "referrerPolicy" in val || "signal" in val || "window" in val);
+}
+function completeAssign(...args) {
+  const [target, ...sources] = args.filter((arg) => arg != null && typeof arg === "object");
+  sources.forEach((source) => {
+    const descriptors = Object.getOwnPropertyNames(source).reduce((descriptors2, key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (descriptor) {
+        descriptors2[key] = Object.getOwnPropertyDescriptor(source, key);
+      }
+      return descriptors2;
+    }, {});
+    Object.getOwnPropertySymbols(source).forEach((sym) => {
+      const descriptor = Object.getOwnPropertyDescriptor(source, sym);
+      if (descriptor?.enumerable) {
+        descriptors[sym] = descriptor;
+      }
+    });
+    Object.defineProperties(target, descriptors);
+  });
+  return target;
+}
+function handleErrorFromRequestHandler(error, ResponseCtor) {
+  return new ResponseCtor(error.stack || error.message || error.toString(), {
+    status: error.status || 500
+  });
+}
+function isolateObject(originalCtx, waitUntilFn) {
+  if (originalCtx == null) {
+    if (waitUntilFn == null) {
+      return {};
+    }
+    return {
+      waitUntil: waitUntilFn
+    };
+  }
+  return completeAssign(Object.create(originalCtx), {
+    waitUntil: waitUntilFn
+  }, originalCtx);
+}
+function handleAbortSignalAndPromiseResponse(response$, abortSignal) {
+  if (abortSignal?.aborted) {
+    throw abortSignal.reason;
+  }
+  if (isPromise(response$) && abortSignal) {
+    let abortSignalFetchErrorHandler = function() {
+      deferred$.reject(abortSignal.reason);
+    };
+    const deferred$ = createDeferredPromise();
+    abortSignal.addEventListener("abort", abortSignalFetchErrorHandler, { once: true });
+    response$.then(function fetchSuccessHandler(res) {
+      deferred$.resolve(res);
+    }).catch(function fetchErrorHandler(err) {
+      deferred$.reject(err);
+    }).finally(() => {
+      abortSignal.removeEventListener("abort", abortSignalFetchErrorHandler);
+    });
+    return deferred$.promise;
+  }
+  return response$;
+}
+const terminateEvents = ["SIGINT", "exit", "SIGTERM"];
+const disposableStacks = /* @__PURE__ */ new Set();
+let eventListenerRegistered = false;
+function ensureEventListenerForDisposableStacks() {
+  if (eventListenerRegistered) {
+    return;
+  }
+  eventListenerRegistered = true;
+  for (const event of terminateEvents) {
+    globalThis.process.once(event, function terminateHandler() {
+      return Promise.allSettled([...disposableStacks].map((stack) => !stack.disposed && stack.disposeAsync()));
+    });
+  }
+}
+function ensureDisposableStackRegisteredForTerminateEvents(disposableStack) {
+  if (globalThis.process) {
+    ensureEventListenerForDisposableStacks();
+    if (!disposableStacks.has(disposableStack)) {
+      disposableStacks.add(disposableStack);
+      disposableStack.defer(() => {
+        disposableStacks.delete(disposableStack);
+      });
+    }
+  }
+}
+class CustomAbortControllerSignal extends EventTarget {
+  aborted = false;
+  _onabort = null;
+  _reason;
+  constructor() {
+    super();
+    const nodeEvents = globalThis.process?.getBuiltinModule?.("node:events");
+    if (nodeEvents?.kMaxEventTargetListeners) {
+      this[nodeEvents.kMaxEventTargetListeners] = 0;
+    }
+  }
+  throwIfAborted() {
+    if (this._nativeCtrl?.signal?.throwIfAborted) {
+      return this._nativeCtrl.signal.throwIfAborted();
+    }
+    if (this.aborted) {
+      throw this._reason;
+    }
+  }
+  _nativeCtrl;
+  ensureNativeCtrl() {
+    if (!this._nativeCtrl) {
+      const isAborted = this.aborted;
+      this._nativeCtrl = new AbortController();
+      if (isAborted) {
+        this._nativeCtrl.abort(this._reason);
+      }
+    }
+    return this._nativeCtrl;
+  }
+  abort(reason) {
+    if (this._nativeCtrl?.abort) {
+      return this._nativeCtrl?.abort(reason);
+    }
+    this._reason = reason || new DOMException("This operation was aborted", "AbortError");
+    this.aborted = true;
+    this.dispatchEvent(new Event("abort"));
+  }
+  get signal() {
+    if (this._nativeCtrl?.signal) {
+      return this._nativeCtrl.signal;
+    }
+    return this;
+  }
+  get reason() {
+    if (this._nativeCtrl?.signal) {
+      return this._nativeCtrl.signal.reason;
+    }
+    return this._reason;
+  }
+  get onabort() {
+    if (this._onabort) {
+      return this._onabort;
+    }
+    return this._onabort;
+  }
+  set onabort(value) {
+    if (this._nativeCtrl?.signal) {
+      this._nativeCtrl.signal.onabort = value;
+      return;
+    }
+    if (this._onabort) {
+      this.removeEventListener("abort", this._onabort);
+    }
+    this._onabort = value;
+    if (value) {
+      this.addEventListener("abort", value);
+    }
+  }
+}
+function createCustomAbortControllerSignal() {
+  if (globalThis.Bun || globalThis.Deno) {
+    return new AbortController();
+  }
+  return new Proxy(new CustomAbortControllerSignal(), {
+    get(target, prop, receiver) {
+      if (prop.toString().includes("kDependantSignals")) {
+        const nativeCtrl = target.ensureNativeCtrl();
+        return Reflect.get(nativeCtrl.signal, prop, nativeCtrl.signal);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, receiver) {
+      if (prop.toString().includes("kDependantSignals")) {
+        const nativeCtrl = target.ensureNativeCtrl();
+        return Reflect.set(nativeCtrl.signal, prop, value, nativeCtrl.signal);
+      }
+      return Reflect.set(target, prop, value, receiver);
+    },
+    getPrototypeOf() {
+      return AbortSignal.prototype;
+    }
+  });
+}
+export {
+  completeAssign,
+  createCustomAbortControllerSignal,
+  createDeferredPromise,
+  ensureDisposableStackRegisteredForTerminateEvents,
+  handleAbortSignalAndPromiseResponse,
+  handleErrorFromRequestHandler,
+  isAsyncIterable,
+  isFetchEvent,
+  isNodeRequest,
+  isPromise,
+  isReadable,
+  isReadableStream,
+  isRequestInit,
+  isServerResponse,
+  isolateObject,
+  iterateAsyncVoid,
+  normalizeNodeRequest,
+  sendNodeResponse
+};
+//# sourceMappingURL=utils.js.map