silgi 0.41.0 → 0.41.2

package/dist/cli/build.mjs

@@ -1212,8 +1212,16 @@ async function prepareScanFile(silgi) {
     }),
     ""
   ];
-  const generateExport = (name, items, defaultEmpty = "{}") => {
+  const generateExport = (name, items, defaultEmpty = "{}", asArray = false) => {
     const hasItems = items.length > 0;
+    if (asArray) {
+      return [
+        `export const ${name} = [`,
+        ...items.map((item) => `  ${item},`),
+        "]",
+        ""
+      ];
+    }
     if (hasItems) {
       return [
         `export const ${name} = {`,
@@ -1233,7 +1241,8 @@ async function prepareScanFile(silgi) {
     ...generateExport("schemas", scanned.schemas),
     ...generateExport("services", scanned.services),
     ...generateExport("shareds", scanned.shareds, "undefined"),
-    ...generateExport("resolvers", scanned.resolvers, "[]"),
+    ...generateExport("resolvers", scanned.resolvers, "[]", true),
+    // array olarak export
     ...generateExport("middlewares", scanned.middlewares)
   ];
   await silgi.callHook("after:scan.ts", importData);

package/dist/cli/index.mjs

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

package/dist/core/index.d.mts

@@ -185,42 +185,24 @@ declare function createService<Path extends string = string, Input extends Stand
 };
 
 type WildcardVariants<Path extends string, Acc extends string = ''> = Path extends `${infer Head}/${infer Tail}` ? Tail extends '' ? `${Acc}${Head}` : `${Acc}${Head}/${Tail}` | `${Acc}${Head}/*` | `${Acc}${Head}/**` | WildcardVariants<Tail, `${Acc}${Head}/`> : `${Acc}${Path}`;
-declare function createMiddleware<S extends WildcardVariants<keyof ServicesObject>, Method extends HttpMethod, UsedMethod extends readonly Method[]>(params: {
-    path: S;
-    method: UsedMethod;
+type MiddlewarePath<S extends WildcardVariants<keyof ServicesObject>> = S | 'global';
+type CreateMiddlewareParams<S extends WildcardVariants<keyof ServicesObject>, UsedMethod extends readonly HttpMethod[] = readonly HttpMethod[], Key extends string = string> = {
+    path: MiddlewarePath<S>;
+    methods?: UsedMethod;
     setup: MiddlewareSetup;
-    global?: undefined;
-}): {
-    [K in `${UsedMethod[number]}:${S}`]: {
-        setup: MiddlewareSetup;
-        method: UsedMethod[number];
-        global: undefined;
-    };
-};
-declare function createMiddleware<Global extends string>(params: {
-    global: Global;
-    setup: MiddlewareSetup;
-    method?: undefined | readonly [];
-    path?: undefined;
-}): {
-    [K in `GLOBAL:${Global}`]: {
-        setup: MiddlewareSetup;
-        global: Global;
-        method: false;
-    };
+    key: Key;
 };
-declare function createMiddleware<Global extends string, Method extends HttpMethod, UsedMethod extends readonly Method[]>(params: {
-    global: Global;
-    setup: MiddlewareSetup;
-    method: UsedMethod;
-    path?: undefined;
-}): {
-    [K in `${UsedMethod[number]}:${Global}`]: {
+type CreateMiddlewareResult<Path extends string, UsedMethod extends readonly HttpMethod[] = readonly HttpMethod[], Key extends string = string> = {
+    [K in `${Key}:${Path}`]: {
         setup: MiddlewareSetup;
-        global: Global;
-        method: UsedMethod[number];
+        methods?: UsedMethod;
+        key: Key;
+        path: Path;
     };
 };
+declare function createMiddleware<S extends WildcardVariants<keyof ServicesObject>, UsedMethod extends readonly HttpMethod[] = readonly HttpMethod[], Path extends MiddlewarePath<S> = MiddlewarePath<S>, Key extends string = string>(params: CreateMiddlewareParams<S, UsedMethod, Key> & {
+    path: Path;
+}): CreateMiddlewareResult<Path, UsedMethod, Key>;
 
 declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
 

package/dist/core/index.mjs

@@ -297,17 +297,7 @@ async function createSilgi(config) {
   if (!silgi.router) {
     silgi.router = createRouter();
   }
-  for (const routeKey in silgi.services) {
-    let method = "";
-    let route = routeKey;
-    if (routeKey.includes(":")) {
-      const [methodPart, ...routeParts2] = routeKey.split(":");
-      method = methodPart.toUpperCase();
-      if (method === "GLOBAL") {
-        method = "";
-      }
-      route = routeParts2.join(":");
-    }
+  for (const [route, object] of Object.entries(silgi.services)) {
     const routeParts = route.split("/").filter(Boolean);
     if (routeParts.length > 0) {
       const prefix = `/${routeParts[0]}`;
@@ -315,41 +305,41 @@ async function createSilgi(config) {
         silgi.routerPrefixs.push(prefix);
       }
     }
-    const methodObject = silgi.services[routeKey];
-    if (methodObject) {
-      addRoute(silgi.router, method, route, {
-        method,
+    const methods = object.methods?.length ? object.methods : ["ALL"];
+    for (const method of methods) {
+      const globalMethod = method === "ALL" ? "" : method.toUpperCase();
+      addRoute(silgi.router, globalMethod, route, {
+        method: [method],
         route,
-        service: methodObject
+        service: object
       });
     }
   }
   if (!silgi._middlewareRouter) {
     silgi._middlewareRouter = createRouter();
   }
-  for (const routeKey in silgi.middlewares) {
-    const routeObject = silgi.middlewares[routeKey];
-    let method = "";
-    let route = routeKey;
-    if (routeKey.includes(":")) {
-      const [methodPart, ...routeParts] = routeKey.split(":");
-      method = methodPart.toUpperCase();
-      if (method === "GLOBAL") {
-        method = "";
-      }
-      route = routeParts.join(":");
+  for (const [route, routeObject] of Object.entries(silgi.middlewares)) {
+    let _route = "";
+    if (route.includes(":")) {
+      const [methodPart, ...routeParts] = route.split(":");
+      methodPart.toUpperCase();
+      _route = routeParts.join(":");
     }
-    if (routeObject.global) {
+    if (_route === "global") {
       silgi.globalMiddlewares.push({
         middleware: routeObject.setup,
-        method,
-        route
+        method: routeObject.methods?.length ? routeObject.methods : ["ALL"],
+        route: _route
       });
-    } else {
-      addRoute(silgi._middlewareRouter, method, route, {
+      continue;
+    }
+    const methods = routeObject.methods?.length ? routeObject.methods : ["ALL"];
+    for (const method of methods) {
+      const globalMethod = method === "ALL" ? "" : method.toUpperCase();
+      addRoute(silgi._middlewareRouter, globalMethod, _route, {
         middleware: routeObject.setup,
-        method,
-        route
+        method: [method],
+        route: _route
       });
     }
   }
@@ -922,7 +912,15 @@ async function middleware(event, url) {
         if (_previous !== void 0 && _previous !== kNotFound) {
           return _previous;
         }
-        if (m.method && m.method !== "GLOBAL" && m.method !== event.req.method || !m.middleware) {
+        let allowedMethods = m.method ?? [];
+        if (!Array.isArray(allowedMethods)) {
+          allowedMethods = [allowedMethods];
+        }
+        const methodIsAllowed = allowedMethods.length === 0 || allowedMethods.includes("ALL") || allowedMethods.includes(event.req.method);
+        if (!methodIsAllowed) {
+          return;
+        }
+        if (!m.middleware) {
           return;
         }
         try {
@@ -952,7 +950,12 @@ async function middleware(event, url) {
           if (_previous !== void 0 && _previous !== kNotFound) {
             return _previous;
           }
-          if (match.data.method && match.data.method !== event.req.method || !match.data.middleware) {
+          let allowedMethods = match.data.method ?? [];
+          if (!Array.isArray(allowedMethods)) {
+            allowedMethods = [allowedMethods];
+          }
+          const methodIsAllowed = allowedMethods.length === 0 || allowedMethods.includes("ALL") || allowedMethods.includes(event.req.method);
+          if (!methodIsAllowed || !match.data.middleware) {
             return;
           }
           event.context.params = match.params;
@@ -1072,36 +1075,14 @@ function createService(params) {
 }
 
 function createMiddleware(params) {
-  if (params.global) {
-    const globalKey = params.global;
-    if (!params.method || params.method.length === 0) {
-      return {
-        [`GLOBAL:${globalKey}`]: {
-          setup: params.setup,
-          global: globalKey,
-          method: false
-        }
-      };
-    }
-    const result2 = {};
-    for (const m of params.method) {
-      result2[`${m}:${globalKey}`] = {
-        setup: params.setup,
-        global: globalKey,
-        method: m
-      };
-    }
-    return result2;
-  }
-  const result = {};
-  for (const m of params.method) {
-    result[`${m}:${params.path}`] = {
+  return {
+    [`${params.key}:${params.path}`]: {
       setup: params.setup,
-      method: m,
-      global: void 0
-    };
-  }
-  return result;
+      methods: params.methods?.length ? params.methods : ["ALL"],
+      key: params.key,
+      path: params.path
+    }
+  };
 }
 
 function createShared(shared) {

package/dist/types/index.d.mts

@@ -284,7 +284,7 @@ interface ServiceSetup<Input extends StandardSchemaV1 = StandardSchemaV1, Output
 interface ResolvedServiceDefinition {
     [routePath: string]: {
         setup: ServiceSetup<any, any, any, any, any, any>;
-        methods: string[];
+        methods: HTTPMethod[];
         input?: StandardSchemaV1;
         output?: StandardSchemaV1;
         queryParams?: {
@@ -515,8 +515,7 @@ interface MiddlewareSetup {
 interface ResolvedMiddlewareDefinition {
     [methodAndPath: string]: {
         setup: MiddlewareSetup;
-        global?: string | undefined;
-        method?: HTTPMethod | false;
+        methods?: HTTPMethod[];
     };
 }
 
@@ -691,13 +690,13 @@ interface ResolvedSchemaDefinition {
     [methodAndRoutePath: string]: BaseMethodSchema;
 }
 
-type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'ALL';
 type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiRuntimeMethods | StandardHTTPMethod : StandardHTTPMethod;
 interface MetaData extends Record<string, unknown> {
 }
 interface SilgiRoute {
     route?: string;
-    method?: HTTPMethod;
+    method?: HTTPMethod | HTTPMethod[];
     service?: ResolvedServiceDefinition[string];
     middleware?: MiddlewareSetup;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.41.0",
+  "version": "0.41.2",
   "private": false,
   "sideEffects": false,
   "exports": {