@deessejs/functions 0.0.1

package/dist/api/index.d.ts

@@ -0,0 +1,6 @@
+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;

package/dist/api/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAPI = void 0;
+const createAPI = (config) => {
+    let context = { ...config.context };
+    const addContext = (key, value) => {
+        context = { ...context, [key]: value };
+        return api;
+    };
+    const api = {
+        context,
+        addContext,
+        commands: config.commands,
+        events: config.events,
+    };
+    return api;
+};
+exports.createAPI = createAPI;
+const api = (0, exports.createAPI)({
+    context: { user: "John Doe" },
+    commands: [],
+    events: [],
+});
+exports.default = api;

package/dist/api/types.d.ts

@@ -0,0 +1,14 @@
+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[];
+};

package/dist/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/checks/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class CheckError extends Error {
+    code: string;
+    details?: any;
+    constructor({ code, message, details }: {
+        code: string;
+        message: string;
+        details?: any;
+    });
+}

package/dist/checks/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckError = void 0;
+class CheckError extends Error {
+    constructor({ code, message, details }) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.CheckError = CheckError;

package/dist/checks/index.d.ts

@@ -0,0 +1,2 @@
+import { Check } from "./types";
+export declare const check: Check;

package/dist/checks/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = void 0;
+const result_1 = require("../types/result");
+const errors_1 = require("./errors");
+const check = ({ args, handler }) => {
+    return async (input) => {
+        const parsed = args.safeParse(input);
+        if (!parsed.success) {
+            return (0, result_1.failure)(new errors_1.CheckError({
+                code: "INVALID_ARGS",
+                message: "Arguments invalides pour le check",
+                details: parsed.error.issues,
+            }));
+        }
+        try {
+            return await handler(parsed.data);
+        }
+        catch (error) {
+            return (0, result_1.failure)(new errors_1.CheckError({
+                code: "INTERNAL_ERROR",
+                message: "Erreur interne lors de l’exécution du check",
+                details: error,
+            }));
+        }
+    };
+};
+exports.check = check;

package/dist/checks/types.d.ts

@@ -0,0 +1,9 @@
+import { AsyncResult } from "../types/async-result";
+import { Unit } from "../types/unit";
+import { CheckError } from "./errors";
+import { z, ZodType } from "zod";
+export type CheckResult = AsyncResult<Unit, CheckError>;
+export type Check<TArgs extends ZodType = ZodType, TError extends CheckError = CheckError> = (options: {
+    args: TArgs;
+    handler: (args: z.infer<TArgs>) => AsyncResult<Unit, TError>;
+}) => (args: z.infer<TArgs>) => AsyncResult<Unit, TError>;

package/dist/checks/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/context/index.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/context/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

package/dist/context/types.d.ts

@@ -0,0 +1 @@
+export type Context = Record<string, unknown>;

package/dist/context/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/errors/index.d.ts

@@ -0,0 +1,9 @@
+import { Exception, ExceptionConfig, ExceptionSpaceConfig, ExceptionGroup } from "./types";
+export declare const exception: (config: ExceptionConfig) => Exception;
+export declare const exceptionSpace: (space: ExceptionSpaceConfig) => {
+    define: (config: Omit<ExceptionConfig, "namespace">) => Exception;
+    severity: "error" | "info" | "warning" | "critical";
+    name: string;
+};
+export declare const raise: (exception: Exception) => Exception;
+export declare const group: (name: string, exceptions: [Exception, ...Exception[]]) => ExceptionGroup;

package/dist/errors/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.group = exports.raise = exports.exceptionSpace = exports.exception = void 0;
+const exception = (config) => {
+    const base = {
+        ...config,
+        stack: config.stack ?? [],
+        cause: config.cause,
+        notes: config.notes ?? [],
+        from(cause) {
+            return (0, exports.exception)({
+                ...config,
+                cause,
+                stack: [...base.stack, cause],
+            });
+        },
+        is(other) {
+            return (other.name === config.name &&
+                (config.namespace ? other.namespace === config.namespace : true));
+        },
+        addNote(note) {
+            return (0, exports.exception)({
+                ...config,
+                notes: [...base.notes, note],
+            });
+        },
+    };
+    return base;
+};
+exports.exception = exception;
+const exceptionSpace = (space) => {
+    return {
+        define: (config) => {
+            return (0, exports.exception)({
+                ...config,
+                namespace: space.name,
+            });
+        },
+        severity: space.severity,
+        name: space.name,
+    };
+};
+exports.exceptionSpace = exceptionSpace;
+const raise = (exception) => {
+    return exception;
+};
+exports.raise = raise;
+const group = (name, exceptions) => ({
+    name,
+    exceptions,
+});
+exports.group = group;

package/dist/errors/types.d.ts

@@ -0,0 +1,26 @@
+import { NonEmptyArray } from "../types";
+export type ExceptionSpaceConfig = {
+    name: string;
+    severity: "info" | "warning" | "error" | "critical";
+};
+export type ExceptionConfig = {
+    name: string;
+    namespace?: string;
+    code?: string;
+    message?: string;
+    cause?: Exception;
+    stack?: Exception[];
+    notes?: string[];
+};
+export type Exception = ExceptionConfig & {
+    stack: Exception[];
+    cause?: Exception;
+    notes: string[];
+    from: (cause: Exception) => Exception;
+    is: (exception: Exception) => boolean;
+    addNote: (note: string) => Exception;
+};
+export type ExceptionGroup = {
+    name: string;
+    exceptions: NonEmptyArray<Exception>;
+};

package/dist/errors/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/events/index.d.ts

@@ -0,0 +1 @@
+export declare const listener: undefined;

package/dist/events/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listener = void 0;
+exports.listener = undefined;

package/dist/events/types.d.ts

@@ -0,0 +1 @@
+export type Event = {};

package/dist/events/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./query";
+export * from "./mutation";
+export * from "./types";

package/dist/functions/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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 });
+__exportStar(require("./query"), exports);
+__exportStar(require("./mutation"), exports);
+__exportStar(require("./types"), exports);

