@deessejs/functions 0.0.29 → 0.0.31

package/dist/context/define.d.ts

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

package/dist/context/define.js

@@ -1,18 +1,19 @@
 "use strict";
-// src/context/index.ts (ou defineContext.ts)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
+        // <const TExtensions> (TS 5.0) ou readonly permet de dire à TS :
+        // "Ne traite pas ça comme un tableau générique, mais comme une suite précise d'éléments"
         withExtensions: (config) => {
             const builder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
-                // extension.functions est maintenant 'any' au niveau du type, 
-                // mais au runtime c'est bien la fonction.
+                // Runtime : on exécute et on fusionne
                 const extensionMethods = extension.functions(dummyContext);
                 Object.assign(builder, extensionMethods);
             }
+            // Typage : On utilise la fusion récursive
             return {
                 ...builder,
                 context: {},

package/dist/extensions/rpc.d.ts

@@ -5,14 +5,15 @@ import { CommandsDefinition, MutationDefinition, QueryDefinition } from "../cont
 export type APINode = CommandsDefinition | {
     [key: string]: APINode;
 };
-export declare const rpc: import("./types").Extension<undefined, Record<string, unknown>, <TContext>(context: TContext) => {
+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: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
-    }) => QueryDefinition<TContext, TArgs, TOutput, TError>;
+        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: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput_1, TError_1>;
-    }) => MutationDefinition<TContext, TArgs, TOutput_1, TError_1>;
+        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;
 }>;

package/dist/extensions/rpc.js

@@ -4,10 +4,9 @@ exports.rpc = void 0;
 const _1 = require(".");
 exports.rpc = (0, _1.extensions)({
     name: "rpc",
-    schema: undefined,
+    schema: undefined, // Pas d'options pour le moment
     context: undefined,
-    // La fonction accepte N'IMPORTE QUEL TContext.
-    // C'est ApplyContext qui se chargera d'injecter le bon type (celui de defineContext).
+    // On garde une signature ultra-clean : <C>(context: C) => ...
     functions: (_options) => (context) => ({
         query: (options) => {
             return { _type: "query", ...options };

package/dist/extensions/types.d.ts

@@ -1,12 +1,12 @@
 import z, { ZodType } from "zod";
-import { UnionToIntersection } from "../utils";
 export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
-type ApplyContext<TFunc, TContext> = TFunc extends (context: TContext) => infer R ? R : never;
-export type ExtensionInstance = {
+export type ExtensionBase = {
     context: any;
-    functions: any;
+    functions: (context: any) => any;
 };
-export type MergeExtensions<TContext, TExtensions extends Array<ExtensionInstance>> = UnionToIntersection<ApplyContext<TExtensions[number]["functions"], TContext>>;
+export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends {
+    functions: (ctx: TContext) => infer R;
+} ? R : {}) & MergeExtensions<TContext, Tail> : {};
 export type ExtensionConfig<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>> = {
     name: string;
     schema?: TSchema;
@@ -17,4 +17,3 @@ export type Extension<TSchema extends ZodType | undefined, TContextAddon extends
     context: TContextAddon;
     functions: TFunctionsFactory;
 };
-export {};

package/package.json

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