Camilla Schoeser
1325 lines
66 KiB
JavaScript
1325 lines
66 KiB
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" || fn.constructor.name === "AsyncGeneratorFunction")
|
|
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() : v.toString(), parenthesisEnd = fnLiteral.indexOf(")"), arrowIndex = fnLiteral.indexOf("=>", parenthesisEnd);
|
|
if (arrowIndex !== -1) {
|
|
let afterArrow = arrowIndex + 2, charCode;
|
|
for (; afterArrow < fnLiteral.length && ((charCode = fnLiteral.charCodeAt(afterArrow)) === 32 || // space
|
|
charCode === 9 || // tab
|
|
charCode === 10 || // newline
|
|
charCode === 13); )
|
|
afterArrow++;
|
|
if (afterArrow < fnLiteral.length && fnLiteral.charCodeAt(afterArrow) !== 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(
|
|
`cookie secret can't be an empty string at (${method}) ${path}`,
|
|
{
|
|
cause: `(${method}) ${path}`
|
|
}
|
|
);
|
|
if (!cookieMeta.secrets)
|
|
throw new Error(
|
|
`cookie secret must be defined (${method}) ${path}`,
|
|
{
|
|
cause: `(${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 && cookieMeta.secrets !== null ? 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), properties = (0, import_schema.getSchemaProperties)(schema);
|
|
if (properties)
|
|
for (const [key, value] of Object.entries(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 = `${maybeStream && maybeAsync ? "await " : ""}${hasSet ? "mapResponse" : "mapCompactResponse"}(${saveResponse}${r}${hasSet ? ",c.set" : ""}${mapResponseContext})
|
|
`;
|
|
return after ? `const _res=${response}` + after + "return _res" : `return ${response}`;
|
|
}, mapResponseContext = 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 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, properties = (0, import_schema.getSchemaProperties)(candidate.schema) ?? (0, import_schema.getSchemaProperties)(type);
|
|
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 = "";
|
|
const bodyProperties = (0, import_schema.getSchemaProperties)(
|
|
(0, import_schema.unwrapImportSchema)(validator.body.schema)
|
|
);
|
|
let i = 0;
|
|
if (bodyProperties)
|
|
for (const [k, v] of Object.entries(bodyProperties))
|
|
!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,
|
|
app.config.cookie ?? {}
|
|
), 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.cookie?.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].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]
|
|
` + (hooks.afterHandle?.length ? `c.response=c.responseValue=r
|
|
` : "") + `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)mep=await mep
|
|
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.length) + adapterVariables + allocateIf("TypeBoxError", hasValidation) + `}=hooks
|
|
const trace=e.trace
|
|
return ${maybeAsync ? "async " : ""}function handle(c){`;
|
|
hooks.beforeHandle?.length && (init += `let be
|
|
`), hooks.afterHandle?.length && (init += `let af
|
|
`), hooks.mapResponse?.length && (init += `let mr
|
|
`), allowMeta && (init += `c.schema=schema
|
|
c.defs=definitions
|
|
`), fnLiteral = init + fnLiteral + "}", init = "";
|
|
try {
|
|
return Function(
|
|
"hooks",
|
|
`"use strict";
|
|
` + fnLiteral
|
|
)({
|
|
handler,
|
|
hooks: (0, import_utils.lifeCycleToFn)(hooks),
|
|
validator: hasValidation ? validator : void 0,
|
|
// @ts-expect-error
|
|
handleError: app.handleError,
|
|
mapResponse: adapterHandler.mapResponse,
|
|
mapCompactResponse: adapterHandler.mapCompactResponse,
|
|
mapEarlyResponse: adapterHandler.mapEarlyResponse,
|
|
isNotEmpty: import_utils.isNotEmpty,
|
|
utils: {
|
|
parseQuery: hasBody ? import_parse_query.parseQuery : void 0,
|
|
parseQueryFromURL: hasQuery ? validator.query?.provider === "standard" ? import_parse_query.parseQueryStandardSchema : import_parse_query.parseQueryFromURL : void 0
|
|
},
|
|
error: {
|
|
ValidationError: hasValidation ? import_error2.ValidationError : void 0,
|
|
ParseError: hasBody ? import_error.ParseError : void 0
|
|
},
|
|
fileType: import_utils3.fileType,
|
|
schema: app.router.history,
|
|
// @ts-expect-error
|
|
definitions: app.definitions.type,
|
|
tee: import_utils4.tee,
|
|
ERROR_CODE: import_error2.ERROR_CODE,
|
|
parseCookie: hasCookie ? import_cookies.parseCookie : void 0,
|
|
signCookie: hasCookie ? import_utils.signCookie : void 0,
|
|
Cookie: hasCookie ? import_index.Cookie : void 0,
|
|
decodeURIComponent: hasQuery ? import_fast_decode_uri_component.default : void 0,
|
|
ElysiaCustomStatusResponse: import_error2.ElysiaCustomStatusResponse,
|
|
ELYSIA_TRACE: hasTrace ? import_trace.ELYSIA_TRACE : void 0,
|
|
ELYSIA_REQUEST_ID: hasTrace ? import_utils.ELYSIA_REQUEST_ID : void 0,
|
|
// @ts-expect-error private property
|
|
getServer: inference.server ? () => app.getServer() : void 0,
|
|
fileUnions: fileUnions.length ? fileUnions : void 0,
|
|
TypeBoxError: hasValidation ? import_typebox.TypeBoxError : void 0,
|
|
parser: app["~parser"],
|
|
...adapter.inject
|
|
});
|
|
} catch (error) {
|
|
const debugHooks = (0, import_utils.lifeCycleToFn)(hooks);
|
|
return console.log("[Composer] failed to generate optimized handler"), console.log("---"), console.log({
|
|
handler: typeof handler == "function" ? handler.toString() : handler,
|
|
instruction: fnLiteral,
|
|
hooks: {
|
|
...debugHooks,
|
|
// @ts-ignore
|
|
transform: debugHooks?.transform?.map?.((x) => x.toString()),
|
|
// @ts-ignore
|
|
resolve: debugHooks?.resolve?.map?.((x) => x.toString()),
|
|
// @ts-ignore
|
|
beforeHandle: debugHooks?.beforeHandle?.map?.(
|
|
(x) => x.toString()
|
|
),
|
|
// @ts-ignore
|
|
afterHandle: debugHooks?.afterHandle?.map?.(
|
|
(x) => x.toString()
|
|
),
|
|
// @ts-ignore
|
|
mapResponse: debugHooks?.mapResponse?.map?.(
|
|
(x) => x.toString()
|
|
),
|
|
// @ts-ignore
|
|
parse: debugHooks?.parse?.map?.((x) => x.toString()),
|
|
// @ts-ignore
|
|
error: debugHooks?.error?.map?.((x) => x.toString()),
|
|
// @ts-ignore
|
|
afterResponse: debugHooks?.afterResponse?.map?.(
|
|
(x) => x.toString()
|
|
),
|
|
// @ts-ignore
|
|
stop: debugHooks?.stop?.map?.((x) => x.toString())
|
|
},
|
|
validator,
|
|
// @ts-expect-error
|
|
definitions: app.definitions.type,
|
|
error
|
|
}), console.log("---"), typeof process?.exit == "function" && process.exit(1), () => new Response("Internal Server Error", { status: 500 });
|
|
}
|
|
}, createOnRequestHandler = (app, addFn) => {
|
|
let fnLiteral = "";
|
|
const reporter = createReport({
|
|
trace: app.event.trace,
|
|
addFn: addFn ?? ((word) => {
|
|
fnLiteral += word;
|
|
})
|
|
})("request", {
|
|
total: app.event.request?.length
|
|
});
|
|
if (app.event.request?.length) {
|
|
fnLiteral += "try{";
|
|
for (let i = 0; i < app.event.request.length; i++) {
|
|
const hook = app.event.request[i], withReturn = hasReturn(hook), maybeAsync = isAsync(hook), endUnit = reporter.resolveChild(app.event.request[i].fn.name);
|
|
withReturn ? (fnLiteral += `re=mapEarlyResponse(${maybeAsync ? "await " : ""}onRequest[${i}](c),c.set)
|
|
`, endUnit("re"), fnLiteral += `if(re!==undefined)return re
|
|
`) : (fnLiteral += `${maybeAsync ? "await " : ""}onRequest[${i}](c)
|
|
`, endUnit());
|
|
}
|
|
fnLiteral += "}catch(error){return app.handleError(c,error,false)}";
|
|
}
|
|
return reporter.resolve(), fnLiteral;
|
|
}, createHoc = (app, fnName = "map") => {
|
|
const hoc = app.extender.higherOrderFunctions;
|
|
if (!hoc.length) return "return " + fnName;
|
|
const adapter = app["~adapter"].composeGeneralHandler;
|
|
let handler = fnName;
|
|
for (let i = 0; i < hoc.length; i++)
|
|
handler = `hoc[${i}](${handler},${adapter.parameters})`;
|
|
return `return function hocMap(${adapter.parameters}){return ${handler}(${adapter.parameters})}`;
|
|
}, composeGeneralHandler = (app) => {
|
|
const adapter = app["~adapter"].composeGeneralHandler;
|
|
app.router.http.build();
|
|
const isWebstandard = app["~adapter"].isWebStandard, hasTrace = app.event.trace?.length;
|
|
let fnLiteral = "";
|
|
const router = app.router;
|
|
let findDynamicRoute = router.http.root.WS ? "const route=router.find(r.method==='GET'&&r.headers.get('upgrade')==='websocket'?'WS':r.method,p)" : "const route=router.find(r.method,p)";
|
|
findDynamicRoute += router.http.root.ALL ? `??router.find('ALL',p)
|
|
` : `
|
|
`, isWebstandard && (findDynamicRoute += 'if(r.method==="HEAD"){const route=router.find("GET",p);if(route){c.params=route.params;const _res=route.store.handler?route.store.handler(c):route.store.compile()(c);if(_res)return Promise.resolve(_res).then((_res)=>{if(!_res.headers)_res.headers=new Headers();return getResponseLength(_res).then((length)=>{_res.headers.set("content-length", length);return new Response(null,{status:_res.status,statusText:_res.statusText,headers:_res.headers});})});}}');
|
|
let afterResponse = `c.error=notFound
|
|
`;
|
|
if (app.event.afterResponse?.length && !app.event.error) {
|
|
afterResponse = `
|
|
c.error=notFound
|
|
`;
|
|
const prefix = app.event.afterResponse.some(isAsync) ? "async" : "";
|
|
afterResponse += `
|
|
${setImmediateFn}(${prefix}()=>{if(c.responseValue instanceof ElysiaCustomStatusResponse) c.set.status=c.responseValue.code
|
|
`;
|
|
for (let i = 0; i < app.event.afterResponse.length; i++) {
|
|
const fn2 = app.event.afterResponse[i].fn;
|
|
afterResponse += `
|
|
${isAsyncName(fn2) ? "await " : ""}afterResponse[${i}](c)
|
|
`;
|
|
}
|
|
afterResponse += `})
|
|
`;
|
|
}
|
|
app.inference.query && (afterResponse += `
|
|
if(c.qi===-1){c.query={}}else{c.query=parseQueryFromURL(c.url,c.qi+1)}`);
|
|
const error404 = adapter.error404(
|
|
!!app.event.request?.length,
|
|
!!app.event.error?.length,
|
|
afterResponse
|
|
);
|
|
findDynamicRoute += error404.code, findDynamicRoute += `
|
|
c.params=route.params
|
|
if(route.store.handler)return route.store.handler(c)
|
|
return route.store.compile()(c)
|
|
`;
|
|
let switchMap = "";
|
|
for (const [path, methods] of Object.entries(router.static)) {
|
|
switchMap += `case'${path}':`, app.config.strictPath !== !0 && (switchMap += `case'${(0, import_utils.getLoosePath)(path)}':`);
|
|
const encoded = (0, import_utils.encodePath)(path);
|
|
path !== encoded && (switchMap += `case'${encoded}':`), switchMap += "switch(r.method){", ("GET" in methods || "WS" in methods) && (switchMap += "case 'GET':", "WS" in methods && (switchMap += `if(r.headers.get('upgrade')==='websocket')return ht[${methods.WS}].composed(c)
|
|
`, "GET" in methods || ("ALL" in methods ? switchMap += `return ht[${methods.ALL}].composed(c)
|
|
` : switchMap += `break map
|
|
`)), "GET" in methods && (switchMap += `return ht[${methods.GET}].composed(c)
|
|
`)), isWebstandard && ("GET" in methods || "ALL" in methods) && !("HEAD" in methods) && (switchMap += `case 'HEAD':return Promise.resolve(ht[${methods.GET ?? methods.ALL}].composed(c)).then(_ht=>getResponseLength(_ht).then((length)=>{_ht.headers.set('content-length', length)
|
|
return new Response(null,{status:_ht.status,statusText:_ht.statusText,headers:_ht.headers})
|
|
}))
|
|
`);
|
|
for (const [method, index] of Object.entries(methods))
|
|
method === "ALL" || method === "GET" || method === "WS" || (switchMap += `case '${method}':return ht[${index}].composed(c)
|
|
`);
|
|
"ALL" in methods ? switchMap += `default:return ht[${methods.ALL}].composed(c)
|
|
` : switchMap += `default:break map
|
|
`, switchMap += "}";
|
|
}
|
|
const maybeAsync = !!app.event.request?.some(isAsync), adapterVariables = adapter.inject ? Object.keys(adapter.inject).join(",") + "," : "";
|
|
fnLiteral += `
|
|
const {app,mapEarlyResponse,NotFoundError,randomId,handleError,status,redirect,getResponseLength,ElysiaCustomStatusResponse,` + // @ts-ignore
|
|
allocateIf("parseQueryFromURL,", app.inference.query) + allocateIf("ELYSIA_TRACE,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID,", hasTrace) + adapterVariables + `}=data
|
|
const store=app.singleton.store
|
|
const decorator=app.singleton.decorator
|
|
const staticRouter=app.router.static.http
|
|
const ht=app.router.history
|
|
const router=app.router.http
|
|
const trace=app.event.trace?.map(x=>typeof x==='function'?x:x.fn)??[]
|
|
const notFound=new NotFoundError()
|
|
const hoc=app.extender.higherOrderFunctions.map(x=>x.fn)
|
|
`, app.event.request?.length && (fnLiteral += `const onRequest=app.event.request.map(x=>x.fn)
|
|
`), app.event.afterResponse?.length && (fnLiteral += `const afterResponse=app.event.afterResponse.map(x=>x.fn)
|
|
`), fnLiteral += error404.declare, app.event.trace?.length && (fnLiteral += "const " + app.event.trace.map((_, i) => `tr${i}=app.event.trace[${i}].fn`).join(",") + `
|
|
`), fnLiteral += `${maybeAsync ? "async " : ""}function map(${adapter.parameters}){`, app.event.request?.length && (fnLiteral += `let re
|
|
`), fnLiteral += adapter.createContext(app), app.event.trace?.length && (fnLiteral += "c[ELYSIA_TRACE]=[" + app.event.trace.map((_, i) => `tr${i}(c)`).join(",") + `]
|
|
`), fnLiteral += createOnRequestHandler(app), switchMap && (fnLiteral += `
|
|
map: switch(p){
|
|
` + switchMap + "}"), fnLiteral += findDynamicRoute + `}
|
|
` + createHoc(app);
|
|
const handleError = composeErrorHandler(app);
|
|
app.handleError = handleError;
|
|
const fn = Function(
|
|
"data",
|
|
`"use strict";
|
|
` + fnLiteral
|
|
)({
|
|
app,
|
|
mapEarlyResponse: app["~adapter"].handler.mapEarlyResponse,
|
|
NotFoundError: import_error2.NotFoundError,
|
|
randomId: import_utils.randomId,
|
|
handleError,
|
|
status: import_error.status,
|
|
redirect: import_utils.redirect,
|
|
getResponseLength: import_utils.getResponseLength,
|
|
ElysiaCustomStatusResponse: import_error2.ElysiaCustomStatusResponse,
|
|
// @ts-ignore
|
|
parseQueryFromURL: app.inference.query ? import_parse_query.parseQueryFromURL : void 0,
|
|
ELYSIA_TRACE: hasTrace ? import_trace.ELYSIA_TRACE : void 0,
|
|
ELYSIA_REQUEST_ID: hasTrace ? import_utils.ELYSIA_REQUEST_ID : void 0,
|
|
...adapter.inject
|
|
});
|
|
return import_utils2.isBun && Bun.gc(!1), fn;
|
|
}, composeErrorHandler = (app) => {
|
|
const hooks = app.event;
|
|
let fnLiteral = "";
|
|
const adapter = app["~adapter"].composeError, adapterVariables = adapter.inject ? Object.keys(adapter.inject).join(",") + "," : "", hasTrace = !!app.event.trace?.length;
|
|
fnLiteral += "const {mapResponse,ERROR_CODE,ElysiaCustomStatusResponse,ValidationError,TransformDecodeError," + allocateIf("onError,", app.event.error) + allocateIf("afterResponse,", app.event.afterResponse) + allocateIf("trace,", app.event.trace) + allocateIf("onMapResponse,", app.event.mapResponse) + allocateIf("ELYSIA_TRACE,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID,", hasTrace) + adapterVariables + `}=inject
|
|
`, fnLiteral += "return async function(context,error,skipGlobal){", fnLiteral += "", hasTrace && (fnLiteral += `const id=context[ELYSIA_REQUEST_ID]
|
|
`);
|
|
const report = createReport({
|
|
context: "context",
|
|
trace: hooks.trace,
|
|
addFn: (word) => {
|
|
fnLiteral += word;
|
|
}
|
|
}), afterResponse = () => {
|
|
if (!hooks.afterResponse?.length && !hasTrace) return "";
|
|
let afterResponse2 = "";
|
|
const prefix = hooks.afterResponse?.some(isAsync) ? "async" : "";
|
|
afterResponse2 += `
|
|
${setImmediateFn}(${prefix}()=>{`;
|
|
const reporter = createReport({
|
|
context: "context",
|
|
trace: hooks.trace,
|
|
addFn: (word) => {
|
|
afterResponse2 += word;
|
|
}
|
|
})("afterResponse", {
|
|
total: hooks.afterResponse?.length,
|
|
name: "context"
|
|
});
|
|
if (hooks.afterResponse?.length && hooks.afterResponse)
|
|
for (let i = 0; i < hooks.afterResponse.length; i++) {
|
|
const fn = hooks.afterResponse[i].fn, endUnit = reporter.resolveChild(fn.name);
|
|
afterResponse2 += `
|
|
${isAsyncName(fn) ? "await " : ""}afterResponse[${i}](context)
|
|
`, endUnit();
|
|
}
|
|
return reporter.resolve(), afterResponse2 += `})
|
|
`, afterResponse2;
|
|
};
|
|
fnLiteral += `const set=context.set
|
|
let _r
|
|
if(!context.code)context.code=error.code??error[ERROR_CODE]
|
|
if(!(context.error instanceof Error))context.error=error
|
|
if(error instanceof ElysiaCustomStatusResponse){set.status=error.status=error.code
|
|
error.message=error.response}`, adapter.declare && (fnLiteral += adapter.declare);
|
|
const saveResponse = hasTrace || hooks.afterResponse?.length ? "context.response = " : "";
|
|
if (fnLiteral += `if(typeof error?.toResponse==='function'&&!(error instanceof ValidationError)&&!(error instanceof TransformDecodeError)){try{let raw=error.toResponse()
|
|
if(typeof raw?.then==='function')raw=await raw
|
|
if(raw instanceof Response)set.status=raw.status
|
|
context.response=context.responseValue=raw
|
|
}catch(toResponseError){
|
|
}
|
|
}
|
|
`, app.event.error)
|
|
for (let i = 0; i < app.event.error.length; i++) {
|
|
const handler = app.event.error[i], response = `${isAsync(handler) ? "await " : ""}onError[${i}](context)
|
|
`;
|
|
if (fnLiteral += "if(skipGlobal!==true&&!context.response){", hasReturn(handler)) {
|
|
fnLiteral += `_r=${response}
|
|
if(_r!==undefined){if(_r instanceof Response){` + afterResponse() + `return mapResponse(_r,set${adapter.mapResponseContext})}if(_r instanceof ElysiaCustomStatusResponse){error.status=error.code
|
|
error.message=error.response}if(set.status===200||!set.status)set.status=error.status
|
|
`;
|
|
const mapResponseReporter2 = report("mapResponse", {
|
|
total: hooks.mapResponse?.length,
|
|
name: "context"
|
|
});
|
|
if (hooks.mapResponse?.length)
|
|
for (let i2 = 0; i2 < hooks.mapResponse.length; i2++) {
|
|
const mapResponse = hooks.mapResponse[i2], endUnit = mapResponseReporter2.resolveChild(
|
|
mapResponse.fn.name
|
|
);
|
|
fnLiteral += `context.response=context.responseValue=_r
|
|
_r=${isAsyncName(mapResponse) ? "await " : ""}onMapResponse[${i2}](context)
|
|
`, endUnit();
|
|
}
|
|
mapResponseReporter2.resolve(), fnLiteral += afterResponse() + `return mapResponse(${saveResponse}_r,set${adapter.mapResponseContext})}`;
|
|
} else fnLiteral += response;
|
|
fnLiteral += "}";
|
|
}
|
|
fnLiteral += `if(error instanceof ValidationError||error instanceof TransformDecodeError){
|
|
if(error.error)error=error.error
|
|
set.status=error.status??422
|
|
` + afterResponse() + adapter.validationError + `
|
|
}
|
|
`, fnLiteral += "if(!context.response&&error instanceof Error){" + afterResponse() + adapter.unknownError + `
|
|
}`;
|
|
const mapResponseReporter = report("mapResponse", {
|
|
total: hooks.mapResponse?.length,
|
|
name: "context"
|
|
});
|
|
if (fnLiteral += `
|
|
if(!context.response)context.response=context.responseValue=error.message??error
|
|
`, hooks.mapResponse?.length) {
|
|
fnLiteral += `let mr
|
|
`;
|
|
for (let i = 0; i < hooks.mapResponse.length; i++) {
|
|
const mapResponse = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
|
|
mapResponse.fn.name
|
|
);
|
|
fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse) ? "await " : ""}onMapResponse[${i}](context)
|
|
if(mr!==undefined)error=context.response=context.responseValue=mr}`, endUnit();
|
|
}
|
|
}
|
|
mapResponseReporter.resolve(), fnLiteral += afterResponse() + `
|
|
return mapResponse(${saveResponse}error,set${adapter.mapResponseContext})}`;
|
|
const mapFn = (x) => typeof x == "function" ? x : x.fn;
|
|
return Function(
|
|
"inject",
|
|
`"use strict";
|
|
` + fnLiteral
|
|
)({
|
|
mapResponse: app["~adapter"].handler.mapResponse,
|
|
ERROR_CODE: import_error2.ERROR_CODE,
|
|
ElysiaCustomStatusResponse: import_error2.ElysiaCustomStatusResponse,
|
|
ValidationError: import_error2.ValidationError,
|
|
TransformDecodeError: import_value.TransformDecodeError,
|
|
onError: app.event.error?.map(mapFn),
|
|
afterResponse: app.event.afterResponse?.map(mapFn),
|
|
trace: app.event.trace?.map(mapFn),
|
|
onMapResponse: app.event.mapResponse?.map(mapFn),
|
|
ELYSIA_TRACE: hasTrace ? import_trace.ELYSIA_TRACE : void 0,
|
|
ELYSIA_REQUEST_ID: hasTrace ? import_utils.ELYSIA_REQUEST_ID : void 0,
|
|
...adapter.inject
|
|
});
|
|
};
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
composeErrorHandler,
|
|
composeGeneralHandler,
|
|
composeHandler,
|
|
createHoc,
|
|
createOnRequestHandler,
|
|
isAsync
|
|
});
|