feat: prep new-src, better build & typecheck

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

Author: tunnckoCore

bun.lock

@@ -0,0 +1,126 @@
+import type {
+  AnySchema,
+  InferSchemaInput,
+  InferSchemaOutput,
+  Prettify,
+  SchemaIssue,
+} from "./types";
+
+export type ValidationError<ErrorKindNames = never> = Prettify<
+  Readonly<{
+    kind: "VALIDATION_ERROR";
+    message: string;
+    issues: readonly SchemaIssue[];
+    key?: ErrorKindNames;
+  }>
+>;
+export type InternalError = Prettify<ReturnType<typeof createInternalError>>;
+export type DefinedError<T> = Prettify<{ readonly kind: string } & T>;
+export type ZagoraError<T> =
+  | ValidationError
+  | InternalError
+  | DefinedError<any>;
+
+export function isValidationError(val: any): val is ValidationError {
+  return Boolean(
+    val &&
+      val.kind === "VALIDATION_ERROR" &&
+      val.issues &&
+      Array.isArray(val.issues) &&
+      val.message &&
+      typeof val.message === "string",
+  );
+}
+export function isInternalError(val: any): val is InternalError {
+  return Boolean(
+    val &&
+      val.kind === "UNKNOWN_ERROR" &&
+      val.message &&
+      typeof val.message === "string" &&
+      val.cause,
+  );
+}
+export function isDefinedError<T>(val: any): val is DefinedError<T> {
+  return Boolean(
+    val &&
+      val.kind &&
+      typeof val.kind === "string" &&
+      val.kind.length > 0 &&
+      val.kind === val.kind.toUpperCase(),
+  );
+}
+
+export function isZagoraError<T>(val: any): val is ZagoraError<T> {
+  return isValidationError(val) || isInternalError(val) || isDefinedError(val);
+}
+
+export function createValidationError<ErrorKindNames = never>(
+  mode: "input" | "output" | "error data",
+  issues: SchemaIssue[],
+  key?: ErrorKindNames,
+) {
+  const modeName = mode.charAt(0).toUpperCase() + mode.slice(1);
+  const str = key ? ` for ${(key as string).toUpperCase()}` : "";
+  const issuesMsg = issues
+    // strip "input" cuz it can be confusing when we are schema validating output and errors too
+    .map((issue) => {
+      const key = issue.path?.join(".");
+      const message = issue.message.replace("Invalid input: ", "");
+      return `${key} => ${message}`;
+    })
+    .join("; ");
+
+  return {
+    kind: "VALIDATION_ERROR" as const,
+    message: `${modeName} validation failed${str}: ${issuesMsg}`,
+    key,
+    issues: issues as SchemaIssue[],
+  } as const;
+}
+
+export function createInternalError(msg: string, cause?: Error) {
+  return {
+    kind: "UNKNOWN_ERROR" as const,
+    message: msg,
+    cause,
+    stack: cause?.stack,
+  } as const;
+}
+
+export function createErrorHelpers(
+  errorMap: any,
+): Record<string, (data: any) => any> {
+  const helpers: any = {};
+  for (const key in errorMap) {
+    const schema = errorMap[key];
+    if (!schema) continue;
+
+    helpers[key] = (data: any) => {
+      return { kind: key, ...data };
+    };
+  }
+  return helpers;
+}
+
+export type ErrorHelpers<
+  TErrorsMap extends Record<string, AnySchema> | undefined,
+> = TErrorsMap extends Record<string, AnySchema>
+  ? {
+      [K in keyof TErrorsMap]: (
+        data: Prettify<Omit<InferSchemaInput<TErrorsMap[K]>, "kind">>,
+      ) => never;
+    }
+  : never;
+
+export type ErrorsMapResolved<
+  TErrorsMap extends Record<string, AnySchema> | undefined,
+> = TErrorsMap extends Record<string, AnySchema>
+  ? Readonly<{ [K in keyof TErrorsMap]: InferSchemaOutput<TErrorsMap[K]> }>
+  : undefined;
+
+export type ResolveErrorKindNames<TErrorsMap> = TErrorsMap extends Record<
+  string,
+  AnySchema
+>
+  ? keyof TErrorsMap
+  : undefined;

new-src/errors.ts

