@deessejs/functions 0.0.13 → 0.0.15

package/dist/api/index.js

@@ -6,7 +6,9 @@ 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") {
+        if (node &&
+            typeof node === "object" &&
+            (node._type === "query" || node._type === "mutation")) {
             const def = node;
             return (input) => {
                 const parsed = (0, parse_1.parseArgs)(def.args, input);

package/dist/api/types.d.ts

@@ -1,8 +1,8 @@
-import z, { ZodType } from "zod";
-import { QueryDefinition } from "../context/define";
+import z from "zod";
+import { MutationDefinition, QueryDefinition } from "../context";
 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;
+type InferOperationFn<T> = T extends QueryDefinition<any, infer TArgs, infer TOutput, infer TError> | MutationDefinition<any, infer TArgs, 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;
+    [K in keyof T]: T[K] extends QueryDefinition<any, any, any, any> | MutationDefinition<any, any, any, any> ? InferOperationFn<T[K]> : T[K] extends Record<string, any> ? ApiRouter<T[K]> : never;
 };
 export {};

package/dist/context/define.d.ts

@@ -1,20 +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> | {
+import { CommandsDefinition, MutationDefinition, QueryDefinition } from "./types";
+export type APINode = CommandsDefinition | {
     [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>;
+        handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
     }) => QueryDefinition<TContext, TArgs, TOutput, TError>;
+    mutation: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception = Exception>(options: {
+        name: string;
+        args: TArgs;
+        handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+    }) => MutationDefinition<TContext, TArgs, TOutput, TError>;
     group: <T extends Record<string, APINode>>(definitions: T) => T;
 };

package/dist/context/define.js

@@ -11,6 +11,14 @@ function defineContext() {
                 handler: options.handler,
             };
         },
+        mutation: (options) => {
+            return {
+                _type: "mutation",
+                name: options.name,
+                args: options.args,
+                handler: options.handler,
+            };
+        },
         group: (definitions) => {
             return definitions;
         },

package/dist/context/index.d.ts

@@ -1 +1,2 @@
 export * from "./define";
+export * from "./types";

package/dist/context/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./define"), exports);
+__exportStar(require("./types"), exports);

package/dist/context/types.d.ts

@@ -1 +1,16 @@
+import z, { ZodType } from "zod";
+import { Exception } from "../errors/types";
+import { AsyncResult } from "../types";
 export type Context = Record<string, unknown>;
+export type CommandDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = {
+    name: string;
+    args: TArgs;
+    handler: (ctx: TContext, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+};
+export type QueryDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = CommandDefinition<TContext, TArgs, TOutput, TError> & {
+    _type: "query";
+};
+export type MutationDefinition<TContext, TArgs extends ZodType, TOutput, TError extends Exception> = CommandDefinition<TContext, TArgs, TOutput, TError> & {
+    _type: "mutation";
+};
+export type CommandsDefinition = QueryDefinition<any, any, any, any> | MutationDefinition<any, any, any, any>;

package/dist/functions/mutation.d.ts

@@ -1,15 +1,8 @@
 import { z, ZodType } from "zod";
 import { Exception } from "../errors/types";
 import { AsyncResult } from "../types";
-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 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 Record<string, unknown> = Record<string, unknown>>(options: {
+export declare function mutation<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/mutation.js

@@ -1,43 +1,15 @@
 "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);
-        return parsed.match({
-            onSuccess: (data) => options.handler(data),
-            onFailure: (error) => {
-                const ValidationError = (0, errors_1.exception)({
-                    name: "ValidationError",
-                    message: error.message,
-                });
-                return Promise.resolve((0, types_1.failure)(ValidationError));
-            },
-        });
-    };
-}
-// 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;
+                const ctx = context;
                 return options.handler(data, ctx);
             },
             onFailure: (error) => {

package/dist/functions/types.d.ts

@@ -27,7 +27,8 @@ export type Query<TArgs extends ZodType = ZodType, TError extends Exception = Ex
     args: TArgs;
     handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
 }) => (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
-export type Mutation<TArgs extends ZodType = ZodType, TError extends Exception = Exception, TOutput = Unit> = (options: {
+export type Mutation<TArgs extends ZodType = ZodType, TError extends Exception = Exception, TOutput = Unit, TContext = {}> = (options: {
+    name: string;
     args: TArgs;
-    handler: (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
-}) => (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+    handler: (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;
+}) => (args: z.infer<TArgs>, ctx: TContext) => AsyncResult<TOutput, TError>;

package/package.json

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