@deessejs/functions 0.0.2 → 0.0.4

package/dist/api/index.d.ts

@@ -1,6 +1,4 @@
 import { API, APIConfig } from "./types";
-export declare const createAPI: <TContext extends Record<string, unknown>>(config: APIConfig<TContext>) => API<TContext>;
-declare const api: API<{
-    user: string;
-}>;
-export default api;
+export declare const createAPI: <TContext extends Record<string, unknown>>(config: APIConfig<TContext>, contextName?: string) => API<TContext>;
+export declare const clearGeneratedContextCache: () => void;
+export declare const getGeneratedContexts: () => string[];

package/dist/api/index.js

@@ -1,7 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAPI = void 0;
-const createAPI = (config) => {
+exports.getGeneratedContexts = exports.clearGeneratedContextCache = exports.createAPI = void 0;
+const generator_1 = require("../context/generator");
+// Cache pour éviter de générer plusieurs fois le même contexte
+const generatedContexts = new Set();
+const createAPI = (config, contextName = 'App') => {
+    // Générer les types de contexte si ce n'est pas déjà fait
+    if (!generatedContexts.has(contextName)) {
+        (0, generator_1.generateContextDeclarationFile)(contextName, config.context)
+            .then(() => {
+            generatedContexts.add(contextName);
+        })
+            .catch((error) => {
+            console.error(`Failed to generate context types for ${contextName}:`, error);
+        });
+    }
     let context = { ...config.context };
     const addContext = (key, value) => {
         context = { ...context, [key]: value };
@@ -16,9 +29,11 @@ const createAPI = (config) => {
     return api;
 };
 exports.createAPI = createAPI;
-const api = (0, exports.createAPI)({
-    context: { user: "John Doe" },
-    commands: [],
-    events: [],
-});
-exports.default = api;
+const clearGeneratedContextCache = () => {
+    generatedContexts.clear();
+};
+exports.clearGeneratedContextCache = clearGeneratedContextCache;
+const getGeneratedContexts = () => {
+    return Array.from(generatedContexts);
+};
+exports.getGeneratedContexts = getGeneratedContexts;

package/dist/context/generated.d.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export type BaseContext = Record<string, unknown>;

package/dist/context/generated.js

@@ -0,0 +1,40 @@
+"use strict";
+// This file is automatically generated by the context type generator.
+// Do not modify this file directly. It will be overwritten when new context types are generated.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import utilities for context access
+__exportStar(require("./index"), exports);
+// Generated context types will be added here by the generator
+// Example:
+// declare module "./generated" {
+//   export interface AppContext {
+//     user: null;
+//     permissions: string[];
+//     settings: {
+//       theme: string;
+//       language: string;
+//     };
+//     database: {
+//       host: string;
+//       port: number;
+//     };
+//   }
+//
+//   export type AppAPI<T extends AppContext = AppContext> = T & {
+//     __contextName: "App";
+//   };
+// }

package/dist/context/generator.d.ts

@@ -0,0 +1,9 @@
+export interface GeneratorOptions {
+    outputPath: string;
+    moduleName: string;
+    contextName: string;
+}
+export declare const generateContextDeclaration: (contextName: string, context: Record<string, unknown>) => string;
+export declare const generateContextDeclarationFile: (contextName: string, context: Record<string, unknown>) => Promise<void>;
+export declare const clearGeneratedCache: () => void;
+export declare const getGeneratedContextNames: () => string[];

package/dist/context/generator.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGeneratedContextNames = exports.clearGeneratedCache = exports.generateContextDeclarationFile = exports.generateContextDeclaration = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const process_1 = __importDefault(require("process"));
+// Cache pour éviter de générer plusieurs fois le même contexte
+const generatedContexts = new Set();
+const generateContextDeclaration = (contextName, context) => {
+    const properties = Object.entries(context)
+        .map(([key, value]) => {
+        const type = inferTypeFromValue(value);
+        return `  ${key}: ${type};`;
+    })
+        .join('\n');
+    return `
+declare module "${process_1.default.cwd()}/packages/functions/src/context/generated" {
+  export interface ${contextName}Context {
+${properties}
+  }
+
+  export type ${contextName}API<T extends ${contextName}Context = ${contextName}Context> = T & {
+    __contextName: "${contextName}";
+  };
+}
+`;
+};
+exports.generateContextDeclaration = generateContextDeclaration;
+const generateContextDeclarationFile = async (contextName, context) => {
+    // Vérifier si le contexte a déjà été généré
+    if (generatedContexts.has(contextName)) {
+        return;
+    }
+    const declaration = (0, exports.generateContextDeclaration)(contextName, context);
+    const outputPath = path_1.default.join(process_1.default.cwd(), 'packages', 'functions', 'src', 'context', 'generated.ts');
+    try {
+        // S'assurer que le répertoire existe
+        const dir = path_1.default.dirname(outputPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // Lire le contenu existant s'il existe
+        let existingContent = '';
+        if (fs_1.default.existsSync(outputPath)) {
+            existingContent = fs_1.default.readFileSync(outputPath, 'utf8');
+        }
+        // Vérifier si le fichier contient déjà notre déclaration
+        if (existingContent.includes(`__contextName: "${contextName}"`)) {
+            generatedContexts.add(contextName);
+            return;
+        }
+        // Écrire ou ajouter au fichier généré
+        const finalContent = existingContent ?
+            `${existingContent}\n\n${declaration}` :
+            declaration;
+        fs_1.default.writeFileSync(outputPath, finalContent, 'utf8');
+        generatedContexts.add(contextName);
+    }
+    catch (error) {
+        console.error(`Failed to generate context types for ${contextName}:`, error);
+        throw error;
+    }
+};
+exports.generateContextDeclarationFile = generateContextDeclarationFile;
+const clearGeneratedCache = () => {
+    generatedContexts.clear();
+};
+exports.clearGeneratedCache = clearGeneratedCache;
+const getGeneratedContextNames = () => {
+    return Array.from(generatedContexts);
+};
+exports.getGeneratedContextNames = getGeneratedContextNames;
+const inferTypeFromValue = (value) => {
+    if (value === null) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        if (value.length > 0) {
+            const elementType = inferTypeFromValue(value[0]);
+            return `${elementType}[]`;
+        }
+        return 'unknown[]';
+    }
+    switch (typeof value) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'object': {
+            if (value !== null && !Array.isArray(value)) {
+                const obj = value;
+                const properties = Object.entries(obj)
+                    .map(([key, val]) => {
+                    const type = inferTypeFromValue(val);
+                    return `    ${key}: ${type};`;
+                })
+                    .join('\n');
+                return `{\n${properties}\n  }`;
+            }
+            return 'Record<string, unknown>';
+        }
+        case 'bigint':
+            return 'bigint';
+        case 'symbol':
+            return 'symbol';
+        case 'undefined':
+            return 'undefined';
+        default:
+            return 'unknown';
+    }
+};

package/dist/context/index.d.ts

@@ -2,3 +2,7 @@ import { Context } from "./types";
 export declare const createContext: (ctx: Context) => void;
 export declare const addContext: <K extends string, V>(key: K, value: V) => void;
 export declare const getContext: () => Context;
+export declare const getCurrentContext: () => Context;
+export declare const clearContext: () => void;
+export declare const setContextProperty: <K extends string, V>(key: K, value: V) => void;
+export declare const getContextProperty: <K extends string>(key: K) => unknown;

package/dist/context/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContext = exports.addContext = exports.createContext = void 0;
+exports.getContextProperty = exports.setContextProperty = exports.clearContext = exports.getCurrentContext = exports.getContext = exports.addContext = exports.createContext = void 0;
 let currentContext = {};
 const createContext = (ctx) => {
     currentContext = { ...ctx };
@@ -12,3 +12,19 @@ const addContext = (key, value) => {
 exports.addContext = addContext;
 const getContext = () => currentContext;
 exports.getContext = getContext;
+const getCurrentContext = () => {
+    return { ...currentContext };
+};
+exports.getCurrentContext = getCurrentContext;
+const clearContext = () => {
+    currentContext = {};
+};
+exports.clearContext = clearContext;
+const setContextProperty = (key, value) => {
+    currentContext = { ...currentContext, [key]: value };
+};
+exports.setContextProperty = setContextProperty;
+const getContextProperty = (key) => {
+    return currentContext[key];
+};
+exports.getContextProperty = getContextProperty;

package/dist/context/typing.d.ts

@@ -0,0 +1,10 @@
+export type AppContext = Record<string, unknown>;
+export declare const getTypedContext: <TContext = AppContext>() => TContext;
+export declare const getSafeTypedContext: <TContext = AppContext>() => TContext | null;
+export declare const assertContextProperty: <K extends string>(key: K) => asserts key is Extract<keyof AppContext, K>;
+export declare const getContextPropertyTyped: <K extends string, T>(key: K) => T | undefined;
+export declare const setContextPropertyTyped: <K extends string, T>(key: K, value: T) => void;
+export type ContextValidator<TContext> = (context: unknown) => context is TContext;
+export declare const createContextValidator: <TContext>(validator: ContextValidator<TContext>) => ContextValidator<TContext>;
+export declare const getValidatedContext: <TContext>(validator: ContextValidator<TContext>) => TContext;
+export declare const assertContextProperties: <TContext extends Record<string, unknown>, TKeys extends readonly (keyof TContext)[]>(keys: TKeys) => asserts keys is TKeys;

package/dist/context/typing.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertContextProperties = exports.getValidatedContext = exports.createContextValidator = exports.setContextPropertyTyped = exports.getContextPropertyTyped = exports.assertContextProperty = exports.getSafeTypedContext = exports.getTypedContext = void 0;
+const index_1 = require("./index");
+// Type utilities for context access
+const getTypedContext = () => {
+    return (0, index_1.getContext)();
+};
+exports.getTypedContext = getTypedContext;
+const getSafeTypedContext = () => {
+    try {
+        const context = (0, index_1.getContext)();
+        return context;
+    }
+    catch {
+        return null;
+    }
+};
+exports.getSafeTypedContext = getSafeTypedContext;
+const assertContextProperty = (key) => {
+    const context = (0, index_1.getContext)();
+    if (!(key in context)) {
+        throw new Error(`Context property '${key}' does not exist`);
+    }
+};
+exports.assertContextProperty = assertContextProperty;
+const getContextPropertyTyped = (key) => {
+    const context = (0, index_1.getContext)();
+    return context[key];
+};
+exports.getContextPropertyTyped = getContextPropertyTyped;
+const setContextPropertyTyped = (key, value) => {
+    const context = (0, index_1.getContext)();
+    const updatedContext = { ...context, [key]: value };
+    // Note: This would require updating the global context
+    // For now, this is a utility that shows how it could work
+    // In a real implementation, you might want to pass the context explicitly
+};
+exports.setContextPropertyTyped = setContextPropertyTyped;
+const createContextValidator = (validator) => {
+    return validator;
+};
+exports.createContextValidator = createContextValidator;
+// Generic context access with validation
+const getValidatedContext = (validator) => {
+    const context = (0, index_1.getContext)();
+    if (validator(context)) {
+        return context;
+    }
+    throw new Error('Context validation failed');
+};
+exports.getValidatedContext = getValidatedContext;
+// Utility for partial context validation
+const assertContextProperties = (keys) => {
+    const context = (0, index_1.getContext)();
+    for (const key of keys) {
+        if (!(key in context)) {
+            throw new Error(`Required context property '${String(key)}' is missing`);
+        }
+    }
+};
+exports.assertContextProperties = assertContextProperties;

package/dist/functions/group.d.ts

@@ -0,0 +1,7 @@
+import { Command, CommandGroupConfig, GroupFromConfig } from "./types";
+export declare const group: <TName extends string, TChildren extends readonly (Command | CommandGroupConfig)[]>(config: {
+    name: TName;
+    children: TChildren;
+}) => {
+    name: TName;
+} & { [K in Extract<TChildren[number], CommandGroupConfig> as K["name"]]: GroupFromConfig<K>; };

package/dist/functions/group.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.group = void 0;
+function isGroup(x) {
+    return (typeof x?.name === "string" && Array.isArray(x.children));
+}
+const groupFromConfig = (cfg) => {
+    const mapped = {};
+    for (const child of cfg.children) {
+        if (isGroup(child)) {
+            mapped[child.name] = groupFromConfig(child);
+        }
+    }
+    return {
+        name: cfg.name,
+        ...mapped,
+    };
+};
+const group = (config) => {
+    const mapped = {};
+    for (const child of config.children) {
+        if (isGroup(child)) {
+            mapped[child.name] = groupFromConfig(child);
+        }
+    }
+    return {
+        name: config.name,
+        ...mapped,
+    };
+};
+exports.group = group;

package/dist/functions/mutation.d.ts

@@ -1,7 +1,16 @@
 import { z, ZodType } from "zod";
 import { Exception } from "../errors/types";
 import { AsyncResult } from "../types";
+import type { AppContext } from "../context/typing";
 export declare function mutation<TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
     args: TArgs;
     handler: (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
 }): (input: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
+export declare const createMutation: <TContext extends AppContext = AppContext>() => <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
+    args: TArgs;
+    handler: (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+}) => (input: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
+export declare function mutationWithContext<TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception, TContext extends AppContext = AppContext>(options: {
+    args: TArgs;
+    handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+}): (input: z.core.output<TArgs>, context?: TContext) => AsyncResult<TOutput, TError>;

package/dist/functions/mutation.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMutation = void 0;
 exports.mutation = mutation;
+exports.mutationWithContext = mutationWithContext;
 const errors_1 = require("../errors");
 const types_1 = require("../types");
 const parse_1 = require("./parse");
+// Mutation functions do not accept context to avoid side effects
+// They remain pure and focused on state modification
 function mutation(options) {
     return (input) => {
         const parsed = (0, parse_1.parseArgs)(options.args, input);
@@ -19,3 +23,30 @@ function mutation(options) {
         });
     };
 }
+// Mutation builder for consistency with query builder
+const createMutation = () => {
+    return (options) => {
+        return mutation(options);
+    };
+};
+exports.createMutation = createMutation;
+// Optional: Mutation that can access context but should not modify it
+function mutationWithContext(options) {
+    return (input, context) => {
+        const parsed = (0, parse_1.parseArgs)(options.args, input);
+        return parsed.match({
+            onSuccess: (data) => {
+                // Use provided context or get from global context
+                const ctx = context ?? globalThis.__context;
+                return options.handler(data, ctx);
+            },
+            onFailure: (error) => {
+                const ValidationError = (0, errors_1.exception)({
+                    name: "ValidationError",
+                    message: error.message,
+                });
+                return Promise.resolve((0, types_1.failure)(ValidationError));
+            },
+        });
+    };
+}

package/dist/functions/query.d.ts

@@ -1,8 +1,17 @@
 import { z, ZodType } from "zod";
 import { Exception } from "../errors/types";
 import { AsyncResult } from "../types";
-import { Context } from "../context/types";
+import type { AppContext } from "../context/typing";
+export declare function query<TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception, TContext extends AppContext = AppContext>(options: {
+    args: TArgs;
+    handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+    contextName?: string;
+}): (input: z.infer<TArgs>, context?: TContext) => AsyncResult<TOutput, TError>;
 export declare function query<TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
     args: TArgs;
-    handler: (args: z.infer<TArgs>, ctx: Context) => AsyncResult<TOutput, TError>;
-}): (input: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
+    handler: (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+}): (input: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+export declare const createQuery: <TContext extends AppContext = AppContext>() => <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
+    args: TArgs;
+    handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+}) => (input: z.core.output<TArgs>, context?: TContext | undefined) => AsyncResult<TOutput, TError>;

