@deessejs/functions 0.0.42 → 0.0.44

package/dist/context/define.js

@@ -1,22 +1,23 @@
 "use strict";
+// defineContext.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
         withExtensions: (config) => {
-            // Créer un contexte runtime vide mais avec le type complet
-            const runtimeContext = {};
-            // Appliquer les extensions en préservant les types
-            const result = {
-                context: runtimeContext,
-            };
+            // runtime builder (inchangé)
+            const runtimeBuilder = {};
+            const dummyContext = {};
             for (const extension of config.extensions) {
-                // Appeler functions avec undefined, puis appliquer sur le contexte
-                const methodsFactory = extension.functions(undefined);
-                const methods = methodsFactory(runtimeContext);
-                Object.assign(result, methods);
+                // appele runtime, pour construire les méthodes effectives
+                const extensionMethods = extension.functions(dummyContext);
+                Object.assign(runtimeBuilder, extensionMethods);
             }
-            return result;
+            // On retourne runtimeBuilder mais on force le type public attendu.
+            return {
+                ...runtimeBuilder,
+                context: {},
+            };
         },
     };
 }

package/dist/context/types.d.ts

@@ -14,11 +14,11 @@ export type MutationDefinition<TContext, TArgs extends ZodType, TOutput, TError
 };
 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>) => QueryDefinition<C, TArgs, TOutput, TError>;
-    mutation: <TArgs extends ZodType, TOutput, TError extends Exception>(def: MutationDefinition<C, TArgs, TOutput, TError>) => MutationDefinition<C, TArgs, TOutput, TError>;
+    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) => TGroup;
+    group?: <TGroup extends Record<string, CommandsDefinition>>(defs: TGroup) => any;
 };

package/dist/extensions/rpc.d.ts

@@ -16,5 +16,4 @@ 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;
-    _contextType: C;
 }>;

package/dist/extensions/rpc.js

@@ -15,7 +15,5 @@ exports.rpc = (0, _1.extensions)({
             return { _type: "mutation", ...options };
         },
         group: (definitions) => definitions,
-        // Exposer le type de contexte pour l'inférence
-        _contextType: context,
     }),
 });

package/dist/extensions/types.d.ts

@@ -10,10 +10,10 @@ type FnCallSignatureMatchesWith<C, F> = F extends {
 export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends {
     functions: infer F;
 } ? FnCallSignatureMatchesWith<TContext, F> : {}) & MergeExtensions<TContext, Tail> : {};
-/** Ici : functions est une fonction qui retourne les méthodes pour un contexte donné */
+/** Ici : functions est *explicitement* une call signature générique */
 export type ExtensionBase = {
     context: any;
-    functions: <TOptions>(options: TOptions) => <C>(context: C) => FunctionsForContext<C>;
+    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.42",
+    "version": "0.0.44",
     "description": "A powerful utility library for building type-safe APIs and functions with context management",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",