@deessejs/functions 0.0.43 → 0.0.45

package/dist/context/define.d.ts

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

package/dist/context/define.js

@@ -4,18 +4,12 @@ exports.defineContext = defineContext;
 function defineContext() {
     return {
         withExtensions: (config) => {
-            // Créer un contexte qui préserve le type TContext
-            const runtimeContext = {};
-            // Appliquer les extensions en préservant les types
-            const result = {
-                context: runtimeContext,
-            };
-            for (const extension of config.extensions) {
-                // Passer le contexte avec son type complet pour que l'inférence fonctionne
-                const methods = extension.functions(runtimeContext);
-                Object.assign(result, methods);
+            const builder = {};
+            for (const ext of config.extensions) {
+                const result = ext();
+                Object.assign(builder, result.functions);
             }
-            return result;
+            return builder;
         },
     };
 }

package/dist/context/types.d.ts

@@ -6,19 +6,23 @@ 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> = {
-    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>;
+    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;
     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) => TGroup;
+    group?: <TGroup extends Record<string, CommandsDefinition>>(defs: TGroup) => any;
 };

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

package/dist/extensions/rpc.js

@@ -1,21 +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,
-        // Exposer le type de contexte pour l'inférence
-        _contextType: context,
-    }),
-});
+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,
+        on: (config) => config,
+    };
+}

package/dist/extensions/types.d.ts

@@ -10,10 +10,10 @@ type FnCallSignatureMatchesWith<C, F> = F extends {
 export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends {
     functions: infer F;
 } ? FnCallSignatureMatchesWith<TContext, F> : {}) & MergeExtensions<TContext, Tail> : {};
-/** Ici : functions est une fonction qui retourne les méthodes pour un contexte donné */
+/** Ici : functions est *explicitement* une call signature générique */
 export type ExtensionBase = {
     context: any;
-    functions: <TOptions>(options: TOptions) => <C>(context: C) => FunctionsForContext<C>;
+    functions: <C>(context: C) => FunctionsForContext<C>;
 };
 /** Helpers pour extensions/InferOptions et définition d'Extension */
 export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@deessejs/functions",
-    "version": "0.0.43",
+    "version": "0.0.45",
     "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"
     }
 }