silgi 0.4.8 → 0.4.11

package/dist/_chunks/index.mjs

@@ -1,6 +1,6 @@
 const name = "silgi";
 const type = "module";
-const version = "0.4.8";
+const version = "0.4.11";
 const packageManager = "pnpm@9.15.1";
 const sideEffects = false;
 const exports = {

package/dist/cli/prepare.mjs

@@ -250,10 +250,29 @@ async function generateRouterDTS(silgi) {
     silgi.hook("close", async () => {
       const { object } = await data();
       const uris = object.uris;
-      const tag = "srn";
-      const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _value]) => {
+      const groupedPaths = /* @__PURE__ */ new Map();
+      Object.entries(uris || {}).forEach(([key, params]) => {
         const [service, resource, method, action] = key.split("/");
-        const routePath = `${tag}/${service}/${resource}/${action}/${_value}`;
+        const basePath = params ? `${service}/${resource}/${action}/${params}` : `${service}/${resource}/${action}`;
+        const fullPath = `${service}/${resource}/${action}`;
+        if (!groupedPaths.has(basePath)) {
+          groupedPaths.set(basePath, /* @__PURE__ */ new Map());
+        }
+        groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
+      });
+      const keys = [
+        "  keys: {",
+        Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
+          return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
+      ${method}: '/${path}'`).join(",")}
+    }`;
+        }).join(",\n"),
+        "  }",
+        ""
+      ].join("\n");
+      const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
+        const [service, resource, method, action] = key.split("/");
+        const routePath = `${service}/${resource}/${action}`;
         if (!acc[routePath]) {
           acc[routePath] = {};
         }
@@ -281,11 +300,16 @@ ${methodEntries}
         "  interface InternalApi extends RouterTypes {}",
         "}"
       ];
+      const content = [
+        keys.slice(0, -1),
+        // son satırdaki boş satırı kaldır
+        ...routerTypes
+      ].join(",\n");
       const context = [
         "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractRouterParamsFromURI } from 'silgi/types'",
         "",
         "export interface RouterTypes {",
-        routerTypes.join(",\n"),
+        content,
         "}",
         "",
         "declare module 'silgi/types' {",

package/dist/core/index.d.mts

@@ -14,49 +14,34 @@ declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
 
 declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 
-type StaticRoutes = keyof SilgiRouterTypes;
-type ExtractStaticPath<T extends string> = T extends `${infer Start}/:${string}` ? Start : T;
-type RouteWithParams<T extends string> = T | `${T}/${string}`;
-type ValidRoute = StaticRoutes | RouteWithParams<ExtractStaticPath<StaticRoutes & string>>;
-type FindMatchingRoute<T extends string> = {
-    [K in StaticRoutes]: ExtractStaticPath<K & string> extends never ? never : T extends `${ExtractStaticPath<K & string>}${string}` ? K : never;
-}[StaticRoutes];
-type Method<R extends ValidRoute> = R extends StaticRoutes ? keyof SilgiRouterTypes[R] : keyof SilgiRouterTypes[FindMatchingRoute<R & string>];
-type DefaultMethodType = 'get' | 'post' | 'put' | 'delete';
-type FetchResponseData<R extends ValidRoute, M extends Method<R>> = R extends StaticRoutes ? SilgiRouterTypes[R][M & keyof SilgiRouterTypes[R]]['output'] : SilgiRouterTypes[FindMatchingRoute<R & string>][M & keyof SilgiRouterTypes[FindMatchingRoute<R & string>]]['output'];
-type RequestBodyOption<R extends ValidRoute, M extends Method<R>> = R extends StaticRoutes ? SilgiRouterTypes[R][M & keyof SilgiRouterTypes[R]] extends {
-    input: infer I;
-} ? {
-    body: I;
-} : {
-    body?: never;
-} : SilgiRouterTypes[FindMatchingRoute<R & string>][M & keyof SilgiRouterTypes[FindMatchingRoute<R & string>]] extends {
-    input: infer I;
-} ? {
-    body: I;
-} : {
-    body?: never;
-};
-type ExtractParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? {
+type TrimAfterFourSlashes<T extends string> = T extends `/${infer S1}/${infer S2}/${infer S3}/${infer _}` ? `/${S1}/${S2}/${S3}` : T;
+type AllPaths = SilgiRouterTypes extends {
+    keys: infer U;
+} ? keyof U extends never ? string : keyof U : string;
+type ExtractPathParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
     [K in Param]: string;
-} & ExtractParams<Rest> : T extends `${string}:${infer Param}` ? {
+} & ExtractPathParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
     [K in Param]: string;
 } : object;
