@deessejs/functions 0.0.61 → 0.0.62

package/dist/context/define.d.ts

@@ -1,8 +1,6 @@
 import { MergeExtensions } from "../extensions/types";
 export declare function defineContext<TContext extends Record<string, any>>(): {
-    withExtensions: <TExtensions extends readonly {
-        functions: (ctx: TContext) => any;
-    }[]>(config: {
+    withExtensions: <TExtensions extends readonly any[]>(config: {
         extensions: readonly [...TExtensions];
     }) => MergeExtensions<TContext, TExtensions> & {
         context: TContext;

package/dist/context/define.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
-        // 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.
+        // ON UTILISE 'readonly any[]'.
+        // C'est vital. Si on met un type plus précis ici, TypeScript risque 
+        // de simplifier le générique de 'rpc' avant qu'on puisse l'injecter.
         withExtensions: (config) => {
             const runtimeBuilder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
+                // Runtime only
                 if (extension && typeof extension.functions === "function") {
                     const extensionMethods = extension.functions(dummyContext);
                     Object.assign(runtimeBuilder, extensionMethods);

package/dist/context/types.d.ts

@@ -13,12 +13,3 @@ 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>) => QueryDefinition<C, TArgs, TOutput, TError>;
-    mutation: <TArgs extends ZodType, TOutput, TError extends Exception>(def: MutationDefinition<C, TArgs, TOutput, TError>) => MutationDefinition<C, TArgs, TOutput, TError>;
-    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;
-};

package/dist/extensions/index.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
-// On n'importe plus FunctionsForContext ici pour ne pas brider le type
+// N'importe PAS FunctionsForContext ici pour le typage, ça brise la généricité.
 function extensions(config) {
-    // Cela permet à TS de renvoyer l'objet exact avec la fonction générique intacte.
+    // On laisse TypeScript retourner l'objet tel quel.
     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/types.d.ts

@@ -1,9 +1,20 @@
 import z, { ZodType } from "zod";
+/**
+ * LA SOLUTION ULTIME : Intersection de ReturnType.
+ *
+ * 1. F & ((c: C) => unknown) : On crée une fonction hybride qui doit satisfaire
+ *    TA fonction générique ET une fonction qui prend ton Contexte.
+ * 2. ReturnType<...> : Pour résoudre le type de retour de cette hybride,
+ *    TypeScript est obligé de remplacer le générique de F par C.
+ * 3. Le "& unknown" assure qu'on ne pollue pas le type de retour (R & unknown = R).
+ */
+type ApplyContext<F, C> = F extends (c: any) => any ? ReturnType<F & ((c: C) => unknown)> : never;
 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> : {};
+    functions: infer F;
+} ? ApplyContext<F, TContext> : {}) & 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> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
     context: TContextAddon;
     functions: TFunctionsFactory;
 };
+export {};

package/package.json

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