silgi 0.38.19 → 0.39.1

package/dist/cli/build.mjs

@@ -1160,9 +1160,9 @@ async function prepareScanFile(silgi) {
     const hasItems = items.length > 0;
     if (hasItems) {
       return [
-        `export const ${name} = deepMergeObjects([`,
-        ...items.map((item) => `  ${item},`),
-        "])",
+        `export const ${name} = {`,
+        ...items.map((item) => `  ...${item},`),
+        "}",
         ""
       ];
     } else {

package/dist/cli/index.mjs

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

package/dist/core/index.d.mts

@@ -1,4 +1,4 @@
-import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, CustomRequestInit, SilgiRuntimeContext, AllPrefixes, NamespacesForPrefix, RoutesForPrefixAndNamespace, MethodSchemas, MergeAll, MiddlewareDefinition, HttpMethod, ServiceMethods, SilgiRuntimeShareds, RouteConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
+import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, RouteEntry, CustomRequestInit, SilgiRuntimeContext, Routers, HTTPMethod, HasPathParams, BaseMethodSchema, WithPathParams, MergeAll, MiddlewareDefinition, HttpMethod, ServiceSetup, SilgiRuntimeShareds, RouteConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
 import { Storage, StorageValue } from 'unstorage';
 import { UseContext } from 'unctx';
 
@@ -7,7 +7,11 @@ declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 /**
  * Fetch API for Silgi framework
  */
-declare function silgiFetch<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], Resolved extends boolean = true, HiddenParameters extends boolean = true>(_request: Route, options?: CustomRequestInit<Schema, Route, Method, Resolved, HiddenParameters>, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+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
  */
@@ -112,120 +116,37 @@ declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEve
  * This utility function helps you define API schemas with proper typing for
  * input, output, path parameters, and query parameters.
  *
- * @template P - API prefix (e.g., '/api')
- * @template N - API namespace (e.g., '/v1')
- * @template R - Route path (e.g., '/users' or '/users/:id')
- * @template Methods - HTTP method definitions
+ * @template Path - API path from Routers type
+ * @template Method - HTTP method
  *
  * @param params - Schema configuration parameters
- * @param params.prefix - API prefix, such as '/api'
- * @param params.namespace - API namespace, such as '/v1'
- * @param params.path - Route path, such as '/users' or '/users/:id'
- * @param params.methods - HTTP method schemas
+ * @param params.path - Complete API path
+ * @param params.method - HTTP method(s) as an array (required)
+ * @param params.setup - Schema definition for the specified methods
  * @returns Route schema object with complete type information
  *
  * @example
- * // Define a user API schema with GET and POST methods
+ * // Define a user API schema with GET and POST methods sharing the same schema
  * const userSchema = createSchema({
- *   prefix: '/api',
- *   namespace: '/v1',
- *   path: '/users',
- *   methods: {
- *     GET: {
- *       output: z.object({
- *         users: z.array(z.object({ id: z.string(), name: z.string() }))
- *       })
- *     },
- *     POST: {
- *       input: z.object({
- *         name: z.string().min(2),
- *         email: z.string().email()
- *       }),
- *       output: z.object({
- *         id: z.string(),
- *         created: z.boolean()
- *       })
- *     }
- *   }
- * });
- *
- * // Define a user detail API with path parameters
- * const userDetailSchema = createSchema({
- *   prefix: '/api',
- *   namespace: '/v1',
- *   path: '/users/:id',
- *   methods: {
- *     GET: {
- *       pathParams: z.object({
- *         id: z.string().uuid()
- *       }),
- *       output: z.object({
- *         name: z.string(),
- *         email: z.string(),
- *         createdAt: z.date()
- *       })
- *     },
- *     PUT: {
- *       pathParams: z.object({
- *         id: z.string().uuid()
- *       }),
- *       input: z.object({
- *         name: z.string().optional(),
- *         email: z.string().email().optional()
- *       }),
- *       queryParams: z.object({
- *         version: z.number().optional()
- *       })
- *     },
- *     DELETE: {
- *       pathParams: z.object({
- *         id: z.string().uuid()
- *       }),
- *       output: z.object({
- *         success: z.boolean()
- *       })
- *     }
- *   }
- * });
- *
- * // Example with nested route parameters
- * const postCommentSchema = createSchema({
- *   prefix: '/api',
- *   namespace: '/v1',
- *   path: '/posts/:postId/comments/:commentId',
- *   methods: {
- *     GET: {
- *       pathParams: z.object({
- *         postId: z.string(),
- *         commentId: z.string()
- *       }),
- *       output: z.object({
- *         content: z.string(),
- *         author: z.string()
- *       })
- *     },
- *     PATCH: {
- *       pathParams: z.object({
- *         postId: z.string(),
- *         commentId: z.string()
- *       }),
- *       input: z.object({
- *         content: z.string().min(1).max(500)
- *       })
- *     }
+ *   path: '/api/v1/users',
+ *   method: ['GET', 'POST'],
+ *   setup: {
+ *     output: z.object({
+ *       users: z.array(z.object({ id: z.string(), name: z.string() }))
+ *     })
  *   }
  * });
  */
-declare function createSchema<P extends AllPrefixes, N extends NamespacesForPrefix<P>, R extends RoutesForPrefixAndNamespace<P, N>, Methods extends MethodSchemas<R> = MethodSchemas<R>>(params: {
-    /** API prefix, such as '/api' */
-    prefix: P;
-    /** API namespace, such as '/v1' */
-    namespace: N;
-    /** Route path, such as '/users' or '/users/:id' */
-    path: R;
-    /** HTTP method schemas */
-    methods: Methods;
-}): Record<`${P}${N}${R}`, Methods>;
+declare function createSchema<Path extends keyof Routers, Method extends HTTPMethod & string, UsedMethod extends readonly Method[], Schema extends HasPathParams<Path> extends true ? BaseMethodSchema & WithPathParams<Path> : BaseMethodSchema>(params: {
+    /** Complete API path */
+    path: Path;
+    /** HTTP method(s) this schema applies to (required) */
+    method: UsedMethod;
+    /** Schema definition */
+    setup: Schema;
+}): {
+    [K in `${UsedMethod[number]}:${string & Path}`]: Schema;
+};
 
 /**
  * Merges multiple service definition objects into a single object.
@@ -236,36 +157,47 @@ declare function createSchema<P extends AllPrefixes, N extends NamespacesForPref
  */
 declare function deepMergeObjects<T extends readonly Record<string, any>[]>(schemas: [...T]): MergeAll<T>;
 
-declare function createService<Schema extends SilgiSchema, Path extends keyof Schema, Resolved extends boolean = false, Methods extends ServiceMethods<Schema, Path, Resolved> = ServiceMethods<Schema, Path, Resolved>>(params: {
+declare function createService<Schema extends SilgiSchema, Path extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false>(params: {
     path: Path;
-    methods: Methods;
+    setup: ServiceSetup<Schema, Path, Resolved, HiddenParameters>;
 }): {
-    [R in Path]: {
-        [M in keyof Methods]: Methods[M];
-    };
+    [K in Path]: ServiceSetup<Schema, Path, 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 MiddlewareParams<Schema extends SilgiSchema, Path extends keyof Schema & string, S extends string = WildcardVariants<Path>, Service extends MiddlewareDefinition = MiddlewareDefinition, Method extends string = HttpMethod, UsedMethod extends readonly Method[] = readonly never[], Global extends boolean = false> = Global extends true ? {
+declare function createMiddleware<Global extends string, Service extends MiddlewareDefinition>(params: {
     global: Global;
-    key: string;
     setup: Service;
-    method?: UsedMethod;
-} : {
-    global?: Global;
+    method?: undefined | readonly [];
+}): {
+    [K in `GLOBAL:${Global}`]: {
+        setup: Service;
+        global: Global;
+        method: false;
+    };
+};
+declare function createMiddleware<Global extends string, Service extends MiddlewareDefinition, Method extends HttpMethod, UsedMethod extends readonly Method[]>(params: {
+    global: Global;
+    setup: Service;
+    method: UsedMethod;
+}): {
+    [K in `${UsedMethod[number]}:${Global}`]: {
+        setup: Service;
+        global: Global;
+        method: UsedMethod[number];
+    };
+};
+declare function createMiddleware<S extends WildcardVariants<keyof Routers>, Service extends MiddlewareDefinition, Method extends HttpMethod, UsedMethod extends readonly Method[]>(params: {
     path: S;
     method: UsedMethod;
     setup: Service;
-};
-type MiddlewareReturn<S extends string, Service extends MiddlewareDefinition, UsedMethod extends readonly string[]> = {
-    [K in S]: {
-        method: boolean;
-        global: boolean;
-        methods: UsedMethod extends readonly [] | undefined ? object : {
-            [M in UsedMethod[number]]: Service;
-        };
+    global?: undefined;
+}): {
+    [K in `${UsedMethod[number]}:${S}`]: {
+        setup: Service;
+        method: UsedMethod[number];
+        global: undefined;
     };
 };
-declare function createMiddleware<Schema extends SilgiSchema, Path extends keyof Schema & string, S extends string = WildcardVariants<Path>, Service extends MiddlewareDefinition = MiddlewareDefinition, Method extends string = HttpMethod, UsedMethod extends readonly Method[] = readonly never[], Global extends boolean = false>(params: MiddlewareParams<Schema, Path, S, Service, Method, UsedMethod, Global>): MiddlewareReturn<S, Service, UsedMethod>;
 
 declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
 

package/dist/core/index.mjs

@@ -296,7 +296,14 @@ async function createSilgi(config) {
   if (!silgi.router) {
     silgi.router = createRouter();
   }
-  for (const route in silgi.services) {
+  for (const routeKey in silgi.services) {
+    let method = "ALL";
+    let route = routeKey;
+    if (routeKey.includes(":")) {
+      const [methodPart, ...routeParts2] = routeKey.split(":");
+      method = methodPart.toUpperCase();
+      route = routeParts2.join(":");
+    }
     const routeParts = route.split("/").filter(Boolean);
     if (routeParts.length > 0) {
       const prefix = `/${routeParts[0]}`;
@@ -304,64 +311,46 @@ async function createSilgi(config) {
         silgi.routerPrefixs.push(prefix);
       }
     }
-    const methods = silgi.services[route];
-    for (const method in methods) {
-      const methodObject = methods[method];
-      if (methodObject) {
-        const _method = (method || "").toUpperCase();
-        const schemaWrapper = silgi.schemas?.[route]?.[method];
-        if (!schemaWrapper) {
-          silgi.logger.warn(`Schema not found for ${route}`);
-          continue;
-        }
-        addRoute(silgi.router, _method, route, {
-          method: _method,
-          route,
-          setup: methodObject,
-          schema: schemaWrapper
-        });
+    const methodObject = silgi.services[routeKey];
+    if (methodObject) {
+      const schemaWrapper = silgi.schemas?.[routeKey];
+      if (!schemaWrapper) {
+        silgi.logger.warn(`Schema not found for ${routeKey}`);
+        continue;
       }
+      addRoute(silgi.router, method, route, {
+        method,
+        route,
+        service: methodObject,
+        schema: schemaWrapper
+      });
     }
   }
   if (!silgi._middlewareRouter) {
     silgi._middlewareRouter = createRouter();
   }
-  for (const route in silgi.middlewares) {
-    const routeObject = silgi.middlewares[route];
+  for (const routeKey in silgi.middlewares) {
+    const routeObject = silgi.middlewares[routeKey];
     const global = routeObject.global ?? false;
+    let method = "ALL";
+    let route = routeKey;
+    if (routeKey.includes(":")) {
+      const [methodPart, ...routeParts] = routeKey.split(":");
+      method = methodPart.toUpperCase();
+      route = routeParts.join(":");
+    }
     if (global) {
-      if ("methods" in routeObject && routeObject.methods && Object.keys(routeObject.methods).length > 0) {
-        for (const methodKey in routeObject.methods) {
-          const _method = (methodKey || "").toUpperCase();
-          const object = routeObject.methods[methodKey];
-          if (!object)
-            continue;
-          silgi.globalMiddlewares.push({
-            setup: object.setup,
-            method: _method,
-            route
-          });
-        }
-      } else {
-        silgi.globalMiddlewares.push({
-          setup: routeObject.setup,
-          route
-        });
-      }
+      silgi.globalMiddlewares.push({
+        middleware: routeObject.setup,
+        method,
+        route
+      });
     } else {
-      if ("methods" in routeObject && routeObject.methods) {
-        for (const method in routeObject.methods) {
-          const _method = (method || "").toUpperCase();
-          const routeObjectMethod = routeObject.methods[method];
-          if (!routeObjectMethod)
-            continue;
-          addRoute(silgi._middlewareRouter, _method, route, {
-            setup: routeObjectMethod.setup,
-            method: _method,
-            route
-          });
-        }
-      }
+      addRoute(silgi._middlewareRouter, method, route, {
+        middleware: routeObject.setup,
+        method,
+        route
+      });
     }
   }
   silgi.hooks.addHooks(silgi.options.hooks);
@@ -604,7 +593,7 @@ function getUrlPrefix(path, method) {
 async function orchestrate(route, event, _input) {
   const silgiCtx = useSilgi();
   const silgiURL = getUrlPrefix(route.route || event.req.url, route.method);
-  const input = _input || (route.setup.rules?.readBeforeBody === false ? {} : await parseRequestInput(event.req));
+  const input = _input || (route.service?.rules?.readBeforeBody === false ? {} : await parseRequestInput(event.req));
   const hookContext = { earlyReturnValue: false };
   const routerParams = _input ? input.path : getRouterParams(event);
   const queryParams = _input ? input.query : getQuery(event);
@@ -622,7 +611,13 @@ async function orchestrate(route, event, _input) {
     }
   };
   try {
-    const setup = route.setup;
+    const setup = route.service;
+    if (!setup) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Service not found"
+      });
+    }
     const cachePromise = cacheExecute(input, route, silgiURL, event);
     const beforeHookPromise = silgiCtx.callHook("fetch:before", {
       url: silgiURL,
@@ -702,8 +697,8 @@ async function orchestrate(route, event, _input) {
   }
 }
 async function cacheExecute(input, route, silgiURL, event) {
-  const setup = route.setup;
-  if (!setup.storage)
+  const setup = route.service;
+  if (!setup || !setup.storage)
     return;
   const cacheKey = setup.storage ? await generateStorageKey({
     url: silgiURL,
@@ -934,11 +929,11 @@ async function middleware(event, url) {
         if (_previous !== void 0 && _previous !== kNotFound) {
           return _previous;
         }
-        if (m.method && m.method !== event.req.method) {
+        if (m.method && m.method !== event.req.method || !m.middleware) {
           return;
         }
         try {
-          await silgiContext.callHook("middleware:global:on", event, m.setup);
+          await silgiContext.callHook("middleware:global:on", event, m.middleware);
         } catch (error) {
           if (isError(error)) {
             throw error;
@@ -950,7 +945,7 @@ async function middleware(event, url) {
             cause: error
           });
         }
-        return m.setup.handler(event, silgiContext);
+        return m.middleware.handler(event, silgiContext);
       });
     }
   }
@@ -964,13 +959,13 @@ async function middleware(event, url) {
           if (_previous !== void 0 && _previous !== kNotFound) {
             return _previous;
           }
-          if (match.data.method && match.data.method !== event.req.method) {
+          if (match.data.method && 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.setup);
+            await silgiContext.callHook("middleware:router:on", event, match.data.middleware);
           } catch (error) {
             if (isError(error)) {
               throw error;
@@ -982,7 +977,7 @@ async function middleware(event, url) {
               cause: error
             });
           }
-          return match.data.setup.handler(event, silgiContext);
+          return match.data.middleware.handler(event, silgiContext);
         });
       }
     }
@@ -1032,11 +1027,13 @@ function getEventContext(event) {
 }
 
 function createSchema(params) {
-  const { namespace, prefix, path, methods } = params;
-  const routeWithPrefix = `${prefix}${namespace}${path}`;
-  return {
-    [routeWithPrefix]: methods
-  };
+  const { path, method, setup } = params;
+  const result = {};
+  for (let i = 0; i < method.length; i++) {
+    const methodName = method[i];
+    result[`${String(methodName)}:${path}`] = setup;
+  }
+  return result;
 }
 
 function deepMerge(target, source) {
@@ -1063,54 +1060,42 @@ function deepMergeObjects(schemas) {
 }
 
 function createService(params) {
-  const { path, methods } = params;
+  const { path, setup } = params;
   return {
-    [path]: methods
+    [path]: setup
   };
 }
 function createMiddleware(params) {
-  if (params.key) {
+  if (params.global) {
+    const globalKey = params.global;
     if (!params.method || params.method.length === 0) {
       return {
-        [params.key]: {
-          method: false,
-          global: params.global,
-          methods: {},
-          setup: params.setup
+        [`GLOBAL:${globalKey}`]: {
+          setup: params.setup,
+          global: globalKey,
+          method: false
         }
       };
     }
-    const methods2 = {};
+    const result2 = {};
     for (const m of params.method) {
-      methods2[m] = {
+      result2[`${m}:${globalKey}`] = {
         setup: params.setup,
-        global: true,
+        global: globalKey,
         method: m
       };
     }
-    return {
-      [params.key]: {
-        global: params.global,
-        method: true,
-        methods: methods2
-      }
-    };
+    return result2;
   }
-  const methods = {};
+  const result = {};
   for (const m of params.method) {
-    methods[m] = {
+    result[`${m}:${params.path}`] = {
       setup: params.setup,
       method: m,
-      global: false
+      global: void 0
     };
   }
-  return {
-    [params.path]: {
-      method: true,
-      global: false,
-      methods
-    }
-  };
+  return result;
 }
 
 function createShared(shared) {

package/dist/types/index.d.mts

@@ -195,6 +195,16 @@ interface SilgiSchema {
 }
 interface MergedSilgiSchema {
 }
+type ExtractMethod<T extends string> = T extends `${infer M}:${string}` ? M : never;
+type ExtractPath<T extends string> = T extends `${string}:${infer P}` ? P : never;
+type RouteEntry<Schema> = {
+    [K in keyof Schema & string]: {
+        method: ExtractMethod<K>;
+        path: ExtractPath<K>;
+        raw: K;
+        schema: Schema[K];
+    };
+}[keyof Schema & string];
 /**
  * Creates an object type representing path parameters extracted from a URL pattern.
  *
@@ -263,9 +273,7 @@ interface ResolvedSchema {
  * typically after processing and validating all schema components.
  */
 interface ResolvedSchemaDefinition {
-    [key: string]: {
-        [method: string]: BaseMethodSchema;
-    };
+    [methodAndRoutePath: string]: BaseMethodSchema;
 }
 
 type CustomDriverName = string & {
@@ -305,17 +313,17 @@ interface SilgiRuntimeSharedsExtend {
 interface ExtendShared {
 }
 
-type ServiceMethods<Schema extends SilgiSchema, Path extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false> = {
-    [M in keyof Schema[Path]]?: ServiceSetup<Schema, Path, M, Resolved, HiddenParameters>;
-};
 /**
  * Yardımcı tipler
  */
 type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
 type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
-type ServiceHandlerParameters<S, R extends keyof S, M extends keyof S[R]> = S[R][M] extends {
+/**
+ * Direct parameter type inference for combined route strings
+ */
+type ServiceHandlerParameters<S, R extends keyof S> = S[R] extends {
     pathParams?: infer P;
-} ? S[R][M] extends {
+} ? S[R] extends {
     queryParams?: infer Q;
 } ? (P extends undefined ? object : {
     path: InferInput<P>;
@@ -323,7 +331,7 @@ type ServiceHandlerParameters<S, R extends keyof S, M extends keyof S[R]> = S[R]
     query: InferInput<Q>;
 }) : (P extends undefined ? object : {
     path: InferInput<P>;
-}) : S[R][M] extends {
+}) : S[R] extends {
     queryParams?: infer Q;
 } ? (Q extends undefined ? object : {
     query: InferInput<Q>;
@@ -331,17 +339,17 @@ type ServiceHandlerParameters<S, R extends keyof S, M extends keyof S[R]> = S[R]
 /**
  * Route ve method'a göre input, output, params çıkarımı
  */
-type ServiceHandlerInput<Schema extends SilgiSchema, Route extends keyof Schema, Method extends keyof Schema[Route], HiddenParameters extends boolean = false> = (Schema[Route][Method] extends {
+type ServiceHandlerInput<Schema extends SilgiSchema, Route extends keyof Schema, HiddenParameters extends boolean = false> = (Schema[Route] extends {
     input?: infer I;
 } ? {
     args: InferInput<I>;
-} : unknown) & (HiddenParameters extends false ? (keyof ServiceHandlerParameters<Schema, Route, Method> extends never ? unknown : {
-    parameters: ServiceHandlerParameters<Schema, Route, Method>;
+} : unknown) & (HiddenParameters extends false ? (keyof ServiceHandlerParameters<Schema, Route> extends never ? unknown : {
+    parameters: ServiceHandlerParameters<Schema, Route>;
 }) : unknown);
-type ServiceHandlerOutput<Schema extends SilgiSchema, Route extends keyof Schema, Method extends keyof Schema[Route]> = Schema[Route][Method] extends {
+type ServiceHandlerOutput<Schema extends SilgiSchema, Route extends keyof Schema> = Schema[Route] extends {
     output?: infer O;
 } ? InferOutput<O> : unknown;
-type ServiceHandlerSource<Schema extends SilgiSchema, Route extends keyof Schema, Method extends keyof Schema[Route]> = Schema[Route][Method] extends {
+type ServiceHandlerSource<Schema extends SilgiSchema, Route extends keyof Schema> = Schema[Route] extends {
     source?: infer S;
 } ? InferInput<S> : unknown;
 /**
@@ -350,29 +358,29 @@ type ServiceHandlerSource<Schema extends SilgiSchema, Route extends keyof Schema
  * Resolved = false  -> handler(input, shared, event, source) // all required
  * Resolved = true -> handler(input, shared?, event?, source?) // only input required
  */
-type ServiceHandler<Schema extends SilgiSchema, Route extends keyof Schema, Method extends keyof Schema[Route], Resolved extends boolean = false, HiddenParameters extends boolean = false> = Resolved extends true ? (input: ServiceHandlerInput<Schema, Route, Method, HiddenParameters>, shared?: SilgiRuntimeShareds, event?: SilgiEvent, source?: ServiceHandlerSource<Schema, Route, Method>) => Promise<ServiceHandlerOutput<Schema, Route, Method>> : (input: ServiceHandlerInput<Schema, Route, Method, HiddenParameters>, shared: SilgiRuntimeShareds, event: SilgiEvent, source: ServiceHandlerSource<Schema, Route, Method>) => Promise<ServiceHandlerOutput<Schema, Route, Method>>;
+type ServiceHandler<Schema extends SilgiSchema, Route extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false> = Resolved extends true ? (input: ServiceHandlerInput<Schema, Route, HiddenParameters>, shared?: SilgiRuntimeShareds, event?: SilgiEvent, source?: ServiceHandlerSource<Schema, Route>) => Promise<ServiceHandlerOutput<Schema, Route>> : (input: ServiceHandlerInput<Schema, Route, HiddenParameters>, shared: SilgiRuntimeShareds, event: SilgiEvent, source: ServiceHandlerSource<Schema, Route>) => Promise<ServiceHandlerOutput<Schema, Route>>;
 /**
  * Servis setup tipi
  */
-interface ServiceSetup<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], Resolved extends boolean = false, HiddenParameters extends boolean = false> {
-    handler: ServiceHandler<Schema, Route, Method, Resolved, HiddenParameters>;
+interface ServiceSetup<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false> {
+    handler: ServiceHandler<Schema, Route, Resolved, HiddenParameters>;
     rules?: RouteConfigService;
     modules?: Partial<SetupModuleOption>;
-    storage?: StorageConfig<ServiceHandlerInput<Schema, Route, Method, HiddenParameters>>;
+    storage?: StorageConfig<ServiceHandlerInput<Schema, Route, HiddenParameters>>;
 }
 /**
  * Represents a fully resolved service definition that maps route paths
- * to their method handlers and configurations.
+ * to their handler and configurations.
  *
  * This interface is designed to be compatible with the structure created
  * by the createService function.
+ *
+ * Format: "METHOD:routePath" => handler + config
  */
 interface ResolvedServiceDefinition {
-    [routePath: string]: {
-        [method: string]: {
-            handler: (...args: any[]) => Promise<any>;
-        } & Omit<ServiceSetup, 'handler'>;
-    };
+    [methodAndRoutePath: string]: {
+        handler: (...args: any[]) => Promise<any>;
+    } & Omit<ServiceSetup, 'handler'>;
 }
 /**
  * SilgiURL tipi
@@ -400,19 +408,10 @@ interface MiddlewareSetup {
 }
 type MiddlewareDefinition = MiddlewareSetup;
 interface ResolvedMiddlewareDefinition {
-    [routePath: string]: {
-        global: true;
-        method: false;
+    [methodAndPath: string]: {
         setup: MiddlewareSetup;
-    } | {
-        global: false;
-        method: true;
-        methods: {
-            [method: string]: {
-                setup: MiddlewareSetup;
-                method: string;
-            };
-        };
+        global?: string | undefined;
+        method: HTTPMethod | false;
     };
 }
 
@@ -703,21 +702,17 @@ type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiR
 interface MetaData extends Record<string, unknown> {
 }
 interface SilgiRoute {
-    route: string;
-    method?: HTTPMethod;
-    schema?: ResolvedSchemaDefinition;
-    setup: ServiceSetup;
-}
-interface MiddlewareRoute {
     route?: string;
     method?: HTTPMethod;
-    setup: MiddlewareSetup;
+    schema?: ResolvedSchemaDefinition;
+    service?: ServiceSetup;
+    middleware?: MiddlewareSetup;
 }
 interface Silgi {
     router: RouterContext<SilgiRoute>;
-    _middlewareRouter: RouterContext<MiddlewareRoute>;
+    _middlewareRouter: RouterContext<SilgiRoute>;
     middlewares: ResolvedMiddlewareDefinition;
-    globalMiddlewares: MiddlewareRoute[];
+    globalMiddlewares: SilgiRoute[];
     routerPrefixs: string[];
     schemas: ResolvedSchemaDefinition;
     services: ResolvedServiceDefinition;
@@ -749,20 +744,24 @@ interface BuildSilgi {
     modules?: Partial<SilgiRuntimeOptions>;
     options?: Partial<SilgiOptions>;
 }
-type CustomRequestInit<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], _Resolved extends boolean = true, _HiddenParameters extends boolean = true> = Omit<RequestInit, 'body' | 'headers' | 'method'> & {
+type CustomRequestInit<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;
-    body?: Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+}>['path'], _Resolved extends boolean = true, _HiddenParameters extends boolean = true> = Omit<RequestInit, 'body' | 'headers' | 'method'> & {
+    method: Method;
+    body?: `${Method}:${Path}` extends keyof Schema ? Schema[`${Method}:${Path}`] extends {
         input?: infer I;
-    } ? I extends StandardSchemaV1 ? StandardSchemaV1.InferInput<I> : unknown : unknown : unknown : unknown;
-    headers?: Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+    } ? I extends StandardSchemaV1 ? StandardSchemaV1.InferInput<I> : unknown : unknown : unknown;
+    headers?: `${Method}:${Path}` extends keyof Schema ? Schema[`${Method}:${Path}`] extends {
         headers?: infer H;
-    } ? H extends StandardSchemaV1 ? StandardSchemaV1.InferInput<H> : unknown : unknown : unknown : unknown;
-} & (Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+    } ? H extends StandardSchemaV1 ? StandardSchemaV1.InferInput<H> : unknown : unknown : unknown;
+} & (`${Method}:${Path}` extends keyof Schema ? Schema[`${Method}:${Path}`] extends {
     pathParams?: infer P;
 } ? P extends StandardSchemaV1 ? {
-    pathParams: StandardSchemaV1.InferInput<P>;
-} : {
-    pathParams?: unknown;
+    pathParams: {
+        [K in keyof StandardSchemaV1.InferInput<P>]: StandardSchemaV1.InferInput<P>[K] extends string ? string | number : StandardSchemaV1.InferInput<P>[K];
+    };
 } : {
     pathParams?: unknown;
 } : {
@@ -1226,4 +1225,4 @@ interface LoadConfigOptions {
     consola?: ConsolaInstance;
 }
 
-export type { AllPaths, AllPrefixes, AppConfig, Awaitable, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, GenImport, GenerateAppOptions, HTTPMethod, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergedSilgiSchema, MetaData, MethodSchemas, MiddlewareDefinition, MiddlewareHandler, MiddlewareRoute, MiddlewareSetup, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedMiddlewareDefinition, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition, ResolvedSilgiTemplate, RouteConfig, RouteConfigService, RouteRules, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceMethods, ServiceSetup, SetupModuleOption, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRoute, SilgiRouterTypes, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeDefaultConfig, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiStorageBase, SilgiTemplate, SilgiURL, StandardHTTPMethod, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, WithPathParams };
+export type { AllPaths, AllPrefixes, AppConfig, Awaitable, BaseMethodSchema, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, GenImport, GenerateAppOptions, HTTPMethod, HasPathParams, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergedSilgiSchema, MetaData, MethodSchemas, MiddlewareDefinition, MiddlewareHandler, MiddlewareSetup, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedMiddlewareDefinition, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition, ResolvedSilgiTemplate, RouteConfig, RouteConfigService, RouteEntry, RouteRules, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceSetup, SetupModuleOption, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRoute, SilgiRouterTypes, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeDefaultConfig, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiStorageBase, SilgiTemplate, SilgiURL, StandardHTTPMethod, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, WithPathParams };

package/package.json

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