package/dist/functions/mutation.d.ts

@@ -0,0 +1,7 @@
+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>;

package/dist/functions/mutation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutation = mutation;
+const errors_1 = require("../errors");
+const types_1 = require("../types");
+const parse_1 = require("./parse");
+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));
+            },
+        });
+    };
+}

package/dist/functions/parse.d.ts

@@ -0,0 +1,4 @@
+import { z, ZodType } from "zod";
+import { Result } from "../types";
+import { Exception } from "../errors/types";
+export declare function parseArgs<TArgs extends ZodType<any, any, any>>(schema: TArgs, input: unknown): Result<z.infer<TArgs>, Exception>;

package/dist/functions/parse.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+const types_1 = require("../types");
+const errors_1 = require("../errors");
+function parseArgs(schema, input) {
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+        return (0, types_1.failure)((0, errors_1.exception)({
+            name: "ValidatedArgsError",
+            message: parsed.error.message,
+        }));
+    }
+    return (0, types_1.success)(parsed.data);
+}

package/dist/functions/query.d.ts

@@ -0,0 +1,8 @@
+import { z, ZodType } from "zod";
+import { Exception } from "../errors/types";
+import { AsyncResult } from "../types";
+import { Context } from "../context/types";
+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>;

package/dist/functions/query.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+function query(options) {
+    return (input) => {
+        const parsed = (0, parse_1.parseArgs)(options.args, input);
+        return parsed.match({
+            onSuccess: (data) => {
+                const ctx = (0, context_1.getContext)();
+                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/types.d.ts

@@ -0,0 +1,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>;
+    onError: (config: {
+        exception: Exception;
+    }) => Promise<Unit>;
+};
+export type CommandGroup = {
+    name: string;
+    children: (Command | CommandGroup)[];
+    add: (child: Command | CommandGroup) => Unit;
+    remove: (child: Command | CommandGroup) => Unit;
+};
+export type Query<TArgs extends ZodType = ZodType, TError extends Exception = Exception, TOutput = Unit, TContext = {}> = (options: {
+    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: {
+    args: TArgs;
+    handler: (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+}) => (args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;

package/dist/functions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+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 });
+__exportStar(require("./functions"), exports);
+__exportStar(require("./types"), exports);

package/dist/types/array.d.ts

@@ -0,0 +1 @@
+export type NonEmptyArray<T> = [T, ...T[]];

package/dist/types/array.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/async-result.d.ts

@@ -0,0 +1,3 @@
+import { Result } from "./result";
+export type AsyncResult<T, E> = Promise<Result<T, E>>;
+export declare const from: <T, E = Error>(fn: () => Promise<T>) => AsyncResult<T, E>;

package/dist/types/async-result.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.from = void 0;
+const try_1 = require("./try");
+const from = (fn) => (0, try_1.tryCatchAsync)(fn);
+exports.from = from;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { NonEmptyArray } from "../types/array";
+export { AsyncResult } from "../types/async-result";
+export { Result, success, failure } from "../types/result";
+export { Maybe, some, none } from "../types/maybe";
+export { Unit, unit } from "../types/unit";
+export { Try, tryCatch, tryCatchAsync } from "../types/try";

package/dist/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryCatchAsync = exports.tryCatch = exports.unit = exports.none = exports.some = exports.failure = exports.success = void 0;
+var result_1 = require("../types/result");
+Object.defineProperty(exports, "success", { enumerable: true, get: function () { return result_1.success; } });
+Object.defineProperty(exports, "failure", { enumerable: true, get: function () { return result_1.failure; } });
+var maybe_1 = require("../types/maybe");
+Object.defineProperty(exports, "some", { enumerable: true, get: function () { return maybe_1.some; } });
+Object.defineProperty(exports, "none", { enumerable: true, get: function () { return maybe_1.none; } });
+var unit_1 = require("../types/unit");
+Object.defineProperty(exports, "unit", { enumerable: true, get: function () { return unit_1.unit; } });
+var try_1 = require("../types/try");
+Object.defineProperty(exports, "tryCatch", { enumerable: true, get: function () { return try_1.tryCatch; } });
+Object.defineProperty(exports, "tryCatchAsync", { enumerable: true, get: function () { return try_1.tryCatchAsync; } });

package/dist/types/maybe.d.ts

@@ -0,0 +1,22 @@
+export type Maybe<T> = Some<T> | None;
+export type Some<T> = {
+    readonly _tag: "Some";
+    readonly value: T;
+    isSome(): this is Some<T>;
+    isNone(): this is None;
+    match<U>(handlers: {
+        onSome: (value: T) => U;
+        onNone: () => U;
+    }): U;
+};
+export type None = {
+    readonly _tag: "None";
+    isSome(): this is Some<never>;
+    isNone(): this is None;
+    match<U>(handlers: {
+        onSome: (value: never) => U;
+        onNone: () => U;
+    }): U;
+};
+export declare const some: <T>(value: T) => Some<T>;
+export declare const none: () => None;

package/dist/types/maybe.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.none = exports.some = void 0;
+const some = (value) => ({
+    _tag: "Some",
+    value,
+    isSome() {
+        return true;
+    },
+    isNone() {
+        return false;
+    },
+    match({ onSome }) {
+        return onSome(value);
+    },
+});
+exports.some = some;
+const none = () => ({
+    _tag: "None",
+    isSome() {
+        return false;
+    },
+    isNone() {
+        return true;
+    },
+    match({ onNone }) {
+        return onNone();
+    },
+});
+exports.none = none;

package/dist/types/result.d.ts

@@ -0,0 +1,24 @@
+import { Exception } from "../errors/types";
+export type Result<T, E = Exception> = Success<T> | Failure<E>;
+export type Success<T> = {
+    readonly _tag: "Success";
+    readonly value: T;
+    isSuccess(): this is Success<T>;
+    isFailure(): this is Failure<never>;
+    match<U>(handlers: {
+        onSuccess: (value: T) => U;
+        onFailure: (error: never) => U;
+    }): U;
+};
+export type Failure<E> = {
+    readonly _tag: "Failure";
+    readonly error: E;
+    isSuccess(): this is Success<never>;
+    isFailure(): this is Failure<E>;
+    match<U>(handlers: {
+        onSuccess: (value: never) => U;
+        onFailure: (error: E) => U;
+    }): U;
+};
+export declare const success: <T>(value: T) => Success<T>;
+export declare const failure: <E>(error: E) => Failure<E>;

package/dist/types/result.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failure = exports.success = void 0;
+const success = (value) => ({
+    _tag: "Success",
+    value,
+    isSuccess() {
+        return true;
+    },
+    isFailure() {
+        return false;
+    },
+    match(handlers) {
+        return handlers.onSuccess(value);
+    },
+});
+exports.success = success;
+const failure = (error) => ({
+    _tag: "Failure",
+    error,
+    isSuccess() {
+        return false;
+    },
+    isFailure() {
+        return true;
+    },
+    match(handlers) {
+        return handlers.onFailure(error);
+    },
+});
+exports.failure = failure;

package/dist/types/try.d.ts

@@ -0,0 +1,5 @@
+import { AsyncResult } from "./async-result";
+import { Result } from "./result";
+export type Try<T> = () => T;
+export declare const tryCatch: <T, E = unknown>(fn: Try<T>) => Result<T, E>;
+export declare const tryCatchAsync: <T, E = unknown>(fn: () => Promise<T> | T) => AsyncResult<T, E>;

package/dist/types/try.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryCatchAsync = exports.tryCatch = void 0;
+const result_1 = require("./result");
+const tryCatch = (fn) => {
+    try {
+        return (0, result_1.success)(fn());
+    }
+    catch (error) {
+        return (0, result_1.failure)(error);
+    }
+};
+exports.tryCatch = tryCatch;
+const tryCatchAsync = async (fn) => {
+    try {
+        const value = await Promise.resolve(fn());
+        return (0, result_1.success)(value);
+    }
+    catch (error) {
+        return (0, result_1.failure)(error);
+    }
+};
+exports.tryCatchAsync = tryCatchAsync;

package/dist/types/unit.d.ts

@@ -0,0 +1,2 @@
+export type Unit = void;
+export declare const unit: Unit;

package/dist/types/unit.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unit = void 0;
+exports.unit = undefined;

package/package.json

@@ -0,0 +1,98 @@
+{
+    "name": "@deessejs/functions",
+    "version": "0.0.1",
+    "description": "A powerful utility library for building type-safe APIs and functions with context management",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "module": "dist/index.esm.js",
+    "exports": {
+      ".": {
+        "import": "./dist/index.esm.js",
+        "require": "./dist/index.js",
+        "types": "./dist/index.d.ts"
+      },
+      "./api": {
+        "import": "./dist/api.esm.js",
+        "require": "./dist/api.js",
+        "types": "./dist/api.d.ts"
+      },
+      "./checks": {
+        "import": "./dist/checks.esm.js",
+        "require": "./dist/checks.js",
+        "types": "./dist/checks.d.ts"
+      },
+      "./context": {
+        "import": "./dist/context.esm.js",
+        "require": "./dist/context.js",
+        "types": "./dist/context.d.ts"
+      },
+      "./errors": {
+        "import": "./dist/errors.esm.js",
+        "require": "./dist/errors.js",
+        "types": "./dist/errors.d.ts"
+      },
+      "./events": {
+        "import": "./dist/events.esm.js",
+        "require": "./dist/events.js",
+        "types": "./dist/events.d.ts"
+      },
+      "./functions": {
+        "import": "./dist/functions.esm.js",
+        "require": "./dist/functions.js",
+        "types": "./dist/functions.d.ts"
+      },
+      "./types": {
+        "import": "./dist/types.esm.js",
+        "require": "./dist/types.js",
+        "types": "./dist/types.d.ts"
+      }
+    },
+    "files": [
+      "dist/**/*",
+      "README.md",
+      "LICENSE"
+    ],
+    "scripts": {
+      "build": "tsc",
+      "build:watch": "tsc --watch",
+      "prepublishOnly": "npm run build",
+      "test": "echo \"Error: no test specified\" && exit 1",
+      "lint": "eslint src --ext .ts",
+      "lint:fix": "eslint src --ext .ts --fix"
+    },
+    "keywords": [
+      "typescript",
+      "api",
+      "functions",
+      "context",
+      "validation",
+      "zod",
+      "type-safe",
+      "utility"
+    ],
+    "author": "Votre Nom",
+    "license": "MIT",
+    "repository": {
+      "type": "git",
+      "url": "https://github.com/votre-organisation/deesse-api.git",
+      "directory": "packages/functions"
+    },
+    "bugs": {
+      "url": "https://github.com/votre-organisation/deesse-api/issues"
+    },
+    "homepage": "https://github.com/votre-organisation/deesse-api#readme",
+    "engines": {
+      "node": ">=16.0.0"
+    },
+    "packageManager": "pnpm@10.11.1",
+    "dependencies": {
+      "zod": "^4.1.12"
+    },
+    "devDependencies": {
+      "@types/node": "^20.0.0",
+      "typescript": "^5.0.0",
+      "eslint": "^8.0.0",
+      "@typescript-eslint/eslint-plugin": "^6.0.0",
+      "@typescript-eslint/parser": "^6.0.0"
+    }
+  }