lightv-schema 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Danil Yeremenchuk
+
+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/README.md

@@ -0,0 +1,100 @@
+# LightvSchema
+
+LightvSchema is a lightweight schema validation library for TypeScript. It provides a simple and efficient way to validate data structures.
+
+## Features
+
+- Lightweight: Minimal footprint with no external dependencies.
+- Type-safe: Leverages TypeScript's type system for compile-time validation.
+- Flexible: Supports custom validation functions and error messages.
+- Extensible: Easily extendable to accommodate new validation rules.
+
+## Warning
+
+This library is my educational project. It is not intended for production use. Use at your own risk.
+
+## Installation
+
+You can install LightvSchema using npm or bun:
+
+```bash
+npm install lightv-schema
+```
+
+or
+
+```bash
+bun add lightv-schema
+```
+
+## Usage
+
+LightvSchema provides a simple API for defining and validating data structures. Here's a quick example:
+
+```typescript
+import { type, transform, validate, parse } from "lightv-schema";
+
+const User = type.Object({
+  id: type.Int(),
+  name: validate.Min(type.String(), 5),
+  email: type.String(),
+  age: transform.ToInt(type.String()),
+  isActive: type.Boolean(),
+  friends: type.Array(type.Object({ id: type.Int(), name: type.String() })),
+  role: type.Union([type.Literal("admin"), type.Literal("user")]),
+});
+
+type User = typeof User.infer;
+
+const userString = `{
+  "id": 1,
+  "name": "John Doe",
+  "email": "test@some.com",
+  "age": "123",
+  "isActive": true,
+  "friends": [
+    { "id": 2, "name": "Jane Doe" },
+    { "id": 3, "name": "Jack Doe" }
+  ],
+  "role": "admin"
+}`;
+const result = parse(User, JSON.parse(userString));
+
+if ("success" in result) {
+  console.log("Parsed user:", result.success);
+} else {
+  console.log("Failed to parse user:", result.failure);
+}
+
+export { type, transform, validate, parse };
+```
+
+Also easy to extend:
+
+```typescript
+import type { Scheme } from "lightv-schema/scheme";
+import { validate } from "lightv-schema";
+
+export function Min<const Item extends Scheme>(
+  item: Item,
+  min: number,
+  message?: string
+) {
+  return validate.Validator(item, (value) => {
+    if (typeof value === "number" && value < min) {
+      return {
+        failure: [message ?? `Number must be greater than or equal to ${min}`],
+      };
+    } else if (typeof value === "string" && value.length < min) {
+      return {
+        failure: [message ?? `String must be at least ${min} characters long`],
+      };
+    } else if (Array.isArray(value) && value.length < min) {
+      return {
+        failure: [message ?? `Array must have at least ${min} elements`],
+      };
+    }
+    return { success: value };
+  });
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import * as type from "./types";
+import * as transform from "./transformers";
+import * as validate from "./validators";
+import { parse } from "./utils";
+export { type, transform, validate, parse };

package/dist/index.js

@@ -0,0 +1,367 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/types.ts
+var exports_types = {};
+__export(exports_types, {
+  Union: () => Union,
+  Tuple: () => Tuple,
+  String: () => String,
+  Object: () => Object2,
+  Nullable: () => Nullable,
+  None: () => None,
+  Literal: () => Literal,
+  Int: () => Int,
+  Float: () => Float,
+  Boolean: () => Boolean,
+  Array: () => Array2
+});
+function Literal(literal, message) {
+  return {
+    type: "literal",
+    literal,
+    message
+  };
+}
+function None() {
+  return {
+    type: "none"
+  };
+}
+function Int(message) {
+  return {
+    type: "int",
+    message
+  };
+}
+function Float(message) {
+  return {
+    type: "float",
+    message
+  };
+}
+function String(message) {
+  return {
+    type: "string",
+    message
+  };
+}
+function Boolean(message) {
+  return {
+    type: "boolean",
+    message
+  };
+}
+function Array2(item, message) {
+  return {
+    type: "array",
+    item,
+    message
+  };
+}
+function Union(items, message) {
+  return {
+    type: "union",
+    items,
+    message
+  };
+}
+function Tuple(items, message) {
+  return {
+    type: "tuple",
+    items,
+    message
+  };
+}
+function Object2(props, message) {
+  return {
+    type: "object",
+    props,
+    message
+  };
+}
+function Nullable(item, message) {
+  return {
+    type: "nullable",
+    item,
+    message
+  };
+}
+
+// src/transformers.ts
+var exports_transformers = {};
+__export(exports_transformers, {
+  Transformer: () => Transformer,
+  ToString: () => ToString,
+  ToInt: () => ToInt
+});
+function Transformer(from, to, transformer) {
+  return {
+    type: "transform",
+    from,
+    to,
+    transformer
+  };
+}
+function ToString(from, message) {
+  return Transformer(from, String(), (value) => {
+    if (value === null || value === undefined) {
+      return { success: "" };
+    }
+    return { success: value.toString() };
+  });
+}
+function ToInt(from, message) {
+  return Transformer(from, Int(), (value) => {
+    if (value === null || value === undefined) {
+      return { failure: [message ?? `Expected integer`] };
+    }
+    if (typeof value === "number") {
+      return { success: Math.floor(value) };
+    } else if (typeof value === "string") {
+      const parsed = parseInt(value, 10);
+      if (isNaN(parsed)) {
+        return { failure: [message ?? `Expected integer`] };
+      }
+      return { success: parsed };
+    }
+    return { failure: [message ?? `Expected integer`] };
+  });
+}
+
+// src/validators.ts
+var exports_validators = {};
+__export(exports_validators, {
+  Validator: () => Validator,
+  Min: () => Min,
+  Max: () => Max
+});
+function Validator(item, validator) {
+  return {
+    type: "validation",
+    item,
+    validator
+  };
+}
+function Min(item, min, message) {
+  return Validator(item, (value) => {
+    if (typeof value === "number" && value < min) {
+      return {
+        failure: [message ?? `Number must be greater than or equal to ${min}`]
+      };
+    } else if (typeof value === "string" && value.length < min) {
+      return {
+        failure: [message ?? `String must be at least ${min} characters long`]
+      };
+    } else if (Array.isArray(value) && value.length < min) {
+      return {
+        failure: [message ?? `Array must have at least ${min} elements`]
+      };
+    }
+    return { success: value };
+  });
+}
+function Max(item, max, message) {
+  return Validator(item, (value) => {
+    if (typeof value === "number" && value > max) {
+      return {
+        failure: [message ?? `Number must be less than or equal to ${max}`]
+      };
+    } else if (typeof value === "string" && value.length > max) {
+      return {
+        failure: [message ?? `String must be at most ${max} characters long`]
+      };
+    } else if (Array.isArray(value) && value.length > max) {
+      return {
+        failure: [message ?? `Array must have at most ${max} elements`]
+      };
+    }
+    return { success: value };
+  });
+}
+
+// src/result.ts
+function isSuccess(result) {
+  return "success" in result;
+}
+function isFailure(result) {
+  return "failure" in result;
+}
+
+// src/utils.ts
+function parse(schema, value) {
+  if (schema.type === "literal") {
+    if (value !== schema.literal) {
+      return {
+        failure: [
+          schema.message ?? `Expected ${schema.literal}`
+        ]
+      };
+    }
+    return { success: schema.literal };
+  } else if (schema.type === "none") {
+    if (value !== null && value !== undefined) {
+      return {
+        failure: [
+          schema.message ?? `Expected null or undefined`
+        ]
+      };
+    }
+  } else if (schema.type === "int") {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      return {
+        failure: [schema.message ?? `Expected integer`]
+      };
+    }
+    return { success: value };
+  } else if (schema.type === "float") {
+    if (typeof value !== "number") {
+      return {
+        failure: [schema.message ?? `Expected float`]
+      };
+    }
+    return { success: value };
+  } else if (schema.type === "string") {
+    if (typeof value !== "string") {
+      return {
+        failure: [schema.message ?? `Expected string`]
+      };
+    }
+    return { success: value };
+  } else if (schema.type === "boolean") {
+    if (typeof value !== "boolean") {
+      return {
+        failure: [schema.message ?? `Expected boolean`]
+      };
+    }
+    return { success: value };
+  } else if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      return {
+        failure: [schema.message ?? `Expected array`]
+      };
+    }
+    const results = value.map((item) => parse(schema.item, item));
+    const failures = results.filter(isFailure);
+    if (failures.length > 0) {
+      return {
+        failure: failures.map((result) => result.failure).flat()
+      };
+    }
+    return {
+      success: results.filter(isSuccess).map((result) => result.success)
+    };
+  } else if (schema.type === "tuple") {
+    if (!Array.isArray(value)) {
+      return {
+        failure: [schema.message ?? `Expected tuple`]
+      };
+    }
+    if (value.length !== schema.items.length) {
+      return {
+        failure: [
+          schema.message ?? `Expected tuple of length ${schema.items.length}`
+        ]
+      };
+    }
+    const results = value.map((item, index) => parse(schema.items[index], item));
+    const failures = results.filter(isFailure);
+    if (failures.length > 0) {
+      return {
+        failure: failures.map((result) => result.failure).flat()
+      };
+    }
+    return {
+      success: results.filter((result) => ("success" in result)).map((result) => result.success)
+    };
+  } else if (schema.type === "union") {
+    const results = schema.items.map((item) => parse(item, value));
+    const failures = results.filter(isFailure);
+    if (failures.length === schema.items.length) {
+      return {
+        failure: failures.map((result) => result.failure).flat()
+      };
+    }
+    const successes = results.filter(isSuccess);
+    if (successes.length > 0) {
+      return {
+        success: successes[0].success
+      };
+    }
+    return {
+      failure: [
+        schema.message ?? `Expected one of ${schema.items.map((item) => item.type)}`
+      ]
+    };
+  } else if (schema.type === "object") {
+    if (typeof value !== "object" || value === null || value === undefined) {
+      return {
+        failure: [schema.message ?? `Expected object`]
+      };
+    }
+    const results = Object.entries(schema.props).map(([key, item]) => [key, parse(item, value[key])]);
+    const failureValues = {};
+    const successValues = {};
+    for (const [key, result] of results) {
+      if (isFailure(result)) {
+        failureValues[key] = result.failure;
+      } else {
+        successValues[key] = result.success;
+      }
+    }
+    if (Object.keys(failureValues).length > 0) {
+      return {
+        failure: failureValues
+      };
+    }
+    return { success: successValues };
+  } else if (schema.type === "validation") {
+    const result = parse(schema.item, value);
+    if (isFailure(result)) {
+      return result;
+    }
+    const validationResult = schema.validator(result.success);
+    if (isFailure(validationResult)) {
+      return {
+        failure: validationResult.failure
+      };
+    }
+    return { success: validationResult.success };
+  } else if (schema.type === "nullable") {
+    if (value === null || value === undefined) {
+      return { success: null };
+    }
+    const result = parse(schema.item, value);
+    if (isFailure(result)) {
+      return result;
+    }
+    return { success: result.success };
+  } else if (schema.type === "transform") {
+    const result = parse(schema.from, value);
+    if (isFailure(result)) {
+      return result;
+    }
+    const transformedResult = schema.transformer(result.success);
+    if (isFailure(transformedResult)) {
+      return {
+        failure: transformedResult.failure
+      };
+    }
+    return { success: transformedResult.success };
+  }
+  throw new Error(`Unsupported scheme type: ${schema.type}`);
+}
+export {
+  exports_validators as validate,
+  exports_types as type,
+  exports_transformers as transform,
+  parse
+};

package/dist/result.d.ts

@@ -0,0 +1,13 @@
+export type Success<Value extends unknown> = {
+    success: Value;
+};
+export type Failure<Error extends unknown> = {
+    failure: Error;
+};
+export type Result<Value extends unknown, Error extends unknown> = Success<Value> | Failure<Error>;
+export declare function isSuccess<Value extends unknown, Error extends unknown>(result: Result<Value, Error>): result is Success<Value>;
+export declare function isFailure<Value extends unknown, Error extends unknown>(result: Result<Value, Error>): result is Failure<Error>;
+export declare function expectSuccess<Value extends unknown, Error extends unknown>(result: Result<Value, Error>, message?: string): Value;
+export declare function expectFailure<Value extends unknown, Error extends unknown>(result: Result<Value, Error>, message?: string): Error;
+export declare function successOr<Value extends unknown, Error extends unknown>(result: Result<Value, Error>, defaultValue: Value): Value;
+export declare function failureOr<Value extends unknown, Error extends unknown>(result: Result<Value, Error>, defaultError: Error): Error;

package/dist/schema.d.ts

@@ -0,0 +1,87 @@
+import type { Result } from "./result";
+export type Validator<T extends unknown> = (value: T) => Result<T, string[]>;
+export type Transformer<T extends unknown, U extends unknown> = (value: T) => Result<U, string[]>;
+export type Fold<T extends unknown> = {} & {
+    [P in keyof T]: T[P];
+};
+export type LiteralSchema<Literal extends unknown> = {
+    readonly type: "literal";
+    readonly literal: Literal;
+    readonly infer: Literal;
+    readonly message?: string;
+};
+export type NoneSchema = {
+    readonly type: "none";
+    readonly infer: null | undefined;
+    readonly message?: string;
+};
+export type IntSchema = {
+    readonly type: "int";
+    readonly infer: number;
+    readonly message?: string;
+};
+export type FloatSchema = {
+    readonly type: "float";
+    readonly infer: number;
+    readonly message?: string;
+};
+export type StringSchema = {
+    readonly type: "string";
+    readonly infer: string;
+    readonly message?: string;
+};
+export type BooleanSchema = {
+    readonly type: "boolean";
+    readonly infer: boolean;
+    readonly message?: string;
+};
+export type ArraySchema<Item extends Schema> = {
+    readonly type: "array";
+    readonly item: Item;
+    readonly infer: Item["infer"][];
+    readonly message?: string;
+};
+export type UnionSchema<Items extends ReadonlyArray<Schema>> = {
+    readonly type: "union";
+    readonly items: Items;
+    readonly infer: Items[number]["infer"];
+    readonly message?: string;
+};
+export type TupleSchema<Items extends ReadonlyArray<Schema>> = {
+    readonly type: "tuple";
+    readonly items: Items;
+    readonly infer: {
+        [Index in keyof Items]: Items[Index]["infer"];
+    };
+    readonly message?: string;
+};
+export type ObjectSchema<Props extends Record<string, Schema>> = {
+    readonly type: "object";
+    readonly props: Props;
+    readonly infer: Fold<{
+        -readonly [Key in keyof Props as Props[Key] extends NullableSchema<any> ? never : Key]: Props[Key]["infer"];
+    } & {
+        -readonly [Key in keyof Props as Props[Key] extends NullableSchema<any> ? Key : never]?: Props[Key]["infer"];
+    }>;
+    readonly message?: string;
+};
+export type NullableSchema<Item extends Schema> = {
+    readonly type: "nullable";
+    readonly item: Item;
+    readonly infer: Item["infer"] | null | undefined;
+    readonly message?: string;
+};
+export type ValidationSchema<Item extends Schema> = {
+    readonly type: "validation";
+    readonly item: Item;
+    readonly validator: Validator<Item>;
+    readonly infer: Item["infer"];
+};
+export type TransformSchema<From extends Schema, To extends Schema> = {
+    readonly type: "transform";
+    readonly from: From;
+    readonly to: To;
+    readonly transformer: Transformer<From["infer"], To["infer"]>;
+    readonly infer: To["infer"];
+};
+export type Schema = LiteralSchema<any> | NoneSchema | IntSchema | FloatSchema | StringSchema | BooleanSchema | ArraySchema<any> | UnionSchema<any[]> | TupleSchema<any[]> | ObjectSchema<any> | NullableSchema<any> | ValidationSchema<any> | TransformSchema<any, any>;

package/dist/transformers.d.ts

@@ -0,0 +1,4 @@
+import type { Schema, Transformer, TransformSchema } from "./schema";
+export declare function Transformer<const From extends Schema, const To extends Schema>(from: From, to: To, transformer: Transformer<From["infer"], To["infer"]>): TransformSchema<From, To>;
+export declare function ToString<const From extends Schema>(from: From, message?: string): TransformSchema<From, import("./schema").StringSchema>;
+export declare function ToInt<const From extends Schema>(from: From, message?: string): TransformSchema<From, import("./schema").IntSchema>;

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+import type { Schema, ArraySchema, BooleanSchema, FloatSchema, IntSchema, NullableSchema, ObjectSchema, StringSchema, TupleSchema, UnionSchema, LiteralSchema, NoneSchema } from "./schema";
+export declare function Literal<T extends string | number | boolean>(literal: T, message?: string): LiteralSchema<T>;
+export declare function None(): NoneSchema;
+export declare function Int(message?: string): IntSchema;
+export declare function Float(message?: string): FloatSchema;
+export declare function String(message?: string): StringSchema;
+export declare function Boolean(message?: string): BooleanSchema;
+export declare function Array<const Item extends Schema>(item: Item, message?: string): ArraySchema<Item>;
+export declare function Union<const Items extends ReadonlyArray<Schema>>(items: Items, message?: string): UnionSchema<Items>;
+export declare function Tuple<const Items extends ReadonlyArray<Schema>>(items: Items, message?: string): TupleSchema<Items>;
+export declare function Object<Props extends Record<string, Schema>>(props: Props, message?: string): ObjectSchema<Props>;
+export declare function Nullable<S extends Schema>(item: S, message?: string): NullableSchema<S>;

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { type Result } from "./result";
+import type { Schema } from "./schema";
+type ParseError<Value extends unknown = unknown> = Value extends Record<string, unknown> ? {
+    [K in keyof Value]: ParseError<Value[K]>;
+} : string[];
+export declare function parse<const S extends Schema, Infer extends unknown = S["infer"]>(schema: S, value: unknown): Result<Infer, ParseError<Infer>>;
+export {};

package/dist/validators.d.ts

@@ -0,0 +1,4 @@
+import type { Schema, ValidationSchema, Validator } from "./schema";
+export declare function Validator<const Item extends Schema>(item: Item, validator: Validator<Item["infer"]>): ValidationSchema<Item>;
+export declare function Min<const Item extends Schema>(item: Item, min: number, message?: string): ValidationSchema<Item>;
+export declare function Max<const Item extends Schema>(item: Item, max: number, message?: string): ValidationSchema<Item>;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "lightv-schema",
+  "version": "0.0.1",
+  "description": "A lightweight schema validation library for TypeScript.",
+  "module": "src/index.ts",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/*.js",
+    "dist/*.d.ts"
+  ],
+  "scripts": {
+    "build": "bun build --target=node ./src/index.ts --outfile=dist/index.js && bun run build:declaration",
+    "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json",
+    "postbuild": "rimraf tsconfig.types.tsbuildinfo"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./scheme": {
+      "types": "./dist/scheme.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}