@deessejs/functions 0.0.44 → 0.0.46

package/dist/context/define.d.ts

@@ -1,8 +1,13 @@
-import { ExtensionBase, MergeExtensions } from "../extensions/types";
+import { Extension } from "../extensions/types";
 export declare function defineContext<TContext extends Record<string, any>>(): {
-    withExtensions: <TExtensions extends readonly ExtensionBase[]>(config: {
-        extensions: readonly [...TExtensions];
-    }) => MergeExtensions<TContext, TExtensions> & {
+    withExtensions: <TExts extends readonly Extension<any>[]>(config: {
+        extensions: [...TExts];
+    }) => MergeExtensions<TContext, TExts> & {
         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,23 +1,21 @@
 "use strict";
-// defineContext.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
+// defineContext.ts
 function defineContext() {
     return {
         withExtensions: (config) => {
-            // 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);
+            const builder = {};
+            for (const ext of config.extensions) {
+                const { functions } = ext(); // ← chaque extension sait maintenant recevoir TContext
+                Object.assign(builder, functions);
             }
-            // On retourne runtimeBuilder mais on force le type public attendu.
-            return {
-                ...runtimeBuilder,
-                context: {},
-            };
+            // 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/context/types.d.ts

@@ -6,11 +6,15 @@ 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 ZodType, TOutput, TError extends Exception> = CommandDefinition<TContext, TArgs, TOutput, TError> & {
+export type QueryDefinition<TContext, TArgs extends z.ZodType, TOutput, TError extends Exception> = {
     _type: "query";
+    args: TArgs;
+    handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
 };
-export type MutationDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = CommandDefinition<TContext, TArgs, TOutput, TError> & {
+export type MutationDefinition<TContext, TArgs extends z.ZodType, TOutput, TError extends Exception> = {
     _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> = {

package/dist/extensions/index.d.ts

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

package/dist/extensions/index.js

@@ -1,16 +1,8 @@
 "use strict";
-// extensions/index.ts (ou extensions.ts)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
 function extensions(config) {
-    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,
-        };
-    };
+    return () => ({
+        functions: config.functions(),
+    });
 }

package/dist/extensions/rpc.d.ts

@@ -1,19 +1,30 @@
-import z, { ZodType } from "zod";
-import { Exception } from "../errors/types";
+import { z } from "zod";
 import { AsyncResult } from "../types";
-import { CommandsDefinition, MutationDefinition, QueryDefinition } from "../context/types";
-export type APINode = CommandsDefinition | {
-    [key: string]: APINode;
+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>;
+        };
+    };
 };
-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: 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: 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

@@ -1,19 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
-const _1 = require(".");
-exports.rpc = (0, _1.extensions)({
-    name: "rpc",
-    schema: undefined, // Pas d'options pour le moment
-    context: undefined,
-    // On garde une signature ultra-clean : <C>(context: C) => ...
-    functions: (_options) => (context) => ({
-        query: (options) => {
-            return { _type: "query", ...options };
-        },
-        mutation: (options) => {
-            return { _type: "mutation", ...options };
-        },
-        group: (definitions) => definitions,
+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.44",
+    "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",
@@ -56,7 +56,11 @@
         "build": "tsc",
         "build:watch": "tsc --watch",
         "prepublishOnly": "npm run build",
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "test": "vitest",
+        "test:ui": "vitest --ui",
+        "test:run": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "test:watch": "vitest watch",
         "lint": "eslint src --ext .ts",
         "lint:fix": "eslint src --ext .ts --fix"
     },
@@ -89,10 +93,19 @@
         "zod": "^4.1.12"
     },
     "devDependencies": {
+        "@testing-library/dom": "^10.4.1",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/jsdom": "^27.0.0",
         "@types/node": "^20.0.0",
-        "typescript": "^5.0.0",
-        "eslint": "^8.0.0",
+        "@types/sinon": "^21.0.0",
         "@typescript-eslint/eslint-plugin": "^6.0.0",
-        "@typescript-eslint/parser": "^6.0.0"
+        "@typescript-eslint/parser": "^6.0.0",
+        "@vitest/coverage-v8": "^4.0.13",
+        "@vitest/ui": "^4.0.13",
+        "eslint": "^8.0.0",
+        "jsdom": "^27.2.0",
+        "sinon": "^21.0.0",
+        "typescript": "^5.0.0",
+        "vitest": "^4.0.13"
     }
 }