silgi 0.42.5 → 0.43.0

package/dist/core/index.mjs

@@ -1,1348 +1,30 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { createContext, getContext } from 'unctx';
-import { toJsonSchema } from '@standard-community/standard-json';
-import consola, { createConsola } from 'consola';
-import { defu } from 'defu';
-import { createHooks } from 'hookable';
-import { createRouter, addRoute, findRoute, findAllRoutes } from 'rou3';
-import { getServicePath } from 'silgi/kit';
-import { useRuntimeConfig, sharedRuntimeConfig } from 'silgi/runtime';
-import { Buffer } from 'node:buffer';
-import { klona } from 'klona';
-import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
-import { isDevelopment } from 'std-env';
-import { FastURL, FastResponse } from 'srvx';
-export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from '../_chunks/silgiApp.mjs';
-
-const asyncRuntimeStorage = createContext({
-  asyncContext: true,
-  AsyncLocalStorage
-});
-function updateRuntimeStorage(runtime) {
-  if (asyncRuntimeStorage.tryUse()) {
-    asyncRuntimeStorage.unset();
-    asyncRuntimeStorage.set(runtime);
-  } else {
-    asyncRuntimeStorage.set(runtime);
-  }
-}
-function useRuntime() {
-  const instance = asyncRuntimeStorage.tryUse();
-  if (!instance) {
-    throw new Error("Runtime instance is unavailable!");
-  }
-  return instance;
-}
-
-const silgiCtx = getContext("silgi");
-function useSilgi() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-function normalizeResult(result) {
-  if (Array.isArray(result)) {
-    return [...result];
-  }
-  if (result && typeof result === "object") {
-    if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) {
-      return Object.values(result);
-    }
-    return { ...result };
-  }
-  return result;
-}
-function tryUseSilgi() {
-  return silgiCtx.tryUse();
-}
-
-const EmptyObject = /* @__PURE__ */ (() => {
-  const C = function() {
-  };
-  C.prototype = /* @__PURE__ */ Object.create(null);
-  return C;
-})();
-
-function hasProp(obj, prop) {
-  try {
-    return prop in obj;
-  } catch {
-    return false;
-  }
-}
-function isJSONSerializable(value, _type) {
-  if (value === null || value === void 0) {
-    return true;
-  }
-  if (_type !== "object") {
-    return _type === "boolean" || _type === "number" || _type === "string";
-  }
-  if (typeof value.toJSON === "function") {
-    return true;
-  }
-  if (Array.isArray(value)) {
-    return true;
-  }
-  if (typeof value.pipe === "function" || typeof value.pipeTo === "function") {
-    return false;
-  }
-  if (value instanceof EmptyObject) {
-    return true;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
-function sanitizeStatusMessage(statusMessage = "") {
-  return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
-}
-function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
-  if (!statusCode) {
-    return defaultStatusCode;
-  }
-  if (typeof statusCode === "string") {
-    statusCode = Number.parseInt(statusCode, 10);
-  }
-  if (statusCode < 100 || statusCode > 999) {
-    return defaultStatusCode;
-  }
-  return statusCode;
-}
-
-class SilgiError extends Error {
-  static __silgi_error__ = true;
-  statusCode = 500;
-  fatal = false;
-  unhandled = false;
-  statusMessage;
-  data;
-  cause;
-  constructor(message, opts = {}) {
-    super(message, opts);
-    if (opts.cause && !this.cause) {
-      this.cause = opts.cause;
-    }
-    if (isDevelopment && opts.cause && opts.cause instanceof Error && opts.cause.stack && this.stack) {
-      this.stack += `
-Caused by: ${opts.cause.stack}`;
-      consola.warn(opts.cause);
-    }
-  }
-  toJSON() {
-    const obj = {
-      message: this.message,
-      statusCode: sanitizeStatusCode(this.statusCode, 500)
-    };
-    if (this.statusMessage) {
-      obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
-    }
-    if (this.data !== void 0) {
-      obj.data = this.data;
-    }
-    return obj;
-  }
-}
-function createError(input) {
-  if (typeof input === "string") {
-    return new SilgiError(input);
-  }
-  const cause = input.cause;
-  const err = new SilgiError(input.message ?? input.statusMessage ?? "", {
-    cause: cause || input
-  });
-  if (hasProp(input, "stack")) {
-    try {
-      Object.defineProperty(err, "stack", {
-        get() {
-          return input.stack;
-        }
-      });
-    } catch {
-      try {
-        err.stack = input.stack;
-      } catch {
-      }
-    }
-  }
-  if (input.data) {
-    err.data = input.data;
-  }
-  const statusCode = input.statusCode ?? input.status ?? cause?.statusCode ?? cause?.status;
-  if (typeof statusCode === "number") {
-    err.statusCode = sanitizeStatusCode(statusCode);
-  }
-  const statusMessage = input.statusMessage ?? input.statusText ?? cause?.statusMessage ?? cause?.statusText;
-  if (statusMessage) {
-    err.statusMessage = sanitizeStatusMessage(statusMessage);
-  }
-  const fatal = input.fatal ?? cause?.fatal;
-  if (fatal !== void 0) {
-    err.fatal = fatal;
-  }
-  const unhandled = input.unhandled ?? cause?.unhandled;
-  if (unhandled !== void 0) {
-    err.unhandled = unhandled;
-  }
-  return err;
-}
-function isError(input) {
-  return input?.constructor?.__silgi_error__ === true;
-}
-
-function replaceRuntimeValues(obj, runtime) {
-  if (!obj || typeof obj !== "object")
-    return obj;
-  for (const key in obj) {
-    if (typeof obj[key] === "string" && obj[key].startsWith("runtime.")) {
-      const runtimePath = obj[key].substring(8).split(".");
-      let value = runtime;
-      for (const segment of runtimePath) {
-        if (value === void 0 || value === null)
-          break;
-        value = value[segment];
-      }
-      if (value !== void 0)
-        obj[key] = value;
-    } else if (typeof obj[key] === "object" && obj[key] !== null) {
-      obj[key] = replaceRuntimeValues(obj[key], runtime);
-    }
-  }
-  return obj;
-}
-
-async function createStorage(silgi) {
-  const storage = createStorage$1();
-  const runtime = useRuntimeConfig();
-  const mounts = klona({
-    ...silgi.options.storage,
-    ...silgi.options.devStorage
-  });
-  for (const [path, opts] of Object.entries(mounts)) {
-    if (opts.driver) {
-      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
-      const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
-      storage.mount(path, driver(processedOpts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-function useSilgiStorage(base = "/memory:cache") {
-  const silgi = useSilgi();
-  return base ? prefixStorage(silgi.storage, base) : silgi.storage;
-}
-async function generateStorageKey(params) {
-  const {
-    url,
-    input,
-    keyGenerator,
-    requestId,
-    storageOptions
-  } = params;
-  const cacheScopePrefix = storageOptions?.scope === "request" ? "req" : "global";
-  const parts = [
-    cacheScopePrefix,
-    // Always include scope prefix first
-    url.raw
-  ].filter(Boolean);
-  if (storageOptions?.scope === "request") {
-    if (!requestId) {
-      throw createError({
-        statusCode: 400,
-        statusMessage: "Request ID is required for request-scoped cache",
-        data: {
-          requestId,
-          url,
-          input,
-          storageOptions,
-          keyGenerator
-        }
-      });
-    }
-    parts.push(requestId);
-  }
-  if (keyGenerator) {
-    const customKey = await Promise.resolve(keyGenerator(input));
-    parts.push(customKey);
-  } else {
-    parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
-  }
-  return Buffer.from(parts.join(":")).toString("base64");
-}
-
-async function runSilgiPlugins(silgi) {
-  for (const plugin of silgi.plugins) {
-    try {
-      await plugin(silgi);
-    } catch (error) {
-      silgi.captureError(silgi, error, { tags: ["plugin"] });
-      throw error;
-    }
-  }
-}
-async function createSilgi(config) {
-  const hooks = createHooks();
-  const silgi = {
-    router: void 0,
-    _middlewareRouter: void 0,
-    routerPrefixs: [],
-    schemas: config.schemas ?? {},
-    services: config.services ?? {},
-    resolvers: config.resolvers ?? [],
-    middlewares: config.middlewares ?? {},
-    globalMiddlewares: config.globalMiddlewares ?? [],
-    shared: config.shared ?? {},
-    plugins: config.plugins ?? [],
-    framework: config.framework ?? {},
-    storage: config.options.putStorage ?? void 0,
-    options: config.options ?? {},
-    hooks,
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    ready: () => {
-      return hooks.callHook("ready", silgi);
-    },
-    envOptions: config.envOptions ?? {},
-    close: () => hooks.callHook("close", silgi),
-    logger: createConsola(defu(config.options?.consolaOptions ?? {}, {
-      tag: "silgi"
-    })).withTag("silgi"),
-    captureError: config.captureError ?? (() => {
-    }),
-    websocket: config.websocket ?? void 0
-  };
-  sharedRuntimeConfig(silgi.options.runtimeConfig);
-  if (!silgi.router) {
-    silgi.router = createRouter();
-  }
-  for (const [_route, object] of Object.entries(silgi.services)) {
-    const { method, type } = getServicePath(_route);
-    if (!object)
-      continue;
-    const path = String(object.path);
-    const routeParts = path.split("/").filter(Boolean);
-    if (routeParts.length > 0) {
-      const prefix = `/${routeParts[0]}`;
-      if (!silgi.routerPrefixs.includes(prefix)) {
-        silgi.routerPrefixs.push(`${type}:${prefix}`);
-      }
-    }
-    let routeWithParams = path;
-    let pathParamNames = {};
-    let queryParamNames = {};
-    if (object.pathParams) {
-      const jsonSchema = await toJsonSchema(object.pathParams);
-      if (jsonSchema && jsonSchema.properties) {
-        pathParamNames = Object.keys(jsonSchema.properties).reduce((acc, key) => {
-          const prop = jsonSchema.properties?.[key];
-          if (typeof prop === "object" && prop !== null && "type" in prop) {
-            acc[key] = prop.type ?? "string";
-          } else {
-            acc[key] = "string";
-          }
-          return acc;
-        }, {});
-        const paramNames = Object.keys(jsonSchema.properties);
-        if (paramNames.length > 0) {
-          const routeParts2 = routeWithParams.split("/");
-          const lastParts = routeParts2.slice(-paramNames.length);
-          const alreadyHasParams = paramNames.every((name, idx) => lastParts[idx] === `:${name}`);
-          if (!alreadyHasParams) {
-            routeWithParams = routeWithParams.replace(/\/+$/, "");
-            for (const param of paramNames) {
-              routeWithParams += `/:${param}`;
-            }
-          }
-        }
-      }
-    }
-    if (object.queryParams) {
-      const jsonSchema = await toJsonSchema(object.queryParams);
-      if (jsonSchema && jsonSchema.properties) {
-        queryParamNames = Object.keys(jsonSchema.properties).reduce((acc, key) => {
-          const prop = jsonSchema.properties?.[key];
-          if (typeof prop === "object" && prop !== null && "type" in prop) {
-            acc[key] = prop.type ?? "string";
-          } else {
-            acc[key] = "string";
-          }
-          return acc;
-        }, {});
-      }
-    }
-    addRoute(silgi.router, method, routeWithParams, {
-      method,
-      route: routeWithParams,
-      service: object,
-      queryParams: queryParamNames,
-      pathParams: pathParamNames
-    });
-  }
-  if (!silgi._middlewareRouter) {
-    silgi._middlewareRouter = createRouter();
-  }
-  for (const [route, routeObject] of Object.entries(silgi.middlewares)) {
-    let _route = "";
-    if (route.includes(":")) {
-      const [methodPart, ...routeParts] = route.split(":");
-      methodPart.toUpperCase();
-      _route = routeParts.join(":");
-    }
-    if (_route === "global") {
-      for (const method of routeObject.methods?.length ? routeObject.methods : ["ALL"]) {
-        silgi.globalMiddlewares.push({
-          middleware: routeObject.setup,
-          method: method === "ALL" ? "" : method.toUpperCase(),
-          route: _route
-        });
-      }
-      continue;
-    }
-    const methods = routeObject.methods?.length ? routeObject.methods : ["ALL"];
-    for (const method of methods) {
-      const globalMethod = method === "ALL" ? "" : method.toUpperCase();
-      addRoute(silgi._middlewareRouter, globalMethod, _route, {
-        middleware: routeObject.setup,
-        method,
-        route: _route
-      });
-    }
-  }
-  silgi.hooks.addHooks(silgi.options.hooks);
-  await runSilgiPlugins(silgi);
-  if (!silgi.storage) {
-    silgi.storage = await createStorage(silgi);
-  }
-  silgi.shared.storage = (...data) => {
-    return useSilgiStorage(...data);
-  };
-  silgi.shared.useRuntimeConfig = useRuntimeConfig;
-  if (silgiCtx.tryUse()) {
-    silgiCtx.unset();
-    silgiCtx.set(silgi);
-  } else {
-    silgiCtx.set(silgi);
-    silgi.hook("close", () => silgiCtx.unset());
-  }
-  hooks.hookOnce("close", async () => {
-    hooks.removeAllHooks();
-    await silgi.storage.dispose();
-  });
-  silgi.logger.info("Silgi Start");
-  return silgi;
-}
-
-class SilgiHttpEvent {
-  static __is_event__ = true;
-  req;
-  url;
-  context;
-  _res;
-  constructor(req, context) {
-    this.context = context || new EmptyObject();
-    this.context.protocol = "HTTP";
-    this.req = req;
-    const _url = req._url;
-    this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
-  }
-  _chain;
-  get res() {
-    if (!this._res) {
-      this._res = new SilgiEventResponse();
-    }
-    return this._res;
-  }
-  get runtime() {
-    return this.req.runtime;
-  }
-  toString() {
-    return `[${this.req.method}] ${this.req.url}`;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-class SilgiEventResponse {
-  status;
-  statusText;
-  _headers;
-  get headers() {
-    if (!this._headers) {
-      this._headers = new Headers();
-    }
-    return this._headers;
-  }
-}
-
-const kNotFound = /* @__PURE__ */ Symbol.for("silgi.notFound");
-const kHandled = /* @__PURE__ */ Symbol.for("silgi.handled");
-function handleResponse(val, event, config) {
-  if (val && val instanceof Promise) {
-    return val.catch((error) => error).then((resolvedVal) => handleResponse(resolvedVal, event, config));
-  }
-  const response = prepareResponse(val, event, config);
-  if (response instanceof Promise) {
-    return handleResponse(response, event, config);
-  }
-  const { onBeforeResponse } = config;
-  return onBeforeResponse ? Promise.resolve(onBeforeResponse(event, response)).then(() => response) : response;
-}
-function prepareResponse(val, event, config, nested) {
-  if (val === kHandled) {
-    return new FastResponse(null);
-  }
-  if (val === kNotFound) {
-    val = createError({
-      statusCode: 404,
-      statusMessage: `Cannot find any route matching [${event.req.method}] ${event.url}`
-    });
-  }
-  if (val && val instanceof Error) {
-    const error = createError(val);
-    const { onError } = config;
-    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
-  }
-  const eventHeaders = event.res._headers;
-  if (!(val instanceof Response)) {
-    const res = prepareResponseBody(val, event, config);
-    const status = event.res.status;
-    return new FastResponse(
-      nullBody(event.req.method, status) ? null : res.body,
-      {
-        status,
-        statusText: event.res.statusText,
-        headers: res.headers && eventHeaders ? mergeHeaders(res.headers, eventHeaders) : res.headers || eventHeaders
-      }
-    );
-  }
-  if (!eventHeaders) {
-    return val;
-  }
-  return new FastResponse(
-    nullBody(event.req.method, val.status) ? null : val.body,
-    {
-      status: val.status,
-      statusText: val.statusText,
-      headers: mergeHeaders(eventHeaders, val.headers)
-    }
-  );
-}
-function nullBody(method, status) {
-  return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
-}
-function mergeHeaders(base, merge) {
-  const mergedHeaders = new Headers(base);
-  for (const [name, value] of merge) {
-    if (name === "set-cookie") {
-      mergedHeaders.append(name, value);
-    } else {
-      mergedHeaders.set(name, value);
-    }
-  }
-  return mergedHeaders;
-}
-const emptyHeaders = new Headers({ "content-length": "0" });
-const jsonHeaders = new Headers({
-  "content-type": "application/json;charset=UTF-8"
-});
-function prepareResponseBody(val, event, config) {
-  if (val === null || val === void 0) {
-    return { body: "", headers: emptyHeaders };
-  }
-  const valType = typeof val;
-  if (valType === "string") {
-    return { body: val };
-  }
-  if (val instanceof Uint8Array) {
-    event.res.headers.set("content-length", val.byteLength.toString());
-    return { body: val };
-  }
-  if (isJSONSerializable(val, valType)) {
-    return {
-      body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
-      headers: jsonHeaders
-    };
-  }
-  if (valType === "bigint") {
-    return { body: val.toString(), headers: jsonHeaders };
-  }
-  if (val instanceof Blob) {
-    const headers = {
-      "content-type": val.type,
-      "content-length": val.size.toString()
-    };
-    if ("name" in val) {
-      const filename = encodeURIComponent(val.name);
-      headers["content-disposition"] = `filename="${filename}"; filename*=UTF-8''${filename}`;
-    }
-    return { body: val.stream(), headers };
-  }
-  if (valType === "symbol") {
-    return { body: val.toString() };
-  }
-  if (valType === "function") {
-    return { body: `${val.name}()` };
-  }
-  return { body: val };
-}
-function errorResponse(error, debug) {
-  return new FastResponse(
-    JSON.stringify(
-      {
-        statusCode: error.statusCode,
-        statusMessage: error.statusMessage,
-        data: error.data,
-        stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
-      },
-      null,
-      2
-    ),
-    {
-      status: error.statusCode,
-      statusText: error.statusMessage,
-      headers: {
-        "content-type": "application/json; charset=utf-8"
-      }
-    }
-  );
-}
-
-async function parseRequestInput(req) {
-  const contentType = req.headers.get("content-type") || "";
-  if (contentType.startsWith("application/json")) {
-    const text = await req.text();
-    if (!text)
-      return void 0;
-    try {
-      return JSON.parse(text);
-    } catch {
-      throw createError({
-        statusCode: 400,
-        statusMessage: "Invalid JSON",
-        data: text
-      });
-    }
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    const text = await req.text();
-    return Object.fromEntries(new URLSearchParams(text));
-  }
-  if (contentType.startsWith("text/")) {
-    return await req.text();
-  }
-  if (contentType.startsWith("application/octet-stream")) {
-    const buffer = await req.arrayBuffer();
-    if (typeof File !== "undefined") {
-      return new File([buffer], "uploaded.bin", { type: contentType });
-    }
-    if (typeof Buffer !== "undefined") {
-      return Buffer.from(buffer);
-    }
-    return new Uint8Array(buffer);
-  }
-  return await req.text();
-}
-
-const plusRegex = /\+/g;
-function parseQuery(input) {
-  const params = new EmptyObject();
-  if (!input || input === "?") {
-    return params;
-  }
-  const inputLength = input.length;
-  let key = "";
-  let value = "";
-  let startingIndex = -1;
-  let equalityIndex = -1;
-  let shouldDecodeKey = false;
-  let shouldDecodeValue = false;
-  let keyHasPlus = false;
-  let valueHasPlus = false;
-  let hasBothKeyValuePair = false;
-  let c = 0;
-  for (let i = 0; i < inputLength + 1; i++) {
-    c = i === inputLength ? 38 : input.charCodeAt(i);
-    switch (c) {
-      case 38: {
-        hasBothKeyValuePair = equalityIndex > startingIndex;
-        if (!hasBothKeyValuePair) {
-          equalityIndex = i;
-        }
-        key = input.slice(startingIndex + 1, equalityIndex);
-        if (hasBothKeyValuePair || key.length > 0) {
-          if (keyHasPlus) {
-            key = key.replace(plusRegex, " ");
-          }
-          if (shouldDecodeKey) {
-            try {
-              key = decodeURIComponent(key);
-            } catch {
-            }
-          }
-          if (hasBothKeyValuePair) {
-            value = input.slice(equalityIndex + 1, i);
-            if (valueHasPlus) {
-              value = value.replace(plusRegex, " ");
-            }
-            if (shouldDecodeValue) {
-              try {
-                value = decodeURIComponent(value);
-              } catch {
-              }
-            }
-          }
-          const currentValue = params[key];
-          if (currentValue === void 0) {
-            params[key] = value;
-          } else {
-            if (Array.isArray(currentValue)) {
-              currentValue.push(value);
-            } else {
-              params[key] = [currentValue, value];
-            }
-          }
-        }
-        value = "";
-        startingIndex = i;
-        equalityIndex = i;
-        shouldDecodeKey = false;
-        shouldDecodeValue = false;
-        keyHasPlus = false;
-        valueHasPlus = false;
-        break;
-      }
-      case 61: {
-        if (equalityIndex <= startingIndex) {
-          equalityIndex = i;
-        } else {
-          shouldDecodeValue = true;
-        }
-        break;
-      }
-      case 43: {
-        if (equalityIndex > startingIndex) {
-          valueHasPlus = true;
-        } else {
-          keyHasPlus = true;
-        }
-        break;
-      }
-      case 37: {
-        if (equalityIndex > startingIndex) {
-          shouldDecodeValue = true;
-        } else {
-          shouldDecodeKey = true;
-        }
-        break;
-      }
-    }
-  }
-  return params;
-}
-
-function getQuery(event) {
-  return parseQuery(event.url.search.slice(1));
-}
-function getRouterParams(event, opts = {}) {
-  let params = event.context.params || {};
-  if (opts.decode) {
-    params = { ...params };
-    for (const key in params) {
-      params[key] = decodeURIComponent(params[key]);
-    }
-  }
-  return params;
-}
-
-function createResolver(resolver) {
-  return resolver;
-}
-function getUrlPrefix(path, method) {
-  const parse = path.includes("://") ? new FastURL(path) : new URL(path, "http://localhost");
-  const cleanedPath = parse.pathname + parse.search + parse.hash;
-  const segments = cleanedPath.split("/").filter(Boolean);
-  if (segments.length < 2) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Invalid URL format",
-      data: { cleanedPath }
-    });
-  }
-  const prefix = `/${segments[0]}`;
-  const namespace = segments[1];
-  return {
-    namespaceName: namespace,
-    prefixName: prefix,
-    raw: path,
-    path: cleanedPath,
-    methodName: method || "GET"
-  };
-}
-
-async function orchestrate(route, event) {
-  const silgiCtx = useSilgi();
-  const silgiURL = getUrlPrefix(route.route || event.req.url, route.method);
-  const input = route.service?.rules?.readBeforeBody === false ? {} : await parseRequestInput(event.req);
-  const hookContext = { earlyReturnValue: false };
-  const routerParams = input.path || getRouterParams(event);
-  const queryParams = input.query || getQuery(event);
-  const inputData = {
-    args: input,
-    query: queryParams,
-    path: routerParams
-  };
-  try {
-    if (!route.service) {
-      throw createError({
-        statusCode: 404,
-        statusMessage: "Service not found"
-      });
-    }
-    const cachePromise = cacheExecute(input, route, silgiURL, event);
-    const beforeHookPromise = silgiCtx.callHook("fetch:before", {
-      url: silgiURL,
-      input,
-      event,
-      route,
-      hookContext
-    });
-    const cacheData = await cachePromise;
-    await beforeHookPromise;
-    if (hookContext.earlyReturnValue !== false) {
-      return hookContext.earlyReturnValue;
-    }
-    if (cacheData?.success) {
-      await silgiCtx.callHook("fetch:after", {
-        event,
-        url: silgiURL,
-        input,
-        result: cacheData.data,
-        success: true,
-        cached: true,
-        // modules: setup.modules,
-        route,
-        hookContext
-      });
-      return cacheData.data;
-    }
-    silgiCtx.shared.$fetch = silgiFetch;
-    silgiCtx.shared.silgi = silgiCtx;
-    const result = await route.service?.handler?.(
-      // input
-      inputData,
-      // shared
-      silgiCtx.shared,
-      // event
-      event
-    );
-    await silgiCtx.callHook("fetch:after", {
-      event,
-      url: silgiURL,
-      input: inputData,
-      result,
-      success: true,
-      route,
-      hookContext
-    });
-    if (route.service?.storage && cacheData?.cachedKey) {
-      await useSilgiStorage(route.service.storage.base).setItem(
-        cacheData.cachedKey,
-        result,
-        // Cast to StorageValue if needed
-        route.service.storage.options
-      );
-    }
-    return result;
-  } catch (err) {
-    await silgiCtx.callHook("fetch:error", {
-      event,
-      input: inputData,
-      error: err instanceof Error ? err : new Error(String(err)),
-      url: silgiURL,
-      route,
-      hookContext
-    });
-    silgiCtx.captureError(
-      silgiCtx,
-      createError({
-        message: err instanceof Error ? err.message : String(err),
-        statusCode: 500,
-        statusMessage: "Internal Server Error",
-        cause: err
-      }),
-      {
-        event,
-        tags: ["execute"]
-      }
-    );
-    throw err;
-  }
-}
-async function cacheExecute(input, route, silgiURL, event) {
-  if (!route.service || !route.service.storage)
-    return;
-  const cacheKey = route.service.storage ? await generateStorageKey({
-    url: silgiURL,
-    input,
-    keyGenerator: route.service.storage.key,
-    storageOptions: route.service.storage,
-    requestId: event?.requestId
-  }) : null;
-  if (cacheKey) {
-    const cachedResult = await useSilgiStorage(route.service.storage.base).getItem(cacheKey);
-    if (cachedResult !== null) {
-      return {
-        success: true,
-        data: normalizeResult(cachedResult),
-        cached: true,
-        cachedKey: cacheKey
-      };
-    }
-  }
-  return {
-    success: false,
-    data: null,
-    cached: false,
-    cachedKey: cacheKey
-  };
-}
-
-function getHeader(name, headers) {
-  if (!headers) {
-    return;
-  }
-  if (headers instanceof Headers) {
-    return headers.get(name);
-  }
-  const lName = name.toLowerCase();
-  if (Array.isArray(headers)) {
-    return headers.find(
-      (h) => h[0] === name || lName === h[0].toLowerCase()
-    )?.[1];
-  }
-  return headers[name] || headers[lName];
-}
-function substitutePathParams(path, pathParams) {
-  if (!pathParams)
-    return path;
-  return path.replace(/:(\w+)/g, (_, key) => {
-    if (key in pathParams) {
-      return encodeURIComponent(pathParams[key]);
-    }
-    return `:${key}`;
-  });
-}
-function withDuplexIfBody(options) {
-  if (!options)
-    return options;
-  if (options.body && !("duplex" in options)) {
-    return { ...options, duplex: "half" };
-  }
-  return options;
-}
-async function silgiFetch(_request, options, context) {
-  let request;
-  if (typeof _request === "string") {
-    _request = substitutePathParams(_request, options?.pathParams);
-    let url = _request;
-    if (url[0] === "/") {
-      const host = getHeader("Host", options?.headers) || ".";
-      const proto = getHeader("X-Forwarded-Proto", options?.headers) === "https" ? "https" : "http";
-      url = `${proto}://${host}${url}`;
-    }
-    request = new Request(url, withDuplexIfBody(options));
-  } else if (options || _request instanceof URL) {
-    request = new Request(_request, withDuplexIfBody(options));
-  } else {
-    request = _request;
-  }
-  const silgiEvent = new SilgiHttpEvent(request, context);
-  let handlerRes;
-  try {
-    handlerRes = handler(silgiEvent);
-  } catch (error) {
-    handlerRes = Promise.reject(error);
-  }
-  return handleResponse(handlerRes, silgiEvent, {});
-}
-async function middleware(event) {
-  const silgiContext = useSilgi();
-  event._chain = Promise.resolve(await silgiContext.callHook("request:on", event));
-  let _chain = void 0;
-  const _middleware = silgiContext.globalMiddlewares;
-  if (_middleware) {
-    _chain = _chain || Promise.resolve();
-    for (const m of _middleware) {
-      _chain = _chain.then(async (_previous) => {
-        if (_previous !== void 0 && _previous !== kNotFound) {
-          return _previous;
-        }
-        if (!(m.method === event.req.method) || !m.middleware) {
-          return;
-        }
-        try {
-          await silgiContext.callHook("middleware:global:on", event, m.middleware);
-        } catch (error) {
-          if (isError(error)) {
-            throw error;
-          }
-          throw createError({
-            message: "Middleware error",
-            statusCode: 500,
-            statusMessage: "Middleware error",
-            cause: error
-          });
-        }
-        return m.middleware.handler?.(event, silgiContext);
-      });
-    }
-  }
-  const _mRouter = silgiContext._middlewareRouter;
-  if (_mRouter) {
-    const matches = findAllRoutes(_mRouter, event.req.method, event.url.pathname);
-    if (matches.length > 0) {
-      _chain = _chain || Promise.resolve();
-      for (const match of matches) {
-        _chain = _chain.then(async (_previous) => {
-          if (_previous !== void 0 && _previous !== kNotFound) {
-            return _previous;
-          }
-          if (!(match.data.method === event.req.method) || !match.data.middleware) {
-            return;
-          }
-          event.context.params = match.params;
-          event.context.matchedRoute = match.data;
-          try {
-            await silgiContext.callHook("middleware:router:on", event, match.data.middleware);
-          } catch (error) {
-            if (isError(error)) {
-              throw error;
-            }
-            throw createError({
-              message: "Middleware error",
-              statusCode: 500,
-              statusMessage: "Middleware error",
-              cause: error
-            });
-          }
-          return match.data.middleware.handler?.(event, silgiContext);
-        });
-      }
-    }
-  }
-  event._chain = _chain;
-  if (event._chain) {
-    const data = await event._chain;
-    if (data !== void 0 && data !== kNotFound) {
-      return data;
-    }
-  }
-}
-async function handler(event) {
-  await middleware(event);
-  const silgiContext = useSilgi();
-  if (silgiContext.router) {
-    const match = findRoute(silgiContext.router, event.req.method, event.url.pathname);
-    if (match) {
-      if (event._chain) {
-        return event._chain.then(async (_previous) => {
-          if (_previous !== void 0 && _previous !== kNotFound) {
-            return _previous;
-          }
-          event.context.params = match.params;
-          event.context.matchedRoute = match.data;
-          return orchestrate(match.data, event);
-        });
-      } else {
-        event.context.params = match.params;
-        event.context.matchedRoute = match.data;
-        return orchestrate(match.data, event);
-      }
-    }
-  }
-  return event._chain ? event._chain.then(
-    (_previous) => _previous === void 0 ? kNotFound : _previous
-  ) : kNotFound;
-}
-function getWebsocket(silgi = useSilgi()) {
-  return {
-    ...silgi.options.websocket,
-    resolve: async (request) => {
-      request.method || "GET";
-      const event = new SilgiHttpEvent(request, {});
-      const silgiContext = useSilgi();
-      const handler2 = silgiContext.router && findRoute(silgiContext.router, event.req.method, event.url.pathname);
-      return handler2?.data.service?.websocket || {};
-    }
-  };
-}
-
-function storageMount(silgi) {
-  const _silgi = silgi || useSilgi();
-  return (base, driver) => {
-    const existingStorage = _silgi.storage.getMount(base);
-    if (existingStorage) {
-      return existingStorage.driver;
-    }
-    const storage = _silgi.storage.mount(base, driver);
-    return storage;
-  };
-}
-
-class EventStream {
-  _event;
-  _transformStream = new TransformStream();
-  _writer;
-  _encoder = new TextEncoder();
-  _writerIsClosed = false;
-  _paused = false;
-  _unsentData;
-  _disposed = false;
-  _handled = false;
-  constructor(event, opts = {}) {
-    this._event = event;
-    this._writer = this._transformStream.writable.getWriter();
-    this._writer.closed.then(() => {
-      this._writerIsClosed = true;
-    });
-    if (opts.autoclose !== false) {
-      this._event?.runtime?.node?.res?.once("close", () => this.close());
-    }
-  }
-  async push(message) {
-    if (typeof message === "string") {
-      await this._sendEvent({ data: message });
-      return;
-    }
-    if (Array.isArray(message)) {
-      if (message.length === 0) {
-        return;
-      }
-      if (typeof message[0] === "string") {
-        const msgs = [];
-        for (const item of message) {
-          msgs.push({ data: item });
-        }
-        await this._sendEvents(msgs);
-        return;
-      }
-      await this._sendEvents(message);
-      return;
-    }
-    await this._sendEvent(message);
-  }
-  async _sendEvent(message) {
-    if (this._writerIsClosed) {
-      return;
-    }
-    if (this._paused && !this._unsentData) {
-      this._unsentData = formatEventStreamMessage(message);
-      return;
-    }
-    if (this._paused) {
-      this._unsentData += formatEventStreamMessage(message);
-      return;
-    }
-    await this._writer.write(this._encoder.encode(formatEventStreamMessage(message))).catch();
-  }
-  async _sendEvents(messages) {
-    if (this._writerIsClosed) {
-      return;
-    }
-    const payload = formatEventStreamMessages(messages);
-    if (this._paused && !this._unsentData) {
-      this._unsentData = payload;
-      return;
-    }
-    if (this._paused) {
-      this._unsentData += payload;
-      return;
-    }
-    await this._writer.write(this._encoder.encode(payload)).catch();
-  }
-  pause() {
-    this._paused = true;
-  }
-  get isPaused() {
-    return this._paused;
-  }
-  async resume() {
-    this._paused = false;
-    await this.flush();
-  }
-  async flush() {
-    if (this._writerIsClosed) {
-      return;
-    }
-    if (this._unsentData?.length) {
-      await this._writer.write(this._encoder.encode(this._unsentData));
-      this._unsentData = void 0;
-    }
-  }
-  /**
-   * Close the stream and the connection if the stream is being sent to the client
-   */
-  async close() {
-    if (this._disposed) {
-      return;
-    }
-    if (!this._writerIsClosed) {
-      try {
-        await this._writer.close();
-      } catch {
-      }
-    }
-    this._disposed = true;
-  }
-  /**
-   * Triggers callback when the writable stream is closed.
-   * It is also triggered after calling the `close()` method.
-   */
-  onClosed(cb) {
-    this._writer.closed.then(cb);
-  }
-  async send() {
-    setEventStreamHeaders(this._event);
-    this._event.res.status = 200;
-    this._handled = true;
-    return this._transformStream.readable;
-  }
-}
-function formatEventStreamMessage(message) {
-  let result = "";
-  if (message.id) {
-    result += `id: ${message.id}
-`;
-  }
-  if (message.event) {
-    result += `event: ${message.event}
-`;
-  }
-  if (typeof message.retry === "number" && Number.isInteger(message.retry)) {
-    result += `retry: ${message.retry}
-`;
-  }
-  result += `data: ${message.data}
-
-`;
-  return result;
-}
-function formatEventStreamMessages(messages) {
-  let result = "";
-  for (const msg of messages) {
-    result += formatEventStreamMessage(msg);
-  }
-  return result;
-}
-function setEventStreamHeaders(event) {
-  event.res.headers.set("content-type", "text/event-stream");
-  event.res.headers.set(
-    "cache-control",
-    "private, no-cache, no-store, no-transform, must-revalidate, max-age=0"
-  );
-  event.res.headers.set("x-accel-buffering", "no");
-  if (!isHttp2Request(event)) {
-    event.res.headers.set("connection", "keep-alive");
-  }
-}
-function isHttp2Request(event) {
-  const rawHeaders = event.req.headers;
-  if (typeof rawHeaders.get === "function") {
-    try {
-      return rawHeaders.has(":path") || rawHeaders.has(":method");
-    } catch {
-      return false;
-    }
-  }
-  return ":path" in rawHeaders || ":method" in rawHeaders;
-}
-
-function createEventStream(event, opts) {
-  return new EventStream(event, opts);
-}
-
-function getEvent(event) {
-  if (event?.event) {
-    return getEvent(event.event);
-  }
-  return event;
-}
-function getEventContext(event) {
-  const _event = getEvent(event);
-  return _event.context;
-}
-
-function deepMerge(target, source) {
-  if (typeof target !== "object" || target === null)
-    return source;
-  if (typeof source !== "object" || source === null)
-    return source;
-  const result = Array.isArray(target) ? [...target] : { ...target };
-  for (const key of Object.keys(source)) {
-    if (key in target) {
-      result[key] = deepMerge(target[key], source[key]);
-    } else {
-      result[key] = source[key];
-    }
-  }
-  return result;
-}
-function deepMergeObjects(schemas) {
-  let merged = {};
-  for (const schema of schemas) {
-    merged = deepMerge(merged, schema);
-  }
-  return merged;
-}
-
-function createMiddleware(params) {
-  return {
-    [`${params.key}:${params.path}`]: {
-      setup: params.setup,
-      methods: params.methods?.length ? params.methods : ["ALL"],
-      key: params.key,
-      path: params.path
-    }
-  };
-}
-
-function createSchema(params) {
-  const { key, ...object } = params;
-  return {
-    [key]: object
-  };
-}
-
-function defineServiceSetup(setup) {
-  return setup;
-}
-function createService(params) {
-  const method = params.method || "ALL";
-  return {
-    [`http:${method}:${params.path}`]: params
-  };
-}
-function createWebSocket(params) {
-  const method = params.method || "ALL";
-  return {
-    [`websocket:${method}:${params.path}`]: params
-  };
-}
-
-function createShared(shared) {
-  return shared;
-}
-
+import { silgiCLICtx, tryUseSilgiCLI, useSilgiCLI } from "./silgiApp.mjs";
+import { updateRuntimeStorage, useRuntime } from "./context.mjs";
+import { silgiCtx, tryUseSilgi, useSilgi } from "./unctx.mjs";
+import { SilgiError, createError, isError } from "./error.mjs";
+import { replaceRuntimeValues } from "./utils/runtime.mjs";
+import { createStorage, useSilgiStorage } from "./utils/storage.mjs";
+import { createSilgi } from "./createSilgi.mjs";
+import { SilgiHttpEvent } from "./event.mjs";
+import { handleResponse, kHandled, kNotFound } from "./response.mjs";
+import { createResolver$1 as createResolver, getUrlPrefix } from "./utils/resolver.mjs";
+import { getWebsocket, handler, middleware, silgiFetch } from "./silgi.mjs";
+import { storageMount } from "./storage.mjs";
+import { createEventStream } from "./utils/event-stream.mjs";
+import { getEvent, getEventContext } from "./utils/event.mjs";
+import { deepMergeObjects } from "./utils/merge.mjs";
+import { createMiddleware } from "./utils/middleware.mjs";
+import { createSchema } from "./utils/schema.mjs";
+import { createService, createWebSocket, defineServiceSetup } from "./utils/service.mjs";
+import { createShared } from "./utils/shared.mjs";
+
+//#region src/core/index.ts
 const autoImportTypes = [
-  "ExtractInputFromURI",
-  "ExtractOutputFromURI",
-  "ExtractPathParamsFromURI",
-  "ExtractQueryParamsFromURI"
+	"ExtractInputFromURI",
+	"ExtractOutputFromURI",
+	"ExtractPathParamsFromURI",
+	"ExtractQueryParamsFromURI"
 ];
 
-export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };
+//#endregion
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };