feat: add tests, 98% coverage, handle sync/async, insane types.. and more

Signed-off-by: tunnckoCore <5038030+tunnckoCore@users.noreply.github.com>

Author: tunnckoCore

new-src/errors.ts

@@ -82,7 +82,7 @@ export function createValidationError<ErrorKindNames = never>(
   } as const;
 }
 
-export function createInternalError(msg: string, cause?: Error) {
+export function createInternalError(msg: string, cause?: any) {
   return {
     kind: "UNKNOWN_ERROR" as const,
     message: msg,

new-src/index.ts

@@ -3,14 +3,13 @@ import {
   type ErrorsMapResolved,
   type ResolveErrorKindNames,
 } from "./errors";
+import type { ConditionalAsync } from "./is-promise";
 
 import type {
   AnySchema,
   InferSchemaInput,
-  InferSchemaInputSafe,
   InferSchemaOutput,
   InferSchemaOutputSafe,
-  IsPromise,
   Prettify,
   ProcedureOptions,
   SpreadTuple,
@@ -30,8 +29,7 @@ export function zagora() {
 }
 
 export class Zagora<
-  TIsHandlerAsync,
-  THandlerFn,
+  THandlerFn extends (...args: any[]) => unknown,
   TContext extends any | undefined = undefined,
   TInputSchema extends AnySchema | undefined = undefined,
   TOutputSchema extends AnySchema | undefined = undefined,
@@ -45,14 +43,7 @@ export class Zagora<
 
   input<TInput extends AnySchema>(
     inputSchema: TInput,
-  ): Zagora<
-    TIsHandlerAsync,
-    THandlerFn,
-    TContext,
-    TInput,
-    TOutputSchema,
-    TErrorsMap
-  > {
+  ): Zagora<THandlerFn, TContext, TInput, TOutputSchema, TErrorsMap> {
     return new Zagora({
       ...this.def,
       inputSchema,
@@ -61,14 +52,7 @@ export class Zagora<
 
   output<TOutput extends AnySchema>(
     outputSchema: TOutput,
-  ): Zagora<
-    TIsHandlerAsync,
-    THandlerFn,
-    TContext,
-    TInputSchema,
-    TOutput,
-    TErrorsMap
-  > {
+  ): Zagora<THandlerFn, TContext, TInputSchema, TOutput, TErrorsMap> {
     return new Zagora({
       ...this.def,
       outputSchema,
@@ -77,14 +61,7 @@ export class Zagora<
 
   context<TNewContext>(
     initialContext?: TNewContext,
-  ): Zagora<
-    TIsHandlerAsync,
-    THandlerFn,
-    TNewContext,
-    TInputSchema,
-    TOutputSchema,
-    TErrorsMap
-  > {
+  ): Zagora<THandlerFn, TNewContext, TInputSchema, TOutputSchema, TErrorsMap> {
     return new Zagora({
       ...this.def,
       initialContext,
@@ -93,14 +70,7 @@ export class Zagora<
 
   errors<TErrors extends Record<string, AnySchema>>(
     errorsMap: TErrors & UppercaseKeys<TErrors>,
-  ): Zagora<
-    TIsHandlerAsync,
-    THandlerFn,
-    TContext,
-    TInputSchema,
-    TOutputSchema,
-    TErrors
-  > {
+  ): Zagora<THandlerFn, TContext, TInputSchema, TOutputSchema, TErrors> {
     return new Zagora({
       ...this.def,
       errorsMap,
@@ -122,14 +92,10 @@ export class Zagora<
             arg: InferSchemaOutput<TInputSchema>,
           ) => any
       : (options: Prettify<ProcedureOptions<TContext, TErrorsMap>>) => any,
-    TReturn = ReturnType<TFn>,
-    TIsAsync extends boolean = IsPromise<TReturn>,
-  >(
-    fn: TFn,
-  ): Zagora<TIsAsync, TFn, TContext, TInputSchema, TOutputSchema, TErrorsMap> {
+  >(fn: TFn): Zagora<TFn, TContext, TInputSchema, TOutputSchema, TErrorsMap> {
     return new Zagora({
       ...this.def,
-      handler: fn as any,
+      handler: fn,
     });
   }
 
@@ -168,19 +134,14 @@ export class Zagora<
 
     type TResolvedResult = Awaited<ReturnType<typeof procedure>>;
 
-    type TResult = TIsHandlerAsync extends true
-      ? Promise<
-          ZagoraResult<
-            InferSchemaOutputSafe<TOutputSchema>,
-            ErrorsMapResolved<TErrorsMap>,
-            TResolvedResult
-          >
-        >
-      : ZagoraResult<
-          InferSchemaOutputSafe<TOutputSchema>,
-          ErrorsMapResolved<TErrorsMap>,
-          TResolvedResult
-        >;
+    type TResult = ConditionalAsync<
+      ReturnType<THandlerFn>,
+      ZagoraResult<
+        InferSchemaOutputSafe<TOutputSchema>,
+        ErrorsMapResolved<TErrorsMap>,
+        TResolvedResult
+      >
+    >;
 
     return procedure as TInputSchema extends AnySchema
       ? InferSchemaInput<TInputSchema> extends readonly any[]

new-src/is-promise.ts

@@ -0,0 +1,69 @@
+/**
+ * Detects the literal type `any`.
+ *
+ * This helper type returns `true` if the type parameter `T` is literally the `any` type,
+ * and `false` otherwise. Uses the `0 extends 1 & T` trick which only passes for `any`.
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+/**
+ * Returns `true` if the supplied value type `V` is a concrete promise.
+ *
+ * ## Behavior:
+ * - `string | number | { … }`         → `false`
+ * - `{ … } | undefined | null | void` → `false`
+ * - `new Promise(...)`                → `true`
+ * - `Promise.resolve(...)`            → `true`
+ * - `async () => …` return type       → `true`
+ * - **explicit** `ReturnType<void>`   → `false`
+ * - `any`                             → `false`
+ * - `Promise<any>`                    → `true`
+ *
+ * ## Special Notes
+ * - The literal value `any` is explicitly treated as "not a promise"
+ * - However, `Promise<any>` IS detected as a promise (since we know it's wrapped)
+ * - Uses array wrapper `[T]` to prevent distributive conditional types
+ *
+ * @template V - The value type you want to test
+ */
+export type IsPromise<V> = IsAny<V> extends true
+  ? false // Bare `any` → treat as non-promise
+  : [V] extends [Promise<any>]
+    ? true // Explicitly Promise<T> → is a promise
+    : [V] extends [PromiseLike<any>]
+      ? true // PromiseLike<T> → is a promise
+      : [Awaited<V>] extends [V]
+        ? false // Awaiting V gives us V → not a promise
+        : IsAny<Awaited<V>> extends true
+          ? false // If Awaited<V> is any, we can't tell → treat as non-promise
+          : true; // Awaiting V gives us something different → is a promise
+
+/**
+ * Conditionally wraps a result type in a Promise based on whether the input type is a Promise.
+ *
+ * ## Use Case
+ * Perfect for functions that should return `Promise<Result>` for async handlers
+ * and `Result` for sync handlers.
+ *
+ * ## Behavior:
+ * - `ConditionalAsync<Promise<T>, Result>` → `Promise<Result>`
+ * - `ConditionalAsync<T, Result>`          → `Result`
+ * - `ConditionalAsync<any, Result>`        → `Result` (bare `any` is treated as sync)
+ * - `ConditionalAsync<Promise<any>, Result>` → `Promise<Result>` (Promise<any> is treated as async)
+ *
+ * ## Example:
+ * ```ts
+ * type Handler<T> = () => T;
+ * type CallableResult<T> = ConditionalAsync<T, Result<Awaited<T>>>;
+ *
+ * // async () => string  →  ReturnType is Promise<string>  →  Promise<Result<string>>
+ * // () => string        →  ReturnType is string           →  Result<string>
+ * // () => Promise<T>    →  ReturnType is Promise<T>       →  Promise<Result<T>>
+ * ```
+ *
+ * @template T - The type to check (typically a function's return type)
+ * @template Result - The result type to wrap conditionally
+ */
+export type ConditionalAsync<T, Result> = IsPromise<T> extends true
+  ? Promise<Result> // Is a promise → wrap in Promise
+  : Result; // Not a promise (including bare `any`) → return as-is

new-src/types.ts

@@ -7,6 +7,8 @@ import type {
   ValidationError,
 } from "./errors";
 
+export * from "./is-promise";
+
 export type Schema<I, O = I> = StandardSchemaV1<I, O>;
 
 export type AnySchema = Schema<any, any>;
@@ -29,11 +31,11 @@ export type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<
 
 export type InferSchemaOutputSafe<T> = T extends AnySchema
   ? InferSchemaOutput<T>
-  : any;
+  : unknown;
 
 export type InferSchemaInputSafe<T> = T extends AnySchema
   ? InferSchemaInput<T>
-  : any;
+  : unknown;
 
 export type UppercaseKeys<T> = {
   [K in keyof T as Uppercase<string & K>]: T[K];
@@ -44,7 +46,15 @@ export type Prettify<T> = {
 } & {};
 
 export type IsOptional<T> = undefined extends T ? true : false;
-export type IsPromise<T> = T extends Promise<any> ? true : false;
+export type IsPromise<T> = T extends Promise<infer _>
+  ? T extends string
+    ? false
+    : T extends number
+      ? false
+      : number
+  : T extends any
+    ? string
+    : false;
 
 // export type DefinedErrorsUnion<TErrorsMap> = TErrorsMap extends Record<
 //   string,