package/dist/functions/query.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQuery = void 0;
 exports.query = query;
 const errors_1 = require("../errors");
 const types_1 = require("../types");
 const parse_1 = require("./parse");
-const context_1 = require("../context");
-// Query finale
+const typing_1 = require("../context/typing");
+// Implementation
 function query(options) {
-    return (input) => {
+    return (input, context) => {
         const parsed = (0, parse_1.parseArgs)(options.args, input);
         return parsed.match({
             onSuccess: (data) => {
-                const ctx = (0, context_1.getContext)();
+                // If context is provided, use it; otherwise get from global context
+                const ctx = context ?? (0, typing_1.getTypedContext)();
                 return options.handler(data, ctx);
             },
             onFailure: (error) => {
@@ -24,3 +26,10 @@ function query(options) {
         });
     };
 }
+// Query builder with strong typing
+const createQuery = () => {
+    return (options) => {
+        return query(options);
+    };
+};
+exports.createQuery = createQuery;

package/dist/functions/types.d.ts

@@ -2,18 +2,25 @@ import { z, ZodType } from "zod";
 import { Exception } from "../errors/types";
 import { AsyncResult, Unit } from "../types";
 export type Command = {
-    beforeInvoke: () => Promise<Unit>;
-    afterInvoke: () => Promise<Unit>;
-    onSuccess: () => Promise<Unit>;
+    beforeInvoke: () => Promise<void>;
+    afterInvoke: () => Promise<void>;
+    onSuccess: () => Promise<void>;
     onError: (config: {
         exception: Exception;
-    }) => Promise<Unit>;
+    }) => Promise<void>;
 };
-export type CommandGroup = {
+export type CommandGroupConfig = {
     name: string;
-    children: (Command | CommandGroup)[];
-    add: (child: Command | CommandGroup) => Unit;
-    remove: (child: Command | CommandGroup) => Unit;
+    children: readonly (Command | CommandGroupConfig)[];
+};
+export type IsGroup<T> = T extends {
+    name: string;
+    children: readonly (Command | CommandGroupConfig)[];
+} ? T : never;
+export type GroupFromConfig<C extends CommandGroupConfig> = {
+    name: C["name"];
+} & {
+    [K in Extract<C["children"][number], CommandGroupConfig> as K["name"]]: GroupFromConfig<K>;
 };
 export type Query<TArgs extends ZodType = ZodType, TError extends Exception = Exception, TOutput = Unit, TContext = {}> = (options: {
     args: TArgs;

package/dist/index.d.ts

@@ -2,3 +2,6 @@ export * from "./api";
 export * from "./api/types";
 export * from "./functions";
 export * from "./types";
+export * from "./context";
+export * from "./context/typing";
+export * from "./context/generator";

package/dist/index.js

@@ -18,3 +18,7 @@ __exportStar(require("./api"), exports);
 __exportStar(require("./api/types"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./types"), exports);
+// Context and typing exports
+__exportStar(require("./context"), exports);
+__exportStar(require("./context/typing"), exports);
+__exportStar(require("./context/generator"), exports);

package/package.json

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