silgi 0.34.9 → 0.34.11

package/dist/cli/build.mjs

@@ -592,6 +592,7 @@ function transformImportPath(path, packageName, relativeTo) {
     const distMatch = importPath.match(/.*?(\/dist\/.*)/);
     if (distMatch && distMatch[1]) {
       importPath = packageName + distMatch[1].substring("/dist".length);
+      importPath = removeExtension(importPath, true);
     }
   } else if (relativeTo) {
     importPath = removeExtension(relativeWithDot(relativeTo, path));
@@ -764,8 +765,10 @@ async function _resolveSilgiModule(silgiModule, silgi) {
           };
         }
       }
-      const runtimeFolder = new URL("runtime", src);
-      await scanSilgiExports(runtimeFolder.pathname, buildTimeModuleMeta._packageName);
+      if (!isPresents(["npm-package"])) {
+        const runtimeFolder = new URL("runtime", src);
+        await scanSilgiExports(runtimeFolder.pathname, buildTimeModuleMeta._packageName);
+      }
     } catch (error) {
       const code = error.code;
       if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
@@ -1056,33 +1059,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);
@@ -1788,20 +1779,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']`,
@@ -1874,7 +1851,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.9";
+const version = "0.34.11";
 const packageJson = {
 	version: version};
 

package/dist/cli/init.mjs

@@ -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/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/kit/index.d.mts

@@ -309,7 +309,7 @@ declare const baseHeaderBannerComment: string[];
 declare function processFilePath(src: string): string;
 declare function isPresents(names: PresetName[]): boolean;
 declare function isRuntimePresents(names: PresetName[]): boolean;
-declare function removeExtension(filePath: string): string;
+declare function removeExtension(filePath: string, force?: boolean): string;
 
 export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addImports, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineFramework, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, isPresents, isRuntimePresents, listMigrations, migrationDown, migrationUp, normalizeTemplate, prettyPath, processFilePath, relativeWithDot, removeExtension, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
 export type { FunctionConfig, JsonPatch, MigrationData, MigrationInfo, MigrationOptions, MigrationResult };

package/dist/kit/index.mjs

@@ -67,9 +67,9 @@ function isRuntimePresents(names) {
   const silgi = useSilgi();
   return names.includes(silgi.options.present);
 }
-function removeExtension(filePath) {
+function removeExtension(filePath, force = false) {
   const silgi = useSilgiCLI();
-  if (silgi.options.typescript.removeFileExtension) {
+  if (silgi.options.typescript.removeFileExtension || force) {
     const ext = extname(filePath);
     return ext ? filePath.slice(0, -ext.length) : filePath;
   }

package/dist/types/index.d.mts

@@ -316,6 +316,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 +371,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 +496,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 +557,6 @@ interface SilgiCLIOptions extends PresetOptions {
         [key: string]: any;
     };
     storages: string[];
-    namespaces: string[];
     hooks: NestedHooks<SilgiCLIHooks$1>;
     plugins: {
         path: string;
@@ -828,43 +821,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 }
  */
-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;
+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;
 }
 /**
- * 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.
+ * Interface for adding path parameters schema to method definitions.
  */
-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 WithPathParams<PathParamsStr extends string> {
+    /** Schema for path parameters */
+    pathParams: StandardSchemaV1<PathParamsObject<PathParamsStr>>;
+}
 /**
- * ResolvedServiceDefinition: ServiceDefinition with generics resolved.
- * Represents the fully resolved service definition structure.
+ * 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.
+ */
+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 {
-    [route: string]: {
-        [method in HTTPMethod$1]: {
-            input?: StandardSchemaV1;
-            output?: StandardSchemaV1;
-            pathParams?: StandardSchemaV1;
-            queryParams?: StandardSchemaV1;
-            source?: StandardSchemaV1;
-        };
+    [key: string]: {
+        [method: string]: BaseMethodSchema;
     };
 }
 
@@ -907,7 +997,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 +1009,7 @@ interface Silgi {
     router: RouterContext<SilgiRoute>;
     routerPrefixs: string[];
     schemas: ResolvedSchemaDefinition;
-    services: ResolvedServiceDefinition;
+    services: ResolvedServiceDefinition$1;
     shared: SilgiRuntimeShareds;
     plugins: SilgiAppPlugin[];
     framework: FrameworkContext;
@@ -1093,64 +1184,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.9",
+  "version": "0.34.11",
   "private": false,
   "sideEffects": false,
   "exports": {