silgi 0.41.17 → 0.41.19

package/dist/cli/build.mjs

@@ -1953,15 +1953,30 @@ async function prepareSchema(silgi) {
     generateTypes(
       await resolveSchema(
         {
-          ...silgi.options.storages?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {},
-          // 'redis': {} -> 'redis': string
-          ...Object.entries(silgi.options.storage).map(([key]) => ({
-            [key]: ""
-          })).reduce((acc, obj) => ({ ...acc, ...obj }), {})
+          ...Object.fromEntries(
+            Object.entries(silgi.options.runtimeConfig).filter(
+              ([key]) => !["app", "nitro", "nuxt"].includes(key)
+            )
+          )
+        }
+      ),
+      {
+        interfaceName: "SilgiRuntimeConfigExtends",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ),
+    "",
+    generateTypes(
+      await resolveSchema(
+        {
+          ...silgi.services ? Object.keys(silgi.services).reduce((acc, key) => ({ ...acc, [key]: "" }), {}) : {}
         }
       ),
       {
-        interfaceName: "SilgiStorageBaseExtends",
+        interfaceName: "RoutersExtend",
         addExport: false,
         addDefaults: false,
         allowExtraKeys: false,
@@ -1977,7 +1992,6 @@ async function prepareSchema(silgi) {
       SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
       ServicesObject: [{}, { extends: ["BaseServices"] }],
       SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
-      SilgiURIs: [{}, { extends: ["SilgiURIsMerge"] }],
       SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
       SilgiEvent: [{}, { extends: ["SilgiModuleEventsExtends"] }],
       SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
@@ -1991,7 +2005,8 @@ async function prepareSchema(silgi) {
       SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }],
       // TODO: bunu kontrol et.
       RouteRules: [{}, { extends: ["RouteRulesExtend"] }],
-      MetaData: [{}, { extends: ["MetaDataExtend"] }]
+      MetaData: [{}, { extends: ["MetaDataExtend"] }],
+      Routers: [{}, { extends: ["RoutersExtend"] }]
     }).replace(/,\s*/g, "\n"),
     "",
     "export {}"

package/dist/cli/index.mjs

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

package/dist/core/index.d.mts

@@ -1,4 +1,4 @@
-import { SilgiConfig, Silgi, SilgiEvent, HTTPMethod, SilgiSchema, RouteEntry, CustomRequestInit, SilgiRuntimeContext, BaseMethodSchema, MergeAll, ServiceSetup, ServicesObject, MiddlewareSetup, SilgiRuntimeShareds, Resolvers, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
+import { SilgiConfig, Silgi, SilgiEvent, HTTPMethod, SilgiSchema, RouteEntry, CustomRequestInit, SilgiRuntimeContext, BaseMethodSchema, MergeAll, Routers, ServiceSetup, 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';
@@ -159,33 +159,27 @@ declare function deepMergeObjects<T extends readonly Record<string, any>[]>(sche
  * Tip güvenliğini artırmak için ServiceSetup objesini doğrudan döndürür.
  */
 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: {
+type Max4Slashes<S extends keyof Routers> = SlashCount<S> extends 0 | 1 | 2 | 3 ? S : never;
+type ServiceSetupsForMethods<Parent extends 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> = {
+    GET?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    POST?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    PUT?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    PATCH?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    DELETE?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    OPTIONS?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    HEAD?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    CONNECT?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+    TRACE?: ServiceSetup<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
+};
+declare function createService<Parent extends StandardSchemaV1, Path extends keyof Routers = 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>(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]: {
-        setup: ServiceSetup<Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
-        methods?: HTTPMethod[];
-        input?: Input;
-        output?: Output;
-        queryParams?: {
-            path?: PathParams;
-            query?: QueryParams;
-        };
-    };
+} & ServiceSetupsForMethods<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>): {
+    [K in Path]: ServiceSetupsForMethods<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 ServicesObject>> = S | 'global';
-interface CreateMiddlewareParams<S extends WildcardVariants<keyof ServicesObject>, UsedMethod extends readonly HTTPMethod[] = readonly HTTPMethod[], Key extends string = string> {
+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> {
     path: MiddlewarePath<S>;
     methods?: UsedMethod;
     setup: MiddlewareSetup;
@@ -199,7 +193,7 @@ type CreateMiddlewareResult<Path extends string, UsedMethod extends readonly HTT
         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> & {
+declare function createMiddleware<S extends WildcardVariants<keyof Routers>, 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>;
 

package/dist/core/index.mjs

@@ -8,6 +8,7 @@ import { Buffer } from 'node:buffer';
 import { klona } from 'klona';
 import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
 import { isDevelopment } from 'std-env';
+import { toJsonSchema } from '@standard-community/standard-json';
 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';
@@ -298,29 +299,37 @@ async function createSilgi(config) {
     silgi.router = createRouter();
   }
   for (const [route, object] of Object.entries(silgi.services)) {
-    const methods = object.methods?.length ? object.methods : ["ALL"];
-    if (methods.includes("GRAPHQL")) {
-      addRoute(silgi.router, "GRAPHQL", route, {
-        method: "GRAPHQL",
-        route,
-        service: object
-      });
-      continue;
-    } else {
-      const routeParts = route.split("/").filter(Boolean);
-      if (routeParts.length > 0) {
-        const prefix = `/${routeParts[0]}`;
-        if (!silgi.routerPrefixs.includes(prefix)) {
-          silgi.routerPrefixs.push(prefix);
-        }
+    const routeParts = route.split("/").filter(Boolean);
+    if (routeParts.length > 0) {
+      const prefix = `/${routeParts[0]}`;
+      if (!silgi.routerPrefixs.includes(prefix)) {
+        silgi.routerPrefixs.push(prefix);
       }
     }
-    for (const method of methods) {
-      const globalMethod = method === "ALL" ? "" : method.toUpperCase();
-      addRoute(silgi.router, globalMethod, route, {
+    for (const [method, routeObject] of Object.entries(object)) {
+      let routeWithParams = route;
+      if (routeObject.pathParams) {
+        const jsonSchema = await toJsonSchema(routeObject.pathParams);
+        if (jsonSchema && jsonSchema.properties) {
+          const paramNames = Object.keys(jsonSchema.properties);
+          if (paramNames.length > 0) {
+            const routeParts2 = routeWithParams.split("/");
+            const lastParts = routeParts2.slice(-paramNames.length);
+            const alreadyHasParams = paramNames.every((name, idx) => lastParts[idx] === `:${name}`);
+            if (!alreadyHasParams) {
+              routeWithParams = routeWithParams.replace(/\/+$/, "");
+              for (const param of paramNames) {
+                routeWithParams += `/:${param}`;
+              }
+            }
+          }
+        }
+      }
+      console.log("Route:", routeWithParams, method);
+      addRoute(silgi.router, method, routeWithParams, {
         method,
-        route,
-        service: object
+        route: routeWithParams,
+        service: routeObject
       });
     }
   }
@@ -391,12 +400,16 @@ class _SilgiEvent {
   req;
   url;
   context;
+  protocol;
+  // Added property
   _res;
   constructor(req, context) {
     this.context = context || new EmptyObject();
     this.req = req;
     const _url = req._url;
     this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+    let proto = this.url.protocol.replace(":", "");
+    this.protocol = proto === "https" ? "http" : proto;
   }
   get res() {
     if (!this._res) {
@@ -607,7 +620,7 @@ async function orchestrate(route, event, _input) {
     pathParams: {},
     queryParams: {}
   };
-  const input = _input || (route.service?.setup.rules?.readBeforeBody === false || isGraphQL ? {} : await parseRequestInput(event.req));
+  const input = _input || (route.service?.rules?.readBeforeBody === false || isGraphQL ? {} : await parseRequestInput(event.req));
   const hookContext = { earlyReturnValue: false };
   const routerParams = _input ? input.path : getRouterParams(event);
   const queryParams = _input ? input.query : getQuery(event);
@@ -619,10 +632,8 @@ async function orchestrate(route, event, _input) {
   }
   const inputData = {
     args: input,
-    parameters: {
-      query: queryParams,
-      path: routerParams
-    }
+    query: queryParams,
+    path: routerParams
   };
   try {
     if (!route.service && route.method !== "GRAPHQL") {
@@ -660,10 +671,17 @@ async function orchestrate(route, event, _input) {
     }
     silgiCtx.shared.$fetch = silgiFetch;
     silgiCtx.shared.silgi = silgiCtx;
-    const result = await route.service?.setup.handler?.(
+    const result = await route.service?.handler?.(
+      // input
       inputData,
+      // shared
       silgiCtx.shared,
-      event
+      // event
+      event,
+      // parent - graphql
+      {},
+      // info - graphql
+      {}
     );
     await silgiCtx.callHook("fetch:after", {
       event,
@@ -674,12 +692,12 @@ async function orchestrate(route, event, _input) {
       route,
       hookContext
     });
-    if (route.service?.setup.storage && cacheData?.cachedKey) {
-      await useSilgiStorage(route.service.setup.storage.base).setItem(
+    if (route.service?.storage && cacheData?.cachedKey) {
+      await useSilgiStorage(route.service.storage.base).setItem(
         cacheData.cachedKey,
         result,
         // Cast to StorageValue if needed
-        route.service.setup.storage.options
+        route.service.storage.options
       );
     }
     return result;
@@ -709,17 +727,17 @@ async function orchestrate(route, event, _input) {
   }
 }
 async function cacheExecute(input, route, silgiURL, event) {
-  if (!route.service || !route.service.setup?.storage)
+  if (!route.service || !route.service.storage)
     return;
-  const cacheKey = route.service.setup.storage ? await generateStorageKey({
+  const cacheKey = route.service.storage ? await generateStorageKey({
     url: silgiURL,
     input,
-    keyGenerator: route.service.setup.storage.key,
-    storageOptions: route.service.setup.storage,
+    keyGenerator: route.service.storage.key,
+    storageOptions: route.service.storage,
     requestId: event?.requestId
   }) : null;
   if (cacheKey) {
-    const cachedResult = await useSilgiStorage(route.service.setup.storage.base).getItem(cacheKey);
+    const cachedResult = await useSilgiStorage(route.service.storage.base).getItem(cacheKey);
     if (cachedResult !== null) {
       return {
         success: true,
@@ -941,7 +959,7 @@ async function middleware(event, url) {
           return _previous;
         }
         const allowedMethod = m.method ?? "";
-        const methodIsAllowed = allowedMethod === "ALL" || allowedMethod === event.req.method || allowedMethod === "GRAPHQL";
+        const methodIsAllowed = allowedMethod === event.req.method || event.protocol === "GRAPHQL";
         if (!methodIsAllowed) {
           return;
         }
@@ -976,7 +994,7 @@ async function middleware(event, url) {
             return _previous;
           }
           const allowedMethod = match.data.method ?? "";
-          const methodIsAllowed = allowedMethod === "ALL" || allowedMethod === event.req.method || allowedMethod === "GRAPHQL";
+          const methodIsAllowed = allowedMethod === event.req.method || event.protocol === "GRAPHQL";
           if (!methodIsAllowed || !match.data.middleware) {
             return;
           }
@@ -1016,10 +1034,7 @@ async function handler(event, url, input) {
         data: {
           method: url?.method || event.req.method,
           route: url?.path,
-          service: {
-            setup: {},
-            methods: ["GRAPHQL"]
-          }
+          service: {}
         },
         params: {}
       };
@@ -1091,22 +1106,18 @@ function deepMergeObjects(schemas) {
 }
 
 function createService(params) {
-  const slashCount = (params.path.match(/\//g) || []).length;
+  const slashCount = (String(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
+  const { path, ...objects } = params;
+  return {
+    [path]: {
+      ...objects
+    }
   };
-  return result;
 }
 
 function createMiddleware(params) {

package/dist/index.mjs

@@ -10,5 +10,6 @@ import 'node:buffer';
 import 'klona';
 import 'unstorage';
 import 'std-env';
+import '@standard-community/standard-json';
 import 'srvx';
 import 'node:async_hooks';

package/dist/types/index.d.mts

@@ -25,6 +25,7 @@ import { ServerRequest } from 'srvx';
 import { Defu } from 'defu';
 import { silgiFetch } from 'silgi';
 import { useRuntimeConfig } from 'silgi/runtime';
+import { GraphQLResolveInfo } from 'graphql';
 import { Unimport } from 'unimport';
 import { ProviderName } from 'std-env';
 import { FetchOptions, FetchResponse } from 'ofetch';
@@ -99,10 +100,15 @@ interface SilgiRuntimeContext extends Record<string, any> {
         runtimeConfig?: SilgiRuntimeConfig;
     };
 }
+type EventProtocol = 'GRAPHQL' | 'HTTP' | 'WEBSOCKET';
 /**
  * Bu nitrojs, h3 event or request context.
  */
 interface SilgiEvent extends Record<string, unknown> {
+    /**
+     * Protocol Type
+     */
+    readonly protocol: EventProtocol;
     /**
      * Event context.
      */
@@ -134,6 +140,8 @@ interface SilgiEvent extends Record<string, unknown> {
  */
 interface Resolvers {
 }
+interface Routers {
+}
 interface RouteRules extends Record<string, unknown> {
 }
 type MergeRouteRules = Partial<RouteRules> & {
@@ -158,7 +166,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 ServicesObject & string;
+type RouterKeys = (keyof ServicesObject extends string ? keyof ServicesObject : never) & (keyof Routers extends string ? keyof Routers : never);
 /**
  * Extracts all prefixes (first segment) in the system, including the leading slash.
  * @example AllPrefixes // '/api' | ...
@@ -241,20 +249,14 @@ type ServiceHandlerInput<Input extends StandardSchemaV1 = StandardSchemaV1, Path
     args: InferInput<Input>;
 } : HasPath<PathParams> extends true ? HasQuery<QueryParams> extends true ? {
     args: InferInput<Input>;
-    parameters: {
-        path: InferInput<PathParams>;
-        query: Partial<InferInput<QueryParams>>;
-    };
+    path: InferInput<PathParams>;
+    query: Partial<InferInput<QueryParams>>;
 } : {
     args: InferInput<Input>;
-    parameters: {
-        path: InferInput<PathParams>;
-    };
+    path: InferInput<PathParams>;
 } : HasQuery<QueryParams> extends true ? {
     args: InferInput<Input>;
-    parameters: {
-        query: InferInput<QueryParams>;
-    };
+    query: InferInput<QueryParams>;
 } : {
     args: InferInput<Input>;
 };
@@ -264,15 +266,19 @@ type ServiceHandlerInput<Input extends StandardSchemaV1 = StandardSchemaV1, Path
  * Resolved = false  -> handler(input, shared, event, source) // all required
  * Resolved = true -> handler(input, shared?, event?, source?) // only input required
  */
-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>> | InferOutput<Output> : (input: ServiceHandlerInput<Input, PathParams, QueryParams, HiddenParameters>, shared: SilgiRuntimeShareds, event: SilgiEvent) => Promise<InferOutput<Output>> | InferOutput<Output>;
+type ServiceHandler<Parent extends StandardSchemaV1, 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, parent?: Parent, info?: GraphQLResolveInfo) => Promise<InferOutput<Output>> | InferOutput<Output> : (input: ServiceHandlerInput<Input, PathParams, QueryParams, HiddenParameters>, shared: SilgiRuntimeShareds, event: SilgiEvent, parent: Parent, info: GraphQLResolveInfo) => Promise<InferOutput<Output>> | InferOutput<Output>;
 /**
  * Servis setup tipi
  */
-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>;
+interface ServiceSetup<Parent extends 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> {
+    handler?: ServiceHandler<Parent, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>;
     rules?: MergeRouteRules;
     modules?: Partial<SetupModuleOption>;
     storage?: StorageConfig<ServiceHandlerInput<Input, PathParams, QueryParams, HiddenParameters>>;
+    input?: Input;
+    output?: Output;
+    pathParams?: PathParams;
+    queryParams?: QueryParams;
 }
 /**
  * Represents a fully resolved service definition that maps route paths
@@ -285,14 +291,15 @@ interface ServiceSetup<Input extends StandardSchemaV1 = StandardSchemaV1, Output
  */
 interface ResolvedServiceDefinition {
     [routePath: string]: {
-        setup: ServiceSetup<any, any, any, any, any, any>;
-        methods: HTTPMethod[];
-        input?: StandardSchemaV1;
-        output?: StandardSchemaV1;
-        queryParams?: {
-            path?: StandardSchemaV1;
-            query?: StandardSchemaV1;
-        };
+        GET?: ServiceSetup<any, any, any, any, any, any>;
+        POST?: ServiceSetup<any, any, any, any, any, any>;
+        PUT?: ServiceSetup<any, any, any, any, any, any>;
+        PATCH?: ServiceSetup<any, any, any, any, any, any>;
+        DELETE?: ServiceSetup<any, any, any, any, any, any>;
+        OPTIONS?: ServiceSetup<any, any, any, any, any, any>;
+        HEAD?: ServiceSetup<any, any, any, any, any, any>;
+        CONNECT?: ServiceSetup<any, any, any, any, any, any>;
+        TRACE?: ServiceSetup<any, any, any, any, any, any>;
     };
 }
 /**
@@ -691,14 +698,14 @@ interface ResolvedSchemaDefinition {
     [methodAndRoutePath: string]: BaseMethodSchema;
 }
 
-type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'ALL' | 'GRAPHQL';
+type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
 type HTTPMethod = StandardHTTPMethod | (keyof SilgiRuntimeMethods extends string ? keyof SilgiRuntimeMethods : never);
 interface MetaData extends Record<string, unknown> {
 }
 interface SilgiRoute {
     route?: string;
     method?: HTTPMethod;
-    service?: ResolvedServiceDefinition[string];
+    service?: ResolvedServiceDefinition[string][keyof ResolvedServiceDefinition[string]];
     middleware?: MiddlewareSetup;
 }
 interface Silgi {
@@ -1222,4 +1229,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, LoadConfigOptions, MergeAll, MergeRouteRules, 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 };
+export type { AllPaths, AllPrefixes, AppConfig, Awaitable, BaseMethodSchema, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, EventProtocol, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, GenImport, GenerateAppOptions, HTTPMethod, HasPathParams, HookResult, LoadConfigOptions, MergeAll, MergeRouteRules, 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, Routers, 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.41.17",
+  "version": "0.41.19",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -114,6 +114,7 @@
     "dotenv": "^16.5.0",
     "escape-string-regexp": "^5.0.0",
     "exsolve": "^1.0.5",
+    "graphql": "^16.11.0",
     "hookable": "^5.5.3",
     "ignore": "^7.0.4",
     "klona": "^2.0.6",