Implementing a Declarative Schema Validation Utility

type ValidationResult<T> = { success: true; data: T } | { success: false; error: string };
 
interface Schema<T> {
  parse(input: unknown): ValidationResult<T>;
}
 
const stringSchema: Schema<string> = {
  parse(input: unknown) {
    return typeof input === "string"
      ? { success: true, data: input }
      : { success: false, error: "Expected string" };
  }
};
 
const numberSchema: Schema<number> = {
  parse(input: unknown) {
    return typeof input === "number"
      ? { success: true, data: input }
      : { success: false, error: "Expected number" };
  }
};
 
function objectSchema<T extends Record<string, Schema<any>>>(shape: T): Schema<{
  [K in keyof T]: T[K] extends Schema<infer U> ? U : never;
}> {
  return {
    parse(input: unknown) {
      if (typeof input !== "object" || input === null) {
        return { success: false, error: "Expected object" };
      }
      const result: Record<string, any> = {};
      for (const key in shape) {
        const fieldResult = shape[key].parse((input as Record<string, any>)[key]);
        if (!fieldResult.success) {
          return { success: false, error: `Invalid key '${key}': ${fieldResult.error}` };
        }
        result[key] = fieldResult.data;
      }
      return { success: true, data: result as any };
    }
  };
}
 
const userSchema = objectSchema({ name: stringSchema, age: numberSchema });
const res = userSchema.parse({ name: "Alice", age: 30 });