@deessejs/functions 0.0.60 → 0.0.61

package/dist/context/define.js

@@ -3,14 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
-        // FIX CRUCIAL :
-        // On contraint TExtensions pour que chaque extension ait une méthode 'functions'
-        // qui accepte TContext. Cela force TS à instancier le générique <C> de rpc immédiatement.
+        // On demande des extensions dont la fonction 'functions' accepte TContext.
+        // Comme 'rpc' (qui sort maintenant "propre" de extensions()) est générique <C>,
+        // TypeScript va remplacer <C> par <TContext> pour satisfaire cette contrainte.
         withExtensions: (config) => {
             const runtimeBuilder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
-                // Au runtime, on vérifie juste que c'est une fonction
                 if (extension && typeof extension.functions === "function") {
                     const extensionMethods = extension.functions(dummyContext);
                     Object.assign(runtimeBuilder, extensionMethods);

package/dist/extensions/index.d.ts

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

package/dist/extensions/index.js

@@ -1,12 +1,14 @@
 "use strict";
-// extensions/index.ts (ou extensions.ts)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
+// On n'importe plus FunctionsForContext ici pour ne pas brider le type
 function extensions(config) {
+    // Cela permet à TS de renvoyer l'objet exact avec la fonction générique intacte.
     return (...args) => {
         const optionsInput = args[0];
         const options = (config.schema ? config.schema.parse(optionsInput) : undefined);
         const contextPart = config.context ? config.context(options) : {};
+        // Ici, functionsBuilder garde son type générique <C>(c: C) => ...
         const functionsBuilder = config.functions(options);
         return {
             context: contextPart,

package/dist/extensions/rpc.d.ts

@@ -5,15 +5,18 @@ import { CommandsDefinition, MutationDefinition, QueryDefinition } from "../cont
 export type APINode = CommandsDefinition | {
     [key: string]: APINode;
 };
-export declare const rpc: import("./types").Extension<undefined, Record<string, unknown>, <C>(context: C) => {
-    query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
-        args: TArgs;
-        handler: (ctx: C, // C sera ici { user: ... }
-        args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
-    }) => QueryDefinition<C, TArgs, TOutput, TError>;
-    mutation: <TArgs extends ZodType<any, any, any>, TOutput_1, TError_1 extends Exception>(options: {
-        args: TArgs;
-        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;
-}>;
+export declare const rpc: (...args: any[]) => {
+    context: Record<string, unknown>;
+    functions: <C>(context: C) => {
+        query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
+            args: TArgs;
+            handler: (ctx: C, // C sera ici { user: ... }
+            args: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
+        }) => QueryDefinition<C, TArgs, TOutput, TError>;
+        mutation: <TArgs extends ZodType<any, any, any>, TOutput_1, TError_1 extends Exception>(options: {
+            args: TArgs;
+            handler: (ctx: C, args: z.core.output<TArgs>) => AsyncResult<TOutput_1, TError_1>;
+        }) => MutationDefinition<C, TArgs, TOutput_1, TError_1>;
+        group: <T extends Record<string, APINode>>(definitions: T) => T;
+    };
+};

package/dist/extensions/types.d.ts

@@ -1,13 +1,9 @@
 import z, { ZodType } from "zod";
-export type ExtensionBase<C = any> = {
-    context: any;
-    functions: (context: C) => any;
-};
 export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends {
     functions: (ctx: any) => infer R;
 } ? R : {}) & MergeExtensions<TContext, Tail> : {};
 export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
-export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctionsFactory extends (<C>(context: C) => any)> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
+export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctionsFactory> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
     context: TContextAddon;
     functions: TFunctionsFactory;
 };

package/package.json

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