silgi 0.41.31 → 0.41.34

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.41.31";
+const version = "0.41.34";
 const packageJson = {
 	version: version};
 

package/dist/core/index.d.mts

@@ -1,33 +1,23 @@
-import { SilgiConfig, Silgi, SilgiEvent, HTTPMethod, SilgiSchema, RouteEntry, CustomRequestInit, SilgiRuntimeContext, BaseMethodSchema, MergeAll, ServiceSetupsForMethods, ServiceDefinitionByMethodAndPath, Routers, ServiceSetup, MiddlewareSetup, SilgiRuntimeShareds, Resolvers, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
+import { SilgiRuntimeConfig, SilgiConfig, Silgi, SilgiEvent, SilgiRuntimeContext, SilgiSchema, RouteEntry, CustomRequestInit, SilgiCLI, SilgiStorageBase, MergeAll, Routers, HTTPMethod, MiddlewareSetup, Resolvers, SilgiURL, BaseMethodSchema, ServiceSetupsForMethods, ServiceDefinitionByMethodAndPath, ServiceSetup, SilgiRuntimeShareds, StorageConfig } from 'silgi/types';
+import { ServerRequest } from 'srvx';
 import { GraphQLResolveInfo } from 'graphql';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { Storage, StorageValue } from 'unstorage';
 import { UseContext } from 'unctx';
+import { Storage, StorageValue } from 'unstorage';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 
-declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
-
-/**
- * Fetch API for Silgi framework
- */
-declare function silgiFetch<Schema extends SilgiSchema = SilgiSchema, Method extends RouteEntry<Schema>['method'] = RouteEntry<Schema>['method'], Path extends Extract<RouteEntry<Schema>, {
-    method: Method;
-}>['path'] = Extract<RouteEntry<Schema>, {
-    method: Method;
-}>['path'], Resolved extends boolean = true, HiddenParameters extends boolean = true>(_request: Path, options?: CustomRequestInit<Schema, Method, Path, Resolved, HiddenParameters>, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+declare function updateRuntimeStorage(runtime: any): void;
 /**
- * Fetch API for Silgi framework using standard Request options
+ * Get access to silgi instance.
+ *
+ * Throws an error if silgi instance is unavailable.
+ * @example
+ * ```js
+ * const runtime = useRuntime()
+ * ```
  */
-declare function silgiFetch(_request: Request | URL, options?: RequestInit & {
-    pathParams?: Record<string, any>;
-}, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
-declare function middleware(event: SilgiEvent, url?: {
-    path?: string;
-    method?: string;
-}): Promise<any>;
-declare function handler(event: SilgiEvent, url?: {
-    path?: string;
-    method?: HTTPMethod | '';
-}, input?: any, parent?: any, info?: GraphQLResolveInfo): Promise<any>;
+declare function useRuntime(): SilgiRuntimeConfig;
+
+declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 
 /**
  * LICENSE: MIT
@@ -97,6 +87,26 @@ declare function createError<DataT = unknown>(input: string | (Partial<SilgiErro
  */
 declare function isError<DataT = unknown>(input: any): input is SilgiError<DataT>;
 
+declare class SilgiHttpEvent implements SilgiEvent {
+    static __is_event__: boolean;
+    req: ServerRequest;
+    url: URL;
+    context: SilgiRuntimeContext;
+    _res?: SilgiEventResponse;
+    constructor(req: ServerRequest, context?: SilgiRuntimeContext);
+    _chain: Promise<unknown> | undefined;
+    [x: string]: unknown;
+    get res(): SilgiEventResponse;
+    toString(): string;
+    toJSON(): string;
+}
+declare class SilgiEventResponse {
+    status?: number;
+    statusText?: string;
+    _headers?: Headers;
+    get headers(): Headers;
+}
+
 type MaybePromise<T> = T | Promise<T>;
 interface SilgiHandlerConfig {
     debug?: boolean;
@@ -111,42 +121,47 @@ declare const kNotFound: symbol;
 declare const kHandled: symbol;
 declare function handleResponse(val: unknown, event: SilgiEvent, config: SilgiHandlerConfig): Response | Promise<Response>;
 
-declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
-declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): T;
+/**
+ * Fetch API for Silgi framework
+ */
+declare function silgiFetch<Schema extends SilgiSchema = SilgiSchema, Method extends RouteEntry<Schema>['method'] = RouteEntry<Schema>['method'], Path extends Extract<RouteEntry<Schema>, {
+    method: Method;
+}>['path'] = Extract<RouteEntry<Schema>, {
+    method: Method;
+}>['path'], Resolved extends boolean = true, HiddenParameters extends boolean = true>(_request: Path, options?: CustomRequestInit<Schema, Method, Path, Resolved, HiddenParameters>, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+/**
+ * Fetch API for Silgi framework using standard Request options
+ */
+declare function silgiFetch(_request: Request | URL, options?: RequestInit & {
+    pathParams?: Record<string, any>;
+}, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+declare function middleware(event: SilgiEvent): Promise<any>;
+declare function handler(event: SilgiEvent, middlewareMode?: boolean, input?: any, parent?: any, info?: GraphQLResolveInfo, callBack?: () => any | Promise<any>): Promise<any>;
+
+declare const silgiCLICtx: UseContext<SilgiCLI>;
+declare function useSilgiCLI(): SilgiCLI;
+declare function tryUseSilgiCLI(): SilgiCLI | null;
+
+declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage['mount']>[1]) => T;
 
+declare const silgiCtx: UseContext<Silgi>;
+declare function useSilgi(): Silgi;
 /**
- * Creates a type-safe API route schema definition.
- *
- * This utility function helps you define API schemas with proper typing for
- * input, output, path parameters, and query parameters.
- *
- * @template Path - API path from Routers type
- * @template Method - HTTP method
- *
- * @param params - Schema configuration parameters
- * @param params.path - Complete API path
- * @param params.method - HTTP method(s) as an array (optional)
- * @param params.setup - Schema definition for the specified methods
- * @returns Route schema object with complete type information
+ * Get access to Nuxt instance.
  *
+ * Returns null if Nuxt instance is unavailable.
  * @example
- * // Define a user API schema with GET and POST methods sharing the same schema
- * const userSchema = createSchema({
- *   path: '/api/v1/users',
- *   method: ['GET', 'POST'],
- *   setup: {
- *     output: z.object({
- *       users: z.array(z.object({ id: z.string(), name: z.string() }))
- *     })
- *   }
- * });
+ * ```js
+ * const silgi = tryUseSilgi()
+ * if (silgi) {
+ *  // Do something
+ * }
+ * ```
  */
-declare function createSchema<Key extends string, Schema extends BaseMethodSchema>(params: {
-    key: Key;
-    setup: Schema;
-}): {
-    [K in Key]: Schema;
-};
+declare function tryUseSilgi(): Silgi | null;
+
+declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
+declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): T;
 
 /**
  * Merges multiple service definition objects into a single object.
@@ -157,13 +172,6 @@ declare function createSchema<Key extends string, Schema extends BaseMethodSchem
  */
 declare function deepMergeObjects<T extends readonly Record<string, any>[]>(schemas: [...T]): MergeAll<T>;
 
-/**
- * ServiceSetup tipinden oluşan bir yardımcı fonksiyon.
- * Tip güvenliğini artırmak için ServiceSetup objesini doğrudan döndürür.
- */
-declare function defineServiceSetup<Parent extends StandardSchemaV1, Method extends HTTPMethod, Path extends keyof Routers, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false>(setup: Omit<ServiceSetup<Parent, Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>, 'method' | 'path' | 'apiType'>): Omit<ServiceSetup<Parent, Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>, 'method' | 'path' | 'apiType'>;
-declare function createService<Path extends string, Method extends HTTPMethod, Parent extends StandardSchemaV1 = StandardSchemaV1, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false>(params: ServiceSetupsForMethods<Parent, Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>): ServiceDefinitionByMethodAndPath<Path, Method, Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
-
 type WildcardVariants<Path extends string, Acc extends string = ''> = Path extends `${infer Head}/${infer Tail}` ? Tail extends '' ? `${Acc}${Head}` : `${Acc}${Head}/${Tail}` | `${Acc}${Head}/*` | `${Acc}${Head}/**` | WildcardVariants<Tail, `${Acc}${Head}/`> : `${Acc}${Path}`;
 type MiddlewarePath<S extends WildcardVariants<keyof Routers>> = S | 'global';
 interface CreateMiddlewareParams<S extends WildcardVariants<keyof Routers>, UsedMethod extends readonly HTTPMethod[] = readonly HTTPMethod[], Key extends string = string> {
@@ -184,53 +192,60 @@ declare function createMiddleware<S extends WildcardVariants<keyof Routers>, Use
     path: Path;
 }): CreateMiddlewareResult<Path, UsedMethod, Key>;
 
-declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
+declare function createResolver(resolver: Resolvers): Resolvers;
+declare function getUrlPrefix(path: string, method?: string): SilgiURL;
 
 /**
  * Recursively replaces values starting with 'runtime.' with their actual values from runtime config
  */
 declare function replaceRuntimeValues(obj: any, runtime: any): any;
 
-declare function createResolver(resolver: Resolvers): Resolvers;
-declare function getUrlPrefix(path: string, method?: string): SilgiURL;
-
-declare function createStorage(silgi: Silgi): Promise<Storage<StorageValue>>;
-declare function useSilgiStorage<T extends StorageValue = StorageValue>(base?: StorageConfig<T>['base'] | (string & {})): Storage<T>;
-
-declare const silgiCtx: UseContext<Silgi>;
-declare function useSilgi(): Silgi;
 /**
- * Get access to Nuxt instance.
+ * Creates a type-safe API route schema definition.
+ *
+ * This utility function helps you define API schemas with proper typing for
+ * input, output, path parameters, and query parameters.
+ *
+ * @template Path - API path from Routers type
+ * @template Method - HTTP method
+ *
+ * @param params - Schema configuration parameters
+ * @param params.path - Complete API path
+ * @param params.method - HTTP method(s) as an array (optional)
+ * @param params.setup - Schema definition for the specified methods
+ * @returns Route schema object with complete type information
  *
- * Returns null if Nuxt instance is unavailable.
  * @example
- * ```js
- * const silgi = tryUseSilgi()
- * if (silgi) {
- *  // Do something
- * }
- * ```
+ * // Define a user API schema with GET and POST methods sharing the same schema
+ * const userSchema = createSchema({
+ *   path: '/api/v1/users',
+ *   method: ['GET', 'POST'],
+ *   setup: {
+ *     output: z.object({
+ *       users: z.array(z.object({ id: z.string(), name: z.string() }))
+ *     })
+ *   }
+ * });
  */
-declare function tryUseSilgi(): Silgi | null;
-
-declare const silgiCLICtx: UseContext<SilgiCLI>;
-declare function useSilgiCLI(): SilgiCLI;
-declare function tryUseSilgiCLI(): SilgiCLI | null;
-
-declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage['mount']>[1]) => T;
+declare function createSchema<Key extends string, Schema extends BaseMethodSchema>(params: {
+    key: Key;
+    setup: Schema;
+}): {
+    [K in Key]: Schema;
+};
 
-declare function updateRuntimeStorage(runtime: any): void;
 /**
- * Get access to silgi instance.
- *
- * Throws an error if silgi instance is unavailable.
- * @example
- * ```js
- * const runtime = useRuntime()
- * ```
+ * ServiceSetup tipinden oluşan bir yardımcı fonksiyon.
+ * Tip güvenliğini artırmak için ServiceSetup objesini doğrudan döndürür.
  */
-declare function useRuntime(): SilgiRuntimeConfig;
+declare function defineServiceSetup<Parent extends StandardSchemaV1, Method extends HTTPMethod, Path extends keyof Routers, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false>(setup: Omit<ServiceSetup<Parent, Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>, 'method' | 'path'>): Omit<ServiceSetup<Parent, Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>, 'method' | 'path'>;
+declare function createService<Path extends string, Method extends HTTPMethod, Parent extends StandardSchemaV1 = StandardSchemaV1, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false>(params: ServiceSetupsForMethods<Parent, Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>): ServiceDefinitionByMethodAndPath<Path, Method, Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+
+declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
+
+declare function createStorage(silgi: Silgi): Promise<Storage<StorageValue>>;
+declare function useSilgiStorage<T extends StorageValue = StorageValue>(base?: StorageConfig<T>['base'] | (string & {})): Storage<T>;
 
 declare const autoImportTypes: string[];
 
-export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };

package/dist/core/index.mjs

@@ -1,3 +1,5 @@
+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';
@@ -5,14 +7,32 @@ import { createHooks } from 'hookable';
 import { createRouter, addRoute, findRoute, findAllRoutes } from 'rou3';
 import { getServicePath } from 'silgi/kit';
 import { useRuntimeConfig, sharedRuntimeConfig } from 'silgi/runtime';
-import { getContext, createContext } from 'unctx';
 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';
-import { AsyncLocalStorage } from 'node:async_hooks';
+
+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() {
@@ -354,30 +374,13 @@ async function createSilgi(config) {
         }, {});
       }
     }
-    if (object.apiType === "rest-graphql") {
-      addRoute(silgi.router, "", routeWithParams, {
-        method: "",
-        route: routeWithParams,
-        service: object,
-        queryParams: queryParamNames,
-        pathParams: pathParamNames
-      });
-      addRoute(silgi.router, method, routeWithParams, {
-        method,
-        route: routeWithParams,
-        service: object,
-        queryParams: queryParamNames,
-        pathParams: pathParamNames
-      });
-    } else {
-      addRoute(silgi.router, method, routeWithParams, {
-        method,
-        route: routeWithParams,
-        service: object,
-        queryParams: queryParamNames,
-        pathParams: pathParamNames
-      });
-    }
+    addRoute(silgi.router, method, routeWithParams, {
+      method,
+      route: routeWithParams,
+      service: object,
+      queryParams: queryParamNames,
+      pathParams: pathParamNames
+    });
   }
   if (!silgi._middlewareRouter) {
     silgi._middlewareRouter = createRouter();
@@ -433,7 +436,7 @@ async function createSilgi(config) {
   return silgi;
 }
 
-class _SilgiEvent {
+class SilgiHttpEvent {
   static __is_event__ = true;
   req;
   url;
@@ -446,6 +449,7 @@ class _SilgiEvent {
     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();
@@ -471,6 +475,139 @@ class SilgiEventResponse {
   }
 }
 
+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")) {
@@ -646,15 +783,7 @@ function getUrlPrefix(path, method) {
 async function orchestrate(route, event, _input, parent, info) {
   const silgiCtx = useSilgi();
   const isGraphQL = event.context.protocol === "GRAPHQL";
-  const silgiURL = !isGraphQL ? getUrlPrefix(route.route || event.req.url, route.method) : {
-    methodName: route.method || "GET",
-    namespaceName: "graphql",
-    prefixName: "/api",
-    path: route.route || "",
-    raw: route.route || "",
-    pathParams: {},
-    queryParams: {}
-  };
+  const silgiURL = getUrlPrefix(route.route || event.req.url, route.method);
   const input = _input || (route.service?.rules?.readBeforeBody === false || isGraphQL ? {} : await parseRequestInput(event.req));
   const hookContext = { earlyReturnValue: false };
   const routerParams = _input ? input.path : getRouterParams(event);
@@ -790,139 +919,6 @@ async function cacheExecute(input, route, silgiURL, event) {
   };
 }
 
-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"
-      }
-    }
-  );
-}
-
 function getHeader(name, headers) {
   if (!headers) {
     return;
@@ -972,7 +968,7 @@ async function silgiFetch(_request, options, context) {
   } else {
     request = _request;
   }
-  const silgiEvent = new _SilgiEvent(request, context);
+  const silgiEvent = new SilgiHttpEvent(request, context);
   let handlerRes;
   try {
     handlerRes = handler(silgiEvent);
@@ -981,9 +977,9 @@ async function silgiFetch(_request, options, context) {
   }
   return handleResponse(handlerRes, silgiEvent, {});
 }
-async function middleware(event, url) {
+async function middleware(event) {
   const silgiContext = useSilgi();
-  const pathname = url?.path || event.url.pathname;
+  event._chain = Promise.resolve(await silgiContext.callHook("request:on", event));
   let _chain = void 0;
   const _middleware = silgiContext.globalMiddlewares;
   if (_middleware) {
@@ -1020,7 +1016,7 @@ async function middleware(event, url) {
   }
   const _mRouter = silgiContext._middlewareRouter;
   if (_mRouter) {
-    const matches = findAllRoutes(_mRouter, url?.method || event.req.method, pathname);
+    const matches = findAllRoutes(_mRouter, event.req.method, event.url.pathname);
     if (matches.length > 0) {
       _chain = _chain || Promise.resolve();
       for (const match of matches) {
@@ -1028,9 +1024,7 @@ async function middleware(event, url) {
           if (_previous !== void 0 && _previous !== kNotFound) {
             return _previous;
           }
-          const allowedMethod = match.data.method ?? "";
-          const methodIsAllowed = allowedMethod === event.req.method || event.protocol === "GRAPHQL";
-          if (!methodIsAllowed || !match.data.middleware) {
+          if (!(match.data.method === event.req.method) || !match.data.middleware) {
             return;
           }
           event.context.params = match.params;
@@ -1053,52 +1047,24 @@ async function middleware(event, url) {
       }
     }
   }
-  return _chain;
+  event._chain = _chain;
 }
-async function handler(event, url, input, parent, info) {
-  url ??= {};
-  url.method = event.context.protocol === "GRAPHQL" ? "" : url.method || event.req.method;
-  const silgiCtx = useSilgi();
-  const pathname = url?.path || event.url.pathname;
-  let _chain = void 0;
-  _chain = Promise.resolve(await silgiCtx.callHook("request:on", event));
-  const data = middleware(event, url);
-  _chain = data;
-  if (silgiCtx.router) {
-    const match = findRoute(silgiCtx.router, url.method, pathname);
-    if (match) {
-      if (url.method === "" && input) {
-        if (input?.path) {
-          const expectedPathKeys = Object.keys(match.data.pathParams ?? {});
-          const inputPathKeys = Object.keys(input.path);
-          for (const key of inputPathKeys) {
-            if (!expectedPathKeys.includes(key)) {
-              throw createError({
-                message: `Unexpected path param key: ${key}`,
-                statusCode: 400,
-                statusMessage: "Invalid path parameter"
-              });
-            }
-          }
-          match.data.pathParams = input.path;
-        }
-        if (input?.query) {
-          const expectedQueryKeys = Object.keys(match.data.queryParams ?? {});
-          const inputQueryKeys = Object.keys(input.query);
-          for (const key of inputQueryKeys) {
-            if (!expectedQueryKeys.includes(key)) {
-              throw createError({
-                message: `Unexpected query param key: ${key}`,
-                statusCode: 400,
-                statusMessage: "Invalid query parameter"
-              });
-            }
-          }
-          match.data.queryParams = input.query;
-        }
+async function handler(event, middlewareMode = false, input, parent, info, callBack) {
+  event._chain = middleware(event);
+  if (middlewareMode) {
+    if (event._chain) {
+      const data = await event._chain;
+      if (data !== void 0 && data !== kNotFound) {
+        return data;
       }
-      if (_chain) {
-        return _chain.then(async (_previous) => {
+    }
+  }
+  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;
           }
@@ -1113,11 +1079,23 @@ async function handler(event, url, input, parent, info) {
       }
     }
   }
-  return _chain ? _chain.then(
+  return event._chain ? event._chain.then(
     (_previous) => _previous === void 0 ? kNotFound : _previous
   ) : kNotFound;
 }
 
+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;
+  };
+}
+
 function getEvent(event) {
   if (event?.event) {
     return getEvent(event.event);
@@ -1129,16 +1107,6 @@ function getEventContext(event) {
   return _event.context;
 }
 
-function createSchema(params) {
-  const { key, setup } = params;
-  const result = {};
-  result[key] = {
-    setup,
-    key
-  };
-  return result;
-}
-
 function deepMerge(target, source) {
   if (typeof target !== "object" || target === null)
     return source;
@@ -1162,15 +1130,6 @@ function deepMergeObjects(schemas) {
   return merged;
 }
 
-function defineServiceSetup(setup) {
-  return setup;
-}
-function createService(params) {
-  return {
-    [`${params.method}:${params.path}`]: params
-  };
-}
-
 function createMiddleware(params) {
   return {
     [`${params.key}:${params.path}`]: {
@@ -1182,40 +1141,27 @@ function createMiddleware(params) {
   };
 }
 
-function createShared(shared) {
-  return shared;
+function createSchema(params) {
+  const { key, setup } = params;
+  const result = {};
+  result[key] = {
+    setup,
+    key
+  };
+  return result;
 }
 
-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;
+function defineServiceSetup(setup) {
+  return setup;
+}
+function createService(params) {
+  return {
+    [`${params.method}:${params.path}`]: params
   };
 }
 
-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;
+function createShared(shared) {
+  return shared;
 }
 
 const autoImportTypes = [
@@ -1225,4 +1171,4 @@ const autoImportTypes = [
   "ExtractQueryParamsFromURI"
 ];
 
-export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage } from './core/index.mjs';
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage } from './core/index.mjs';
 import 'silgi/types';
+import 'srvx';
 import 'graphql';
-import '@standard-schema/spec';
-import 'unstorage';
 import 'unctx';
+import 'unstorage';
+import '@standard-schema/spec';

package/dist/index.mjs

@@ -1,5 +1,7 @@
-export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage } from './core/index.mjs';
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage } from './core/index.mjs';
 export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from './_chunks/silgiApp.mjs';
+import 'node:async_hooks';
+import 'unctx';
 import '@standard-community/standard-json';
 import 'consola';
 import 'defu';
@@ -7,10 +9,8 @@ import 'hookable';
 import 'rou3';
 import 'silgi/kit';
 import 'silgi/runtime';
-import 'unctx';
 import 'node:buffer';
 import 'klona';
 import 'unstorage';
 import 'std-env';
 import 'srvx';
-import 'node:async_hooks';

package/dist/types/index.d.mts

@@ -106,6 +106,7 @@ type EventProtocol = 'GRAPHQL' | 'HTTP' | 'WEBSOCKET';
  * Bu nitrojs, h3 event or request context.
  */
 interface SilgiEvent extends Record<string, unknown> {
+    _chain: Promise<unknown> | undefined;
     /**
      * Event context.
      */
@@ -270,7 +271,6 @@ type ServiceHandler<Parent extends StandardSchemaV1, Input extends StandardSchem
 interface ServiceSetup<Parent extends StandardSchemaV1 = StandardSchemaV1, Method extends HTTPMethod = HTTPMethod, Path extends string = string, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false> {
     path: Path;
     method: Method;
-    apiType: 'rest' | 'rest-graphql';
     handler?: ServiceHandler<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
     rules?: MergeRouteRules;
     modules?: Partial<SetupModuleOption>;
@@ -469,7 +469,7 @@ interface ResolvedModuleMeta extends ModuleMeta {
 }
 type ModuleHookContext = Readonly<{
     event?: SilgiEvent;
-    url: SilgiURL;
+    url?: SilgiURL;
     input?: unknown;
     result?: unknown;
     route?: SilgiRoute;
@@ -477,7 +477,7 @@ type ModuleHookContext = Readonly<{
     success?: boolean;
     cached?: boolean;
 }> & {
-    hookContext: {
+    hookContext?: {
         earlyReturnValue: any | false;
     };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.41.31",
+  "version": "0.41.34",
   "private": false,
   "sideEffects": false,
   "exports": {