silgi 0.40.1 → 0.41.1

package/dist/cli/build.mjs

@@ -581,7 +581,7 @@ function resolveGroupSyntax(group) {
   return groups;
 }
 
-const DEFAULT_FUNCTION_EXPORT_NAMES = ["createSchema", "createService", "createRoute", "createShared", "createMiddleware"];
+const DEFAULT_FUNCTION_EXPORT_NAMES = ["createSchema", "createService", "createResolver", "createShared", "createMiddleware"];
 const DEFAULT_INTERFACE_EXTENDS_NAMES = ["ExtendShared", "ExtendContext"];
 function generateUniqueIdentifier(filePath, exportName) {
   const fileBaseName = basename(filePath);
@@ -592,7 +592,7 @@ function categorizeExports(exportedEntities, filePath, functionExportCategories
   createService: "service",
   createSchema: "schema",
   createShared: "shared",
-  createRoute: "route",
+  createResolver: "resolver",
   createMiddleware: "middleware"
 }, interfaceExportCategories = {
   ExtendShared: "shared",
@@ -659,8 +659,8 @@ function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, pa
         case "schema":
           options.schemas.push(uniqueId);
           break;
-        case "route":
-          options.routers.push(uniqueId);
+        case "resolvers":
+          options.resolvers.push(uniqueId);
           break;
         case "middleware":
           options.middlewares?.push?.(uniqueId);
@@ -763,8 +763,8 @@ async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()
       functionExportCategories[name] = "schema";
     else if (name === "createShared")
       functionExportCategories[name] = "shared";
-    else if (name === "createRoute")
-      functionExportCategories[name] = "route";
+    else if (name === "createResolver")
+      functionExportCategories[name] = "resolver";
     else if (name === "createMiddleware")
       functionExportCategories[name] = "middleware";
     else functionExportCategories[name] = name;
@@ -1196,7 +1196,7 @@ async function prepareScanFile(silgi) {
   const scanned = {
     services: [],
     shareds: [],
-    routers: [],
+    resolvers: [],
     schemas: [],
     middlewares: [],
     addImportItem,
@@ -1233,7 +1233,7 @@ async function prepareScanFile(silgi) {
     ...generateExport("schemas", scanned.schemas),
     ...generateExport("services", scanned.services),
     ...generateExport("shareds", scanned.shareds, "undefined"),
-    ...generateExport("routers", scanned.routers),
+    ...generateExport("resolvers", scanned.resolvers, "[]"),
     ...generateExport("middlewares", scanned.middlewares)
   ];
   await silgi.callHook("after:scan.ts", importData);
@@ -1276,7 +1276,7 @@ async function readScanFile(silgi) {
     silgi.schemas = scanFile.schemas || {};
     silgi.services = scanFile.services || {};
     silgi.shareds = scanFile.shareds || {};
-    silgi.routers = scanFile.routers || {};
+    silgi.resolvers = scanFile.resolvers || {};
     return {
       context,
       object: {
@@ -1488,7 +1488,7 @@ async function createSilgiCLI(config = {}, opts = {}) {
     middleware: [],
     shareds: {},
     schemas: {},
-    routers: {},
+    resolvers: [],
     unimport: void 0,
     options,
     hooks,
@@ -1702,7 +1702,7 @@ async function prepareCoreFile(silgi) {
             name: "middlewares"
           },
           {
-            name: "routers"
+            name: "resolvers"
           }
         ]
       },
@@ -1794,7 +1794,7 @@ async function prepareCoreFile(silgi) {
     " services: services,",
     " middlewares: middlewares,",
     " schemas: schemas,",
-    " routers: routers,",
+    " resolvers: resolvers,",
     ` plugins: [${plugins.join(", ")}],`,
     "",
     _data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
@@ -1870,6 +1870,7 @@ async function prepareSchema(silgi) {
     contexts: [],
     setupModuleOption: [],
     shareds: [],
+    resolvers: [],
     events: [],
     hooks: [],
     runtimeHooks: [],
@@ -1894,7 +1895,8 @@ async function prepareSchema(silgi) {
     "",
     `type SchemaExtends = typeof import('${silgiScanTS}')['schemas']`,
     `type BaseServices = typeof import('${silgiScanTS}')['services']`,
-    `type RoutersExtend = typeof import('${silgiScanTS}')['routers']`,
+    `type ResolversExtend = ${data.resolvers?.length ? data.resolvers.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
     "",
     `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
     "",
@@ -1977,8 +1979,9 @@ async function prepareSchema(silgi) {
       SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
       SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
       SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
-      Routers: [{}, { extends: ["RoutersExtend"] }],
+      Resolvers: [{}, { extends: ["ResolversExtend"] }],
       SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }],
+      // TODO: bunu kontrol et.
       RouteRules: [{}, { extends: ["RouteRulesExtend"] }],
       MetaData: [{}, { extends: ["MetaDataExtend"] }]
     }).replace(/,\s*/g, "\n"),

package/dist/cli/index.mjs

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

package/dist/cli/loader.mjs

@@ -351,10 +351,13 @@ async function resolvePathOptions(options) {
   }
   options.alias = {
     ...options.alias,
-    "~/": join(options.srcDir, "/"),
-    "@/": join(options.srcDir, "/"),
-    "~~/": join(options.rootDir, "/"),
-    "@@/": join(options.rootDir, "/")
+    // '~/': join(options.srcDir, '/'),
+    // '@/': join(options.srcDir, '/'),
+    // '~~/': join(options.rootDir, '/'),
+    // '@@/': join(options.rootDir, '/'),
+    "#server/*": join(options.silgi.serverDir, "/*"),
+    "#silgi/*": join(options.build.dir, "/*"),
+    "#types/*": join(options.build.typesDir, "/*")
   };
   if (options.preset === "npm-package") {
     options.alias = {

package/dist/core/index.d.mts

@@ -1,4 +1,5 @@
-import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, RouteEntry, CustomRequestInit, SilgiRuntimeContext, Routers, HTTPMethod, HasPathParams, BaseMethodSchema, WithPathParams, MergeAll, ServiceSetup, HttpMethod, MiddlewareSetup, SilgiRuntimeShareds, RouterConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
+import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, RouteEntry, CustomRequestInit, SilgiRuntimeContext, BaseMethodSchema, MergeAll, HTTPMethod, ServiceSetup, ServicesObject, HttpMethod, MiddlewareSetup, SilgiRuntimeShareds, Resolvers, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Storage, StorageValue } from 'unstorage';
 import { UseContext } from 'unctx';
 
@@ -138,15 +139,11 @@ declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEve
  *   }
  * });
  */
-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 (optional) */
-    method?: UsedMethod;
-    /** Schema definition */
+declare function createSchema<Key extends string, Schema extends BaseMethodSchema>(params: {
+    key: Key;
     setup: Schema;
 }): {
-    [K in `${UsedMethod[number]}:${string & Path}`]: Schema;
+    [K in Key]: Schema;
 };
 
 /**
@@ -162,51 +159,50 @@ declare function deepMergeObjects<T extends readonly Record<string, any>[]>(sche
  * 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<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false>(path: Route, setup: ServiceSetup<Schema, Route, Resolved, HiddenParameters>): ServiceSetup<Schema, Route, Resolved, HiddenParameters>;
-declare function createService<Schema extends SilgiSchema, Path extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false>(params: {
-    path: Path;
-    setup: ServiceSetup<Schema, Path, Resolved, HiddenParameters>;
+type SlashCount<S extends string, Count extends any[] = []> = S extends `${infer _Prefix}/${infer Rest}` ? SlashCount<Rest, [any, ...Count]> : Count['length'];
+type Max4Slashes<S extends string> = SlashCount<S> extends 0 | 1 | 2 | 3 | 4 ? S : never;
+declare function createService<Path extends string = string, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | never | undefined = never, QueryParams extends StandardSchemaV1 | never | undefined = never, Resolved extends boolean = false, HiddenParameters extends boolean = false>(params: {
+    path: Max4Slashes<Path>;
+    methods: HTTPMethod[];
+    input?: Input;
+    output?: Output;
+    queryParams?: {
+        path?: PathParams;
+        query?: QueryParams;
+    };
+    setup: ServiceSetup<Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
 }): {
-    [K in Path]: ServiceSetup<Schema, Path, Resolved, HiddenParameters>;
+    [K in Path]: {
+        setup: ServiceSetup<Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+        methods: HTTPMethod[];
+        input?: Input;
+        output?: Output;
+        queryParams?: {
+            path?: PathParams;
+            query?: QueryParams;
+        };
+    };
 };
 
 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}`;
-declare function createMiddleware<S extends WildcardVariants<keyof Routers>, Method extends HttpMethod, UsedMethod extends readonly Method[]>(params: {
-    path: S;
-    method: UsedMethod;
-    setup: MiddlewareSetup;
-    global?: undefined;
-}): {
-    [K in `${UsedMethod[number]}:${S}`]: {
-        setup: MiddlewareSetup;
-        method: UsedMethod[number];
-        global: undefined;
-    };
-};
-declare function createMiddleware<Global extends string>(params: {
-    global: Global;
+type MiddlewarePath<S extends WildcardVariants<keyof ServicesObject>> = S | 'global';
+type CreateMiddlewareParams<S extends WildcardVariants<keyof ServicesObject>, UsedMethod extends readonly HttpMethod[] = readonly HttpMethod[], Key extends string = string> = {
+    path: MiddlewarePath<S>;
+    methods?: UsedMethod;
     setup: MiddlewareSetup;
-    method?: undefined | readonly [];
-    path?: undefined;
-}): {
-    [K in `GLOBAL:${Global}`]: {
-        setup: MiddlewareSetup;
-        global: Global;
-        method: false;
-    };
+    key: Key;
 };
-declare function createMiddleware<Global extends string, Method extends HttpMethod, UsedMethod extends readonly Method[]>(params: {
-    global: Global;
-    setup: MiddlewareSetup;
-    method: UsedMethod;
-    path?: undefined;
-}): {
-    [K in `${UsedMethod[number]}:${Global}`]: {
+type CreateMiddlewareResult<Path extends string, UsedMethod extends readonly HttpMethod[] = readonly HttpMethod[], Key extends string = string> = {
+    [K in `${Key}:${Path}`]: {
         setup: MiddlewareSetup;
-        global: Global;
-        method: UsedMethod[number];
+        methods?: UsedMethod;
+        key: Key;
+        path: Path;
     };
 };
+declare function createMiddleware<S extends WildcardVariants<keyof ServicesObject>, UsedMethod extends readonly HttpMethod[] = readonly HttpMethod[], Path extends MiddlewarePath<S> = MiddlewarePath<S>, Key extends string = string>(params: CreateMiddlewareParams<S, UsedMethod, Key> & {
+    path: Path;
+}): CreateMiddlewareResult<Path, UsedMethod, Key>;
 
 declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
 
@@ -215,9 +211,7 @@ declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntim
  */
 declare function replaceRuntimeValues(obj: any, runtime: any): any;
 
-declare function createRoute<URL extends string>(params: RouterConfig<URL>): {
-    [K in URL]: RouterConfig<URL>;
-};
+declare function createResolver(resolver: Resolvers): Resolvers;
 declare function getUrlPrefix(path: string, method?: string): SilgiURL;
 
 declare function createStorage(silgi: Silgi): Promise<Storage<StorageValue>>;
@@ -259,4 +253,4 @@ declare function useRuntime(): SilgiRuntimeConfig;
 
 declare const autoImportTypes: string[];
 
-export { SilgiError, autoImportTypes, createError, createMiddleware, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };
+export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };

package/dist/core/index.mjs

@@ -270,7 +270,7 @@ async function createSilgi(config) {
     routerPrefixs: [],
     schemas: config.schemas ?? {},
     services: config.services ?? {},
-    routers: config.routers ?? {},
+    resolvers: config.resolvers ?? [],
     middlewares: config.middlewares ?? {},
     globalMiddlewares: config.globalMiddlewares ?? [],
     shared: config.shared ?? {},
@@ -297,14 +297,7 @@ async function createSilgi(config) {
   if (!silgi.router) {
     silgi.router = createRouter();
   }
-  for (const routeKey in silgi.services) {
-    let method = "GLOBAL";
-    let route = routeKey;
-    if (routeKey.includes(":")) {
-      const [methodPart, ...routeParts2] = routeKey.split(":");
-      method = methodPart.toUpperCase();
-      route = routeParts2.join(":");
-    }
+  for (const [route, object] of Object.entries(silgi.services)) {
     const routeParts = route.split("/").filter(Boolean);
     if (routeParts.length > 0) {
       const prefix = `/${routeParts[0]}`;
@@ -312,44 +305,41 @@ async function createSilgi(config) {
         silgi.routerPrefixs.push(prefix);
       }
     }
-    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,
+    const methods = object.methods?.length ? object.methods : ["ALL"];
+    for (const method of methods) {
+      const globalMethod = method === "ALL" ? "" : method.toUpperCase();
+      addRoute(silgi.router, globalMethod, route, {
+        method: [method],
         route,
-        service: methodObject,
-        schema: schemaWrapper
+        service: object
       });
     }
   }
   if (!silgi._middlewareRouter) {
     silgi._middlewareRouter = createRouter();
   }
-  for (const routeKey in silgi.middlewares) {
-    const routeObject = silgi.middlewares[routeKey];
-    let method = "ALL";
-    let route = routeKey;
-    if (routeKey.includes(":")) {
-      const [methodPart, ...routeParts] = routeKey.split(":");
-      method = methodPart.toUpperCase();
-      route = routeParts.join(":");
+  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 (routeObject.global) {
+    if (_route === "global") {
       silgi.globalMiddlewares.push({
         middleware: routeObject.setup,
-        method,
-        route
+        method: routeObject.methods?.length ? routeObject.methods : ["ALL"],
+        route: _route
       });
-    } else {
-      addRoute(silgi._middlewareRouter, method, 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
+        method: [method],
+        route: _route
       });
     }
   }
@@ -561,12 +551,8 @@ function getRouterParams(event, opts = {}) {
   return params;
 }
 
-function createRoute(params) {
-  return {
-    [params.route]: {
-      ...params
-    }
-  };
+function createResolver(resolver) {
+  return resolver;
 }
 function getUrlPrefix(path, method) {
   const parse = path.includes("://") ? new FastURL(path) : new URL(path, "http://localhost");
@@ -593,7 +579,7 @@ function getUrlPrefix(path, method) {
 async function orchestrate(route, event, _input, graphql) {
   const silgiCtx = useSilgi();
   const silgiURL = getUrlPrefix(route.route || event.req.url, route.method);
-  const input = _input || (route.service?.rules?.readBeforeBody === false || graphql ? {} : await parseRequestInput(event.req));
+  const input = _input || (route.service?.setup.rules?.readBeforeBody === false || graphql ? {} : await parseRequestInput(event.req));
   const hookContext = { earlyReturnValue: false };
   const routerParams = _input ? input.path : getRouterParams(event);
   const queryParams = _input ? input.query : getQuery(event);
@@ -611,8 +597,7 @@ async function orchestrate(route, event, _input, graphql) {
     }
   };
   try {
-    const setup = route.service;
-    if (!setup) {
+    if (!route.service) {
       throw createError({
         statusCode: 404,
         statusMessage: "Service not found"
@@ -647,11 +632,10 @@ async function orchestrate(route, event, _input, graphql) {
     }
     silgiCtx.shared.$fetch = silgiFetch;
     silgiCtx.shared.silgi = silgiCtx;
-    const result = await setup?.handler(
+    const result = await route.service?.setup.handler(
       inputData,
       silgiCtx.shared,
-      event,
-      event.context.source
+      event
     );
     await silgiCtx.callHook("fetch:after", {
       event,
@@ -662,12 +646,12 @@ async function orchestrate(route, event, _input, graphql) {
       route,
       hookContext
     });
-    if (setup.storage && cacheData?.cachedKey) {
-      await useSilgiStorage(setup.storage.base).setItem(
+    if (route.service.setup.storage && cacheData?.cachedKey) {
+      await useSilgiStorage(route.service.setup.storage.base).setItem(
         cacheData.cachedKey,
         result,
         // Cast to StorageValue if needed
-        setup.storage.options
+        route.service.setup.storage.options
       );
     }
     return result;
@@ -697,18 +681,17 @@ async function orchestrate(route, event, _input, graphql) {
   }
 }
 async function cacheExecute(input, route, silgiURL, event) {
-  const setup = route.service;
-  if (!setup || !setup.storage)
+  if (!route.service || !route.service.setup.storage)
     return;
-  const cacheKey = setup.storage ? await generateStorageKey({
+  const cacheKey = route.service.setup.storage ? await generateStorageKey({
     url: silgiURL,
     input,
-    keyGenerator: setup.storage.key,
-    storageOptions: setup.storage,
+    keyGenerator: route.service.setup.storage.key,
+    storageOptions: route.service.setup.storage,
     requestId: event?.requestId
   }) : null;
   if (cacheKey) {
-    const cachedResult = await useSilgiStorage(setup.storage.base).getItem(cacheKey);
+    const cachedResult = await useSilgiStorage(route.service.setup.storage.base).getItem(cacheKey);
     if (cachedResult !== null) {
       return {
         success: true,
@@ -929,7 +912,15 @@ async function middleware(event, url) {
         if (_previous !== void 0 && _previous !== kNotFound) {
           return _previous;
         }
-        if (m.method && m.method !== "GLOBAL" && m.method !== event.req.method || !m.middleware) {
+        let allowedMethods = m.method ?? [];
+        if (!Array.isArray(allowedMethods)) {
+          allowedMethods = [allowedMethods];
+        }
+        const methodIsAllowed = allowedMethods.length === 0 || allowedMethods.includes("ALL") || allowedMethods.includes(event.req.method);
+        if (!methodIsAllowed) {
+          return;
+        }
+        if (!m.middleware) {
           return;
         }
         try {
@@ -959,7 +950,12 @@ async function middleware(event, url) {
           if (_previous !== void 0 && _previous !== kNotFound) {
             return _previous;
           }
-          if (match.data.method && match.data.method !== event.req.method || !match.data.middleware) {
+          let allowedMethods = match.data.method ?? [];
+          if (!Array.isArray(allowedMethods)) {
+            allowedMethods = [allowedMethods];
+          }
+          const methodIsAllowed = allowedMethods.length === 0 || allowedMethods.includes("ALL") || allowedMethods.includes(event.req.method);
+          if (!methodIsAllowed || !match.data.middleware) {
             return;
           }
           event.context.params = match.params;
@@ -1027,15 +1023,12 @@ function getEventContext(event) {
 }
 
 function createSchema(params) {
-  const { path, method, setup } = params;
+  const { key, setup } = params;
   const result = {};
-  if (!method) {
-    throw new Error(`Method is required createSchema ${path}`);
-  }
-  for (let i = 0; i < method.length; i++) {
-    const methodName = method[i];
-    result[`${String(methodName)}:${path}`] = setup;
-  }
+  result[key] = {
+    setup,
+    key
+  };
   return result;
 }
 
@@ -1062,47 +1055,34 @@ function deepMergeObjects(schemas) {
   return merged;
 }
 
-function defineServiceSetup(path, setup) {
-  return setup;
-}
 function createService(params) {
-  const { path, setup } = params;
-  return {
-    [path]: setup
+  const slashCount = (params.path.match(/\//g) || []).length;
+  if (slashCount > 4) {
+    throw new Error(
+      `Path '${params.path}' is invalid: maximum 4 '/' allowed (found ${slashCount})`
+    );
+  }
+  const result = {};
+  const { path, setup, methods, input, output, queryParams } = params;
+  result[path] = {
+    setup,
+    methods,
+    input,
+    output,
+    queryParams
   };
+  return result;
 }
 
 function createMiddleware(params) {
-  if (params.global) {
-    const globalKey = params.global;
-    if (!params.method || params.method.length === 0) {
-      return {
-        [`GLOBAL:${globalKey}`]: {
-          setup: params.setup,
-          global: globalKey,
-          method: false
-        }
-      };
-    }
-    const result2 = {};
-    for (const m of params.method) {
-      result2[`${m}:${globalKey}`] = {
-        setup: params.setup,
-        global: globalKey,
-        method: m
-      };
-    }
-    return result2;
-  }
-  const result = {};
-  for (const m of params.method) {
-    result[`${m}:${params.path}`] = {
+  return {
+    [`${params.key}:${params.path}`]: {
       setup: params.setup,
-      method: m,
-      global: void 0
-    };
-  }
-  return result;
+      methods: params.methods?.length ? params.methods : ["ALL"],
+      key: params.key,
+      path: params.path
+    }
+  };
 }
 
 function createShared(shared) {
@@ -1148,4 +1128,4 @@ const autoImportTypes = [
   "ExtractQueryParamsFromURI"
 ];
 
-export { SilgiError, autoImportTypes, createError, createMiddleware, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };
+export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { SilgiError, autoImportTypes, createError, createMiddleware, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage } from './core/index.mjs';
+export { SilgiError, autoImportTypes, createError, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, 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 'consola';
 import 'defu';

package/dist/kit/index.mjs

@@ -76,11 +76,14 @@ function removeExtension(filePath, force = false) {
   return filePath;
 }
 function getServicePath(_route) {
-  let method = "ALL";
+  let method = "";
   let route = _route;
   if (route.includes(":")) {
     const [methodPart, ...routeParts] = route.split(":");
     method = methodPart.toUpperCase();
+    if (method === "GLOBAL") {
+      method = "";
+    }
     route = routeParts.join(":");
   }
   return {

package/dist/types/index.d.mts

@@ -94,7 +94,6 @@ interface SilgiRuntimeContext extends Record<string, any> {
     matchedRoute?: SilgiRoute;
     sessions?: Record<string, Session>;
     clientAddress?: string;
-    source?: any;
     silgi: {
         runtimeConfig?: SilgiRuntimeConfig;
     };
@@ -130,13 +129,11 @@ interface SilgiEvent extends Record<string, unknown> {
 }
 
 /**
- * Main interface containing all route definitions.
- * Example:
- * {
- *   "/api/blueSpace/basket/getBook": { ... }
- * }
+ * Route configuration interface.
  */
-interface Routers {
+interface Resolvers {
+}
+interface RouteRules extends Record<string, unknown> {
 }
 /**
  * Extracts the prefix (first segment) from a URL, including the leading slash.
@@ -157,7 +154,7 @@ type ExtractRoute<URL extends string> = URL extends `/${string}/${string}/${infe
  * Gets all route keys from Routers as strings.
  * All keys should start with a leading slash.
  */
-type RouterKeys = keyof Routers & string;
+type RouterKeys = keyof ServicesObject & string;
 /**
  * Extracts all prefixes (first segment) in the system, including the leading slash.
  * @example AllPrefixes // '/api' | ...
@@ -181,100 +178,6 @@ type RoutesForPrefixAndNamespace<P extends string, N extends string> = RouterKey
  * ExtractPathParamKeys<'/users/:id?'> // 'id'
  */
 type ExtractPathParamKeys<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param extends `${infer Key}?` ? Key | ExtractPathParamKeys<Rest> : Param | ExtractPathParamKeys<Rest> : S extends `${string}:${infer Param}` ? Param extends `${infer Key}?` ? Key : Param : never;
-/**
- * Route configuration interface.
- */
-interface RouterConfig<T extends string = string> {
-    route: T;
-    setup?: any;
-    readBeforeBody?: boolean;
-}
-type RouterConfigService<T extends string = string> = Omit<RouterConfig<T>, 'route' | 'setup'>;
-
-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.
- *
- * @example
- * PathParamsObject<'/users/:id/posts/:postId'> // { id?: string | number, postId?: string | number }
- */
-type PathParamsObject<S extends string> = {
-    [K in ExtractPathParamKeys<S>]?: string | number;
-};
-/**
- * Determines if a URL pattern contains any path parameters.
- *
- * @example
- * HasPathParams<'/users/:id'> // true
- * HasPathParams<'/users'> // false
- */
-type HasPathParams<S extends string> = ExtractPathParamKeys<S> extends never ? false : true;
-/**
- * Base schema definition for API method handlers.
- * Defines the structure of input/output data.
- */
-interface BaseMethodSchema {
-    /** Schema for request body */
-    input?: StandardSchemaV1;
-    /** Schema for response body */
-    output?: StandardSchemaV1;
-    /** Schema for URL query parameters */
-    queryParams?: StandardSchemaV1;
-    /** Schema for source data (contextual information) */
-    source?: StandardSchemaV1;
-}
-/**
- * Interface for adding path parameters schema to method definitions.
- */
-interface WithPathParams<PathParamsStr extends string> {
-    /** Schema for path parameters */
-    pathParams: StandardSchemaV1<PathParamsObject<PathParamsStr>>;
-}
-/**
- * Defines the schema structure for HTTP methods, conditionally including
- * path parameters based on the URL pattern.
- *
- * @example
- * // For a route with path parameters:
- * type UserMethodSchema = MethodSchemas<'/:id'>
- * // Result includes required pathParams for each method
- *
- * // For a route without path parameters:
- * type ListMethodSchema = MethodSchemas<''>
- * // Result doesn't allow pathParams property
- */
-type MethodSchemas<PathParamsStr extends string = ''> = {
-    [K in HTTPMethod]?: HasPathParams<PathParamsStr> extends true ? BaseMethodSchema & WithPathParams<PathParamsStr> : BaseMethodSchema & {
-        pathParams?: never;
-    };
-};
-/**
- * Represents a fully resolved schema definition that maps API route paths
- * to their method schemas.
- */
-interface ResolvedSchema {
-    [routePath: string]: MethodSchemas<string>;
-}
-/**
- * Represents a schema definition that has been fully resolved,
- * typically after processing and validating all schema components.
- */
-interface ResolvedSchemaDefinition {
-    [methodAndRoutePath: string]: BaseMethodSchema;
-}
 
 type CustomDriverName = string & {
     _custom?: any;
@@ -313,60 +216,61 @@ interface SilgiRuntimeSharedsExtend {
 interface ExtendShared {
 }
 
+interface ServicesObject {
+}
 /**
  * Yardımcı tipler
  */
 type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
 type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
-/**
- * Direct parameter type inference for combined route strings
- */
-type ServiceHandlerParameters<S, R extends keyof S> = S[R] extends {
-    pathParams?: infer P;
-} ? S[R] extends {
-    queryParams?: infer Q;
-} ? (P extends undefined ? object : {
-    path: InferInput<P>;
-}) & (Q extends undefined ? object : {
-    query: InferInput<Q>;
-}) : (P extends undefined ? object : {
-    path: InferInput<P>;
-}) : S[R] extends {
-    queryParams?: infer Q;
-} ? (Q extends undefined ? object : {
-    query: InferInput<Q>;
-}) : object;
 /**
  * Route ve method'a göre input, output, params çıkarımı
+ *
+ * - Eğer PathParams veya QueryParams never/undefined ise parameters alanı eklenmez.
+ * - args her zaman zorunlu.
  */
-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> extends never ? unknown : {
-    parameters: ServiceHandlerParameters<Schema, Route>;
-}) : unknown);
-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> = Schema[Route] extends {
-    source?: infer S;
-} ? InferInput<S> : unknown;
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUndefined<T> = [undefined] extends [T] ? true : false;
+type HasPath<T> = IsNever<T> extends true ? false : IsUndefined<T> extends true ? false : true;
+type HasQuery<T> = IsNever<T> extends true ? false : IsUndefined<T> extends true ? false : true;
+type ServiceHandlerInput<Input extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | never | undefined = never, QueryParams extends StandardSchemaV1 | never | undefined = never, HiddenParameters extends boolean = false> = HiddenParameters extends true ? {
+    args: InferInput<Input>;
+} : HasPath<PathParams> extends true ? HasQuery<QueryParams> extends true ? {
+    args: InferInput<Input>;
+    parameters: {
+        path: InferInput<PathParams>;
+        query: Partial<InferInput<QueryParams>>;
+    };
+} : {
+    args: InferInput<Input>;
+    parameters: {
+        path: InferInput<PathParams>;
+    };
+} : HasQuery<QueryParams> extends true ? {
+    args: InferInput<Input>;
+    parameters: {
+        query: InferInput<QueryParams>;
+    };
+} : {
+    args: InferInput<Input>;
+};
 /**
  * Handler fonksiyon tipi
  *
  * 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, 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>>;
+type ServiceHandler<Input extends StandardSchemaV1, Output extends StandardSchemaV1, PathParams extends StandardSchemaV1 | never | undefined = never, QueryParams extends StandardSchemaV1 | never | undefined = never, Resolved extends boolean = false, HiddenParameters extends boolean = false> = Resolved extends true ? (input: ServiceHandlerInput<Input, PathParams, QueryParams, HiddenParameters>, shared?: SilgiRuntimeShareds, event?: SilgiEvent) => Promise<InferOutput<Output>> : (input: ServiceHandlerInput<Input, PathParams, QueryParams, HiddenParameters>, shared: SilgiRuntimeShareds, event: SilgiEvent) => Promise<InferOutput<Output>>;
 /**
  * Servis setup tipi
  */
-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?: RouterConfigService;
+interface ServiceSetup<Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | never | undefined = never, QueryParams extends StandardSchemaV1 | never | undefined = never, Resolved extends boolean = false, HiddenParameters extends boolean = false> {
+    handler: ServiceHandler<Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    rules?: RouteRules & {
+        readBeforeBody?: boolean;
+    };
     modules?: Partial<SetupModuleOption>;
-    storage?: StorageConfig<ServiceHandlerInput<Schema, Route, HiddenParameters>>;
+    storage?: StorageConfig<ServiceHandlerInput<Input, PathParams, QueryParams, HiddenParameters>>;
 }
 /**
  * Represents a fully resolved service definition that maps route paths
@@ -375,13 +279,19 @@ interface ServiceSetup<Schema extends SilgiSchema = SilgiSchema, Route extends k
  * This interface is designed to be compatible with the structure created
  * by the createService function.
  *
- * Format: "METHOD:routePath" => handler + config
+ * Format: "routePath" => setup + methods + input + output + queryParams
  */
 interface ResolvedServiceDefinition {
-    [methodAndRoutePath: string]: {
-        handler: (...args: any[]) => Promise<any>;
-        storage?: StorageConfig<any>;
-    } & Omit<ServiceSetup, 'handler' | 'storage'>;
+    [routePath: string]: {
+        setup: ServiceSetup<any, any, any, any, any, any>;
+        methods: HTTPMethod[];
+        input?: StandardSchemaV1;
+        output?: StandardSchemaV1;
+        queryParams?: {
+            path?: StandardSchemaV1;
+            query?: StandardSchemaV1;
+        };
+    };
 }
 /**
  * SilgiURL tipi
@@ -405,7 +315,7 @@ interface SilgiCLI {
     services: ResolvedServiceDefinition;
     middleware: SilgiRoute[];
     shareds: SilgiRuntimeShareds;
-    routers: Record<string, RouterConfig>;
+    resolvers: any[];
     schemas: Record<string, any>;
     templates: SilgiTemplate[];
     hooks: Hookable<SilgiCLIHooks>;
@@ -592,8 +502,6 @@ interface SilgiModule<TOptions extends ModuleOptionsCustom = ModuleOptionsCustom
     getMeta?: () => Promise<ModuleMeta>;
 }
 
-interface RouteRules extends Record<string, unknown> {
-}
 type MiddlewareHandler<Response extends EventHandlerResponse = EventHandlerResponse> = (event: SilgiEvent, silgi: Silgi) => Response;
 /**
  * Middleware Setup tipi
@@ -607,8 +515,7 @@ interface MiddlewareSetup {
 interface ResolvedMiddlewareDefinition {
     [methodAndPath: string]: {
         setup: MiddlewareSetup;
-        global?: string | undefined;
-        method?: HTTPMethod | false;
+        methods?: HTTPMethod[];
     };
 }
 
@@ -698,15 +605,99 @@ interface SilgiOptions {
     [key: string]: any;
 }
 
-type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'GLOBAL';
+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.
+ *
+ * @example
+ * PathParamsObject<'/users/:id/posts/:postId'> // { id?: string | number, postId?: string | number }
+ */
+type PathParamsObject<S extends string> = {
+    [K in ExtractPathParamKeys<S>]?: string | number;
+};
+/**
+ * Determines if a URL pattern contains any path parameters.
+ *
+ * @example
+ * HasPathParams<'/users/:id'> // true
+ * HasPathParams<'/users'> // false
+ */
+type HasPathParams<S extends string> = ExtractPathParamKeys<S> extends never ? false : true;
+/**
+ * Base schema definition for API method handlers.
+ * Defines the structure of input/output data.
+ */
+interface BaseMethodSchema {
+    /** Schema for request body */
+    input?: StandardSchemaV1;
+    /** Schema for response body */
+    output?: StandardSchemaV1;
+    /** Schema for URL query parameters */
+    queryParams?: StandardSchemaV1;
+    /** Schema for source data (contextual information) */
+    source?: StandardSchemaV1;
+}
+/**
+ * Interface for adding path parameters schema to method definitions.
+ */
+interface WithPathParams<PathParamsStr extends string> {
+    /** Schema for path parameters */
+    pathParams: StandardSchemaV1<PathParamsObject<PathParamsStr>>;
+}
+/**
+ * Defines the schema structure for HTTP methods, conditionally including
+ * path parameters based on the URL pattern.
+ *
+ * @example
+ * // For a route with path parameters:
+ * type UserMethodSchema = MethodSchemas<'/:id'>
+ * // Result includes required pathParams for each method
+ *
+ * // For a route without path parameters:
+ * type ListMethodSchema = MethodSchemas<''>
+ * // Result doesn't allow pathParams property
+ */
+type MethodSchemas<PathParamsStr extends string = ''> = {
+    [K in HTTPMethod]?: HasPathParams<PathParamsStr> extends true ? BaseMethodSchema & WithPathParams<PathParamsStr> : BaseMethodSchema & {
+        pathParams?: never;
+    };
+};
+/**
+ * Represents a fully resolved schema definition that maps API route paths
+ * to their method schemas.
+ */
+interface ResolvedSchema {
+    [routePath: string]: MethodSchemas<string>;
+}
+/**
+ * Represents a schema definition that has been fully resolved,
+ * typically after processing and validating all schema components.
+ */
+interface ResolvedSchemaDefinition {
+    [methodAndRoutePath: string]: BaseMethodSchema;
+}
+
+type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'ALL';
 type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiRuntimeMethods | StandardHTTPMethod : StandardHTTPMethod;
 interface MetaData extends Record<string, unknown> {
 }
 interface SilgiRoute {
     route?: string;
-    method?: HTTPMethod;
-    schema?: ResolvedSchemaDefinition;
-    service?: ServiceSetup;
+    method?: HTTPMethod | HTTPMethod[];
+    service?: ResolvedServiceDefinition[string];
     middleware?: MiddlewareSetup;
 }
 interface Silgi {
@@ -716,7 +707,7 @@ interface Silgi {
     globalMiddlewares: SilgiRoute[];
     routerPrefixs: string[];
     schemas: ResolvedSchemaDefinition;
-    routers: Record<string, RouterConfig>;
+    resolvers: any[];
     services: ResolvedServiceDefinition;
     shared: SilgiRuntimeShareds;
     plugins: SilgiAppPlugin[];
@@ -847,7 +838,7 @@ interface SilgiCLIHooks extends SilgiHooks {
     'before:scan.ts': (data: {
         services: string[];
         shareds: string[];
-        routers: string[];
+        resolvers: string[];
         schemas: string[];
         middlewares: string[];
         addImportItem: (data: GenImport | GenImport[]) => void;
@@ -865,6 +856,10 @@ interface SilgiCLIHooks extends SilgiHooks {
             key: string;
             value: string;
         }[];
+        resolvers: {
+            key: string;
+            value: string;
+        }[];
         methods: {
             key: string;
             value: string;
@@ -1226,4 +1221,4 @@ interface LoadConfigOptions {
     consola?: ConsolaInstance;
 }
 
-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, MiddlewareHandler, MiddlewareSetup, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedMiddlewareDefinition, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition, ResolvedSilgiTemplate, RouteEntry, RouteRules, RouterConfig, RouterConfigService, 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 };
+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, MiddlewareHandler, MiddlewareSetup, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedMiddlewareDefinition, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition, ResolvedSilgiTemplate, Resolvers, RouteEntry, RouteRules, RouterParams, RoutesForPrefixAndNamespace, ScanFile, Schema, ServiceHandler, ServiceHandlerInput, ServiceSetup, ServicesObject, 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.40.1",
+  "version": "0.41.1",
   "private": false,
   "sideEffects": false,
   "exports": {