@axeom/schema 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Axeom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,347 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AxeomSchema: () => AxeomSchema,
+  default: () => index_default,
+  s: () => s
+});
+module.exports = __toCommonJS(index_exports);
+var AxeomSchema = class {
+  _output;
+  _isOptional;
+  _isOptionalVal = false;
+  _isNullable = false;
+  _defaultValue;
+  _transforms = [];
+  /**
+   * Validates and parses the input data, applying all transforms and refinements.
+   * Throws an error if validation fails.
+   */
+  async parse(data) {
+    if (data === void 0) {
+      if (this._defaultValue !== void 0) data = this._defaultValue;
+      else if (this._isOptionalVal) return void 0;
+      else throw new Error("Required field is missing");
+    }
+    if (data === null) {
+      if (this._isNullable) return null;
+      throw new Error("Field cannot be null");
+    }
+    const result = this._validate(data);
+    if (!result.success) throw new Error(result.error);
+    let finalData = result.data;
+    for (const transform of this._transforms) {
+      finalData = await transform(finalData);
+    }
+    return finalData;
+  }
+  /**
+   * Marks the field as optional, allowing 'undefined' inputs.
+   */
+  optional() {
+    this._isOptionalVal = true;
+    return this;
+  }
+  /**
+   * Marks the field as nullable, allowing 'null' inputs.
+   */
+  nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  /**
+   * Sets a default value if the input is missing.
+   */
+  default(val) {
+    this._defaultValue = val;
+    return this;
+  }
+  /**
+   * Transforms the validated output into a new value or type.
+   */
+  transform(fn) {
+    this._transforms.push(fn);
+    return this;
+  }
+  /**
+   * Adds a custom validation check. Throws if the function returns false.
+   */
+  refine(fn, message = "Invalid value") {
+    return this.transform(async (data) => {
+      if (!await fn(data)) throw new Error(message);
+      return data;
+    });
+  }
+};
+var StringSchema = class extends AxeomSchema {
+  _validate(data) {
+    return typeof data === "string" ? { success: true, data } : { success: false, error: `Expected string, got ${typeof data}` };
+  }
+  toJSONSchema() {
+    return {
+      type: "string",
+      ...this._isOptionalVal ? { optional: true } : {},
+      ...this._isNullable ? { nullable: true } : {},
+      ...this._defaultValue !== void 0 ? { default: this._defaultValue } : {}
+    };
+  }
+  min(n) {
+    this.refine((v) => v.length >= n, `Too short (min ${n} characters)`);
+    return this;
+  }
+  max(n) {
+    this.refine((v) => v.length <= n, `Too long (max ${n} characters)`);
+    return this;
+  }
+  length(n) {
+    this.refine((v) => v.length === n, `Must be exactly ${n} characters`);
+    return this;
+  }
+  email() {
+    this.refine((v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v), "Invalid email address");
+    return this;
+  }
+  url() {
+    this.refine((v) => {
+      try {
+        new URL(v);
+        return true;
+      } catch {
+        return false;
+      }
+    }, "Invalid URL");
+    return this;
+  }
+  regex(re, message = "Does not match pattern") {
+    this.refine((v) => re.test(v), message);
+    return this;
+  }
+  trim() {
+    this.transform((v) => v.trim());
+    return this;
+  }
+  toLowerCase() {
+    this.transform((v) => v.toLowerCase());
+    return this;
+  }
+  toUpperCase() {
+    this.transform((v) => v.toUpperCase());
+    return this;
+  }
+};
+var NumberSchema = class extends AxeomSchema {
+  _validate(data) {
+    return typeof data === "number" ? { success: true, data } : { success: false, error: `Expected number, got ${typeof data}` };
+  }
+  toJSONSchema() {
+    return {
+      type: "number",
+      ...this._isOptionalVal ? { optional: true } : {},
+      ...this._isNullable ? { nullable: true } : {},
+      ...this._defaultValue !== void 0 ? { default: this._defaultValue } : {}
+    };
+  }
+  min(n) {
+    this.refine((v) => v >= n, `Must be greater than or equal to ${n}`);
+    return this;
+  }
+  max(n) {
+    this.refine((v) => v <= n, `Must be less than or equal to ${n}`);
+    return this;
+  }
+  int() {
+    this.refine((v) => Number.isInteger(v), "Must be an integer");
+    return this;
+  }
+  positive() {
+    return this.min(0);
+  }
+  negative() {
+    return this.max(0);
+  }
+};
+var BooleanSchema = class extends AxeomSchema {
+  _validate(data) {
+    return typeof data === "boolean" ? { success: true, data } : { success: false, error: `Expected boolean, got ${typeof data}` };
+  }
+  toJSONSchema() {
+    return {
+      type: "boolean",
+      ...this._isOptionalVal ? { optional: true } : {},
+      ...this._isNullable ? { nullable: true } : {},
+      ...this._defaultValue !== void 0 ? { default: this._defaultValue } : {}
+    };
+  }
+};
+var AnySchema = class extends AxeomSchema {
+  _validate(data) {
+    return { success: true, data };
+  }
+  toJSONSchema() {
+    return { type: "any" };
+  }
+};
+var EnumSchema = class extends AxeomSchema {
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+  _validate(data) {
+    return typeof data === "string" && this.values.includes(data) ? { success: true, data } : {
+      success: false,
+      error: `Invalid value. Expected one of: ${this.values.join(", ")}`
+    };
+  }
+  toJSONSchema() {
+    return {
+      type: "string",
+      enum: this.values
+    };
+  }
+};
+var ObjectSchema = class extends AxeomSchema {
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  _validate(data) {
+    return typeof data === "object" && data !== null ? { success: true, data } : { success: false, error: "Expected object" };
+  }
+  toJSONSchema() {
+    const properties = {};
+    for (const key in this.shape) {
+      properties[key] = this.shape[key].toJSONSchema();
+    }
+    return {
+      type: "object",
+      properties,
+      required: Object.keys(this.shape).filter((key) => !this.shape[key]._isOptionalVal)
+    };
+  }
+  async parse(data) {
+    const base = await super.parse(data);
+    const result = {};
+    const errors = [];
+    for (const key in this.shape) {
+      try {
+        result[key] = await this.shape[key].parse(base[key]);
+      } catch (e) {
+        errors.push(`${key}: ${e.message}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(errors.join(", "));
+    }
+    return result;
+  }
+};
+var ArraySchema = class extends AxeomSchema {
+  constructor(itemSchema) {
+    super();
+    this.itemSchema = itemSchema;
+  }
+  _validate(data) {
+    return Array.isArray(data) ? { success: true, data } : { success: false, error: "Expected array" };
+  }
+  toJSONSchema() {
+    return {
+      type: "array",
+      items: this.itemSchema.toJSONSchema()
+    };
+  }
+  min(n) {
+    this.refine((v) => v.length >= n, `Must have at least ${n} items`);
+    return this;
+  }
+  max(n) {
+    this.refine((v) => v.length <= n, `Must have at most ${n} items`);
+    return this;
+  }
+  length(n) {
+    this.refine((v) => v.length === n, `Must have exactly ${n} items`);
+    return this;
+  }
+  async parse(data) {
+    const base = await super.parse(data);
+    const result = await Promise.all(
+      base.map(
+        (item, i) => this.itemSchema.parse(item).catch((e) => {
+          throw new Error(`[${i}]: ${e.message}`);
+        })
+      )
+    );
+    return result;
+  }
+};
+var FileSchema = class extends AxeomSchema {
+  _validate(data) {
+    return data instanceof File || data instanceof Blob ? { success: true, data } : { success: false, error: "Expected File or Blob" };
+  }
+  toJSONSchema() {
+    return {
+      type: "string",
+      format: "binary"
+    };
+  }
+  max(sizeInBytes, message) {
+    return this.refine(
+      (v) => v.size <= sizeInBytes,
+      message || `File is too large (max ${sizeInBytes} bytes)`
+    );
+  }
+  min(sizeInBytes, message) {
+    return this.refine(
+      (v) => v.size >= sizeInBytes,
+      message || `File is too small (min ${sizeInBytes} bytes)`
+    );
+  }
+  type(mimeType, message) {
+    return this.refine(
+      (v) => v.type.startsWith(mimeType),
+      message || `Invalid file type (expected ${mimeType})`
+    );
+  }
+};
+var s = {
+  /** Create a string validator */
+  string: () => new StringSchema(),
+  /** Create a number validator */
+  number: () => new NumberSchema(),
+  /** Create a boolean validator */
+  boolean: () => new BooleanSchema(),
+  /** Create a validator that allows any input */
+  any: () => new AnySchema(),
+  /** Create an enum validator from an array of strings */
+  enum: (values) => new EnumSchema(values),
+  /** Create an object validator from a shape record */
+  object: (shape) => new ObjectSchema(shape),
+  /** Create an array validator for a specific item type */
+  array: (item) => new ArraySchema(item),
+  /** Create a file/blob validator */
+  file: () => new FileSchema()
+};
+var index_default = s;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AxeomSchema,
+  s
+});

package/dist/index.d.cts

@@ -0,0 +1,223 @@
+/**
+ * Axeom Schema
+ * A zero-dependency, ultra-lightweight validation library.
+ */
+type ValidationResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Standard Validator interface for Axeom.
+ */
+interface Validator<T = any> {
+    readonly _output: T;
+    readonly _isOptional?: boolean;
+    parse: (data: unknown) => T | Promise<T>;
+}
+/**
+ * Infer the type of an Axeom Schema.
+ */
+type Infer<S> = S extends Validator<infer T> ? T : never;
+/**
+ * Base Schema class providing chainable modifiers for all schema types.
+ */
+declare abstract class AxeomSchema<T> implements Validator<T> {
+    readonly _output: T;
+    readonly _isOptional: boolean;
+    protected _isOptionalVal: boolean;
+    protected _isNullable: boolean;
+    protected _defaultValue?: T;
+    protected _transforms: Array<(data: any) => any>;
+    /**
+     * Generates a standard JSON Schema representation of the validator.
+     */
+    abstract toJSONSchema(): any;
+    protected abstract _validate(data: unknown): ValidationResult<T>;
+    /**
+     * Validates and parses the input data, applying all transforms and refinements.
+     * Throws an error if validation fails.
+     */
+    parse(data: unknown): Promise<T>;
+    /**
+     * Marks the field as optional, allowing 'undefined' inputs.
+     */
+    optional(): this & {
+        readonly _isOptional: true;
+        readonly _output: T | undefined;
+    };
+    /**
+     * Marks the field as nullable, allowing 'null' inputs.
+     */
+    nullable(): this & {
+        readonly _output: T | null;
+    };
+    /**
+     * Sets a default value if the input is missing.
+     */
+    default(val: T): this;
+    /**
+     * Transforms the validated output into a new value or type.
+     */
+    transform<U>(fn: (data: T) => U | Promise<U>): AxeomSchema<U> & this;
+    /**
+     * Adds a custom validation check. Throws if the function returns false.
+     */
+    refine(fn: (data: T) => boolean | Promise<boolean>, message?: string): this;
+}
+/**
+ * String Schema
+ */
+declare class StringSchema extends AxeomSchema<string> {
+    protected _validate(data: unknown): ValidationResult<string>;
+    toJSONSchema(): {
+        default?: string | undefined;
+        nullable?: boolean | undefined;
+        optional?: boolean | undefined;
+        type: string;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    length(n: number): this;
+    email(): this;
+    url(): this;
+    regex(re: RegExp, message?: string): this;
+    trim(): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+}
+/**
+ * Number Schema
+ */
+declare class NumberSchema extends AxeomSchema<number> {
+    protected _validate(data: unknown): ValidationResult<number>;
+    toJSONSchema(): {
+        default?: number | undefined;
+        nullable?: boolean | undefined;
+        optional?: boolean | undefined;
+        type: string;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    int(): this;
+    positive(): this;
+    negative(): this;
+}
+/**
+ * Boolean Schema
+ */
+declare class BooleanSchema extends AxeomSchema<boolean> {
+    protected _validate(data: unknown): ValidationResult<boolean>;
+    toJSONSchema(): {
+        default?: boolean | undefined;
+        nullable?: boolean | undefined;
+        optional?: boolean | undefined;
+        type: string;
+    };
+}
+/**
+ * Any Schema
+ */
+declare class AnySchema extends AxeomSchema<any> {
+    protected _validate(data: unknown): ValidationResult<any>;
+    toJSONSchema(): {
+        type: string;
+    };
+}
+/**
+ * Enum Schema - Validates that the input is one of a specific set of strings.
+ */
+declare class EnumSchema<T extends string> extends AxeomSchema<T> {
+    private values;
+    constructor(values: T[]);
+    protected _validate(data: unknown): ValidationResult<T>;
+    toJSONSchema(): {
+        type: string;
+        enum: T[];
+    };
+}
+/**
+ * Type to correctly infer optional vs required properties in an object schema.
+ */
+type InferObject<T extends Record<string, Validator>> = {
+    [K in keyof T as T[K] extends {
+        _isOptional: true;
+    } ? never : K]: T[K]["_output"];
+} & {
+    [K in keyof T as T[K] extends {
+        _isOptional: true;
+    } ? K : never]?: T[K]["_output"];
+};
+/**
+ * Object Schema - Handles recursive validation of properties
+ */
+declare class ObjectSchema<T extends Record<string, Validator>> extends AxeomSchema<InferObject<T>> {
+    private shape;
+    constructor(shape: T);
+    protected _validate(data: unknown): ValidationResult<InferObject<T>>;
+    toJSONSchema(): {
+        type: string;
+        properties: any;
+        required: string[];
+    };
+    parse(data: unknown): Promise<InferObject<T>>;
+}
+/**
+ * Array Schema - Handles recursive validation of items
+ */
+declare class ArraySchema<T extends Validator> extends AxeomSchema<T["_output"][]> {
+    private itemSchema;
+    constructor(itemSchema: T);
+    protected _validate(data: unknown): ValidationResult<T["_output"][]>;
+    toJSONSchema(): {
+        type: string;
+        items: any;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    length(n: number): this;
+    parse(data: unknown): Promise<T["_output"][]>;
+}
+/**
+ * File Schema - Validates that the input is a standard File or Blob.
+ */
+declare class FileSchema extends AxeomSchema<File> {
+    protected _validate(data: unknown): ValidationResult<File>;
+    toJSONSchema(): {
+        type: string;
+        format: string;
+    };
+    max(sizeInBytes: number, message?: string): this;
+    min(sizeInBytes: number, message?: string): this;
+    type(mimeType: MimeType, message?: string): this;
+}
+/**
+ * Common Mime Types for autocomplete
+ */
+type MimeType = "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/svg+xml" | "application/pdf" | "application/json" | "application/xml" | "application/zip" | "application/x-zip-compressed" | "application/octet-stream" | "text/plain" | "text/html" | "text/css" | "text/javascript" | "video/mp4" | "video/mpeg" | "audio/mpeg" | "audio/wav" | "image/" | "video/" | "audio/" | "text/" | "application/" | (string & {});
+/**
+ * The main library interface.
+ * Use this to create new schema validators.
+ */
+declare const s: {
+    /** Create a string validator */
+    string: () => StringSchema;
+    /** Create a number validator */
+    number: () => NumberSchema;
+    /** Create a boolean validator */
+    boolean: () => BooleanSchema;
+    /** Create a validator that allows any input */
+    any: () => AnySchema;
+    /** Create an enum validator from an array of strings */
+    enum: <T extends string>(values: T[]) => EnumSchema<T>;
+    /** Create an object validator from a shape record */
+    object: <T extends Record<string, Validator>>(shape: T) => ObjectSchema<T>;
+    /** Create an array validator for a specific item type */
+    array: <T extends Validator>(item: T) => ArraySchema<T>;
+    /** Create a file/blob validator */
+    file: () => FileSchema;
+};
+
+export { AxeomSchema, type Infer, type InferObject, type MimeType, type Validator, s as default, s };

package/dist/index.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Axeom Schema
+ * A zero-dependency, ultra-lightweight validation library.
+ */
+type ValidationResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Standard Validator interface for Axeom.
+ */
+interface Validator<T = any> {
+    readonly _output: T;
+    readonly _isOptional?: boolean;
+    parse: (data: unknown) => T | Promise<T>;
+}
+/**
+ * Infer the type of an Axeom Schema.
+ */
+type Infer<S> = S extends Validator<infer T> ? T : never;
+/**
+ * Base Schema class providing chainable modifiers for all schema types.
+ */
+declare abstract class AxeomSchema<T> implements Validator<T> {
+    readonly _output: T;
+    readonly _isOptional: boolean;
+    protected _isOptionalVal: boolean;
+    protected _isNullable: boolean;
+    protected _defaultValue?: T;
+    protected _transforms: Array<(data: any) => any>;
+    /**
+     * Generates a standard JSON Schema representation of the validator.
+     */
+    abstract toJSONSchema(): any;
+    protected abstract _validate(data: unknown): ValidationResult<T>;
+    /**
+     * Validates and parses the input data, applying all transforms and refinements.
+     * Throws an error if validation fails.
+     */
+    parse(data: unknown): Promise<T>;
+    /**
+     * Marks the field as optional, allowing 'undefined' inputs.
+     */
+    optional(): this & {
+        readonly _isOptional: true;
+        readonly _output: T | undefined;
+    };
+    /**
+     * Marks the field as nullable, allowing 'null' inputs.
+     */
+    nullable(): this & {
+        readonly _output: T | null;
+    };
+    /**
+     * Sets a default value if the input is missing.
+     */
+    default(val: T): this;
+    /**
+     * Transforms the validated output into a new value or type.
+     */
+    transform<U>(fn: (data: T) => U | Promise<U>): AxeomSchema<U> & this;
+    /**
+     * Adds a custom validation check. Throws if the function returns false.
+     */
+    refine(fn: (data: T) => boolean | Promise<boolean>, message?: string): this;
+}
+/**
+ * String Schema
+ */
+declare class StringSchema extends AxeomSchema<string> {
+    protected _validate(data: unknown): ValidationResult<string>;
+    toJSONSchema(): {
+        default?: string | undefined;
+        nullable?: boolean | undefined;
+        optional?: boolean | undefined;
+        type: string;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    length(n: number): this;
+    email(): this;
+    url(): this;
+    regex(re: RegExp, message?: string): this;
+    trim(): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+}
+/**
+ * Number Schema
+ */
+declare class NumberSchema extends AxeomSchema<number> {
+    protected _validate(data: unknown): ValidationResult<number>;
+    toJSONSchema(): {
+        default?: number | undefined;
+        nullable?: boolean | undefined;
+        optional?: boolean | undefined;
+        type: string;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    int(): this;
+    positive(): this;
+    negative(): this;
+}
+/**
+ * Boolean Schema
+ */
+declare class BooleanSchema extends AxeomSchema<boolean> {
+    protected _validate(data: unknown): ValidationResult<boolean>;
+    toJSONSchema(): {
+        default?: boolean | undefined;
+        nullable?: boolean | undefined;
+        optional?: boolean | undefined;
+        type: string;
+    };
+}
+/**
+ * Any Schema
+ */
+declare class AnySchema extends AxeomSchema<any> {
+    protected _validate(data: unknown): ValidationResult<any>;
+    toJSONSchema(): {
+        type: string;
+    };
+}
+/**
+ * Enum Schema - Validates that the input is one of a specific set of strings.
+ */
+declare class EnumSchema<T extends string> extends AxeomSchema<T> {
+    private values;
+    constructor(values: T[]);
+    protected _validate(data: unknown): ValidationResult<T>;
+    toJSONSchema(): {
+        type: string;
+        enum: T[];
+    };
+}
+/**
+ * Type to correctly infer optional vs required properties in an object schema.
+ */
+type InferObject<T extends Record<string, Validator>> = {
+    [K in keyof T as T[K] extends {
+        _isOptional: true;
+    } ? never : K]: T[K]["_output"];
+} & {
+    [K in keyof T as T[K] extends {
+        _isOptional: true;
+    } ? K : never]?: T[K]["_output"];
+};
+/**
+ * Object Schema - Handles recursive validation of properties
+ */
+declare class ObjectSchema<T extends Record<string, Validator>> extends AxeomSchema<InferObject<T>> {
+    private shape;
+    constructor(shape: T);
+    protected _validate(data: unknown): ValidationResult<InferObject<T>>;
+    toJSONSchema(): {
+        type: string;
+        properties: any;
+        required: string[];
+    };
+    parse(data: unknown): Promise<InferObject<T>>;
+}
+/**
+ * Array Schema - Handles recursive validation of items
+ */
+declare class ArraySchema<T extends Validator> extends AxeomSchema<T["_output"][]> {
+    private itemSchema;
+    constructor(itemSchema: T);
+    protected _validate(data: unknown): ValidationResult<T["_output"][]>;
+    toJSONSchema(): {
+        type: string;
+        items: any;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    length(n: number): this;
+    parse(data: unknown): Promise<T["_output"][]>;
+}
+/**
+ * File Schema - Validates that the input is a standard File or Blob.
+ */
+declare class FileSchema extends AxeomSchema<File> {
+    protected _validate(data: unknown): ValidationResult<File>;
+    toJSONSchema(): {
+        type: string;
+        format: string;
+    };
+    max(sizeInBytes: number, message?: string): this;
+    min(sizeInBytes: number, message?: string): this;
+    type(mimeType: MimeType, message?: string): this;
+}
+/**
+ * Common Mime Types for autocomplete
+ */
+type MimeType = "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/svg+xml" | "application/pdf" | "application/json" | "application/xml" | "application/zip" | "application/x-zip-compressed" | "application/octet-stream" | "text/plain" | "text/html" | "text/css" | "text/javascript" | "video/mp4" | "video/mpeg" | "audio/mpeg" | "audio/wav" | "image/" | "video/" | "audio/" | "text/" | "application/" | (string & {});
+/**
+ * The main library interface.
+ * Use this to create new schema validators.
+ */
+declare const s: {
+    /** Create a string validator */
+    string: () => StringSchema;
+    /** Create a number validator */
+    number: () => NumberSchema;
+    /** Create a boolean validator */
+    boolean: () => BooleanSchema;
+    /** Create a validator that allows any input */
+    any: () => AnySchema;
+    /** Create an enum validator from an array of strings */
+    enum: <T extends string>(values: T[]) => EnumSchema<T>;
+    /** Create an object validator from a shape record */
+    object: <T extends Record<string, Validator>>(shape: T) => ObjectSchema<T>;
+    /** Create an array validator for a specific item type */
+    array: <T extends Validator>(item: T) => ArraySchema<T>;
+    /** Create a file/blob validator */
+    file: () => FileSchema;
+};
+
+export { AxeomSchema, type Infer, type InferObject, type MimeType, type Validator, s as default, s };

package/dist/index.js

@@ -0,0 +1,321 @@
+// src/index.ts
+var AxeomSchema = class {
+  _output;
+  _isOptional;
+  _isOptionalVal = false;
+  _isNullable = false;
+  _defaultValue;
+  _transforms = [];
+  /**
+   * Validates and parses the input data, applying all transforms and refinements.
+   * Throws an error if validation fails.
+   */
+  async parse(data) {
+    if (data === void 0) {
+      if (this._defaultValue !== void 0) data = this._defaultValue;
+      else if (this._isOptionalVal) return void 0;
+      else throw new Error("Required field is missing");
+    }
+    if (data === null) {
+      if (this._isNullable) return null;
+      throw new Error("Field cannot be null");
+    }
+    const result = this._validate(data);
+    if (!result.success) throw new Error(result.error);
+    let finalData = result.data;
+    for (const transform of this._transforms) {
+      finalData = await transform(finalData);
+    }
+    return finalData;
+  }
+  /**
+   * Marks the field as optional, allowing 'undefined' inputs.
+   */
+  optional() {
+    this._isOptionalVal = true;
+    return this;
+  }
+  /**
+   * Marks the field as nullable, allowing 'null' inputs.
+   */
+  nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  /**
+   * Sets a default value if the input is missing.
+   */
+  default(val) {
+    this._defaultValue = val;
+    return this;
+  }
+  /**
+   * Transforms the validated output into a new value or type.
+   */
+  transform(fn) {
+    this._transforms.push(fn);
+    return this;
+  }
+  /**
+   * Adds a custom validation check. Throws if the function returns false.
+   */
+  refine(fn, message = "Invalid value") {
+    return this.transform(async (data) => {
+      if (!await fn(data)) throw new Error(message);
+      return data;
+    });
+  }
+};
+var StringSchema = class extends AxeomSchema {
+  _validate(data) {
+    return typeof data === "string" ? { success: true, data } : { success: false, error: `Expected string, got ${typeof data}` };
+  }
+  toJSONSchema() {
+    return {
+      type: "string",
+      ...this._isOptionalVal ? { optional: true } : {},
+      ...this._isNullable ? { nullable: true } : {},
+      ...this._defaultValue !== void 0 ? { default: this._defaultValue } : {}
+    };
+  }
+  min(n) {
+    this.refine((v) => v.length >= n, `Too short (min ${n} characters)`);
+    return this;
+  }
+  max(n) {
+    this.refine((v) => v.length <= n, `Too long (max ${n} characters)`);
+    return this;
+  }
+  length(n) {
+    this.refine((v) => v.length === n, `Must be exactly ${n} characters`);
+    return this;
+  }
+  email() {
+    this.refine((v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v), "Invalid email address");
+    return this;
+  }
+  url() {
+    this.refine((v) => {
+      try {
+        new URL(v);
+        return true;
+      } catch {
+        return false;
+      }
+    }, "Invalid URL");
+    return this;
+  }
+  regex(re, message = "Does not match pattern") {
+    this.refine((v) => re.test(v), message);
+    return this;
+  }
+  trim() {
+    this.transform((v) => v.trim());
+    return this;
+  }
+  toLowerCase() {
+    this.transform((v) => v.toLowerCase());
+    return this;
+  }
+  toUpperCase() {
+    this.transform((v) => v.toUpperCase());
+    return this;
+  }
+};
+var NumberSchema = class extends AxeomSchema {
+  _validate(data) {
+    return typeof data === "number" ? { success: true, data } : { success: false, error: `Expected number, got ${typeof data}` };
+  }
+  toJSONSchema() {
+    return {
+      type: "number",
+      ...this._isOptionalVal ? { optional: true } : {},
+      ...this._isNullable ? { nullable: true } : {},
+      ...this._defaultValue !== void 0 ? { default: this._defaultValue } : {}
+    };
+  }
+  min(n) {
+    this.refine((v) => v >= n, `Must be greater than or equal to ${n}`);
+    return this;
+  }
+  max(n) {
+    this.refine((v) => v <= n, `Must be less than or equal to ${n}`);
+    return this;
+  }
+  int() {
+    this.refine((v) => Number.isInteger(v), "Must be an integer");
+    return this;
+  }
+  positive() {
+    return this.min(0);
+  }
+  negative() {
+    return this.max(0);
+  }
+};
+var BooleanSchema = class extends AxeomSchema {
+  _validate(data) {
+    return typeof data === "boolean" ? { success: true, data } : { success: false, error: `Expected boolean, got ${typeof data}` };
+  }
+  toJSONSchema() {
+    return {
+      type: "boolean",
+      ...this._isOptionalVal ? { optional: true } : {},
+      ...this._isNullable ? { nullable: true } : {},
+      ...this._defaultValue !== void 0 ? { default: this._defaultValue } : {}
+    };
+  }
+};
+var AnySchema = class extends AxeomSchema {
+  _validate(data) {
+    return { success: true, data };
+  }
+  toJSONSchema() {
+    return { type: "any" };
+  }
+};
+var EnumSchema = class extends AxeomSchema {
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+  _validate(data) {
+    return typeof data === "string" && this.values.includes(data) ? { success: true, data } : {
+      success: false,
+      error: `Invalid value. Expected one of: ${this.values.join(", ")}`
+    };
+  }
+  toJSONSchema() {
+    return {
+      type: "string",
+      enum: this.values
+    };
+  }
+};
+var ObjectSchema = class extends AxeomSchema {
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  _validate(data) {
+    return typeof data === "object" && data !== null ? { success: true, data } : { success: false, error: "Expected object" };
+  }
+  toJSONSchema() {
+    const properties = {};
+    for (const key in this.shape) {
+      properties[key] = this.shape[key].toJSONSchema();
+    }
+    return {
+      type: "object",
+      properties,
+      required: Object.keys(this.shape).filter((key) => !this.shape[key]._isOptionalVal)
+    };
+  }
+  async parse(data) {
+    const base = await super.parse(data);
+    const result = {};
+    const errors = [];
+    for (const key in this.shape) {
+      try {
+        result[key] = await this.shape[key].parse(base[key]);
+      } catch (e) {
+        errors.push(`${key}: ${e.message}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(errors.join(", "));
+    }
+    return result;
+  }
+};
+var ArraySchema = class extends AxeomSchema {
+  constructor(itemSchema) {
+    super();
+    this.itemSchema = itemSchema;
+  }
+  _validate(data) {
+    return Array.isArray(data) ? { success: true, data } : { success: false, error: "Expected array" };
+  }
+  toJSONSchema() {
+    return {
+      type: "array",
+      items: this.itemSchema.toJSONSchema()
+    };
+  }
+  min(n) {
+    this.refine((v) => v.length >= n, `Must have at least ${n} items`);
+    return this;
+  }
+  max(n) {
+    this.refine((v) => v.length <= n, `Must have at most ${n} items`);
+    return this;
+  }
+  length(n) {
+    this.refine((v) => v.length === n, `Must have exactly ${n} items`);
+    return this;
+  }
+  async parse(data) {
+    const base = await super.parse(data);
+    const result = await Promise.all(
+      base.map(
+        (item, i) => this.itemSchema.parse(item).catch((e) => {
+          throw new Error(`[${i}]: ${e.message}`);
+        })
+      )
+    );
+    return result;
+  }
+};
+var FileSchema = class extends AxeomSchema {
+  _validate(data) {
+    return data instanceof File || data instanceof Blob ? { success: true, data } : { success: false, error: "Expected File or Blob" };
+  }
+  toJSONSchema() {
+    return {
+      type: "string",
+      format: "binary"
+    };
+  }
+  max(sizeInBytes, message) {
+    return this.refine(
+      (v) => v.size <= sizeInBytes,
+      message || `File is too large (max ${sizeInBytes} bytes)`
+    );
+  }
+  min(sizeInBytes, message) {
+    return this.refine(
+      (v) => v.size >= sizeInBytes,
+      message || `File is too small (min ${sizeInBytes} bytes)`
+    );
+  }
+  type(mimeType, message) {
+    return this.refine(
+      (v) => v.type.startsWith(mimeType),
+      message || `Invalid file type (expected ${mimeType})`
+    );
+  }
+};
+var s = {
+  /** Create a string validator */
+  string: () => new StringSchema(),
+  /** Create a number validator */
+  number: () => new NumberSchema(),
+  /** Create a boolean validator */
+  boolean: () => new BooleanSchema(),
+  /** Create a validator that allows any input */
+  any: () => new AnySchema(),
+  /** Create an enum validator from an array of strings */
+  enum: (values) => new EnumSchema(values),
+  /** Create an object validator from a shape record */
+  object: (shape) => new ObjectSchema(shape),
+  /** Create an array validator for a specific item type */
+  array: (item) => new ArraySchema(item),
+  /** Create a file/blob validator */
+  file: () => new FileSchema()
+};
+var index_default = s;
+export {
+  AxeomSchema,
+  index_default as default,
+  s
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@axeom/schema",
+  "version": "0.1.1",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}