silgi 0.34.10 → 0.34.12

package/dist/build.mjs

@@ -14,6 +14,7 @@ import 'unimport';
 import '@clack/prompts';
 import 'node:fs';
 import 'dotenv';
+import 'knitwork';
 import 'mlly';
 import 'dev-jiti';
 import './cli/compatibility.mjs';
@@ -26,7 +27,6 @@ import 'ufo';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
-import 'knitwork';
 import 'klona';
 import 'silgi/runtime';
 import 'unstorage';

package/dist/cli/build.mjs

@@ -2,12 +2,13 @@ import { consola } from 'consola';
 import { createHooks, createDebugger } from 'hookable';
 import { resolve, join, relative, extname, basename, dirname, isAbsolute } from 'pathe';
 import { useSilgiCLI, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
-import { isPresents, addTemplate, addCoreFile, relativeWithDot, hash, removeExtension, resolveAlias, directoryToURL, addImports, baseHeaderBannerComment, writeFile, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, genEnsureSafeVar, toArray, isDirectory } from 'silgi/kit';
+import { isPresents, addTemplate, addCoreFile, genEnsureSafeVar, relativeWithDot, hash, removeExtension, resolveAlias, directoryToURL, addImports, baseHeaderBannerComment, writeFile, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, toArray, isDirectory } from 'silgi/kit';
 import { runtimeDir } from 'silgi/runtime/meta';
 import { scanExports, createUnimport, toExports } from 'unimport';
 import * as p from '@clack/prompts';
 import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import * as dotenv from 'dotenv';
+import { genImport, genTypeImport, genObjectFromRawEntries, genAugmentation } from 'knitwork';
 import { findTypeExports, findExports, resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
 import { createJiti } from 'dev-jiti';
 import { h as hasInstalledModule } from './compatibility.mjs';
@@ -18,7 +19,6 @@ import { withTrailingSlash, isRelative } from 'ufo';
 import { readFile, readdir } from 'node:fs/promises';
 import { globby } from 'globby';
 import ignore from 'ignore';
-import { genImport, genTypeImport, genAugmentation, genObjectFromRawEntries } from 'knitwork';
 import { klona } from 'klona';
 import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
 import { createStorage, builtinDrivers } from 'unstorage';
@@ -223,6 +223,52 @@ async function h3Framework(silgi, skip = false) {
   }
 }
 
+async function nextJS(silgi, skip = false) {
+  if (!isPresents(["next"]) && skip === false)
+    return;
+  if (isPresents(["next"])) {
+    silgi.hook("after:schema.ts", (data) => {
+      data.unshift("type FrameworkContextExtends = {}");
+    });
+  }
+  const defaultConfig = {
+    serverExternalPackages: [
+      "mlly",
+      "silgi",
+      "h3",
+      "@silgi/openapi",
+      "@silgi/scalar",
+      "@silgi/ecosystem"
+    ],
+    eslint: {
+      ignoreDuringBuilds: true
+    },
+    output: "standalone"
+  };
+  await silgi.callHook("nextjs:prepare", {
+    config: defaultConfig
+  });
+  const template = [
+    genImport("defu", ["defu"]),
+    genTypeImport("next", ["NextConfig"]),
+    "export function withNextConfig(config: NextConfig) {",
+    "return defu(config,",
+    // TODO: make the output code more properly intend.
+    genObjectFromRawEntries(
+      Object.entries(defaultConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
+      ""
+    ),
+    ")}",
+    ""
+  ];
+  addTemplate({
+    filename: "next.config.ts",
+    where: ".silgi",
+    write: true,
+    getContents: () => template.join("\n")
+  });
+}
+
 async function nitroFramework(silgi, skip = false) {
   if (!isPresents(["nitro"]) && skip === false)
     return;
@@ -276,7 +322,8 @@ const frameworkSetup = [
   emptyFramework,
   h3Framework,
   nitroFramework,
-  nuxtFramework
+  nuxtFramework,
+  nextJS
 ];
 
 async function registerModuleExportScan(silgi) {
@@ -1059,33 +1106,21 @@ async function prepareScanFile(silgi) {
     }),
     ""
   ];
+  const generateExport = (name, items, defaultEmpty = "{}") => {
+    const hasItems = items.length > 0;
+    return [
+      `export const ${name} = ${hasItems ? "deepMergeObjects([" : defaultEmpty}`,
+      ...items.map((item) => `  ${item},`),
+      hasItems ? "])" : defaultEmpty === "{}" ? "}" : "",
+      ""
+    ];
+  };
   const importData = [
     "",
-    scanned.schemas.length > 0 ? "export const schemas = deepMergeObjects([" : "export const schemas = {",
-    ...scanned.schemas.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.schemas.length > 0 ? "])" : "}",
-    "",
-    scanned.services.length > 0 ? "export const services = deepMergeObjects([" : "export const services = {",
-    ...scanned.services.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.services.length > 0 ? "])" : "}",
-    "",
-    scanned.shareds.length > 0 ? "export const shareds = deepMergeObjects([" : "export const shareds = {",
-    ...scanned.shareds.map((name) => {
-      return `  ${name},`;
-    }),
-    "",
-    scanned.shareds.length > 0 ? "])" : "}",
-    "",
-    scanned.routers.length > 0 ? "export const routers = deepMergeObjects([" : "export const routers = {",
-    ...scanned.routers.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.routers.length > 0 ? "])" : "}",
-    ""
+    ...generateExport("schemas", scanned.schemas),
+    ...generateExport("services", scanned.services),
+    ...generateExport("shareds", scanned.shareds, "undefined"),
+    ...generateExport("routers", scanned.routers)
   ];
   await silgi.callHook("after:scan.ts", importData);
   importData.unshift(...importsContent);
@@ -1394,14 +1429,14 @@ async function createSilgiCLI(config = {}, opts = {}) {
       packageImport: "silgi/runtime/internal/debug"
     });
   }