-type RouterParams<R extends ValidRoute, M extends Method<R>> = R extends StaticRoutes ? SilgiRouterTypes[R][M & keyof SilgiRouterTypes[R]] extends {
-    params: infer P;
+type ValidRoute = AllPaths | (string & {});
+type Method<R extends ValidRoute> = TrimAfterFourSlashes<R> extends keyof SilgiRouterTypes ? keyof SilgiRouterTypes[TrimAfterFourSlashes<R>] : never;
+type FetchResponseData<R extends ValidRoute, M extends Method<R>> = TrimAfterFourSlashes<R> extends keyof SilgiRouterTypes ? SilgiRouterTypes[TrimAfterFourSlashes<R>][M]['output'] : never;
+type RequestBodyOption<R extends ValidRoute, M extends Method<R>> = TrimAfterFourSlashes<R> extends keyof SilgiRouterTypes ? SilgiRouterTypes[TrimAfterFourSlashes<R>][M] extends {
+    input: infer I;
 } ? {
-    params: P;
-} : R extends `${string}:${string}` ? {
-    params: ExtractParams<R>;
-} : {
-    params?: never;
+    body: I;
 } : {
-    params: ExtractParams<FindMatchingRoute<R & string>>;
-};
+    body?: never;
+} : never;
+type RouterParams<R extends ValidRoute> = ExtractPathParams<R>;
 type SilgiFetchOptions<R extends ValidRoute, M extends Method<R>> = {
     method: M;
-} & RequestBodyOption<R, M> & RouterParams<R, M> & Omit<FetchOptions, 'query' | 'body' | 'method'>;
-type SilgiFetchClient = <R extends ValidRoute, M extends Method<R> | DefaultMethodType = 'get'>(url: R, options: SilgiFetchOptions<R, M extends Method<R> ? M : Extract<Method<R>, DefaultMethodType>>) => Promise<FetchResponseData<R, M extends Method<R> ? M : Extract<Method<R>, DefaultMethodType>>>;
+} & RequestBodyOption<R, M> & (RouterParams<R> extends object ? {
+    params: RouterParams<R>;
+} : {
+    params?: never;
+}) & Omit<FetchOptions, 'query' | 'body' | 'method'>;
+type SilgiFetchClient = <R extends ValidRoute, M extends Method<R> = 'get' extends Method<R> ? 'get' : Method<R>>(url: R, options: SilgiFetchOptions<R, M>) => Promise<FetchResponseData<R, M>>;
 declare function createSilgiFetch(options: FetchOptions | ((options: FetchOptions) => FetchOptions), localFetch?: typeof globalThis.$fetch): SilgiFetchClient;
 
 interface Options {

package/dist/core/index.d.ts

@@ -14,49 +14,34 @@ declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
 
 declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 
-type StaticRoutes = keyof SilgiRouterTypes;
-type ExtractStaticPath<T extends string> = T extends `${infer Start}/:${string}` ? Start : T;
-type RouteWithParams<T extends string> = T | `${T}/${string}`;
-type ValidRoute = StaticRoutes | RouteWithParams<ExtractStaticPath<StaticRoutes & string>>;
-type FindMatchingRoute<T extends string> = {
-    [K in StaticRoutes]: ExtractStaticPath<K & string> extends never ? never : T extends `${ExtractStaticPath<K & string>}${string}` ? K : never;
-}[StaticRoutes];
-type Method<R extends ValidRoute> = R extends StaticRoutes ? keyof SilgiRouterTypes[R] : keyof SilgiRouterTypes[FindMatchingRoute<R & string>];
-type DefaultMethodType = 'get' | 'post' | 'put' | 'delete';
-type FetchResponseData<R extends ValidRoute, M extends Method<R>> = R extends StaticRoutes ? SilgiRouterTypes[R][M & keyof SilgiRouterTypes[R]]['output'] : SilgiRouterTypes[FindMatchingRoute<R & string>][M & keyof SilgiRouterTypes[FindMatchingRoute<R & string>]]['output'];
-type RequestBodyOption<R extends ValidRoute, M extends Method<R>> = R extends StaticRoutes ? SilgiRouterTypes[R][M & keyof SilgiRouterTypes[R]] extends {
-    input: infer I;
-} ? {
-    body: I;
-} : {
-    body?: never;
-} : SilgiRouterTypes[FindMatchingRoute<R & string>][M & keyof SilgiRouterTypes[FindMatchingRoute<R & string>]] extends {
-    input: infer I;
-} ? {
-    body: I;
-} : {
-    body?: never;
-};
-type ExtractParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? {
+type TrimAfterFourSlashes<T extends string> = T extends `/${infer S1}/${infer S2}/${infer S3}/${infer _}` ? `/${S1}/${S2}/${S3}` : T;
+type AllPaths = SilgiRouterTypes extends {
+    keys: infer U;
+} ? keyof U extends never ? string : keyof U : string;
+type ExtractPathParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
     [K in Param]: string;
-} & ExtractParams<Rest> : T extends `${string}:${infer Param}` ? {
+} & ExtractPathParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
     [K in Param]: string;
 } : object;
