@deessejs/functions 0.0.45 → 0.0.46

package/dist/context/define.d.ts

@@ -1,14 +1,13 @@
-import { ExtensionBase } from "../extensions";
-export declare function defineContext<TContext>(): {
-    withExtensions: <TExts extends readonly ExtensionBase[]>(config: {
+import { Extension } from "../extensions/types";
+export declare function defineContext<TContext extends Record<string, any>>(): {
+    withExtensions: <TExts extends readonly Extension<any>[]>(config: {
         extensions: [...TExts];
-    }) => MergeAllExtensions<TContext, TExts> & {
+    }) => MergeExtensions<TContext, TExts> & {
         context: TContext;
     };
 };
-type MergeAllExtensions<TContext, TExts extends readonly any[]> = {
-    [K in keyof TExts]: TExts[K] extends {
-        functions: infer F;
-    } ? F extends (ctx: TContext) => infer R ? R : never : never;
-}[number];
+type MergeExtensions<TContext, TExts extends readonly Extension<any>[]> = UnionToIntersection<{
+    [K in keyof TExts]: TExts[K] extends Extension<infer F> ? F extends (ctx: TContext) => infer R ? R : never : never;
+}[number]>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export {};

package/dist/context/define.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
+// defineContext.ts
 function defineContext() {
     return {
         withExtensions: (config) => {
             const builder = {};
             for (const ext of config.extensions) {
-                const result = ext();
-                Object.assign(builder, result.functions);
+                const { functions } = ext(); // ← chaque extension sait maintenant recevoir TContext
+                Object.assign(builder, functions);
             }
+            // On ajoute la propriété context (runtime value = null, mais type correct)
+            Object.defineProperty(builder, "context", {
+                get() { return null; },
+                enumerable: true,
+            });
             return builder;
         },
     };

package/dist/extensions/rpc.d.ts

@@ -1,29 +1,30 @@
 import { z } from "zod";
-import { Exception } from "../errors/types";
 import { AsyncResult } from "../types";
-export type QueryDef<TContext, TArgs extends z.ZodType, TOutput, TError extends Exception = never> = {
-    _type: "query";
-    args: TArgs;
-    handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
-};
-export type MutationDef<TContext, TArgs extends z.ZodType, TOutput, TError extends Exception = never> = {
-    _type: "mutation";
-    args: TArgs;
-    handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
-};
-export type EventHandler<TContext, TPayload> = {
-    event: string;
-    handler: (ctx: TContext, payload: TPayload) => AsyncResult<any, any>;
-};
-export declare function rpc<TContext>(): {
-    query: <TArgs extends z.ZodType, TOutput, TError extends Exception = never>(def: QueryDef<TContext, TArgs, TOutput, TError>) => QueryDef<TContext, TArgs, TOutput, TError>;
-    mutation: <TArgs extends z.ZodType, TOutput, TError extends Exception = never>(def: MutationDef<TContext, TArgs, TOutput, TError>) => MutationDef<TContext, TArgs, TOutput, TError>;
-    group: <T extends Record<string, any>>(g: T) => T;
-    on: <TPayload>(config: {
-        event: string;
-        handler: (ctx: TContext, payload: TPayload) => AsyncResult<any, any>;
-    }) => {
-        event: string;
-        handler: (ctx: TContext, payload: TPayload) => AsyncResult<any, any>;
+export declare const rpc: () => {
+    functions: <TContext>() => {
+        query: <TArgs extends z.ZodType, TOutput, TError = never>(def: {
+            args: TArgs;
+            handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+        }) => {
+            args: TArgs;
+            handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+            _type: "query";
+        };
+        mutation: <TArgs extends z.ZodType, TOutput_1, TError_1 = never>(def: {
+            args: TArgs;
+            handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput_1, TError_1>;
+        }) => {
+            args: TArgs;
+            handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput_1, TError_1>;
+            _type: "mutation";
+        };
+        group: <G>(group: G) => G;
+        on: <TPayload>(config: {
+            event: string;
+            handler: (ctx: TContext, payload: TPayload) => AsyncResult<any, any>;
+        }) => {
+            event: string;
+            handler: (ctx: TContext, payload: TPayload) => AsyncResult<any, any>;
+        };
     };
 };

package/dist/extensions/rpc.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = rpc;
-// Fonction générique : on passe le type du contexte ici !
-function rpc() {
-    return {
-        query: (def) => def,
-        mutation: (def) => def,
-        group: (g) => g,
+exports.rpc = void 0;
+const rpc = () => ({
+    functions: () => ({
+        query: (def) => ({ _type: "query", ...def }),
+        mutation: (def) => ({ _type: "mutation", ...def }),
+        group: (group) => group,
         on: (config) => config,
-    };
-}
+    }),
+});
+exports.rpc = rpc;

package/dist/extensions/types.d.ts

@@ -21,10 +21,9 @@ export type ExtensionConfig<TSchema extends ZodType | undefined, TContextAddon e
     name: string;
     schema?: TSchema;
     context?: (options: InferOptions<TSchema>) => TContextAddon;
-    functions: (options: InferOptions<TSchema>) => (<C>(context: C) => any);
+    functions: (options: InferOptions<TSchema>) => <C>(context: C) => any;
 };
-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 type Extension<F extends (ctx: any) => any> = () => {
+    functions: F;
 };
 export {};

package/package.json

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