-  for (const framework of frameworkSetup) {
-    await framework(silgi);
-  }
   await scanAndSyncOptions(silgi);
   await scanModules$1(silgi);
   await scanSilgiExports();
   await installModules(silgi, true);
   useCLIRuntimeConfig(silgi);
+  for (const framework of frameworkSetup) {
+    await framework(silgi);
+  }
   await writeScanFiles(silgi);
   silgi.storage = await createStorageCLI(silgi);
   silgi.hooks.hook("close", async () => {
@@ -1791,20 +1826,6 @@ async function prepareSchema(silgi) {
     ""
   ];
   const importData = [
-    generateTypes(
-      await resolveSchema(
-        {
-          ...silgi.options.namespaces?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {}
-        }
-      ),
-      {
-        interfaceName: "InferredNamespaces",
-        addExport: false,
-        addDefaults: false,
-        allowExtraKeys: false,
-        indentation: 0
-      }
-    ),
     "",
     `type SchemaExtends = typeof import('${silgiScanTS}')['schemas']`,
     `type BaseServices = typeof import('${silgiScanTS}')['services']`,
@@ -1877,7 +1898,6 @@ async function prepareSchema(silgi) {
       FrameworkContext: [{}, { extends: ["FrameworkContextExtends"] }],
       SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
       ServicesObject: [{}, { extends: ["BaseServices"] }],
-      SilgiNamespaces: [{}, { extends: ["InferredNamespaces"] }],
       SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
       SilgiURIs: [{}, { extends: ["SilgiURIsMerge"] }],
       SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],

package/dist/cli/index.mjs

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

package/dist/cli/init.mjs

@@ -13,6 +13,7 @@ import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'unimport';
 import 'dotenv';
+import 'knitwork';
 import 'mlly';
 import 'dev-jiti';
 import './compatibility.mjs';
@@ -23,7 +24,6 @@ import 'exsolve';
 import 'ufo';
 import 'globby';
 import 'ignore';
-import 'knitwork';
 import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
@@ -69,8 +69,6 @@ const command = defineCommand({
       "export default defineSilgiConfig({",
       `  preset: '${framework}',`,
       `  compatibilityDate: '${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}',`,
-      "  // Please create a namespace for your project",
-      "  namespaces: [],",
       "",
       "})",
       ""

package/dist/cli/install.mjs

@@ -15,6 +15,7 @@ import 'unimport';
 import '@clack/prompts';
 import 'node:fs';
 import 'dotenv';
+import 'knitwork';
 import 'mlly';
 import 'dev-jiti';
 import './compatibility.mjs';
@@ -26,7 +27,6 @@ import 'ufo';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
-import 'knitwork';
 import 'klona';
 import 'silgi/runtime';
 import 'unstorage';

package/dist/cli/watch.mjs

@@ -17,6 +17,7 @@ import 'unimport';
 import '@clack/prompts';
 import 'node:fs';
 import 'dotenv';
+import 'knitwork';
 import 'mlly';
 import 'dev-jiti';
 import './compatibility.mjs';
@@ -28,7 +29,6 @@ import 'ufo';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
-import 'knitwork';
 import 'klona';
 import 'silgi/runtime';
 import 'unstorage';

package/dist/core/index.d.mts

@@ -1,4 +1,4 @@
-import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, ServiceSetup, CustomRequestInit, SilgiRuntimeContext, AllPrefixes, NamespacesForPrefix, RoutesForPrefixAndNamespace, HTTPMethod, ExtractPathParamKeys, MergeAll, SilgiRuntimeShareds, RouteConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase } from 'silgi/types';
+import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, ServiceSetup, CustomRequestInit, SilgiRuntimeContext, AllPrefixes, NamespacesForPrefix, RoutesForPrefixAndNamespace, MethodSchemas, MergeAll, ServiceMethods, SilgiRuntimeShareds, RouteConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase } from 'silgi/types';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Storage, StorageValue } from 'unstorage';
 import { UseContext } from 'unctx';
@@ -106,62 +106,6 @@ declare function handleResponse(val: unknown, event: SilgiEvent, config: SilgiHa
 declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
 declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): T;
 
-/**
- * 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;
-    };
-};
 /**
  * Creates a type-safe API route schema definition.
  *
@@ -288,9 +232,6 @@ declare function createSchema<P extends AllPrefixes, N extends NamespacesForPref
  */
 declare function deepMergeObjects<T extends readonly Record<string, any>[]>(schemas: [...T]): MergeAll<T>;
 
-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>;
-};
 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: {
     path: Path;
     methods: Methods;

package/dist/types/index.d.mts

@@ -15,8 +15,9 @@ import { H3Event, HTTPMethod as HTTPMethod$1, Session } from 'h3';
 import * as nitropack_types from 'nitropack/types';
 import { NitroRuntimeConfig } from 'nitropack/types';
 import { Defu } from 'defu';
-import { Stats } from 'node:fs';
 import * as next from 'next';
+import { NextConfig } from 'next';
+import { Stats } from 'node:fs';
 import { ESMImport, ESMCodeGenOptions } from 'knitwork';
 import { Unimport } from 'unimport';
 import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
@@ -304,6 +305,9 @@ interface SilgiCLIHooks extends SilgiHooks {
     'app:templatesGenerated': (app: SilgiCLI, templates: ResolvedSilgiTemplate[], options?: GenerateAppOptions) => HookResult;
     'scanFiles:done': (app: SilgiCLI) => HookResult;
     'prepare:commands': (commands: Commands[]) => HookResult;
+    'nextjs:prepare': (data: {
+        config: NextConfig;
+    }) => HookResult;
 }
 type TSReference = {
     types: string;
@@ -316,6 +320,9 @@ interface GenerateAppOptions {
     filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
 }
 
+type ServiceMethods<Schema extends SilgiSchema$1, 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
  */
@@ -368,24 +375,20 @@ interface ServiceSetup<Schema extends SilgiSchema$1 = SilgiSchema$1, Route exten
     storage?: StorageConfig$1<ServiceHandlerInput<Schema, Route, Method, HiddenParameters>>;
 }
 /**
- * Servis tanımı (tek bir route+method için)
+ * Represents a fully resolved service definition that maps route paths
+ * to their method handlers and configurations.
+ *
+ * This interface is designed to be compatible with the structure created
+ * by the createService function.
  */
-type ServiceDefinition<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route], Resolved extends boolean = false> = {
-    [R in Route]: {
-        [M in Method]: ServiceSetup<Schema, R, M, Resolved>;
+interface ResolvedServiceDefinition$1 {
+    [routePath: string]: {
+        [method: string]: {
+            handler: (...args: any[]) => Promise<any>;
+            modules?: Partial<SilgiRuntimeActions$1>;
+            storage?: StorageConfig$1<any>;
+        };
     };
-};
-/**
- * Çoklu servisleri birleştirmek için yardımcı tip
- */
-type MergeServiceDefinitions<T extends object[]> = T extends [infer F, ...infer R] ? F & MergeServiceDefinitions<R extends object[] ? R : []> : unknown;
-/**
- * Servis oluşturmak için parametreler
- */
-interface CreateServiceParams<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route], Resolved extends boolean = false> {
-    route: Route;
-    method: Method;
-    setup: ServiceSetup<Schema, Route, Method, Resolved>;
 }
 /**
  * SilgiURL tipi
@@ -497,14 +500,9 @@ interface SilgiModule<TOptions extends ModuleOptionsCustom = ModuleOptionsCustom
 
 interface SilgiRuntimeMethods {
 }
-interface SilgiNamespaces {
-}
 type CommandType = 'run' | 'prepare' | 'install' | 'dev' | 'init';
-interface DefaultNamespaces extends SilgiNamespaces {
-}
 interface SilgiRouterTypes {
 }
-type BaseSilgiMethodType = 'post' | 'delete' | 'put' | 'get' | keyof SilgiRuntimeMethods | (string & {});
 interface DefaultHooks {
 }
 type DeepPartial<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? {
@@ -563,7 +561,6 @@ interface SilgiCLIOptions extends PresetOptions {
         [key: string]: any;
     };
     storages: string[];
-    namespaces: string[];
     hooks: NestedHooks<SilgiCLIHooks$1>;
     plugins: {
         path: string;
@@ -828,43 +825,140 @@ interface CapturedErrorContext {
 }
 type CaptureError = (silgi: Silgi, error: Error, context: CapturedErrorContext) => void;
 
+/**
+ * Main interface containing all route definitions.
+ * Example:
+ * {
+ *   "/api/blueSpace/basket/getBook": { ... }
+ * }
+ */
+interface Routers {
+}
+/**
+ * Extracts the prefix (first segment) from a URL, including the leading slash.
+ * @example ExtractPrefix<'/api/blueSpace/basket'> // '/api'
+ */
+type ExtractPrefix<URL extends string> = URL extends `/${infer Prefix}/${string}` ? `/${Prefix}` : never;
+/**
+ * Extracts the namespace (second segment) from a URL, including the leading slash.
+ * @example ExtractNamespace<'/api/blueSpace/basket'> // '/blueSpace'
+ */
+type ExtractNamespace<URL extends string> = URL extends `/${string}/${infer Namespace}/${string}` ? `/${Namespace}` : never;
+/**
+ * Extracts the route (third and subsequent segments) from a URL, including the leading slash.
+ * @example ExtractRoute<'/api/blueSpace/basket/getBook'> // '/basket/getBook'
+ */
+type ExtractRoute<URL extends string> = URL extends `/${string}/${string}/${infer Route}` ? `/${Route}` : never;
+/**
+ * Gets all route keys from Routers as strings.
+ * All keys should start with a leading slash.
+ */
+type RouterKeys = keyof Routers & string;
+/**
+ * Extracts all prefixes (first segment) in the system, including the leading slash.
+ * @example AllPrefixes // '/api' | ...
+ */
+type AllPrefixes = RouterKeys extends infer K ? K extends string ? ExtractPrefix<K> : never : never;
+/**
+ * Extracts all namespaces (second segment) for a given prefix, including the leading slash.
+ * @example NamespacesForPrefix<'/api'> // '/blueSpace' | ...
+ */
+type NamespacesForPrefix<P extends string> = RouterKeys extends infer K ? K extends string ? K extends `${P}/${infer N}/${string}` ? `/${N}` : never : never : never;
+/**
+ * Extracts all routes (third and subsequent segments) for a given prefix and namespace, including the leading slash.
+ * @example RoutesForPrefixAndNamespace<'/api', '/blueSpace'> // '/basket/getBook' | ...
+ */
+type RoutesForPrefixAndNamespace<P extends string, N extends string> = RouterKeys extends infer K ? K extends string ? K extends `${P}${N}${infer R}` ? `${R}` : never : never : never;
+/**
+ * Extracts path parameter keys from a URL pattern string.
+ *
+ * @example
+ * ExtractPathParamKeys<'/users/:id/posts/:postId'> // 'id' | 'postId'
+ * 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 RouteConfig<T> {
+    route: T;
+    setup?: any;
+}
+
 interface SilgiSchema {
 }
 interface MergedSilgiSchema {
 }
 /**
- * Utility type for schema generics to avoid repetition
+ * 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 SchemaParams<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TPathParams extends StandardSchemaV1 | undefined = undefined, TQueryParams extends StandardSchemaV1 | undefined = undefined, TSource extends StandardSchemaV1 | undefined = undefined> {
-    input?: TInput;
-    output?: TOutput;
-    pathParams?: TPathParams;
-    queryParams?: TQueryParams;
-    source?: TSource;
+interface WithPathParams<PathParamsStr extends string> {
+    /** Schema for path parameters */
+    pathParams: StandardSchemaV1<PathParamsObject<PathParamsStr>>;
 }
 /**
- * Defines the structure for schema components within a service endpoint.
- * Allows specifying schemas for input, output, path parameters, query parameters, and source data.
- * @template TInput - The schema type for the request body/input.
- * @template TOutput - The schema type for the response body/output.
- * @template TPathParams - The schema type for URL path parameters.
- * @template TQueryParams - The schema type for URL query parameters.
- * @template TSource - The schema type for the source data or context.
+ * 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$1]?: 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.
  */
-type SchemaDefinition<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TPathParams extends StandardSchemaV1 | undefined = undefined, TQueryParams extends StandardSchemaV1 | undefined = undefined, TSource extends StandardSchemaV1 | undefined = undefined> = SchemaParams<TInput, TOutput, TPathParams, TQueryParams, TSource>;
+interface ResolvedSchema {
+    [routePath: string]: MethodSchemas<string>;
+}
 /**
- * ResolvedServiceDefinition: ServiceDefinition with generics resolved.
- * Represents the fully resolved service definition structure.
+ * Represents a schema definition that has been fully resolved,
+ * typically after processing and validating all schema components.
  */
 interface ResolvedSchemaDefinition {
-    [route: string]: {
-        [method in HTTPMethod$1]: {
-            input?: StandardSchemaV1;
-            output?: StandardSchemaV1;
-            pathParams?: StandardSchemaV1;
-            queryParams?: StandardSchemaV1;
-            source?: StandardSchemaV1;
-        };
+    [key: string]: {
+        [method: string]: BaseMethodSchema;
     };
 }
 
@@ -907,7 +1001,8 @@ interface ExtendShared {
 
 interface FrameworkContext {
 }
-type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiRuntimeMethods | StandardHTTPMethod : StandardHTTPMethod;
 interface SilgiRoute {
     route: string;
     method?: HTTPMethod;
@@ -918,7 +1013,7 @@ interface Silgi {
     router: RouterContext<SilgiRoute>;
     routerPrefixs: string[];
     schemas: ResolvedSchemaDefinition;
-    services: ResolvedServiceDefinition;
+    services: ResolvedServiceDefinition$1;
     shared: SilgiRuntimeShareds;
     plugins: SilgiAppPlugin[];
     framework: FrameworkContext;
@@ -1093,64 +1188,4 @@ interface GraphQLJSON {
     references: any;
 }
 
-/**
- * Main interface containing all route definitions.
- * Example:
- * {
- *   "/api/blueSpace/basket/getBook": { ... }
- * }
- */
-interface Routers {
-}
-/**
- * Extracts the prefix (first segment) from a URL, including the leading slash.
- * @example ExtractPrefix<'/api/blueSpace/basket'> // '/api'
- */
-type ExtractPrefix<URL extends string> = URL extends `/${infer Prefix}/${string}` ? `/${Prefix}` : never;
-/**
- * Extracts the namespace (second segment) from a URL, including the leading slash.
- * @example ExtractNamespace<'/api/blueSpace/basket'> // '/blueSpace'
- */
-type ExtractNamespace<URL extends string> = URL extends `/${string}/${infer Namespace}/${string}` ? `/${Namespace}` : never;
-/**
- * Extracts the route (third and subsequent segments) from a URL, including the leading slash.
- * @example ExtractRoute<'/api/blueSpace/basket/getBook'> // '/basket/getBook'
- */
-type ExtractRoute<URL extends string> = URL extends `/${string}/${string}/${infer Route}` ? `/${Route}` : never;
-/**
- * Gets all route keys from Routers as strings.
- * All keys should start with a leading slash.
- */
-type RouterKeys = keyof Routers & string;
-/**
- * Extracts all prefixes (first segment) in the system, including the leading slash.
- * @example AllPrefixes // '/api' | ...
- */
-type AllPrefixes = RouterKeys extends infer K ? K extends string ? ExtractPrefix<K> : never : never;
-/**
- * Extracts all namespaces (second segment) for a given prefix, including the leading slash.
- * @example NamespacesForPrefix<'/api'> // '/blueSpace' | ...
- */
-type NamespacesForPrefix<P extends string> = RouterKeys extends infer K ? K extends string ? K extends `${P}/${infer N}/${string}` ? `/${N}` : never : never : never;
-/**
- * Extracts all routes (third and subsequent segments) for a given prefix and namespace, including the leading slash.
- * @example RoutesForPrefixAndNamespace<'/api', '/blueSpace'> // '/basket/getBook' | ...
- */
-type RoutesForPrefixAndNamespace<P extends string, N extends string> = RouterKeys extends infer K ? K extends string ? K extends `${P}${N}${infer R}` ? `${R}` : never : never : never;
-/**
- * Extracts path parameter keys from a URL pattern string.
- *
- * @example
- * ExtractPathParamKeys<'/users/:id/posts/:postId'> // 'id' | 'postId'
- * 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 RouteConfig<T> {
-    route: T;
-    setup?: any;
-}
-
-export type { AllPaths, AllPrefixes, AppConfig, Awaitable, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateServiceParams, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HTTPMethod, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergeServiceDefinitions, MergedSilgiSchema, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchemaDefinition, ResolvedSilgiTemplate, RouteConfig, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, SchemaDefinition, SchemaParams, ServiceDefinition, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceSetup, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRoute, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiStorageBase, SilgiTemplate, SilgiURL, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes };
+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, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HTTPMethod, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergedSilgiSchema, MethodSchemas, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition$1 as ResolvedServiceDefinition, ResolvedSilgiTemplate, RouteConfig, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceMethods, ServiceSetup, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRoute, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, 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.34.10",
+  "version": "0.34.12",
   "private": false,
   "sideEffects": false,
   "exports": {