@deessejs/functions 0.0.46 → 0.0.47

package/dist/context/define.d.ts

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

@@ -21,9 +21,10 @@ 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<F extends (ctx: any) => any> = () => {
-    functions: F;
+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.46",
+    "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",