elysia
Version:
Ergonomic Framework for Human
949 lines (948 loc) • 67.3 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: !0 });
}, __copyProps = (to, from, except, desc) => {
if (from && typeof from == "object" || typeof from == "function")
for (let key of __getOwnPropNames(from))
!__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
mod
)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
var compose_exports = {};
__export(compose_exports, {
composeErrorHandler: () => composeErrorHandler,
composeGeneralHandler: () => composeGeneralHandler,
composeHandler: () => composeHandler,
createHoc: () => createHoc,
createOnRequestHandler: () => createOnRequestHandler,
isAsync: () => isAsync
});
module.exports = __toCommonJS(compose_exports);
var import_index = require('./index.js'), import_value = require("@sinclair/typebox/value"), import_typebox = require("@sinclair/typebox"), import_fast_decode_uri_component = __toESM(require("fast-decode-uri-component")), import_parse_query = require('./parse-query.js'), import_utils = require('./utils.js'), import_utils2 = require('./universal/utils.js'), import_error = require('./error.js'), import_error2 = require('./error.js'), import_trace = require('./trace.js'), import_schema = require('./schema.js'), import_sucrose = require('./sucrose.js'), import_cookies = require('./cookies.js'), import_utils3 = require('./type-system/utils.js'), import_utils4 = require('./adapter/utils.js'), import_replace_schema = require('./replace-schema.js');
const allocateIf = (value, condition) => condition ? value : "", defaultParsers = [
"json",
"text",
"urlencoded",
"arrayBuffer",
"formdata",
"application/json",
// eslint-disable-next-line sonarjs/no-duplicate-string
"text/plain",
// eslint-disable-next-line sonarjs/no-duplicate-string
"application/x-www-form-urlencoded",
// eslint-disable-next-line sonarjs/no-duplicate-string
"application/octet-stream",
// eslint-disable-next-line sonarjs/no-duplicate-string
"multipart/form-data"
], createReport = ({
context = "c",
trace = [],
addFn
}) => {
if (!trace.length)
return () => ({
resolveChild() {
return () => {
};
},
resolve() {
}
});
for (let i = 0; i < trace.length; i++)
addFn(
`let report${i},reportChild${i},reportErr${i},reportErrChild${i};let trace${i}=${context}[ELYSIA_TRACE]?.[${i}]??trace[${i}](${context});
`
);
return (event, {
name,
total = 0,
alias
} = {}) => {
name || (name = "anonymous");
const reporter = event === "error" ? "reportErr" : "report";
for (let i = 0; i < trace.length; i++)
addFn(
`${alias ? "const " : ""}${alias ?? reporter}${i}=trace${i}.${event}({id,event:'${event}',name:'${name}',begin:performance.now(),total:${total}})
`
), alias && addFn(`${reporter}${i}=${alias}${i}
`);
return {
resolve() {
for (let i = 0; i < trace.length; i++)
addFn(`${alias ?? reporter}${i}.resolve()
`);
},
resolveChild(name2) {
for (let i = 0; i < trace.length; i++)
addFn(
`${reporter}Child${i}=${reporter}${i}.resolveChild?.shift()?.({id,event:'${event}',name:'${name2}',begin:performance.now()})
`
);
return (binding) => {
for (let i = 0; i < trace.length; i++)
addFn(
binding ? `if(${binding} instanceof Error){${reporter}Child${i}?.(${binding}) }else{${reporter}Child${i}?.()}` : `${reporter}Child${i}?.()
`
);
};
}
};
};
}, composeCleaner = ({
schema,
name,
type,
typeAlias = type,
normalize,
ignoreTryCatch = !1
}) => !normalize || !schema.Clean ? "" : normalize === !0 || normalize === "exactMirror" ? ignoreTryCatch ? `${name}=validator.${typeAlias}.Clean(${name})
` : `try{${name}=validator.${typeAlias}.Clean(${name})
}catch{}` : normalize === "typebox" ? `${name}=validator.${typeAlias}.Clean(${name})
` : "", composeValidationFactory = ({
injectResponse = "",
normalize = !1,
validator,
encodeSchema = !1,
isStaticResponse = !1,
hasSanitize = !1,
allowUnsafeValidationDetails = !1
}) => ({
validate: (type, value = `c.${type}`, error) => `c.set.status=422;throw new ValidationError('${type}',validator.${type},${value},${allowUnsafeValidationDetails}${error ? "," + error : ""})`,
response: (name = "r") => {
if (isStaticResponse || !validator.response) return "";
let code = injectResponse + `
`;
code += `if(${name} instanceof ElysiaCustomStatusResponse){c.set.status=${name}.code
${name}=${name}.response}if(${name} instanceof Response === false && typeof ${name}?.next !== 'function' && !(${name} instanceof ReadableStream))switch(c.set.status){`;
for (const [status2, value] of Object.entries(validator.response)) {
if (code += `
case ${status2}:
`, value.provider === "standard") {
code += `let vare${status2}=validator.response[${status2}].Check(${name})
if(vare${status2} instanceof Promise)vare${status2}=await vare${status2}
if(vare${status2}.issues)throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails},vare${status2}.issues)
${name}=vare${status2}.value
c.set.status=${status2}
break
`;
continue;
}
let noValidate = value.schema?.noValidate === !0;
if (!noValidate && value.schema?.$ref && value.schema?.$defs) {
const refKey = value.schema.$ref, defKey = typeof refKey == "string" && refKey.includes("/") ? refKey.split("/").pop() : refKey;
value.schema.$defs[defKey]?.noValidate === !0 && (noValidate = !0);
}
const appliedCleaner = noValidate || hasSanitize, clean = ({ ignoreTryCatch = !1 } = {}) => composeCleaner({
name,
schema: value,
type: "response",
typeAlias: `response[${status2}]`,
normalize,
ignoreTryCatch
});
appliedCleaner && (code += clean());
const applyErrorCleaner = !appliedCleaner && normalize && !noValidate;
encodeSchema && value.hasTransform && !noValidate ? (code += `try{${name}=validator.response[${status2}].Encode(${name})
`, appliedCleaner || (code += clean({ ignoreTryCatch: !0 })), code += `c.set.status=${status2}}catch{` + (applyErrorCleaner ? `try{
` + clean({ ignoreTryCatch: !0 }) + `${name}=validator.response[${status2}].Encode(${name})
}catch{throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})}` : `throw new ValidationError('response',validator.response[${status2}],${name}),${allowUnsafeValidationDetails}`) + "}") : (appliedCleaner || (code += clean()), noValidate || (code += `if(validator.response[${status2}].Check(${name})===false)throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})
c.set.status=${status2}
`)), code += `break
`;
}
return code + "}";
}
}), isAsyncName = (v) => (v?.fn ?? v).constructor.name === "AsyncFunction", matchResponseClone = /=>\s?response\.clone\(/, matchFnReturn = /(?:return|=>)\s?\S+\(|a(?:sync|wait)/, isAsync = (v) => {
const isObject = typeof v == "object";
if (isObject && v.isAsync !== void 0) return v.isAsync;
const fn = isObject ? v.fn : v;
if (fn.constructor.name === "AsyncFunction") return !0;
const literal = fn.toString();
if (matchResponseClone.test(literal))
return isObject && (v.isAsync = !1), !1;
const result = matchFnReturn.test(literal);
return isObject && (v.isAsync = result), result;
}, hasReturn = (v) => {
const isObject = typeof v == "object";
if (isObject && v.hasReturn !== void 0) return v.hasReturn;
const fnLiteral = isObject ? v.fn.toString() : typeof v == "string" ? v.toString() : v, parenthesisEnd = fnLiteral.indexOf(")");
if (fnLiteral.charCodeAt(parenthesisEnd + 2) === 61 && fnLiteral.charCodeAt(parenthesisEnd + 5) !== 123)
return isObject && (v.hasReturn = !0), !0;
const result = fnLiteral.includes("return");
return isObject && (v.hasReturn = result), result;
}, isGenerator = (v) => {
const fn = v?.fn ?? v;
return fn.constructor.name === "AsyncGeneratorFunction" || fn.constructor.name === "GeneratorFunction";
}, coerceTransformDecodeError = (fnLiteral, type, allowUnsafeValidationDetails = !1, value = `c.${type}`) => `try{${fnLiteral}}catch(error){if(error.constructor.name === 'TransformDecodeError'){c.set.status=422
throw error.error ?? new ValidationError('${type}',validator.${type},${value},${allowUnsafeValidationDetails})}}`, setImmediateFn = import_utils.hasSetImmediate ? "setImmediate" : "Promise.resolve().then", composeHandler = ({
app,
path,
method,
hooks,
validator,
handler,
allowMeta = !1,
inference
}) => {
const adapter = app["~adapter"].composeHandler, adapterHandler = app["~adapter"].handler, isHandleFn = typeof handler == "function";
if (!isHandleFn) {
handler = adapterHandler.mapResponse(handler, {
// @ts-expect-error private property
headers: app.setHeaders ?? {}
});
const isResponse = handler instanceof Response || // @ts-ignore If it's not instanceof Response, it might be a polyfill (only on Node)
handler?.constructor?.name === "Response" && typeof handler?.clone == "function";
if (hooks.parse?.length && hooks.transform?.length && hooks.beforeHandle?.length && hooks.afterHandle?.length)
return isResponse ? Function(
"a",
`"use strict";
return function(){return a.clone()}`
)(handler) : Function(
"a",
`"use strict";
return function(){return a}`
)(handler);
if (isResponse) {
const response = handler;
handler = () => response.clone();
}
}
const handle = isHandleFn ? "handler(c)" : "handler", hasTrace = !!hooks.trace?.length;
let fnLiteral = "";
if (inference = (0, import_sucrose.sucrose)(
Object.assign({ handler }, hooks),
inference,
app.config.sucrose
), adapter.declare) {
const literal = adapter.declare(inference);
literal && (fnLiteral += literal);
}
inference.server && (fnLiteral += `Object.defineProperty(c,'server',{get:function(){return getServer()}})
`), validator.createBody?.(), validator.createQuery?.(), validator.createHeaders?.(), validator.createParams?.(), validator.createCookie?.(), validator.createResponse?.();
const hasValidation = !!validator.body || !!validator.headers || !!validator.params || !!validator.query || !!validator.cookie || !!validator.response, hasQuery = inference.query || !!validator.query, requestNoBody = hooks.parse?.length === 1 && // @ts-expect-error
hooks.parse[0].fn === "none", hasBody = method !== "" && method !== "GET" && method !== "HEAD" && (inference.body || !!validator.body || !!hooks.parse?.length) && !requestNoBody, defaultHeaders = app.setHeaders, hasDefaultHeaders = defaultHeaders && !!Object.keys(defaultHeaders).length, hasHeaders = inference.headers || !!validator.headers || adapter.preferWebstandardHeaders !== !0 && inference.body, hasCookie = inference.cookie || !!validator.cookie, cookieMeta = validator.cookie?.config ? (0, import_utils.mergeCookie)(validator?.cookie?.config, app.config.cookie) : app.config.cookie;
let _encodeCookie = "";
const encodeCookie = () => {
if (_encodeCookie) return _encodeCookie;
if (cookieMeta?.sign) {
if (!cookieMeta.secrets)
throw new Error(
`t.Cookie required secret which is not set in (${method}) ${path}.`
);
const secret = cookieMeta.secrets ? typeof cookieMeta.secrets == "string" ? cookieMeta.secrets : cookieMeta.secrets[0] : void 0;
if (_encodeCookie += `const _setCookie = c.set.cookie
if(_setCookie){`, cookieMeta.sign === !0)
_encodeCookie += `for(const [key, cookie] of Object.entries(_setCookie)){c.set.cookie[key].value=await signCookie(cookie.value,${secret ? JSON.stringify(secret) : "undefined"})}`;
else {
typeof cookieMeta.sign == "string" && (cookieMeta.sign = [cookieMeta.sign]);
for (const name of cookieMeta.sign)
_encodeCookie += `if(_setCookie[${JSON.stringify(name)}]?.value)c.set.cookie[${JSON.stringify(name)}].value=await signCookie(_setCookie[${JSON.stringify(name)}].value,${secret ? JSON.stringify(secret) : "undefined"})
`;
}
_encodeCookie += `}
`;
}
return _encodeCookie;
}, normalize = app.config.normalize, encodeSchema = app.config.encodeSchema, allowUnsafeValidationDetails = app.config.allowUnsafeValidationDetails, validation = composeValidationFactory({
normalize,
validator,
encodeSchema,
isStaticResponse: handler instanceof Response,
hasSanitize: !!app.config.sanitize,
allowUnsafeValidationDetails
});
hasHeaders && (fnLiteral += adapter.headers), hasTrace && (fnLiteral += `const id=c[ELYSIA_REQUEST_ID]
`);
const report = createReport({
trace: hooks.trace,
addFn: (word) => {
fnLiteral += word;
}
});
if (fnLiteral += "try{", hasCookie) {
const get = (name, defaultValue) => {
const value = cookieMeta?.[name] ?? defaultValue;
return value === void 0 ? "" : value ? typeof value == "string" ? `${name}:${JSON.stringify(value)},` : value instanceof Date ? `${name}: new Date(${value.getTime()}),` : `${name}:${value},` : typeof defaultValue == "string" ? `${name}:"${defaultValue}",` : `${name}:${defaultValue},`;
}, options = cookieMeta ? `{secrets:${cookieMeta.secrets !== void 0 ? typeof cookieMeta.secrets == "string" ? JSON.stringify(cookieMeta.secrets) : "[" + cookieMeta.secrets.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},sign:${cookieMeta.sign === !0 ? !0 : cookieMeta.sign !== void 0 ? typeof cookieMeta.sign == "string" ? JSON.stringify(cookieMeta.sign) : "[" + cookieMeta.sign.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},` + get("domain") + get("expires") + get("httpOnly") + get("maxAge") + get("path", "/") + get("priority") + get("sameSite") + get("secure") + "}" : "undefined";
hasHeaders ? fnLiteral += `
c.cookie=await parseCookie(c.set,c.headers.cookie,${options})
` : fnLiteral += `
c.cookie=await parseCookie(c.set,c.request.headers.get('cookie'),${options})
`;
}
if (hasQuery) {
let arrayProperties = {}, objectProperties = {}, hasArrayProperty = !1, hasObjectProperty = !1;
if (validator.query?.schema) {
const schema = (0, import_schema.unwrapImportSchema)(validator.query?.schema);
if (import_typebox.Kind in schema && schema.properties)
for (const [key, value] of Object.entries(schema.properties))
(0, import_schema.hasElysiaMeta)("ArrayQuery", value) && (arrayProperties[key] = !0, hasArrayProperty = !0), (0, import_schema.hasElysiaMeta)("ObjectString", value) && (objectProperties[key] = !0, hasObjectProperty = !0);
}
fnLiteral += `if(c.qi===-1){c.query=Object.create(null)}else{c.query=parseQueryFromURL(c.url,c.qi+1${//
hasArrayProperty ? "," + JSON.stringify(arrayProperties) : hasObjectProperty ? ",undefined" : ""}${//
hasObjectProperty ? "," + JSON.stringify(objectProperties) : ""})}`;
}
const isAsyncHandler = typeof handler == "function" && isAsync(handler), saveResponse = hasTrace || hooks.afterResponse?.length ? "c.response=c.responseValue= " : "", responseKeys = Object.keys(validator.response ?? {}), hasMultipleResponses = responseKeys.length > 1, hasSingle200 = responseKeys.length === 0 || responseKeys.length === 1 && responseKeys[0] === "200", maybeAsync = hasCookie || hasBody || isAsyncHandler || !!hooks.parse?.length || !!hooks.afterHandle?.some(isAsync) || !!hooks.beforeHandle?.some(isAsync) || !!hooks.transform?.some(isAsync) || !!hooks.mapResponse?.some(isAsync) || validator.body?.provider === "standard" || validator.headers?.provider === "standard" || validator.query?.provider === "standard" || validator.params?.provider === "standard" || validator.cookie?.provider === "standard" || Object.values(validator.response ?? {}).find(
(x) => x.provider === "standard"
), maybeStream = (typeof handler == "function" ? isGenerator(handler) : !1) || !!hooks.beforeHandle?.some(isGenerator) || !!hooks.afterHandle?.some(isGenerator) || !!hooks.transform?.some(isGenerator), hasSet = inference.cookie || inference.set || hasHeaders || hasTrace || hasMultipleResponses || !hasSingle200 || isHandleFn && hasDefaultHeaders || maybeStream;
let _afterResponse;
const afterResponse = (hasStream = !0) => {
if (_afterResponse !== void 0) return _afterResponse;
if (!hooks.afterResponse?.length && !hasTrace) return "";
let afterResponse2 = "";
afterResponse2 += `
${setImmediateFn}(async()=>{if(c.responseValue){if(c.responseValue instanceof ElysiaCustomStatusResponse) c.set.status=c.responseValue.code
` + (hasStream ? `if(typeof afterHandlerStreamListener!=='undefined')for await(const v of afterHandlerStreamListener){}
` : "") + `}
`;
const reporter = createReport({
trace: hooks.trace,
addFn: (word) => {
afterResponse2 += word;
}
})("afterResponse", {
total: hooks.afterResponse?.length
});
if (hooks.afterResponse?.length && hooks.afterResponse)
for (let i = 0; i < hooks.afterResponse.length; i++) {
const endUnit = reporter.resolveChild(
hooks.afterResponse[i].fn.name
), prefix = isAsync(hooks.afterResponse[i]) ? "await " : "";
afterResponse2 += `
${prefix}e.afterResponse[${i}](c)
`, endUnit();
}
return reporter.resolve(), afterResponse2 += `})
`, _afterResponse = afterResponse2;
}, mapResponse = (r = "r") => {
const after = afterResponse(), response = `${hasSet ? "mapResponse" : "mapCompactResponse"}(${saveResponse}${r}${hasSet ? ",c.set" : ""}${mapResponseContext})
`;
return after ? `const _res=${response}` + after + "return _res" : `return ${response}`;
}, mapResponseContext = maybeStream && adapter.mapResponseContext ? `,${adapter.mapResponseContext}` : "";
(hasTrace || inference.route) && (fnLiteral += `c.route=\`${path}\`
`), (hasTrace || hooks.afterResponse?.length) && (fnLiteral += `let afterHandlerStreamListener
`);
const parseReporter = report("parse", {
total: hooks.parse?.length
});
if (hasBody) {
const hasBodyInference = !!hooks.parse?.length || inference.body || validator.body;
adapter.parser.declare && (fnLiteral += adapter.parser.declare), fnLiteral += `
try{`;
let parser = typeof hooks.parse == "string" ? hooks.parse : Array.isArray(hooks.parse) && hooks.parse.length === 1 ? typeof hooks.parse[0] == "string" ? hooks.parse[0] : typeof hooks.parse[0].fn == "string" ? hooks.parse[0].fn : void 0 : void 0;
if (!parser && validator.body && !hooks.parse?.length) {
const schema = validator.body.schema;
schema && schema.anyOf && schema[import_typebox.Kind] === "Union" && schema.anyOf?.length === 2 && schema.anyOf?.find((x) => x[import_typebox.Kind] === "ElysiaForm") && (parser = "formdata");
}
if (parser && defaultParsers.includes(parser)) {
const reporter = report("parse", {
total: hooks.parse?.length
}), isOptionalBody = !!validator.body?.isOptional;
switch (parser) {
case "json":
case "application/json":
fnLiteral += adapter.parser.json(isOptionalBody);
break;
case "text":
case "text/plain":
fnLiteral += adapter.parser.text(isOptionalBody);
break;
case "urlencoded":
case "application/x-www-form-urlencoded":
fnLiteral += adapter.parser.urlencoded(isOptionalBody);
break;
case "arrayBuffer":
case "application/octet-stream":
fnLiteral += adapter.parser.arrayBuffer(isOptionalBody);
break;
case "formdata":
case "multipart/form-data":
fnLiteral += adapter.parser.formData(isOptionalBody);
break;
default:
parser[0] in app["~parser"] && (fnLiteral += hasHeaders ? "let contentType = c.headers['content-type']" : "let contentType = c.request.headers.get('content-type')", fnLiteral += `
if(contentType){const index=contentType.indexOf(';')
if(index!==-1)contentType=contentType.substring(0,index)}
else{contentType=''}c.contentType=contentType
let result=parser['${parser}'](c, contentType)
if(result instanceof Promise)result=await result
if(result instanceof ElysiaCustomStatusResponse)throw result
if(result!==undefined)c.body=result
delete c.contentType
`);
break;
}
reporter.resolve();
} else if (hasBodyInference) {
fnLiteral += `
`, fnLiteral += `let contentType
if(c.request.body)`, fnLiteral += hasHeaders ? `contentType=c.headers['content-type']
` : `contentType=c.request.headers.get('content-type')
`;
let hasDefaultParser = !1;
if (hooks.parse?.length)
fnLiteral += `if(contentType){
const index=contentType.indexOf(';')
if(index!==-1)contentType=contentType.substring(0,index)}else{contentType=''}let used=false
c.contentType=contentType
`;
else {
hasDefaultParser = !0;
const isOptionalBody = !!validator.body?.isOptional;
fnLiteral += `if(contentType)switch(contentType.charCodeAt(12)){
case 106:` + adapter.parser.json(isOptionalBody) + `break
case 120:` + adapter.parser.urlencoded(isOptionalBody) + `break
case 111:` + adapter.parser.arrayBuffer(isOptionalBody) + `break
case 114:` + adapter.parser.formData(isOptionalBody) + `break
default:if(contentType.charCodeAt(0)===116){` + adapter.parser.text(isOptionalBody) + `}break
}`;
}
const reporter = report("parse", {
total: hooks.parse?.length
});
if (hooks.parse)
for (let i = 0; i < hooks.parse.length; i++) {
const name = `bo${i}`;
if (i !== 0 && (fnLiteral += `
if(!used){`), typeof hooks.parse[i].fn == "string") {
const endUnit = reporter.resolveChild(
hooks.parse[i].fn
), isOptionalBody = !!validator.body?.isOptional;
switch (hooks.parse[i].fn) {
case "json":
case "application/json":
hasDefaultParser = !0, fnLiteral += adapter.parser.json(isOptionalBody);
break;
case "text":
case "text/plain":
hasDefaultParser = !0, fnLiteral += adapter.parser.text(isOptionalBody);
break;
case "urlencoded":
case "application/x-www-form-urlencoded":
hasDefaultParser = !0, fnLiteral += adapter.parser.urlencoded(isOptionalBody);
break;
case "arrayBuffer":
case "application/octet-stream":
hasDefaultParser = !0, fnLiteral += adapter.parser.arrayBuffer(isOptionalBody);
break;
case "formdata":
case "multipart/form-data":
hasDefaultParser = !0, fnLiteral += adapter.parser.formData(isOptionalBody);
break;
default:
fnLiteral += `let ${name}=parser['${hooks.parse[i].fn}'](c,contentType)
if(${name} instanceof Promise)${name}=await ${name}
if(${name}!==undefined){c.body=${name};used=true;}
`;
}
endUnit();
} else {
const endUnit = reporter.resolveChild(
hooks.parse[i].fn.name
);
fnLiteral += `let ${name}=e.parse[${i}]
${name}=${name}(c,contentType)
if(${name} instanceof Promise)${name}=await ${name}
if(${name}!==undefined){c.body=${name};used=true}`, endUnit();
}
if (i !== 0 && (fnLiteral += "}"), hasDefaultParser) break;
}
if (reporter.resolve(), !hasDefaultParser) {
const isOptionalBody = !!validator.body?.isOptional;
hooks.parse?.length && (fnLiteral += `
if(!used){
`), fnLiteral += `switch(contentType){case 'application/json':
` + adapter.parser.json(isOptionalBody) + `break
case 'text/plain':` + adapter.parser.text(isOptionalBody) + `break
case 'application/x-www-form-urlencoded':` + adapter.parser.urlencoded(isOptionalBody) + `break
case 'application/octet-stream':` + adapter.parser.arrayBuffer(isOptionalBody) + `break
case 'multipart/form-data':` + adapter.parser.formData(isOptionalBody) + `break
`;
for (const key of Object.keys(app["~parser"]))
fnLiteral += `case '${key}':let bo${key}=parser['${key}'](c,contentType)
if(bo${key} instanceof Promise)bo${key}=await bo${key}
if(bo${key} instanceof ElysiaCustomStatusResponse){` + mapResponse(`bo${key}`) + `}if(bo${key}!==undefined)c.body=bo${key}
break
`;
hooks.parse?.length && (fnLiteral += "}"), fnLiteral += "}";
}
hooks.parse?.length && (fnLiteral += `
delete c.contentType`);
}
fnLiteral += "}catch(error){throw new ParseError(error)}";
}
if (parseReporter.resolve(), hooks?.transform || hasTrace) {
const reporter = report("transform", {
total: hooks.transform?.length
});
if (hooks.transform?.length) {
fnLiteral += `let transformed
`;
for (let i = 0; i < hooks.transform.length; i++) {
const transform = hooks.transform[i], endUnit = reporter.resolveChild(transform.fn.name);
fnLiteral += isAsync(transform) ? `transformed=await e.transform[${i}](c)
` : `transformed=e.transform[${i}](c)
`, transform.subType === "mapDerive" ? fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse("transformed") + `}else{transformed.request=c.request
transformed.store=c.store
transformed.qi=c.qi
transformed.path=c.path
transformed.url=c.url
transformed.redirect=c.redirect
transformed.set=c.set
transformed.error=c.error
c=transformed}` : fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse("transformed") + `}else Object.assign(c,transformed)
`, endUnit();
}
}
reporter.resolve();
}
const fileUnions = [];
if (validator) {
if (validator.headers) {
if (validator.headers.hasDefault)
for (const [key, value] of Object.entries(
import_value.Value.Default(
// @ts-ignore
validator.headers.schema,
{}
)
)) {
const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
parsed !== void 0 && (fnLiteral += `c.headers['${key}']??=${parsed}
`);
}
fnLiteral += composeCleaner({
name: "c.headers",
schema: validator.headers,
type: "headers",
normalize
}), validator.headers.isOptional && (fnLiteral += "if(isNotEmpty(c.headers)){"), validator.headers?.provider === "standard" ? fnLiteral += `let vah=validator.headers.Check(c.headers)
if(vah instanceof Promise)vah=await vah
if(vah.issues){` + validation.validate("headers", void 0, "vah.issues") + `}else{c.headers=vah.value}
` : validator.headers?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.headers.Check(c.headers) === false){" + validation.validate("headers") + "}"), validator.headers.hasTransform && (fnLiteral += coerceTransformDecodeError(
`c.headers=validator.headers.Decode(c.headers)
`,
"headers",
allowUnsafeValidationDetails
)), validator.headers.isOptional && (fnLiteral += "}");
}
if (validator.params) {
if (validator.params.hasDefault)
for (const [key, value] of Object.entries(
import_value.Value.Default(
// @ts-ignore
validator.params.schema,
{}
)
)) {
const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
parsed !== void 0 && (fnLiteral += `c.params['${key}']??=${parsed}
`);
}
validator.params.provider === "standard" ? fnLiteral += `let vap=validator.params.Check(c.params)
if(vap instanceof Promise)vap=await vap
if(vap.issues){` + validation.validate("params", void 0, "vap.issues") + `}else{c.params=vap.value}
` : validator.params?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.params.Check(c.params)===false){" + validation.validate("params") + "}"), validator.params.hasTransform && (fnLiteral += coerceTransformDecodeError(
`c.params=validator.params.Decode(c.params)
`,
"params",
allowUnsafeValidationDetails
));
}
if (validator.query) {
if (import_typebox.Kind in validator.query?.schema && validator.query.hasDefault)
for (const [key, value] of Object.entries(
import_value.Value.Default(
// @ts-ignore
validator.query.schema,
{}
)
)) {
const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
parsed !== void 0 && (fnLiteral += `if(c.query['${key}']===undefined)c.query['${key}']=${parsed}
`);
}
fnLiteral += composeCleaner({
name: "c.query",
schema: validator.query,
type: "query",
normalize
}), validator.query.isOptional && (fnLiteral += "if(isNotEmpty(c.query)){"), validator.query.provider === "standard" ? fnLiteral += `let vaq=validator.query.Check(c.query)
if(vaq instanceof Promise)vaq=await vaq
if(vaq.issues){` + validation.validate("query", void 0, "vaq.issues") + `}else{c.query=vaq.value}
` : validator.query?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.query.Check(c.query)===false){" + validation.validate("query") + "}"), validator.query.hasTransform && (fnLiteral += coerceTransformDecodeError(
`c.query=validator.query.Decode(c.query)
`,
"query",
allowUnsafeValidationDetails
), fnLiteral += coerceTransformDecodeError(
`c.query=validator.query.Decode(c.query)
`,
"query",
allowUnsafeValidationDetails
)), validator.query.isOptional && (fnLiteral += "}");
}
if (hasBody && validator.body) {
(validator.body.hasTransform || validator.body.isOptional) && (fnLiteral += `const isNotEmptyObject=c.body&&(typeof c.body==="object"&&(isNotEmpty(c.body)||c.body instanceof ArrayBuffer))
`);
const hasUnion = (0, import_schema.isUnion)(validator.body.schema);
let hasNonUnionFileWithDefault = !1;
if (validator.body.hasDefault) {
let value = import_value.Value.Default(
validator.body.schema,
validator.body.schema.type === "object" || (0, import_schema.unwrapImportSchema)(validator.body.schema)[import_typebox.Kind] === "Object" ? {} : void 0
);
const schema = (0, import_schema.unwrapImportSchema)(validator.body.schema);
if (!hasUnion && value && typeof value == "object" && ((0, import_schema.hasType)("File", schema) || (0, import_schema.hasType)("Files", schema))) {
hasNonUnionFileWithDefault = !0;
for (const [k, v] of Object.entries(value))
(v === "File" || v === "Files") && delete value[k];
(0, import_utils.isNotEmpty)(value) || (value = void 0);
}
const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
value != null && (Array.isArray(value) ? fnLiteral += `if(!c.body)c.body=${parsed}
` : typeof value == "object" ? fnLiteral += `c.body=Object.assign(${parsed},c.body)
` : fnLiteral += `c.body=${parsed}
`), fnLiteral += composeCleaner({
name: "c.body",
schema: validator.body,
type: "body",
normalize
}), validator.body.provider === "standard" ? fnLiteral += `let vab=validator.body.Check(c.body)
if(vab instanceof Promise)vab=await vab
if(vab.issues){` + validation.validate("body", void 0, "vab.issues") + `}else{c.body=vab.value}
` : validator.body?.schema?.noValidate !== !0 && (validator.body.isOptional ? fnLiteral += "if(isNotEmptyObject&&validator.body.Check(c.body)===false){" + validation.validate("body") + "}" : fnLiteral += "if(validator.body.Check(c.body)===false){" + validation.validate("body") + "}");
} else
fnLiteral += composeCleaner({
name: "c.body",
schema: validator.body,
type: "body",
normalize
}), validator.body.provider === "standard" ? fnLiteral += `let vab=validator.body.Check(c.body)
if(vab instanceof Promise)vab=await vab
if(vab.issues){` + validation.validate("body", void 0, "vab.issues") + `}else{c.body=vab.value}
` : validator.body?.schema?.noValidate !== !0 && (validator.body.isOptional ? fnLiteral += "if(isNotEmptyObject&&validator.body.Check(c.body)===false){" + validation.validate("body") + "}" : fnLiteral += "if(validator.body.Check(c.body)===false){" + validation.validate("body") + "}");
if (validator.body.hasTransform && (fnLiteral += coerceTransformDecodeError(
`if(isNotEmptyObject)c.body=validator.body.Decode(c.body)
`,
"body",
allowUnsafeValidationDetails
)), hasUnion && validator.body.schema.anyOf?.length) {
const iterator = Object.values(
validator.body.schema.anyOf
);
for (let i = 0; i < iterator.length; i++) {
const type = iterator[i];
if ((0, import_schema.hasType)("File", type) || (0, import_schema.hasType)("Files", type)) {
const candidate = (0, import_schema.getSchemaValidator)(type, {
// @ts-expect-error private property
modules: app.definitions.typebox,
dynamic: !app.config.aot,
// @ts-expect-error private property
models: app.definitions.type,
normalize: app.config.normalize,
additionalCoerce: (0, import_replace_schema.coercePrimitiveRoot)(),
sanitize: () => app.config.sanitize
});
if (candidate) {
const isFirst = fileUnions.length === 0;
let properties = candidate.schema?.properties ?? type.properties;
if (!properties && candidate.schema?.anyOf) {
const objectSchema = candidate.schema.anyOf.find(
(s) => s.type === "object" || import_typebox.Kind in s && s[import_typebox.Kind] === "Object"
);
objectSchema && (properties = objectSchema.properties);
}
if (!properties) continue;
const iterator2 = Object.entries(properties);
let validator2 = isFirst ? `
` : " else ";
validator2 += `if(fileUnions[${fileUnions.length}].Check(c.body)){`;
let validateFile = "", validatorLength = 0;
for (let i2 = 0; i2 < iterator2.length; i2++) {
const [k, v] = iterator2[i2];
!v.extension || v[import_typebox.Kind] !== "File" && v[import_typebox.Kind] !== "Files" || (validatorLength && (validateFile += ","), validateFile += `fileType(c.body.${k},${JSON.stringify(v.extension)},'body.${k}')`, validatorLength++);
}
validateFile && (validatorLength === 1 ? validator2 += `await ${validateFile}
` : validatorLength > 1 && (validator2 += `await Promise.all([${validateFile}])
`), validator2 += "}", fnLiteral += validator2, fileUnions.push(candidate));
}
}
}
} else if (hasNonUnionFileWithDefault || !hasUnion && ((0, import_schema.hasType)(
"File",
(0, import_schema.unwrapImportSchema)(validator.body.schema)
) || (0, import_schema.hasType)(
"Files",
(0, import_schema.unwrapImportSchema)(validator.body.schema)
))) {
let validateFile = "", i = 0;
for (const [k, v] of Object.entries(
(0, import_schema.unwrapImportSchema)(validator.body.schema).properties
))
!v.extension || v[import_typebox.Kind] !== "File" && v[import_typebox.Kind] !== "Files" || (i && (validateFile += ","), validateFile += `fileType(c.body.${k},${JSON.stringify(v.extension)},'body.${k}')`, i++);
i && (fnLiteral += `
`), i === 1 ? fnLiteral += `await ${validateFile}
` : i > 1 && (fnLiteral += `await Promise.all([${validateFile}])
`);
}
}
validator.cookie && (validator.cookie.config = (0, import_utils.mergeCookie)(
validator.cookie.config,
validator.cookie?.config ?? {}
), fnLiteral += `let cookieValue={}
for(const [key,value] of Object.entries(c.cookie))cookieValue[key]=value.value
`, validator.cookie.isOptional && (fnLiteral += "if(isNotEmpty(c.cookie)){"), validator.cookie.provider === "standard" ? (fnLiteral += `let vac=validator.cookie.Check(cookieValue)
if(vac instanceof Promise)vac=await vac
if(vac.issues){` + validation.validate("cookie", void 0, "vac.issues") + `}else{cookieValue=vac.value}
`, fnLiteral += `for(const k of Object.keys(cookieValue))c.cookie[k].value=cookieValue[k]
`) : validator.body?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.cookie.Check(cookieValue)===false){" + validation.validate("cookie", "cookieValue") + "}", validator.cookie.hasTransform && (fnLiteral += coerceTransformDecodeError(
"for(const [key,value] of Object.entries(validator.cookie.Decode(cookieValue))){c.cookie[key].cookie.value = value}",
"cookie",
allowUnsafeValidationDetails
))), validator.cookie.isOptional && (fnLiteral += "}"));
}
if (hooks?.beforeHandle || hasTrace) {
const reporter = report("beforeHandle", {
total: hooks.beforeHandle?.length
});
let hasResolve = !1;
if (hooks.beforeHandle?.length)
for (let i = 0; i < hooks.beforeHandle.length; i++) {
const beforeHandle = hooks.beforeHandle[i], endUnit = reporter.resolveChild(beforeHandle.fn.name), returning = hasReturn(beforeHandle);
if (beforeHandle.subType === "resolve" || beforeHandle.subType === "mapResolve")
hasResolve || (hasResolve = !0, fnLiteral += `
let resolved
`), fnLiteral += isAsync(beforeHandle) ? `resolved=await e.beforeHandle[${i}](c);
` : `resolved=e.beforeHandle[${i}](c);
`, beforeHandle.subType === "mapResolve" ? fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse("resolved") + `}else{resolved.request=c.request
resolved.store=c.store
resolved.qi=c.qi
resolved.path=c.path
resolved.url=c.url
resolved.redirect=c.redirect
resolved.set=c.set
resolved.error=c.error
c=resolved}` : fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse("resolved") + `}else Object.assign(c, resolved)
`, endUnit();
else if (!returning)
fnLiteral += isAsync(beforeHandle) ? `await e.beforeHandle[${i}](c)
` : `e.beforeHandle[${i}](c)
`, endUnit();
else {
if (fnLiteral += isAsync(beforeHandle) ? `be=await e.beforeHandle[${i}](c)
` : `be=e.beforeHandle[${i}](c)
`, endUnit("be"), fnLiteral += "if(be!==undefined){", reporter.resolve(), hooks.afterHandle?.length || hasTrace) {
report("handle", {
name: isHandleFn ? handler.name : void 0
}).resolve();
const reporter2 = report("afterHandle", {
total: hooks.afterHandle?.length
});
if (hooks.afterHandle?.length)
for (let i2 = 0; i2 < hooks.afterHandle.length; i2++) {
const hook = hooks.afterHandle[i2], returning2 = hasReturn(hook), endUnit2 = reporter2.resolveChild(
hook.fn.name
);
fnLiteral += `c.response=c.responseValue=be
`, returning2 ? (fnLiteral += isAsync(hook.fn) ? `af=await e.afterHandle[${i2}](c)
` : `af=e.afterHandle[${i2}](c)
`, fnLiteral += `if(af!==undefined) c.response=c.responseValue=be=af
`) : fnLiteral += isAsync(hook.fn) ? `await e.afterHandle[${i2}](c, be)
` : `e.afterHandle[${i2}](c, be)
`, endUnit2("af");
}
reporter2.resolve();
}
validator.response && (fnLiteral += validation.response("be"));
const mapResponseReporter = report("mapResponse", {
total: hooks.mapResponse?.length
});
if (hooks.mapResponse?.length) {
fnLiteral += `c.response=c.responseValue=be
`;
for (let i2 = 0; i2 < hooks.mapResponse.length; i2++) {
const mapResponse2 = hooks.mapResponse[i2], endUnit2 = mapResponseReporter.resolveChild(
mapResponse2.fn.name
);
fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i2}](c)
if(mr!==undefined)be=c.response=c.responseValue=mr}`, endUnit2();
}
}
mapResponseReporter.resolve(), fnLiteral += afterResponse(), fnLiteral += encodeCookie(), fnLiteral += `return mapEarlyResponse(${saveResponse}be,c.set${mapResponseContext})}
`;
}
}
reporter.resolve();
}
function reportHandler(name) {
const handleReporter = report("handle", {
name,
alias: "reportHandler"
});
return () => {
hasTrace && (fnLiteral += 'if(r&&(r[Symbol.iterator]||r[Symbol.asyncIterator])&&typeof r.next==="function"){' + (maybeAsync ? "" : "(async()=>{") + `const stream=await tee(r,3)
r=stream[0]
const listener=stream[1]
` + (hasTrace || hooks.afterResponse?.length ? `afterHandlerStreamListener=stream[2]
` : "") + `${setImmediateFn}(async ()=>{if(listener)for await(const v of listener){}
`, handleReporter.resolve(), fnLiteral += "})" + (maybeAsync ? "" : "})()") + "}else{", handleReporter.resolve(), fnLiteral += `}
`);
};
}
if (hooks.afterHandle?.length || hasTrace) {
const resolveHandler = reportHandler(
isHandleFn ? handler.name : void 0
);
hooks.afterHandle?.length ? fnLiteral += isAsyncHandler ? `let r=c.response=c.responseValue=await ${handle}
` : `let r=c.response=c.responseValue=${handle}
` : fnLiteral += isAsyncHandler ? `let r=await ${handle}
` : `let r=${handle}
`, resolveHandler();
const reporter = report("afterHandle", {
total: hooks.afterHandle?.length
});
if (hooks.afterHandle?.length)
for (let i = 0; i < hooks.afterHandle.length; i++) {
const hook = hooks.afterHandle[i], returning = hasReturn(hook), endUnit = reporter.resolveChild(hook.fn.name);
returning ? (fnLiteral += isAsync(hook.fn) ? `af=await e.afterHandle[${i}](c)
` : `af=e.afterHandle[${i}](c)
`, endUnit("af"), validator.response ? (fnLiteral += "if(af!==undefined){", reporter.resolve(), fnLiteral += validation.response("af"), fnLiteral += "c.response=c.responseValue=af}") : (fnLiteral += "if(af!==undefined){", reporter.resolve(), fnLiteral += "c.response=c.responseValue=af}")) : (fnLiteral += isAsync(hook.fn) ? `await e.afterHandle[${i}](c)
` : `e.afterHandle[${i}](c)
`, endUnit());
}
reporter.resolve(), hooks.afterHandle?.length && (fnLiteral += `r=c.response
`), validator.response && (fnLiteral += validation.response()), fnLiteral += encodeCookie();
const mapResponseReporter = report("mapResponse", {
total: hooks.mapResponse?.length
});
if (hooks.mapResponse?.length)
for (let i = 0; i < hooks.mapResponse.length; i++) {
const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
mapResponse2.fn.name
);
fnLiteral += `mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i}](c)
if(mr!==undefined)r=c.response=c.responseValue=mr
`, endUnit();
}
mapResponseReporter.resolve(), fnLiteral += mapResponse();
} else {
const resolveHandler = reportHandler(
isHandleFn ? handler.name : void 0
);
if (validator.response || hooks.mapResponse?.length || hasTrace) {
fnLiteral += isAsyncHandler ? `let r=await ${handle}
` : `let r=${handle}
`, resolveHandler(), validator.response && (fnLiteral += validation.response());
const mapResponseReporter = report("mapResponse", {
total: hooks.mapResponse?.length
});
if (hooks.mapResponse?.length) {
fnLiteral += `
c.response=c.responseValue=r
`;
for (let i = 0; i < hooks.mapResponse.length; i++) {
const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
mapResponse2.fn.name
);
fnLiteral += `
if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i}](c)
if(mr!==undefined)r=c.response=c.responseValue=mr}
`, endUnit();
}
}
mapResponseReporter.resolve(), fnLiteral += encodeCookie(), handler instanceof Response ? (fnLiteral += afterResponse(), fnLiteral += inference.set ? `if(isNotEmpty(c.set.headers)||c.set.status!==200||c.set.redirect||c.set.cookie)return mapResponse(${saveResponse}${handle}.clone(),c.set${mapResponseContext})
else return ${handle}.clone()` : `return ${handle}.clone()`, fnLiteral += `
`) : fnLiteral += mapResponse();
} else if (hasCookie || hasTrace) {
fnLiteral += isAsyncHandler ? `let r=await ${handle}
` : `let r=${handle}
`, resolveHandler();
const mapResponseReporter = report("mapResponse", {
total: hooks.mapResponse?.length
});
if (hooks.mapResponse?.length) {
fnLiteral += `c.response=c.responseValue= r
`;
for (let i = 0; i < hooks.mapResponse.length; i++) {
const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
mapResponse2.fn.name
);
fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i}](c)
if(mr!==undefined)r=c.response=c.responseValue=mr}`, endUnit();
}
}
mapResponseReporter.resolve(), fnLiteral += encodeCookie() + mapResponse();
} else {
resolveHandler();
const handled = isAsyncHandler ? `await ${handle}` : handle;
handler instanceof Response ? (fnLiteral += afterResponse(), fnLiteral += inference.set ? `if(isNotEmpty(c.set.headers)||c.set.status!==200||c.set.redirect||c.set.cookie)return mapResponse(${saveResponse}${handle}.clone(),c.set${mapResponseContext})
else return ${handle}.clone()
` : `return ${handle}.clone()
`) : fnLiteral += mapResponse(handled);
}
}
if (fnLiteral += `
}catch(error){`, !maybeAsync && hooks.error?.length && (fnLiteral += "return(async()=>{"), fnLiteral += `const set=c.set
if(!set.status||set.status<300)set.status=error?.status||500
`, hasCookie && (fnLiteral += encodeCookie()), hasTrace && hooks.trace)
for (let i = 0; i < hooks.trace.length; i++)
fnLiteral += `report${i}?.resolve(error);reportChild${i}?.(error)
`;
const errorReporter = report("error", {
total: hooks.error?.length
});
if (hooks.error?.length) {
fnLiteral += `c.error=error
`, hasValidation ? fnLiteral += `if(error instanceof TypeBoxError){c.code="VALIDATION"
c.set.status=422}else{c.code=error.code??error[ERROR_CODE]??"UNKNOWN"}` : fnLiteral += `c.code=error.code??error[ERROR_CODE]??"UNKNOWN"
`, fnLiteral += `let er
`, hooks.mapResponse?.length && (fnLiteral += `let mep
`);
for (let i = 0; i < hooks.error.length; i++) {
const endUnit = errorReporter.resolveChild(hooks.error[i].fn.name);
if (isAsync(hooks.error[i]) ? fnLiteral += `er=await e.error[${i}](c)
` : fnLiteral += `er=e.error[${i}](c)
if(er instanceof Promise)er=await er
`, endUnit(), hooks.mapResponse?.length) {
const mapResponseReporter = report("mapResponse", {
total: hooks.mapResponse?.length
});
for (let i2 = 0; i2 < hooks.mapResponse.length; i2++) {
const mapResponse2 = hooks.mapResponse[i2], endUnit2 = mapResponseReporter.resolveChild(
mapResponse2.fn.name
);
fnLiteral += `c.response=c.responseValue=er
mep=e.mapResponse[${i2}](c)
if(mep instanceof Promise)er=await er
if(mep!==undefined)er=mep
`, endUnit2();
}
mapResponseReporter.resolve();
}
if (fnLiteral += `er=mapEarlyResponse(er,set${mapResponseContext})
`, fnLiteral += "if(er){", hasTrace && hooks.trace) {
for (let i2 = 0; i2 < hooks.trace.length; i2++)
fnLiteral += `report${i2}.resolve()
`;
errorReporter.resolve();
}
fnLiteral += afterResponse(!1), fnLiteral += "return er}";
}
}
errorReporter.resolve(), fnLiteral += "return handleError(c,error,true)", !maybeAsync && hooks.error?.length && (fnLiteral += "})()"), fnLiteral += "}";
const adapterVariables = adapter.inject ? Object.keys(adapter.inject).join(",") + "," : "";
let init = "const {handler,handleError,hooks:e, " + allocateIf("validator,", hasValidation) + "mapResponse,mapCompactResponse,mapEarlyResponse,isNotEmpty,utils:{" + allocateIf("parseQuery,", hasBody) + allocateIf("parseQueryFromURL,", hasQuery) + "},error:{" + allocateIf("ValidationError,", hasValidation) + allocateIf("ParseError", hasBody) + "},fileType,schema,definitions,tee,ERROR_CODE," + allocateIf("parseCookie,", hasCookie) + allocateIf("signCookie,", hasCookie) + allocateIf("decodeURIComponent,", hasQuery) + "ElysiaCustomStatusResponse," + allocateIf("ELYSIA_TRACE,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID,", hasTrace) + allocateIf("parser,", hooks.parse?.length) + allocateIf("getServer,", inference.server) + allocateIf("fileUnions,", fileUnions.leng