@@ -0,0 +1,185 @@
+import {
+  createErrorHelpers,
+  type ErrorsMapResolved,
+  type ResolveErrorKindNames,
+} from "./errors";
+
+import type {
+  AnySchema,
+  InferSchemaInput,
+  InferSchemaOutput,
+  IsPromise,
+  Prettify,
+  ProcedureOptions,
+  SpreadTuple,
+  UppercaseKeys,
+  ZagoraDef,
+  ZagoraResult,
+} from "./types";
+
+import { createProcedure, deepMerge } from "./utils";
+
+export * as errors from "./errors";
+export * as types from "./types";
+export * as utils from "./utils";
+
+export function zagora() {
+  return new Zagora();
+}
+
+export class Zagora<
+  TIsHandlerAsync,
+  THandlerFn,
+  TContext extends any | undefined = undefined,
+  TInputSchema extends AnySchema = never,
+  TOutputSchema extends AnySchema = never,
+  TErrorsMap extends Record<string, AnySchema> | undefined = undefined,
+> {
+  constructor(
+    private def: Partial<
+      ZagoraDef<TContext, TInputSchema, TOutputSchema, TErrorsMap>
+    > = {},
+  ) {}
+
+  input<TInput extends AnySchema>(
+    inputSchema: TInput,
+  ): Zagora<
+    TIsHandlerAsync,
+    THandlerFn,
+    TContext,
+    TInput,
+    TOutputSchema,
+    TErrorsMap
+  > {
+    return new Zagora({
+      ...this.def,
+      inputSchema: inputSchema,
+    });
+  }
+
+  output<TOutput extends AnySchema>(
+    outputSchema: TOutput,
+  ): Zagora<
+    TIsHandlerAsync,
+    THandlerFn,
+    TContext,
+    TInputSchema,
+    TOutput,
+    TErrorsMap
+  > {
+    return new Zagora({
+      ...this.def,
+      outputSchema: outputSchema,
+    });
+  }
+
+  context<TNewContext>(
+    initialContext?: TNewContext,
+  ): Zagora<
+    TIsHandlerAsync,
+    THandlerFn,
+    TNewContext,
+    TInputSchema,
+    TOutputSchema,
+    TErrorsMap
+  > {
+    return new Zagora({
+      ...this.def,
+      initialContext,
+    }) as any;
+  }
+
+  errors<TErrors extends Record<string, AnySchema>>(
+    errorsMap: TErrors & UppercaseKeys<TErrors>,
+  ): Zagora<
+    TIsHandlerAsync,
+    THandlerFn,
+    TContext,
+    TInputSchema,
+    TOutputSchema,
+    TErrors
+  > {
+    return new Zagora({
+      ...this.def,
+      errorsMap,
+    });
+  }
+
+  handler<
+    TFn extends InferSchemaOutput<TInputSchema> extends readonly any[]
+      ? SpreadTuple<
+          [
+            Prettify<ProcedureOptions<TContext, TErrorsMap>>,
+            ...InferSchemaOutput<TInputSchema>,
+          ],
+          any
+        >
+      : (
+          options: Prettify<ProcedureOptions<TContext, TErrorsMap>>,
+          arg: InferSchemaOutput<TInputSchema>,
+        ) => any,
+    TReturn = ReturnType<TFn>,
+    TIsAsync extends boolean = IsPromise<TReturn>,
+  >(
+    fn: TFn,
+  ): Zagora<TIsAsync, TFn, TContext, TInputSchema, TOutputSchema, TErrorsMap> {
+    return new Zagora({
+      ...this.def,
+      handler: fn as any,
+    });
+  }
+
+  callable<
+    TNewContext extends TContext,
+    TKindNames extends ResolveErrorKindNames<TErrorsMap>,
+  >(context?: TNewContext) {
+    if (typeof this.def.handler !== "function") {
+      this.def.handler = () => {};
+    }
+
+    const { initialContext, errorsMap } = this.def;
+    const handlerFn = this.def.handler;
+    const inputSchema = this.def.inputSchema as TInputSchema;
+    const outputSchema = this.def.outputSchema as TOutputSchema;
+
+    const mergedContext = context
+      ? deepMerge(initialContext, context)
+      : initialContext;
+
+    const errors = errorsMap ? createErrorHelpers(errorsMap as any) : undefined;
+    const options = {
+      errors: errors,
+      context: mergedContext,
+    } as Prettify<
+      ProcedureOptions<Prettify<TNewContext & TContext>, TErrorsMap>
+    >;
+
+    const procedure = createProcedure<TKindNames>({
+      inputSchema,
+      outputSchema,
+      errorsMap,
+      options,
+      handlerFn,
+    });
+
+    type TResolvedResult = Awaited<ReturnType<typeof procedure>>;
+
+    type TResult = TIsHandlerAsync extends true
+      ? Promise<
+          ZagoraResult<
+            InferSchemaOutput<TOutputSchema>,
+            ErrorsMapResolved<TErrorsMap>,
+            TResolvedResult
+          >
+        >
+      : ZagoraResult<
+          InferSchemaOutput<TOutputSchema>,
+          ErrorsMapResolved<TErrorsMap>,
+          TResolvedResult
+        >;
+
+    return procedure as InferSchemaInput<TInputSchema> extends readonly any[]
+      ? SpreadTuple<InferSchemaInput<TInputSchema>, TResult>
+      : (arg: InferSchemaOutput<TInputSchema>) => TResult;
+  }
+}