@deessejs/functions 0.0.11 → 0.0.13

package/dist/api/index.d.ts

@@ -1,8 +1,5 @@
-import type { AsyncResult } from "../types";
-export type QueryFn<TArgs, TOutput, TError> = (input: TArgs) => AsyncResult<TOutput, TError>;
-export declare const createAPI: <TContext extends Record<string, unknown>>(config: {
-    context: TContext;
-}) => {
-    [key: string]: TContext | QueryFn<any, any, any>;
-    context: TContext;
-} & Record<string, QueryFn<any, any, any>>;
+import { ApiRouter } from "./types";
+export declare function createAPI<TCtx extends Record<string, unknown>, TRoot extends Record<string, any>>(config: {
+    context: TCtx;
+    root: TRoot;
+}): ApiRouter<TRoot>;

package/dist/api/index.js

@@ -1,20 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAPI = void 0;
-const query_1 = require("../functions/query");
-const createAPI = (config) => {
-    const ctx = { ...config.context };
-    const api = {
-        context: ctx,
-    };
-    const query = (options) => {
-        const result = (0, query_1.query)(options);
-        api[options.name] = result;
-        return result;
-    };
-    return {
-        ...api,
-        query,
-    };
-};
 exports.createAPI = createAPI;
+const errors_1 = require("../errors");
+const parse_1 = require("../functions/parse");
+const types_1 = require("../types");
+function createAPI(config) {
+    const hydrate = (node) => {
+        if (node && typeof node === "object" && node._type === "query") {
+            const def = node;
+            return (input) => {
+                const parsed = (0, parse_1.parseArgs)(def.args, input);
+                return parsed.match({
+                    onSuccess: (data) => {
+                        return def.handler(data, config.context);
+                    },
+                    onFailure: (error) => {
+                        const ValidationError = (0, errors_1.exception)({
+                            name: "ValidationError",
+                            message: error.message,
+                        });
+                        return Promise.resolve((0, types_1.failure)(ValidationError));
+                    },
+                });
+            };
+        }
+        if (node && typeof node === "object") {
+            const group = {};
+            for (const key in node) {
+                group[key] = hydrate(node[key]);
+            }
+            return group;
+        }
+        return node;
+    };
+    return hydrate(config.root);
+}

package/dist/api/types.d.ts

@@ -1,14 +1,8 @@
-import { Command } from "../functions/types";
-import { Event } from "../events/types";
-import { Context } from "../context/types";
-export type APIConfig<TContext extends Context = Context> = {
-    context: TContext;
-    commands: Command[];
-    events: Event[];
-};
-export type API<TContext extends Context = Context> = {
-    context: TContext;
-    addContext: <K extends string, V>(key: K, value: V) => API<TContext & Record<K, V>>;
-    commands: Command[];
-    events: Event[];
+import z, { ZodType } from "zod";
+import { QueryDefinition } from "../context/define";
+import { AsyncResult } from "../types";
+type InferQueryFn<T> = T extends QueryDefinition<any, infer TArgs extends ZodType<any, any, any>, infer TOutput, infer TError> ? (input: z.input<TArgs>) => AsyncResult<TOutput, TError> : never;
+export type ApiRouter<T> = {
+    [K in keyof T]: T[K] extends QueryDefinition<any, any, any, any> ? InferQueryFn<T[K]> : T[K] extends Record<string, any> ? ApiRouter<T[K]> : never;
 };
+export {};

package/dist/context/define.d.ts

@@ -0,0 +1,20 @@
+import z, { ZodType } from "zod";
+import { Exception } from "../errors/types";
+import { AsyncResult } from "../types";
+export type QueryDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = {
+    _type: "query";
+    name: string;
+    args: TArgs;
+    handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+};
+export type APINode = QueryDefinition<any, any, any, any> | {
+    [key: string]: APINode;
+};
+export declare function defineContext<TContext extends Record<string, unknown>>(): {
+    query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
+        name: string;
+        args: TArgs;
+        handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+    }) => QueryDefinition<TContext, TArgs, TOutput, TError>;
+    group: <T extends Record<string, APINode>>(definitions: T) => T;
+};

package/dist/context/define.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineContext = defineContext;
+function defineContext() {
+    return {
+        query: (options) => {
+            return {
+                _type: "query",
+                name: options.name,
+                args: options.args,
+                handler: options.handler,
+            };
+        },
+        group: (definitions) => {
+            return definitions;
+        },
+    };
+}

package/dist/context/index.d.ts

@@ -1,8 +1 @@
-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;
+export * from "./define";

package/dist/context/index.js

@@ -1,30 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContextProperty = exports.setContextProperty = exports.clearContext = exports.getCurrentContext = exports.getContext = exports.addContext = exports.createContext = void 0;
-let currentContext = {};
-const createContext = (ctx) => {
-    currentContext = { ...ctx };
-};
-exports.createContext = createContext;
-const addContext = (key, value) => {
-    currentContext = { ...currentContext, [key]: value };
-};
-exports.addContext = addContext;
-const getContext = () => currentContext;
-exports.getContext = getContext;
-const getCurrentContext = () => {
-    return { ...currentContext };
-};
-exports.getCurrentContext = getCurrentContext;
-const clearContext = () => {
-    currentContext = {};
+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);
 };
-exports.clearContext = clearContext;
-const setContextProperty = (key, value) => {
-    currentContext = { ...currentContext, [key]: value };
-};
-exports.setContextProperty = setContextProperty;
-const getContextProperty = (key) => {
-    return currentContext[key];
-};
-exports.getContextProperty = getContextProperty;
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./define"), exports);

package/dist/functions/mutation.d.ts

@@ -1,16 +1,15 @@
 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: {
+export declare const createMutation: <TContext extends Record<string, unknown> = Record<string, unknown>>() => <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: {
+export declare function mutationWithContext<TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception, TContext extends Record<string, unknown> = Record<string, unknown>>(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/query.d.ts

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

package/dist/functions/query.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = query;
-const typing_1 = require("../context/typing");
 const errors_1 = require("../errors");
 const types_1 = require("../types");
 const parse_1 = require("./parse");
@@ -10,7 +9,7 @@ function query(options) {
         const parsed = (0, parse_1.parseArgs)(options.args, input);
         return parsed.match({
             onSuccess: (data) => {
-                const ctx = context ?? (0, typing_1.getTypedContext)();
+                const ctx = context;
                 return options.handler(data, ctx);
             },
             onFailure: (error) => {

package/dist/index.d.ts

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

package/dist/index.js

@@ -20,4 +20,3 @@ __exportStar(require("./functions"), exports);
 __exportStar(require("./types"), exports);
 // Context and typing exports
 __exportStar(require("./context"), exports);
-__exportStar(require("./context/typing"), exports);

package/package.json

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