-type RouterParams<R extends ValidRoute, M extends Method<R>> = R extends StaticRoutes ? SilgiRouterTypes[R][M & keyof SilgiRouterTypes[R]] extends {
-    params: infer P;
+type ValidRoute = AllPaths | (string & {});
+type Method<R extends ValidRoute> = TrimAfterFourSlashes<R> extends keyof SilgiRouterTypes ? keyof SilgiRouterTypes[TrimAfterFourSlashes<R>] : never;
+type FetchResponseData<R extends ValidRoute, M extends Method<R>> = TrimAfterFourSlashes<R> extends keyof SilgiRouterTypes ? SilgiRouterTypes[TrimAfterFourSlashes<R>][M]['output'] : never;
+type RequestBodyOption<R extends ValidRoute, M extends Method<R>> = TrimAfterFourSlashes<R> extends keyof SilgiRouterTypes ? SilgiRouterTypes[TrimAfterFourSlashes<R>][M] extends {
+    input: infer I;
 } ? {
-    params: P;
-} : R extends `${string}:${string}` ? {
-    params: ExtractParams<R>;
-} : {
-    params?: never;
+    body: I;
 } : {
-    params: ExtractParams<FindMatchingRoute<R & string>>;
-};
+    body?: never;
+} : never;
+type RouterParams<R extends ValidRoute> = ExtractPathParams<R>;
 type SilgiFetchOptions<R extends ValidRoute, M extends Method<R>> = {
     method: M;
-} & RequestBodyOption<R, M> & RouterParams<R, M> & Omit<FetchOptions, 'query' | 'body' | 'method'>;
-type SilgiFetchClient = <R extends ValidRoute, M extends Method<R> | DefaultMethodType = 'get'>(url: R, options: SilgiFetchOptions<R, M extends Method<R> ? M : Extract<Method<R>, DefaultMethodType>>) => Promise<FetchResponseData<R, M extends Method<R> ? M : Extract<Method<R>, DefaultMethodType>>>;
+} & RequestBodyOption<R, M> & (RouterParams<R> extends object ? {
+    params: RouterParams<R>;
+} : {
+    params?: never;
+}) & Omit<FetchOptions, 'query' | 'body' | 'method'>;
+type SilgiFetchClient = <R extends ValidRoute, M extends Method<R> = 'get' extends Method<R> ? 'get' : Method<R>>(url: R, options: SilgiFetchOptions<R, M>) => Promise<FetchResponseData<R, M>>;
 declare function createSilgiFetch(options: FetchOptions | ((options: FetchOptions) => FetchOptions), localFetch?: typeof globalThis.$fetch): SilgiFetchClient;
 
 interface Options {

package/dist/core/index.mjs

@@ -1124,12 +1124,14 @@ async function createSilgi(config) {
 }
 
 function createSilgiFetch(options, localFetch) {
-  return (url, opts = {}) => {
-    opts = typeof options === "function" ? options(opts) : { ...options, ...opts };
-    if (!opts.method)
-      opts.method = "get";
-    const $fetch = getFetch(url, opts, localFetch);
-    return $fetch(fillPath(url, opts?.path), opts);
+  return (url, opts) => {
+    const finalOpts = {
+      ...typeof options === "function" ? options(opts) : options,
+      ...opts,
+      method: opts.method || "get"
+    };
+    const $fetch = getFetch(url, finalOpts, localFetch);
+    return $fetch(fillPath(url, opts.params), finalOpts);
   };
 }
 function getFetch(url, opts, localFetch) {

package/dist/ecosystem/nitro/index.mjs

@@ -48,7 +48,7 @@ const module = {
         imports: ["silgi"]
       });
       nitro.options.imports.presets.push({
-        from: "silgi/type",
+        from: "silgi/types",
         imports: autoImportTypes.map((type) => type),
         type: true
       });

package/dist/ecosystem/nuxt/module.mjs

@@ -20,7 +20,7 @@ const module = defineNuxtModule({
     nuxt.options.nitro.modules ||= [];
     nuxt.options.nitro.modules.push(await resolvePath("silgi/ecosystem/nitro"));
     nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ path: relativeWithDot(nuxt.options.buildDir, join(silgi.build.dir, "silgi.d.ts")) });
+      references.push({ path: relativeWithDot(nuxt.options.buildDir, join(silgi.build.typesDir, "silgi.d.ts")) });
     });
     nuxt.options.imports.presets.push({
       from: "silgi/types",

package/dist/meta/index.d.mts

@@ -1,3 +1,3 @@
-const version = "0.4.8";
+const version = "0.4.11";
 
 export { version };

package/dist/meta/index.d.ts

@@ -1,3 +1,3 @@
-const version = "0.4.8";
+const version = "0.4.11";
 
 export { version };

package/dist/runtime/internal/nuxt.d.ts

@@ -1,18 +1,18 @@
-import type { AvailableRouterMethod } from 'nitropack';
 import type { FetchError } from 'ofetch';
 import type { SilgiRouterTypes } from 'silgi/types';
-import { type AsyncData, type FetchResult, type UseFetchOptions } from 'nuxt/app';
-type RouteString<T extends keyof SilgiRouterTypes> = T | (string & {});
-export type KeysOf<T> = Array<T extends T ? keyof T extends string ? keyof T : never : never>;
-export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
-export declare function useSilgiFetch<ResT = void, ErrorT = FetchError, ReqT extends keyof SilgiRouterTypes = keyof SilgiRouterTypes, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, DataT = SilgiRouterTypes[ReqT][Method] extends {
-    output: any;
-} ? SilgiRouterTypes[ReqT][Method]['output'] : any, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = SilgiRouterTypes[ReqT][Method] extends {
-    output: infer T;
-} ? T : never>(url: RouteString<ReqT> | (() => RouteString<ReqT>), options?: Omit<UseFetchOptions<any, any, any, any, ReqT>, 'method' | 'body'> & {
-    method?: keyof SilgiRouterTypes[ReqT];
-    body?: SilgiRouterTypes[ReqT][Method] extends {
-        input: any;
-    } ? SilgiRouterTypes[ReqT][Method]['input'] : never;
-}): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, ErrorT | null>;
+import { type AsyncData } from 'nuxt/app';
+type TrimAfterFourSlashes<T extends string> = T extends `/${infer S1}/${infer S2}/${infer S3}/${infer _}` ? `/${S1}/${S2}/${S3}` : T;
+type AllPaths = SilgiRouterTypes extends {
+    keys: infer U;
+} ? keyof U extends never ? string : keyof U : string;
+type ExtractPathParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractPathParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : unknown;
+export declare function useSilgiFetch<P extends AllPaths | (string & {}), BasePath extends keyof SilgiRouterTypes = TrimAfterFourSlashes<P> extends keyof SilgiRouterTypes ? TrimAfterFourSlashes<P> : never, M extends keyof SilgiRouterTypes[BasePath] = keyof SilgiRouterTypes[BasePath]>(path: P, options?: {
+    method?: M;
+    params?: ExtractPathParams<P>;
+    body?: SilgiRouterTypes[BasePath][M]['input'];
+}): AsyncData<SilgiRouterTypes[BasePath][M]["output"], FetchError | null>;
 export {};

package/dist/runtime/internal/nuxt.mjs

@@ -1,8 +1,11 @@
 import { useFetch } from "nuxt/app";
-export function useSilgiFetch(url, options) {
-  const resolvedUrl = typeof url === "function" ? url() : url;
-  return useFetch(resolvedUrl, {
-    ...options,
-    method: options?.method?.toUpperCase() ?? "GET"
+function replacePathParams(template, params) {
+  return template.replace(/:([^/]+)/g, (_, param) => params[param] || `:${param}`);
+}
+export function useSilgiFetch(path, options) {
+  const resolvedPath = options?.params ? replacePathParams(path, options.params) : path;
+  return useFetch(resolvedPath, {
+    method: options?.method,
+    body: options?.body
   });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.4.8",
+  "version": "0.4.11",
   "sideEffects": false,
   "exports": {
     "./cli": {