@deessejs/functions 0.0.37 → 0.0.39

package/dist/context/define.js

@@ -7,16 +7,24 @@ function defineContext() {
         withExtensions: (config) => {
             // runtime builder (inchangé)
             const runtimeBuilder = {};
-            const dummyContext = {};
+            // Utiliser un contexte runtime vide, mais conserver le type complet
+            const runtimeContext = {};
             for (const extension of config.extensions) {
-                // appele runtime, pour construire les méthodes effectives
-                const extensionMethods = extension.functions(dummyContext);
+                // Passer le contexte runtime complet (même vide) pour conserver les types
+                const extensionMethods = extension.functions(runtimeContext);
                 Object.assign(runtimeBuilder, extensionMethods);
             }
-            // On retourne runtimeBuilder mais on force le type public attendu.
+            // Créer un objet context qui préserve les types pour l'inférence
+            const contextProxy = new Proxy({}, {
+                get(_, prop) {
+                    // Retourner undefined pour les propriétés inconnues, mais préserver le type
+                    return runtimeContext[prop];
+                }
+            });
+            // On retourne runtimeBuilder avec un contexte qui préserve les types
             return {
                 ...runtimeBuilder,
-                context: {},
+                context: contextProxy,
             };
         },
     };

package/dist/context/types.d.ts

@@ -13,3 +13,12 @@ export type MutationDefinition<TContext, TArgs extends ZodType, TOutput, TError
     _type: "mutation";
 };
 export type CommandsDefinition = QueryDefinition<any, any, any, any> | MutationDefinition<any, any, any, any>;
+export type FunctionsForContext<C> = {
+    query: <TArgs extends ZodType, TOutput, TError extends Exception>(def: QueryDefinition<C, TArgs, TOutput, TError>) => any;
+    mutation: <TArgs extends ZodType, TOutput, TError extends Exception>(def: MutationDefinition<C, TArgs, TOutput, TError>) => any;
+    on?: <TEvent extends string, TPayload>(config: {
+        event: TEvent;
+        handler: (ctx: C, payload: TPayload) => AsyncResult<any, any>;
+    }) => any;
+    group?: <TGroup extends Record<string, CommandsDefinition>>(defs: TGroup) => any;
+};

package/dist/extensions/index.d.ts

@@ -1,6 +1,7 @@
 import { ZodType } from "zod";
 import { Extension, InferOptions } from "./types";
-export declare function extensions<TSchema extends ZodType | undefined = undefined, TContextAddon extends Record<string, unknown> = Record<string, unknown>, TFunctionsFactory extends (<C>(context: C) => any) = (<C>(context: C) => any)>(config: {
+import { FunctionsForContext } from "../context";
+export declare function extensions<TSchema extends ZodType | undefined = undefined, TContextAddon extends Record<string, unknown> = Record<string, unknown>, TFunctionsFactory extends (<C>(context: C) => FunctionsForContext<C>) = (<C>(context: C) => FunctionsForContext<C>)>(config: {
     name: string;
     schema?: TSchema;
     context?: (options: InferOptions<TSchema>) => TContextAddon;

package/dist/extensions/index.js

@@ -1,4 +1,5 @@
 "use strict";
+// extensions/index.ts (ou extensions.ts)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
 function extensions(config) {

package/dist/extensions/rpc.d.ts

@@ -16,4 +16,5 @@ export declare const rpc: import("./types").Extension<undefined, Record<string,
         handler: (ctx: C, args: z.infer<TArgs>) => AsyncResult<TOutput_1, TError_1>;
     }) => MutationDefinition<C, TArgs, TOutput_1, TError_1>;
     group: <T extends Record<string, APINode>>(definitions: T) => T;
+    context: C;
 }>;

package/dist/extensions/rpc.js

@@ -15,5 +15,7 @@ exports.rpc = (0, _1.extensions)({
             return { _type: "mutation", ...options };
         },
         group: (definitions) => definitions,
+        // Pour le typing, on expose le type de contexte
+        context: context,
     }),
 });

package/dist/extensions/types.d.ts

@@ -1,4 +1,5 @@
 import z, { ZodType } from "zod";
+import { FunctionsForContext } from "../context";
 /** Utilitaire d'inférence d'appel générique (déjà présent chez toi) */
 type FnCallSignatureMatchesWith<C, F> = F extends {
     (context: C): infer R;
@@ -12,7 +13,7 @@ export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExt
 /** Ici : functions est *explicitement* une call signature générique */
 export type ExtensionBase = {
     context: any;
-    functions: <C>(context: C) => any;
+    functions: <C>(context: C) => FunctionsForContext<C>;
 };
 /** Helpers pour extensions/InferOptions et définition d'Extension */
 export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@deessejs/functions",
-    "version": "0.0.37",
+    "version": "0.0.39",
     "description": "A powerful utility library for building type-safe APIs and functions with context management",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",