silgi 0.37.52 → 0.38.1

package/dist/cli/build.mjs

@@ -164,12 +164,6 @@ async function h3Framework(silgi, skip = false) {
         specifier: "nitropack/types"
       }
     ]);
-    data.events.push({
-      key: "H3Event",
-      value: "H3Event",
-      extends: true,
-      isSilgiContext: false
-    });
   });
   silgi.hook("prepare:types", (opts) => {
     addTemplate({
@@ -435,18 +429,18 @@ async function registerModuleExportScan(silgi) {
         });
         options.runtimeHooks.push({ key: configKey, value: importName });
       }
-      if (hasTypeExport("ModuleRuntimeActions")) {
-        const importName = hash(`${configKey}ModuleRuntimeActions`);
+      if (hasTypeExport("SetupModuleOption")) {
+        const importName = hash(`${configKey}SetupModuleOption`);
         options.addImportItemType({
           imports: [
             {
               as: importName,
-              name: "ModuleRuntimeActions"
+              name: "SetupModuleOption"
             }
           ],
           specifier
         });
-        options.actions.push({ key: configKey, value: importName });
+        options.setupModuleOption.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeMethods")) {
         const importName = hash(`${configKey}ModuleRuntimeMethods`);
@@ -461,6 +455,19 @@ async function registerModuleExportScan(silgi) {
         });
         options.methods.push({ key: configKey, value: importName });
       }
+      if (hasTypeExport("RouteRules")) {
+        const importName = hash(`${configKey}RouteRules`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "RouteRules"
+            }
+          ],
+          specifier
+        });
+        options.routeRules.push({ key: configKey, value: importName });
+      }
     }
   });
 }
@@ -560,7 +567,7 @@ function resolveGroupSyntax(group) {
   return groups;
 }
 
