@deessejs/functions 0.0.21 → 0.0.23

package/dist/context/define.d.ts

@@ -1,7 +1,11 @@
 import { UnionToIntersection } from "../utils";
-export type MergeExtensions<TContext, TExtensions extends Array<(...args: any) => any>> = UnionToIntersection<ReturnType<TExtensions[number]>>;
+export type ExtensionInstance = {
+    context: Record<string, any>;
+    functions: (...args: any[]) => any;
+};
+export type MergeExtensions<TContext, TExtensions extends Array<ExtensionInstance>> = UnionToIntersection<ReturnType<TExtensions[number]["functions"]>>;
 export declare function defineContext<TContext extends Record<string, unknown>>(): {
-    withExtensions: <TExtensions extends Array<(...args: any) => any>>(config: {
+    withExtensions: <TExtensions extends Array<ExtensionInstance>>(config: {
         extensions: TExtensions;
     }) => MergeExtensions<TContext, TExtensions> & {
         context: TContext;

package/dist/context/define.js

@@ -5,9 +5,9 @@ function defineContext() {
     return {
         withExtensions: (config) => {
             const builder = {};
-            for (const createExtension of config.extensions) {
-                const extensionInstance = createExtension();
-                Object.assign(builder, extensionInstance);
+            for (const extension of config.extensions) {
+                const extensionMethods = extension.functions();
+                Object.assign(builder, extensionMethods);
             }
             return {
                 ...builder,

package/dist/extensions/index.d.ts

@@ -1,2 +1,3 @@
-import { ExtensionConfig } from "./types";
-export declare const extensions: (config: ExtensionConfig) => void;
+import { ZodType } from "zod";
+import { Extension, ExtensionConfig } from "./types";
+export declare function extensions<TSchema extends ZodType | undefined = undefined, TContextAddon extends Record<string, unknown> = Record<string, unknown>, TFunctions extends Record<string, unknown> = Record<string, unknown>>(config: ExtensionConfig<TSchema, TContextAddon, TFunctions>): Extension<TSchema, TContextAddon, TFunctions>;

package/dist/extensions/index.js

@@ -1,5 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensions = void 0;
-const extensions = (config) => { };
 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,
+        };
+    };
+}

package/dist/extensions/rpc.d.ts

@@ -5,15 +5,14 @@ import { CommandsDefinition, MutationDefinition, QueryDefinition } from "../cont
 export type APINode = CommandsDefinition | {
     [key: string]: APINode;
 };
-export declare const rpc: <TContext>() => () => {
-    query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
+export declare const rpc: import("./types").Extension<undefined, Record<string, unknown>, {
+    query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
         args: TArgs;
-        handler: (ctx: TContext, // <--- Le contexte est injecté ici
-        args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
-    }) => QueryDefinition<TContext, TArgs, TOutput, TError>;
-    mutation: <TArgs extends ZodType<any, any, any>, TOutput_1, TError_1 extends Exception = Exception>(options: {
+        handler: (ctx: unknown, args: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
+    }) => QueryDefinition<unknown, TArgs, TOutput, TError>;
+    mutation: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
         args: TArgs;
-        handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput_1, TError_1>;
-    }) => MutationDefinition<TContext, TArgs, TOutput_1, TError_1>;
+        handler: (ctx: unknown, args: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
+    }) => MutationDefinition<unknown, TArgs, TOutput, TError>;
     group: <T extends Record<string, APINode>>(definitions: T) => T;
-};
+}>;

package/dist/extensions/rpc.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
-// Cette fonction retourne une "ExtensionFn"
-const rpc = () => {
-    return () => ({
-        query: (options) => {
-            return {
-                _type: "query",
-                args: options.args,
-                handler: options.handler,
-            };
-        },
-        mutation: (options) => {
-            return {
-                _type: "mutation",
-                args: options.args,
-                handler: options.handler,
-            };
-        },
-        group: (definitions) => {
-            return definitions;
-        },
-    });
-};
-exports.rpc = rpc;
+const _1 = require(".");
+exports.rpc = (0, _1.extensions)({
+    // Pas d'options, pas de contexte ajouté
+    schema: undefined,
+    context: undefined,
+    // Définition des fonctions
+    functions: (_options) => {
+        // On retourne la fonction générique
+        return () => ({
+            query: (options) => {
+                return { _type: "query", ...options };
+            },
+            mutation: (options) => {
+                return { _type: "mutation", ...options };
+            },
+            group: (definitions) => definitions,
+        });
+    },
+});

package/dist/extensions/types.d.ts

@@ -1,4 +1,11 @@
-export type ExtensionConfig = {
-    context: undefined;
-    functions: undefined;
+import z, { ZodType } from "zod";
+export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
+export type ExtensionConfig<TSchema extends ZodType | undefined, TContext extends Record<string, unknown>, TFunctions extends Record<string, unknown>> = {
+    schema: TSchema;
+    context?: (options: InferOptions<TSchema>) => TContext;
+    functions: (options: InferOptions<TSchema>) => <TAppContext extends TContext>() => TFunctions;
+};
+export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctions extends Record<string, unknown>> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
+    context: TContextAddon;
+    functions: <TAppContext>() => TFunctions;
 };

package/package.json

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