@deessejs/functions 0.0.45 → 0.0.47

package/dist/context/define.d.ts

@@ -1,14 +1,8 @@
-import { ExtensionBase } from "../extensions";
-export declare function defineContext<TContext>(): {
-    withExtensions: <TExts extends readonly ExtensionBase[]>(config: {
-        extensions: [...TExts];
-    }) => MergeAllExtensions<TContext, TExts> & {
+import { ExtensionBase, MergeExtensions } from "../extensions/types";
+export declare function defineContext<TContext extends Record<string, any>>(): {
+    withExtensions: <TExtensions extends readonly ExtensionBase[]>(config: {
+        extensions: readonly [...TExtensions];
+    }) => MergeExtensions<TContext, TExtensions> & {
         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];
-export {};

package/dist/context/define.js

@@ -4,12 +4,18 @@ exports.defineContext = defineContext;
 function defineContext() {
     return {
         withExtensions: (config) => {
-            const builder = {};
-            for (const ext of config.extensions) {
-                const result = ext();
-                Object.assign(builder, result.functions);
-            }
-            return builder;
+            // runtime builder (inchangé)
+            const runtimeBuilder = {};
+            const dummyContext = {};
+            for (const extension of config.extensions) {
+                // appele runtime, pour construire les méthodes effectives
+                const extensionMethods = extension.functions(dummyContext);
+                Object.assign(runtimeBuilder, extensionMethods);
+            } // Typage public : MergeExtensions instancié avec le TContext exact
+            return {
+                ...runtimeBuilder,
+                context: {},
+            };
         },
     };
 }

package/dist/context/types.d.ts

@@ -6,23 +6,19 @@ export type CommandDefinition<TContext, TArgs extends ZodType, TOutput, TError e
     args: TArgs;
     handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
 };
-export type QueryDefinition<TContext, TArgs extends z.ZodType, TOutput, TError extends Exception> = {
+export type QueryDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = CommandDefinition<TContext, TArgs, TOutput, TError> & {
     _type: "query";
-    args: TArgs;
-    handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
 };
-export type MutationDefinition<TContext, TArgs extends z.ZodType, TOutput, TError extends Exception> = {
+export type MutationDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = CommandDefinition<TContext, TArgs, TOutput, TError> & {
     _type: "mutation";
-    args: TArgs;
-    handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
 };
 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>) => any;
-    mutation: <TArgs extends ZodType, TOutput, TError extends Exception>(def: MutationDefinition<C, TArgs, TOutput, TError>) => any;
+    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) => any;
+    group?: <TGroup extends Record<string, CommandsDefinition>>(defs: TGroup) => TGroup;
 };

package/dist/extensions/index.d.ts

@@ -1,10 +1,9 @@
-import { FunctionsForContext } from "../context";
-export type ExtensionBase = {
-    (): {
-        functions: FunctionsForContext<any>;
-    };
-};
-export declare function extensions<TFunctions extends FunctionsForContext<any>>(config: {
+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: {
     name: string;
-    functions: () => TFunctions;
-}): ExtensionBase;
+    schema?: TSchema;
+    context?: (options: InferOptions<TSchema>) => TContextAddon;
+    functions: (options: InferOptions<TSchema>) => TFunctionsFactory;
+}): Extension<TSchema, TContextAddon, TFunctionsFactory>;

package/dist/extensions/index.js

@@ -1,8 +1,16 @@
 "use strict";
+// extensions/index.ts (ou extensions.ts)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
 function extensions(config) {
-    return () => ({
-        functions: config.functions(),
-    });
+    return (...args) => {
+        const optionsInput = args[0];
+        const options = (config.schema ? config.schema.parse(optionsInput) : undefined);
+        const contextPart = config.context ? config.context(options) : {};
+        const functionsBuilder = config.functions(options);
+        return {
+            context: contextPart,
+            functions: functionsBuilder,
+        };
+    };
 }

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/package.json

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