@deessejs/functions 0.0.4 → 0.0.6

package/dist/api/index.d.ts

@@ -1,4 +1,11 @@
-import { API, APIConfig } from "./types";
-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[];
+import { z, ZodType } from "zod";
+import { AsyncResult } from "../types";
+export declare const createAPI: <TContext extends Record<string, unknown>>(config: {
+    context: TContext;
+}) => {
+    readonly context: TContext;
+    readonly query: <TArgs extends ZodType, TOutput, TError = Error>(options: {
+        args: TArgs;
+        handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+    }) => (input: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+};

package/dist/api/index.js

@@ -1,39 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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);
+exports.createAPI = void 0;
+const createAPI = (config) => {
+    const ctx = { ...config.context };
+    const query = (options) => {
+        const fn = (input) => {
+            const parsed = options.args.safeParse(input);
+            if (!parsed.success) {
+                return Promise.resolve({ error: parsed.error });
+            }
+            return options.handler(parsed.data, ctx);
+        };
+        Object.defineProperty(fn, "name", {
+            value: options.handler.name || "query",
         });
-    }
-    let context = { ...config.context };
-    const addContext = (key, value) => {
-        context = { ...context, [key]: value };
-        return api;
+        return fn;
     };
-    const api = {
-        context,
-        addContext,
-        commands: config.commands,
-        events: config.events,
+    return {
+        context: ctx,
+        query,
     };
-    return api;
 };
 exports.createAPI = createAPI;
-const clearGeneratedContextCache = () => {
-    generatedContexts.clear();
-};
-exports.clearGeneratedContextCache = clearGeneratedContextCache;
-const getGeneratedContexts = () => {
-    return Array.from(generatedContexts);
-};
-exports.getGeneratedContexts = getGeneratedContexts;

package/dist/context/typing.d.ts

@@ -1,10 +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;
+export type AppContext = Record<string, unknown>;
+export declare const getTypedContext: <TContext extends AppContext = AppContext>() => TContext;
+export declare const getSafeTypedContext: <TContext extends AppContext = AppContext>() => TContext | null;
+export declare const assertContextProperty: <K extends keyof AppContext>(key: K) => asserts key is K;
+export declare const getContextPropertyTyped: <K extends keyof AppContext, T>(key: K) => T | undefined;
+export declare const setContextPropertyTyped: <K extends string, T>(key: K, value: T) => void;

package/dist/context/typing.js

@@ -1,8 +1,30 @@
 "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;
+exports.setContextPropertyTyped = exports.getContextPropertyTyped = exports.assertContextProperty = exports.getSafeTypedContext = exports.getTypedContext = exports.assertContextProperties = exports.getValidatedContext = exports.createContextValidator = void 0;
 const index_1 = require("./index");
-// Type utilities for context access
+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;
 const getTypedContext = () => {
     return (0, index_1.getContext)();
 };
@@ -32,31 +54,7 @@ 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
+    // Note: Update global context as needed
 };
 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;
+// Other utilities (validator, etc.) remain unchanged...

package/dist/errors/index.d.ts

@@ -2,7 +2,7 @@ import { Exception, ExceptionConfig, ExceptionSpaceConfig, ExceptionGroup } from
 export declare const exception: (config: ExceptionConfig) => Exception;
 export declare const exceptionSpace: (space: ExceptionSpaceConfig) => {
     define: (config: Omit<ExceptionConfig, "namespace">) => Exception;
-    severity: "error" | "info" | "warning" | "critical";
+    severity: "info" | "warning" | "error" | "critical";
     name: string;
 };
 export declare const raise: (exception: Exception) => Exception;

package/dist/functions/query.js

@@ -12,7 +12,6 @@ function query(options) {
         const parsed = (0, parse_1.parseArgs)(options.args, input);
         return parsed.match({
             onSuccess: (data) => {
-                // If context is provided, use it; otherwise get from global context
                 const ctx = context ?? (0, typing_1.getTypedContext)();
                 return options.handler(data, ctx);
             },
@@ -26,7 +25,7 @@ function query(options) {
         });
     };
 }
-// Query builder with strong typing
+// Query builder
 const createQuery = () => {
     return (options) => {
         return query(options);

package/package.json

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