-const DEFAULT_FUNCTION_EXPORT_NAMES = ["createSchema", "createService", "createRoute", "createShared"];
+const DEFAULT_FUNCTION_EXPORT_NAMES = ["createSchema", "createService", "createRoute", "createShared", "createMiddleware"];
 const DEFAULT_INTERFACE_EXTENDS_NAMES = ["ExtendShared", "ExtendContext"];
 function generateUniqueIdentifier(filePath, exportName) {
   const fileBaseName = basename(filePath);
@@ -571,7 +578,8 @@ function categorizeExports(exportedEntities, filePath, functionExportCategories
   createService: "service",
   createSchema: "schema",
   createShared: "shared",
-  createRoute: "route"
+  createRoute: "route",
+  createMiddleware: "middleware"
 }, interfaceExportCategories = {
   ExtendShared: "shared",
   ExtendContext: "context"
@@ -640,6 +648,9 @@ function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, pa
         case "route":
           options.routers.push(uniqueId);
           break;
+        case "middleware":
+          options.middlewares?.push?.(uniqueId);
+          break;
       }
       options.addImportItem({
         specifier: transformImportPath(path, packageName, silgiInstance.options.silgi.serverDir),
@@ -740,6 +751,8 @@ async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()
       functionExportCategories[name] = "shared";
     else if (name === "createRoute")
       functionExportCategories[name] = "route";
+    else if (name === "createMiddleware")
+      functionExportCategories[name] = "middleware";
     else functionExportCategories[name] = name;
   });
   const interfaceExportCategories = {};
@@ -1116,6 +1129,7 @@ async function prepareScanFile(silgi) {
     shareds: [],
     routers: [],
     schemas: [],
+    middlewares: [],
     addImportItem,
     addImportItemType
   };
@@ -1150,7 +1164,8 @@ async function prepareScanFile(silgi) {
     ...generateExport("schemas", scanned.schemas),
     ...generateExport("services", scanned.services),
     ...generateExport("shareds", scanned.shareds, "undefined"),
-    ...generateExport("routers", scanned.routers)
+    ...generateExport("routers", scanned.routers),
+    ...generateExport("middlewares", scanned.middlewares)
   ];
   await silgi.callHook("after:scan.ts", importData);
   importData.unshift(...importsContent);
@@ -1420,6 +1435,7 @@ async function createSilgiCLI(config = {}, opts = {}) {
   const silgi = {
     scannedURIs: /* @__PURE__ */ new Map(),
     services: {},
+    middleware: [],
     shareds: {},
     schemas: {},
     unimport: void 0,
@@ -1674,6 +1690,9 @@ async function prepareCoreFile(silgi) {
           },
           {
             name: "schemas"
+          },
+          {
+            name: "middlewares"
           }
         ]
       },
@@ -1763,6 +1782,7 @@ async function prepareCoreFile(silgi) {
     " framework: option?.framework,",
     " shared: shareds,",
     " services: services,",
+    " middlewares: middlewares,",
     " schemas: schemas,",
     ` plugins: [${plugins.join(", ")}],`,
     "",
@@ -1842,13 +1862,14 @@ async function prepareSchema(silgi) {
     addImportItemType,
     options: [],
     contexts: [],
-    actions: [],
+    setupModuleOption: [],
     shareds: [],
     events: [],
     hooks: [],
     runtimeHooks: [],
     runtimeOptions: [],
-    methods: []
+    methods: [],
+    routeRules: []
   };
   await silgi.callHook("before:schema.ts", data);
   const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan`);
@@ -1879,7 +1900,7 @@ async function prepareSchema(silgi) {
     }).join(",\n")}
 }` : "interface SilgiModuleEventsExtends {}",
     "",
-    `type RuntimeActionExtends = ${data.actions?.length ? data.actions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    `type SetupModuleOptionExtend = ${data.setupModuleOption?.length ? data.setupModuleOption.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
     "",
     `type RuntimeMethodExtends = ${data.methods?.length ? data.methods.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
     "",
@@ -1889,6 +1910,7 @@ async function prepareSchema(silgi) {
     "",
     `type SilgiRuntimeOptionExtends = ${data.runtimeOptions?.length ? data.runtimeOptions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
     "",
+    `type RouteRulesExtend = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
     silgi.options.typescript.generateRuntimeConfigTypes ? generateTypes(
       await resolveSchema(
         {
@@ -1939,14 +1961,15 @@ async function prepareSchema(silgi) {
       SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
       SilgiEvent: [{}, { extends: ["SilgiModuleEventsExtends"] }],
       SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
-      SilgiRuntimeActions: [{}, { extends: ["RuntimeActionExtends"] }],
+      SetupModuleOption: [{}, { extends: ["SetupModuleOptionExtend"] }],
       SilgiRuntimeOptions: [{}, { extends: ["SilgiRuntimeOptionExtends"] }],
       SilgiRuntimeHooks: [{}, { extends: ["SilgiRuntimeHooksExtends"] }],
       SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
       SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
       SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
       Routers: [{}, { extends: ["RoutersExtend"] }],
-      SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }]
+      SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }],
+      RouteRules: [{}, { extends: ["RouteRulesExtend"] }]
     }).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.37.52";
+const version = "0.38.1";
 const packageJson = {
 	version: version};
 

package/dist/core/index.d.mts

@@ -1,4 +1,4 @@
-import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, CustomRequestInit, SilgiRuntimeContext, AllPrefixes, NamespacesForPrefix, RoutesForPrefixAndNamespace, MethodSchemas, MergeAll, ServiceMethods, SilgiRuntimeShareds, RouteConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
+import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, CustomRequestInit, SilgiRuntimeContext, AllPrefixes, NamespacesForPrefix, RoutesForPrefixAndNamespace, MethodSchemas, MergeAll, MiddlewareDefinition, HttpMethod, ServiceMethods, SilgiRuntimeShareds, RouteConfig, SilgiURL, StorageConfig, SilgiCLI, SilgiStorageBase, SilgiRuntimeConfig } from 'silgi/types';
 import { Storage, StorageValue } from 'unstorage';
 import { UseContext } from 'unctx';
 
@@ -240,6 +240,26 @@ declare function createService<Schema extends SilgiSchema, Path extends keyof Sc
         [M in keyof Methods]: Methods[M];
     };
 };
+type WildcardVariants<Path extends string, Acc extends string = ''> = Path extends `${infer Head}/${infer Tail}` ? Tail extends '' ? `${Acc}${Head}` : `${Acc}${Head}/${Tail}` | `${Acc}${Head}/*` | `${Acc}${Head}/**` | WildcardVariants<Tail, `${Acc}${Head}/`> : `${Acc}${Path}`;
+type MiddlewareParams<Schema extends SilgiSchema, Path extends keyof Schema & string, S extends string = WildcardVariants<Path>, Service extends MiddlewareDefinition = MiddlewareDefinition, Method extends string = HttpMethod, UsedMethod extends readonly Method[] = readonly never[]> = ({
+    path: S;
+    method?: UsedMethod;
+    setup: Service;
+}) | ({
+    global: true;
+    key: S;
+    method?: UsedMethod;
+    setup: Service;
+});
+type MiddlewareReturn<S extends string, Service extends MiddlewareDefinition, UsedMethod extends readonly string[]> = {
+    [K in S]: {
+        method: boolean;
+        global: boolean;
+    } & (UsedMethod extends readonly [] | undefined ? Service : {
+        [M in UsedMethod[number]]: Service;
+    }) & (S extends string ? (never extends S ? object : object) : Service) & (Service);
+};
+declare function createMiddleware<Schema extends SilgiSchema, Path extends keyof Schema & string, S extends string = WildcardVariants<Path>, Service extends MiddlewareDefinition = MiddlewareDefinition, Method extends string = HttpMethod, UsedMethod extends readonly Method[] = readonly never[]>(params: MiddlewareParams<Schema, Path, S, Service, Method, UsedMethod>): MiddlewareReturn<S, Service, UsedMethod>;
 
 declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
 
@@ -292,4 +312,4 @@ declare function useRuntime(): SilgiRuntimeConfig;
 
 declare const autoImportTypes: string[];
 
-export { SilgiError, autoImportTypes, createError, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };
+export { SilgiError, autoImportTypes, createError, createMiddleware, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };

package/dist/core/index.mjs

@@ -1,7 +1,7 @@
 import { createConsola } from 'consola';
 import { defu } from 'defu';
 import { createHooks } from 'hookable';
-import { createRouter, addRoute, findRoute } from 'rou3';
+import { createRouter, addRoute, findRoute, findAllRoutes } from 'rou3';
 import { useRuntimeConfig, sharedRuntimeConfig } from 'silgi/runtime';
 import { getContext, createContext } from 'unctx';
 import { Buffer } from 'node:buffer';
@@ -260,9 +260,12 @@ async function createSilgi(config) {
   const hooks = createHooks();
   const silgi = {
     router: void 0,
+    _middlewareRouter: void 0,
     routerPrefixs: [],
     schemas: config.schemas ?? {},
     services: config.services ?? {},
+    middlewares: config.middlewares ?? {},
+    globalMiddlewares: config.globalMiddlewares ?? [],
     shared: config.shared ?? {},
     plugins: config.plugins ?? [],
     framework: config.framework ?? {},
@@ -308,12 +311,50 @@ async function createSilgi(config) {
         addRoute(silgi.router, _method, route, {
           method: _method,
           route,
-          service: methodObject,
+          setup: methodObject,
           schema: schemaWrapper
         });
       }
     }
   }
+  if (!silgi._middlewareRouter) {
+    silgi._middlewareRouter = createRouter();
+  }
+  for (const route in silgi.middlewares) {
+    const routeObject = silgi.middlewares[route];
+    if ("global" in routeObject || "method" in routeObject) {
+      const global = routeObject.global ?? false;
+      const method = routeObject.method ?? false;
+      if (global && !method) {
+        silgi.globalMiddlewares.push({
+          setup: routeObject.setup,
+          route
+        });
+      } else if (method) {
+        for (const methodKey in routeObject) {
+          if (["global", "setup", "method"].includes(methodKey))
+            continue;
+          const _method = (methodKey || "").toUpperCase();
+          const object = routeObject[methodKey];
+          silgi.globalMiddlewares.push({
+            setup: object.setup,
+            method: _method,
+            route
+          });
+        }
+      }
+    } else {
+      for (const method in routeObject) {
+        const _method = (method || "").toUpperCase();
+        const routeObjectMethod = routeObject[method];
+        addRoute(silgi._middlewareRouter, _method, route, {
+          setup: routeObjectMethod.setup,
+          method: _method,
+          route
+        });
+      }
+    }
+  }
   silgi.hooks.addHooks(silgi.options.hooks);
   await runSilgiPlugins(silgi);
   if (!silgi.storage) {
@@ -381,13 +422,32 @@ async function parseRequestInput(req) {
     const text = await req.text();
     if (!text)
       return void 0;
-    return JSON.parse(text);
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Invalid JSON",
+        data: text
+      });
+    }
+  }
+  if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    const text = await req.text();
+    return Object.fromEntries(new URLSearchParams(text));
   }
   if (contentType.startsWith("text/")) {
     return await req.text();
   }
   if (contentType.startsWith("application/octet-stream")) {
-    return new File([await req.arrayBuffer()], "uploaded.bin", { type: contentType });
+    const buffer = await req.arrayBuffer();
+    if (typeof File !== "undefined") {
+      return new File([buffer], "uploaded.bin", { type: contentType });
+    }
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(buffer);
+    }
+    return new Uint8Array(buffer);
   }
   return await req.text();
 }
@@ -534,8 +594,28 @@ function getUrlPrefix(path, method) {
 
 async function orchestrate(route, event, _input) {
   const silgiCtx = useSilgi();
+  if (route.method !== event.req.method) {
+    throw createError({
+      statusCode: 405,
+      statusMessage: "Method Not Allowed",
+      data: {
+        method: event.method,
+        expected: route.method,
+        route: route.route
+      }
+    });
+  }
+  if (!route.route) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Route not found",
+      data: {
+        route
+      }
+    });
+  }
   const silgiURL = getUrlPrefix(route.route, route.method);
-  const input = _input || (route.service.routerRule?.readBeforeBody === false ? {} : await parseRequestInput(event.req));
+  const input = _input || (route.setup.rules?.readBeforeBody === false ? {} : await parseRequestInput(event.req));
   const hookContext = { earlyReturnValue: false };
   const routerParams = _input ? input.path : getRouterParams(event);
   const queryParams = _input ? input.query : getQuery(event);
@@ -553,7 +633,7 @@ async function orchestrate(route, event, _input) {
     }
   };
   try {
-    const service = route.service;
+    const setup = route.setup;
     const cachePromise = cacheExecute(input, route, silgiURL, event);
     const beforeHookPromise = silgiCtx.callHook("fetch:before", {
       url: silgiURL,
@@ -583,7 +663,7 @@ async function orchestrate(route, event, _input) {
     }
     silgiCtx.shared.$fetch = silgiFetch;
     silgiCtx.shared.silgi = silgiCtx;
-    const result = await service?.handler(
+    const result = await setup?.handler(
       inputData,
       silgiCtx.shared,
       event,
@@ -598,12 +678,12 @@ async function orchestrate(route, event, _input) {
       route,
       hookContext
     });
-    if (service.storage && cacheData?.cachedKey) {
-      await useSilgiStorage(service.storage.base).setItem(
+    if (setup.storage && cacheData?.cachedKey) {
+      await useSilgiStorage(setup.storage.base).setItem(
         cacheData.cachedKey,
         result,
         // Cast to StorageValue if needed
-        service.storage.options
+        setup.storage.options
       );
     }
     return result;
@@ -633,7 +713,7 @@ async function orchestrate(route, event, _input) {
   }
 }
 async function cacheExecute(input, route, silgiURL, event) {
-  const setup = route.service;
+  const setup = route.setup;
   if (!setup.storage)
     return;
   const cacheKey = setup.storage ? await generateStorageKey({
@@ -829,7 +909,7 @@ function withDuplexIfBody(options) {
   return options;
 }
 async function silgiFetch(_request, options, context) {
-  const silgiCtx = useSilgi();
+  useSilgi();
   let request;
   if (typeof _request === "string") {
     _request = substitutePathParams(_request, options?.pathParams);
@@ -845,15 +925,6 @@ async function silgiFetch(_request, options, context) {
   } else {
     request = _request;
   }
-  const silgiURL = getUrlPrefix(request.url, request.method);
-  const match = findRoute(silgiCtx.router, request.method, silgiURL.path);
-  if (!match) {
-    throw createError({
-      message: "Route not found",
-      statusCode: 404,
-      statusMessage: "Route not found"
-    });
-  }
   const silgiEvent = new _SilgiEvent(request, context);
   let handlerRes;
   try {
@@ -863,11 +934,59 @@ async function silgiFetch(_request, options, context) {
   }
   return handleResponse(handlerRes, silgiEvent, {});
 }
+async function middleware(event, url) {
+  const silgiContext = useSilgi();
+  const pathname = url?.path || event.url.pathname;
+  let _chain = void 0;
+  const _middleware = silgiContext.globalMiddlewares;
+  if (_middleware) {
+    _chain = _chain || Promise.resolve();
+    for (const m of _middleware) {
+      _chain = _chain.then(async (_previous) => {
+        if (_previous !== void 0 && _previous !== kNotFound) {
+          return _previous;
+        }
+        if (m.method && m.method !== event.req.method) {
+          return;
+        }
+        if (m.method && m.method !== event.req.method) {
+          return;
+        }
+        await silgiContext.callHook("middleware:global:on", event, m.setup);
+        return m.setup.handler(event, silgiContext);
+      });
+    }
+  }
+  const _mRouter = silgiContext._middlewareRouter;
+  if (_mRouter) {
+    const matches = findAllRoutes(_mRouter, event.req.method, pathname);
+    if (matches.length > 0) {
+      _chain = _chain || Promise.resolve();
+      for (const match of matches) {
+        _chain = _chain.then(async (_previous) => {
+          if (_previous !== void 0 && _previous !== kNotFound) {
+            return _previous;
+          }
+          if (match.data.method && match.data.method !== event.req.method) {
+            return;
+          }
+          event.context.params = match.params;
+          event.context.matchedRoute = match.data;
+          await silgiContext.callHook("middleware:router:on", event, match.data.setup);
+          return match.data.setup.handler(event, silgiContext);
+        });
+      }
+    }
+  }
+  return _chain;
+}
 async function handler(event, url, input) {
   const silgiCtx = useSilgi();
   const pathname = url?.path || event.url.pathname;
   let _chain = void 0;
   _chain = Promise.resolve(await silgiCtx.callHook("request:on", event));
+  const data = middleware(event, url);
+  _chain = data;
   if (silgiCtx.router) {
     const match = findRoute(silgiCtx.router, url?.method || event.req.method, pathname);
     if (match) {
@@ -940,6 +1059,52 @@ function createService(params) {
     [path]: methods
   };
 }
+function createMiddleware(params) {
+  if (params.key) {
+    if (!params.method || params.method.length === 0) {
+      return {
+        [params.key]: {
+          method: false,
+          global: params.global,
+          setup: params.setup
+        }
+      };
+    }
+    const result2 = {
+      [params.key]: {
+        global: params.global,
+        method: true
+      }
+    };
+    for (const m of params.method) {
+      result2[params.key][m] = {
+        setup: params.setup,
+        global: true,
+        method: m
+      };
+    }
+    return result2;
+  }
+  if (!params.method || params.method.length === 0) {
+    return {
+      [params.path]: {
+        method: true,
+        global: false,
+        setup: params.setup
+      }
+    };
+  }
+  const result = {
+    [params.path]: {}
+  };
+  for (const m of params.method) {
+    result[params.path][m] = {
+      setup: params.setup,
+      method: m
+    };
+  }
+  return result;
+}
 
 function createShared(shared) {
   return shared;
@@ -984,4 +1149,4 @@ const autoImportTypes = [
   "ExtractQueryParamsFromURI"
 ];
 
-export { SilgiError, autoImportTypes, createError, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };
+export { SilgiError, autoImportTypes, createError, createMiddleware, createRoute, createSchema, createService, createShared, createSilgi, createStorage, deepMergeObjects, getEvent, getEventContext, getUrlPrefix, handleResponse, handler, isError, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage };

package/dist/index.d.mts

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

package/dist/index.mjs

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

@@ -44,7 +44,7 @@ type RequiredServiceType<T> = {
         [P in keyof T[K]]-?: any;
     } : never;
 };
-type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
+type EventHandlerResponse<T = unknown> = T | Promise<T>;
 type HookResult = Promise<void> | void;
 interface EnvOptions {
     prefix?: string;
@@ -280,7 +280,7 @@ interface StorageMounts {
 interface SilgiStorageBase {
 }
 type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
-interface StorageConfig<TInput> {
+interface StorageConfig<TInput = unknown> {
     options: TransactionOptions;
     base: 'memory' | keyof SilgiStorageBase;
     key?: StorageKeyGenerator<TInput>;
@@ -356,8 +356,8 @@ type ServiceHandler<Schema extends SilgiSchema, Route extends keyof Schema, Meth
  */
 interface ServiceSetup<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], Resolved extends boolean = false, HiddenParameters extends boolean = false> {
     handler: ServiceHandler<Schema, Route, Method, Resolved, HiddenParameters>;
-    routerRule?: RouteConfigService;
-    modules?: Partial<SilgiRuntimeActions>;
+    rules?: RouteConfigService;
+    modules?: Partial<SetupModuleOption>;
     storage?: StorageConfig<ServiceHandlerInput<Schema, Route, Method, HiddenParameters>>;
 }
 /**
@@ -371,9 +371,7 @@ interface ResolvedServiceDefinition {
     [routePath: string]: {
         [method: string]: {
             handler: (...args: any[]) => Promise<any>;
-            modules?: Partial<SilgiRuntimeActions>;
-            storage?: StorageConfig<any>;
-        };
+        } & Omit<ServiceSetup, 'handler'>;
     };
 }
 /**
@@ -388,6 +386,36 @@ interface SilgiURL {
     pathParams?: Record<string, string | undefined>;
     queryParams?: Record<string, string>;
 }
+interface RouteRules extends Record<string, unknown> {
+}
+type MiddlewareHandler<Response extends EventHandlerResponse = EventHandlerResponse> = (event: SilgiEvent, silgi: Silgi) => Response;
+/**
+ * Middleware Setup tipi
+ */
+interface MiddlewareSetup {
+    handler: MiddlewareHandler;
+    rules?: RouteRules;
+    modules?: Partial<SetupModuleOption>;
+    storage?: StorageConfig;
+}
+type MiddlewareDefinition = MiddlewareSetup;
+type ResolvedMiddlewareDefinition = {
+    [routePath: string]: {
+        global: boolean;
+        method: false;
+        setup: MiddlewareSetup;
+    };
+} | {
+    [routePath: string]: {
+        [method: string]: {
+            setup: MiddlewareSetup;
+            method: string;
+        } & {
+            global: boolean;
+            method: boolean;
+        };
+    };
+};
 
 interface SilgiCLI {
     _ignore?: Ignore;
@@ -396,6 +424,7 @@ interface SilgiCLI {
         path?: string;
     }[];
     services: ResolvedServiceDefinition;
+    middleware: SilgiRoute[];
     shareds: SilgiRuntimeShareds;
     schemas: Record<string, any>;
     scannedURIs: Map<string, string>;
@@ -484,7 +513,7 @@ interface ResolvedSilgiTemplate<Options = TemplateDefaultOptions> extends SilgiT
     modified?: boolean;
 }
 
-interface SilgiRuntimeActions {
+interface SetupModuleOption {
 }
 interface SilgiModuleOptions {
 }
@@ -629,6 +658,8 @@ interface SilgiRuntimeHooks {
      * @returns Promise
      */
     'close': (silgi: Silgi) => HookResult;
+    'middleware:global:on': (event: SilgiEvent, setup: MiddlewareSetup) => HookResult;
+    'middleware:router:on': (event: SilgiEvent, setup: MiddlewareSetup) => HookResult;
     'request:on': (event: SilgiEvent) => HookResult;
     'fetch:before': (context: ModuleHookContext) => HookResult;
     'fetch:after': (context: ModuleHookContext) => HookResult;
@@ -673,13 +704,21 @@ type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiR
 interface SilgiMeta extends Record<string, unknown> {
 }
 interface SilgiRoute {
-    route: string;
-    method: HTTPMethod;
-    service: ServiceSetup;
-    schema: ResolvedSchemaDefinition;
+    route?: string;
+    method?: HTTPMethod;
+    schema?: ResolvedSchemaDefinition;
+    setup: ServiceSetup;
+}
+interface MiddlewareRoute {
+    route?: string;
+    method?: HTTPMethod;
+    setup: MiddlewareSetup;
 }
 interface Silgi {
     router: RouterContext<SilgiRoute>;
+    _middlewareRouter: RouterContext<MiddlewareRoute>;
+    middlewares: ResolvedMiddlewareDefinition;
+    globalMiddlewares: MiddlewareRoute[];
     routerPrefixs: string[];
     schemas: ResolvedSchemaDefinition;
     services: ResolvedServiceDefinition;
@@ -810,6 +849,7 @@ interface SilgiCLIHooks extends SilgiHooks {
         shareds: string[];
         routers: string[];
         schemas: string[];
+        middlewares: string[];
         addImportItem: (data: GenImport | GenImport[]) => void;
         addImportItemType: (data: GenImport | GenImport[]) => void;
     }) => HookResult;
@@ -833,7 +873,7 @@ interface SilgiCLIHooks extends SilgiHooks {
             key: string;
             value: string;
         }[];
-        actions: {
+        setupModuleOption: {
             key: string;
             value: string;
         }[];
@@ -841,6 +881,10 @@ interface SilgiCLIHooks extends SilgiHooks {
             key: string;
             value: string;
         }[];
+        routeRules: {
+            key: string;
+            value: string;
+        }[];
         events: {
             key: string;
             value: string;
@@ -1185,12 +1229,4 @@ interface LoadConfigOptions {
     consola?: ConsolaInstance;
 }
 
-interface GraphQLJSON {
-    queries: any;
-    mutations: any;
-    types: any;
-    inputs: any;
-    references: any;
-}
-
-export type { AllPaths, AllPrefixes, AppConfig, Awaitable, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, GenImport, GenerateAppOptions, GraphQLJSON, HTTPMethod, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergedSilgiSchema, MethodSchemas, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition, ResolvedSilgiTemplate, RouteConfig, RouteConfigService, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceMethods, ServiceSetup, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiMeta, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRoute, SilgiRouterTypes, SilgiRuntimeActions, 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, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, GenImport, GenerateAppOptions, HTTPMethod, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergedSilgiSchema, MethodSchemas, MiddlewareDefinition, MiddlewareHandler, MiddlewareRoute, MiddlewareSetup, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedMiddlewareDefinition, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchema, ResolvedSchemaDefinition, ResolvedServiceDefinition, ResolvedSilgiTemplate, RouteConfig, RouteConfigService, RouteRules, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceMethods, ServiceSetup, SetupModuleOption, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiMeta, 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.37.52",
+  "version": "0.38.1",
   "private": false,
   "sideEffects": false,
   "exports": {