@deessejs/functions 0.0.58 → 0.0.60

package/dist/context/define.d.ts

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

package/dist/context/define.js

@@ -3,16 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
-        // ON UTILISE ExtensionBase (la version simple définie ci-dessus).
-        // TExtensions va capturer le type EXACT et BRUT de tes extensions (ex: rpc avec ses génériques <C> intacts).
+        // 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.
         withExtensions: (config) => {
             const runtimeBuilder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
-                // Au runtime, on s'en fiche des types, on exécute juste
-                const ext = extension;
-                if (ext && typeof ext.functions === "function") {
-                    const extensionMethods = ext.functions(dummyContext);
+                // 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/types.d.ts

@@ -1,28 +1,13 @@
 import z, { ZodType } from "zod";
-/**
- * C'est le seul mécanisme fiable.
- * F est ta fonction générique <C>(c: C) => API<C>
- * On lui dit : "Si je te donne TContext, que me renvoies-tu ?"
- * TypeScript est obligé de calculer le résultat avec TContext.
- */
-type ApplyContext<F, C> = F extends (context: C) => infer R ? R : never;
-/**
- * ICI EST LA CLÉ :
- * On définit 'functions' comme 'any'.
- * Pourquoi ? Pour que TypeScript ne transforme PAS ta fonction générique <C>
- * en une fonction générique "morte" ou "unknown" quand elle passe dans un tableau.
- */
-export type ExtensionBase = {
+export type ExtensionBase<C = any> = {
     context: any;
-    functions: any;
+    functions: (context: C) => any;
 };
-/**
- * On itère, et on applique ApplyContext sur la fonction brute.
- */
-export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends ExtensionBase ? ApplyContext<Head["functions"], TContext> : {}) & MergeExtensions<TContext, Tail> : {};
+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]) => {
     context: TContextAddon;
     functions: TFunctionsFactory;
 };
-export {};

package/package.json

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