@deessejs/functions 0.0.24 → 0.0.25

package/dist/context/define.d.ts

@@ -1,10 +1,5 @@
-import { UnionToIntersection } from "../utils";
-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>>(): {
+import { ExtensionInstance, MergeExtensions } from "../extensions/types";
+export declare function defineContext<TContext extends Record<string, any>>(): {
     withExtensions: <TExtensions extends Array<ExtensionInstance>>(config: {
         extensions: TExtensions;
     }) => MergeExtensions<TContext, TExtensions> & {

package/dist/context/define.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
+// Utiliser 'any' ici évite des conflits de variance avec 'unknown'
 function defineContext() {
     return {
         withExtensions: (config) => {
             const builder = {};
+            const dummyContext = {};
             for (const extension of config.extensions) {
-                const extensionMethods = extension.functions({});
+                // Runtime : On appelle la factory
+                const extensionMethods = extension.functions(dummyContext);
                 Object.assign(builder, extensionMethods);
             }
             return {

package/dist/extensions/index.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
-function extensions(
-// config ne prend plus TFunctionsFactory en générique explicite sur ExtensionConfig
-// On le type "à la main" ici pour l'inférence
-config) {
+function extensions(config) {
     return (...args) => {
         const optionsInput = args[0];
         const options = (config.schema ? config.schema.parse(optionsInput) : undefined);

package/dist/extensions/rpc.d.ts

@@ -5,7 +5,7 @@ import { CommandsDefinition, MutationDefinition, QueryDefinition } from "../cont
 export type APINode = CommandsDefinition | {
     [key: string]: APINode;
 };
-export declare const rpc: import("./types").Extension<undefined, Record<string, unknown>, <TContext>(context: TContext) => {
+export declare const rpc: import("./types").Extension<undefined, Record<string, unknown>, <TContext extends Record<string, any>>(context: TContext) => {
     query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
         args: TArgs;
         handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;

package/dist/extensions/rpc.js

@@ -6,7 +6,8 @@ exports.rpc = (0, _1.extensions)({
     name: "rpc",
     schema: undefined,
     context: undefined,
-    // Ici, TS va inférer que TFunctionsFactory est : <TContext>(context: TContext) => { ... }
+    // FIX CRUCIAL : <TContext extends Record<string, any>>
+    // Cela garantit à TypeScript que TContext est bien un objet compatible
     functions: (_options) => (context) => ({
         query: (options) => {
             return { _type: "query", ...options };

package/dist/extensions/types.d.ts

@@ -1,7 +1,7 @@
 import z, { ZodType } from "zod";
 import { UnionToIntersection } from "../utils";
 export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
-type ApplyContext<TFunc, TContext> = TFunc extends (ctx: TContext) => infer R ? R : never;
+type ApplyContext<TFunc, TContext> = TFunc extends (context: TContext) => infer R ? R : never;
 export type ExtensionInstance = {
     context: Record<string, unknown>;
     functions: (context: any) => Record<string, unknown>;
@@ -11,7 +11,7 @@ export type ExtensionConfig<TSchema extends ZodType | undefined, TContextAddon e
     name: string;
     schema?: TSchema;
     context?: (options: InferOptions<TSchema>) => TContextAddon;
-    functions: (options: InferOptions<TSchema>) => (context: any) => any;
+    functions: (options: InferOptions<TSchema>) => (context: any) => Record<string, any>;
 };
 export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctionsFactory extends (context: any) => any> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
     context: TContextAddon;

package/package.json

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