@lowerdeck/validation 1.0.0

package/src/validators/nullable.ts

@@ -0,0 +1,16 @@
+import { ValidationType, ValidationTypeValue } from '../lib/types';
+
+export let nullable = <A extends ValidationType<any>>(
+  validator: A
+): ValidationType<ValidationTypeValue<A> | null> => ({
+  ...validator,
+
+  nullable: true,
+  validate: value => {
+    if (value === null) {
+      return { success: true, value };
+    }
+
+    return validator.validate(value);
+  }
+});

package/src/validators/number.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'vitest';
+import { number } from './number';
+
+describe('number', () => {
+  test('should return success for a valid number', () => {
+    let result = number({}).validate(42);
+    expect(result).toEqual({ success: true, value: 42 });
+  });
+
+  test('should return an error for an invalid number', () => {
+    let result = number({}).validate('not a number');
+    expect(result).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected number, received string',
+          received: 'string',
+          expected: 'number'
+        }
+      ]
+    });
+  });
+
+  test('should use the provided error message', () => {
+    let result = number({ message: 'Custom error message' }).validate('not a number');
+    expect(result).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_type',
+          message: 'Custom error message',
+          received: 'string',
+          expected: 'number'
+        }
+      ]
+    });
+  });
+});

package/src/validators/number.ts

@@ -0,0 +1,23 @@
+import { error } from '../lib/result';
+import { ValidatorOptions } from '../lib/types';
+import { createValidator } from '../lib/validator';
+
+export let number = createValidator<number, ValidatorOptions<number>>(
+  'number',
+  (opts, value) => {
+    let number = typeof value == 'string' ? parseFloat(value) : value;
+
+    if (typeof number != 'number' || isNaN(number)) {
+      return error([
+        {
+          code: 'invalid_type',
+          message: opts.message ?? `Invalid input, expected number, received ${typeof value}`,
+          received: typeof value,
+          expected: 'number'
+        }
+      ]);
+    }
+
+    return { success: true, value: number };
+  }
+);

package/src/validators/object.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'vitest';
+import { number } from './number';
+import { object } from './object';
+import { string } from './string';
+
+describe('object', () => {
+  test('should validate an object with the correct shape', () => {
+    let validator = object({
+      name: string(),
+      age: number()
+    });
+
+    let result: any = validator.validate({
+      name: 'John Doe',
+      age: 42
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.value).toEqual({
+      name: 'John Doe',
+      age: 42
+    });
+  });
+
+  test('should return an error for an object with an invalid shape', () => {
+    let validator = object({
+      name: string(),
+      age: number()
+    });
+
+    let result: any = validator.validate({
+      name: 'John Doe',
+      age: 'Test'
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.errors).toEqual([
+      {
+        code: 'invalid_type',
+        message: 'Invalid input, expected number, received string',
+        received: 'string',
+        expected: 'number',
+        path: ['age']
+      }
+    ]);
+  });
+
+  test('should return an error for a non-object input', () => {
+    let validator = object({
+      name: string(),
+      age: number()
+    });
+
+    let result: any = validator.validate('not an object');
+
+    expect(result.success).toBe(false);
+    expect(result.errors).toEqual([
+      {
+        code: 'invalid_type',
+        message: 'Invalid input, expected object, received string',
+        received: 'string',
+        expected: 'object'
+      }
+    ]);
+  });
+});

package/src/validators/object.ts

@@ -0,0 +1,66 @@
+import { error, success } from '../lib/result';
+import { ValidationType, ValidationTypeValue, ValidatorOptions } from '../lib/types';
+
+type KeysWhichExtend<T, SelectedType> = {
+  [key in keyof T]: SelectedType extends T[key] ? key : never;
+}[keyof T];
+type Optional<T> = Partial<Pick<T, KeysWhichExtend<T, undefined>>>;
+type Required<T> = Omit<T, KeysWhichExtend<T, undefined>>;
+export type UndefinedIsOptional<T> = Optional<T> & Required<T>;
+
+export let object = <Validator extends { [key: string]: ValidationType<any> }>(
+  shape: Validator,
+  opts?: ValidatorOptions<Record<string, ValidationTypeValue<Validator>>>
+): ValidationType<
+  UndefinedIsOptional<{
+    [key in keyof Validator]: ValidationTypeValue<Validator[key]>;
+  }>
+> => ({
+  type: 'object',
+  name: opts?.name,
+  description: opts?.description,
+  properties: shape,
+  examples: [
+    Object.fromEntries(
+      Object.entries(shape)
+        .map(([key, validator]) => {
+          let example = validator.examples?.[0];
+          // For nullable fields, if there's no example, don't include it
+          // This prevents undefined from becoming {} in Object.fromEntries
+          if (example === undefined && validator.nullable) {
+            return null; // Will be filtered out
+          }
+          return [key, example];
+        })
+        .filter((entry): entry is [string, any] => entry !== null)
+    )
+  ] as any,
+  validate: value => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return error([
+        {
+          code: 'invalid_type',
+          message: `Invalid input, expected object, received ${typeof value}`,
+          received: Array.isArray(value) ? 'array' : typeof value,
+          expected: 'object'
+        }
+      ]);
+    }
+
+    let values: {
+      [key in keyof Validator]: ValidationTypeValue<Validator[key]>;
+    } = {} as any;
+
+    for (let [key, validator] of Object.entries(shape)) {
+      let result = validator.validate(value[key]);
+
+      if (!result.success) {
+        return error(result.errors.map(e => ({ ...e, path: [key, ...(e.path ?? [])] })));
+      }
+
+      values[key as keyof Validator] = result.value;
+    }
+
+    return success(values);
+  }
+});

package/src/validators/optional.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'vitest';
+import { optional } from './optional';
+import { string } from './string';
+
+describe('optional', () => {
+  test('should return a new validator with optional values', () => {
+    let validator = optional(string());
+
+    expect(validator.type).toBe('string');
+    expect(validator.optional).toBe(true);
+
+    expect(validator.validate(undefined)).toEqual({ success: true, value: undefined });
+    expect(validator.validate('hello')).toEqual({ success: true, value: 'hello' });
+  });
+
+  test('should pass through the validation result of the original validator', () => {
+    let validator = optional(string());
+
+    expect(validator.validate(undefined)).toEqual({ success: true, value: undefined });
+    expect(validator.validate('hello')).toEqual({ success: true, value: 'hello' });
+    expect(validator.validate(123)).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected string, received number',
+          received: 'number',
+          expected: 'string'
+        }
+      ]
+    });
+  });
+});

package/src/validators/optional.ts

@@ -0,0 +1,16 @@
+import { ValidationType, ValidationTypeValue } from '../lib/types';
+
+export let optional = <A extends ValidationType<any>>(
+  validator: A
+): ValidationType<ValidationTypeValue<A> | undefined> => ({
+  ...validator,
+
+  optional: true,
+  validate: value => {
+    if (value === undefined) {
+      return { success: true, value };
+    }
+
+    return validator.validate(value);
+  }
+});

package/src/validators/record.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest';
+import { number } from './number';
+import { record } from './record';
+import { string } from './string';
+
+describe('record', () => {
+  test('should validate an empty object', () => {
+    let validator = record(string());
+    let result: any = validator.validate({});
+    expect(result.success).toBe(true);
+    expect(result.value).toEqual({});
+  });
+
+  test('should validate an object with string keys and string values', () => {
+    let validator = record(string());
+    let result: any = validator.validate({ foo: 'bar', baz: 'qux' });
+    expect(result.success).toBe(true);
+    expect(result.value).toEqual({ foo: 'bar', baz: 'qux' });
+  });
+
+  test('should validate an object with string keys and number values', () => {
+    let validator = record(number());
+    let result: any = validator.validate({ foo: 1, bar: 2 });
+    expect(result.success).toBe(true);
+    expect(result.value).toEqual({ foo: 1, bar: 2 });
+  });
+
+  test('should fail to validate a non-object', () => {
+    let validator = record(string());
+    let result: any = validator.validate('not an object');
+    expect(result.success).toBe(false);
+    expect(result.errors).toEqual([
+      {
+        code: 'invalid_type',
+        message: 'Invalid input, expected object',
+        received: 'not an object',
+        expected: 'object'
+      }
+    ]);
+  });
+
+  test('should fail to validate an object with invalid values', () => {
+    let validator = record(string());
+    let result: any = validator.validate({ foo: 'bar', baz: 123 });
+    expect(result.success).toBe(false);
+    expect(result.errors).toEqual([
+      {
+        code: 'invalid_type',
+        message: 'Invalid input, expected string, received number',
+        received: 'number',
+        expected: 'string',
+        path: ['baz']
+      }
+    ]);
+  });
+});

package/src/validators/record.ts

@@ -0,0 +1,56 @@
+import { error, success } from '../lib/result';
+import { ValidationType, ValidationTypeValue, ValidatorOptions } from '../lib/types';
+
+export let record = <Validator extends ValidationType<any>>(
+  validator: Validator,
+  opts?: ValidatorOptions<Record<string, ValidationTypeValue<Validator>>>
+): ValidationType<Record<string, ValidationTypeValue<Validator>>> => ({
+  type: 'record',
+  items: validator,
+  name: opts?.name,
+  description: opts?.description,
+  examples: Array.isArray(validator.examples)
+    ? [
+        {
+          key1: validator.examples[0]
+        }
+      ]
+    : undefined,
+  validate: value => {
+    if (typeof value != 'object' || value === null || Array.isArray(value)) {
+      return error([
+        {
+          code: 'invalid_type',
+          message: `Invalid input, expected object`,
+          received: value,
+          expected: 'object'
+        }
+      ]);
+    }
+
+    let values: Record<string, ValidationTypeValue<Validator>> = {};
+
+    for (let [key, val] of Object.entries(value)) {
+      if (typeof key != 'string') {
+        return error([
+          {
+            code: 'invalid_type',
+            message: `Invalid input, expected object with string keys, received ${typeof key}`,
+            received: key,
+            expected: 'string'
+          }
+        ]);
+      }
+
+      let result = validator.validate(val);
+
+      if (!result.success) {
+        return error(result.errors.map(e => ({ ...e, path: [key, ...(e.path ?? [])] })));
+      }
+
+      values[key] = result.value;
+    }
+
+    return success(values);
+  }
+});

package/src/validators/string.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'vitest';
+import { string } from './string';
+
+describe('string', () => {
+  test('should return success when given a string', () => {
+    let result = string({}).validate('hello');
+    expect(result).toEqual({ success: true, value: 'hello' });
+  });
+
+  test('should return an error when given a non-string value', () => {
+    let result = string({}).validate(123);
+    expect(result).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected string, received number',
+          received: 'number',
+          expected: 'string'
+        }
+      ]
+    });
+  });
+
+  test('should use the provided error message', () => {
+    let result = string({ message: 'Custom error message' }).validate(123);
+    expect(result).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_type',
+          message: 'Custom error message',
+          received: 'number',
+          expected: 'string'
+        }
+      ]
+    });
+  });
+});

package/src/validators/string.ts

@@ -0,0 +1,30 @@
+import { error } from '../lib/result';
+import { ValidatorOptions } from '../lib/types';
+import { createValidator } from '../lib/validator';
+
+export let string = createValidator<string, ValidatorOptions<string>>(
+  'string',
+  (opts, value) => {
+    if (typeof value != 'string') {
+      return error([
+        {
+          code: 'invalid_type',
+          message: opts.message ?? `Invalid input, expected string, received ${typeof value}`,
+          received: typeof value,
+          expected: 'string'
+        }
+      ]);
+    }
+
+    if (value.length > 100_000) {
+      return error([
+        {
+          code: 'max_length',
+          message: 'Input is too long'
+        }
+      ]);
+    }
+
+    return { success: true, value };
+  }
+);

package/src/validators/union.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from 'vitest';
+import { error, success } from '../lib/result';
+import { array, number, object, string } from './index';
+import { union } from './union';
+
+describe('union', () => {
+  test('should validate a string', () => {
+    let validator = union([string(), number()]);
+
+    expect(validator.validate('hello')).toEqual(success('hello'));
+  });
+
+  test('should validate a number', () => {
+    let validator = union([string(), number()]);
+
+    expect(validator.validate(42)).toEqual(success(42));
+  });
+
+  test('should not validate an object', () => {
+    let validator = union([string(), number()]);
+
+    expect(validator.validate({})).toEqual(
+      error([
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected string, received object',
+          expected: 'string',
+          received: 'object'
+        },
+        {
+          code: 'invalid_type',
+          expected: 'number',
+          message: 'Invalid input, expected number, received object',
+          received: 'object'
+        }
+      ])
+    );
+  });
+
+  test('should validate an array of strings', () => {
+    let validator = union([string(), array(string())]);
+
+    expect(validator.validate(['hello', 'world'])).toEqual(success(['hello', 'world']));
+  });
+
+  test('should validate an array of numbers', () => {
+    let validator = union([number(), array(number())]);
+
+    expect(validator.validate([1, 2, 3])).toEqual(success([1, 2, 3]));
+  });
+
+  test('should not validate an array of objects', () => {
+    let validator = union([string(), array(object({}))]);
+
+    expect(validator.validate(['hello', {}])).toEqual(
+      error([
+        {
+          code: 'invalid_type',
+          expected: 'string',
+          message: 'Invalid input, expected string, received object',
+          received: 'object'
+        },
+        {
+          code: 'invalid_type',
+          expected: 'object',
+          message: 'Invalid input, expected object, received string',
+          path: ['0'],
+          received: 'string'
+        }
+      ])
+    );
+  });
+});

package/src/validators/union.ts

@@ -0,0 +1,38 @@
+import { error } from '../lib/result';
+import {
+  ValidationError,
+  ValidationType,
+  ValidationTypeValue,
+  ValidatorOptions
+} from '../lib/types';
+
+export let union = <
+  A extends ValidationType<any>,
+  B extends ValidationType<any>,
+  Rest extends ValidationType<any>[]
+>(
+  validators: [A, B, ...Rest],
+  opts?: ValidatorOptions<
+    ValidationTypeValue<A> | ValidationTypeValue<B> | ValidationTypeValue<Rest[number]>
+  >
+): ValidationType<
+  ValidationTypeValue<A> | ValidationTypeValue<B> | ValidationTypeValue<Rest[number]>
+> => ({
+  type: 'union',
+  name: opts?.name,
+  items: validators,
+  description: opts?.description,
+  examples: validators.flatMap(v => v.examples || []),
+  validate: value => {
+    let errors: ValidationError[] = [];
+
+    for (let validator of validators) {
+      let result = validator.validate(value);
+      if (result.success) return result;
+
+      errors.push(...result.errors);
+    }
+
+    return error(errors);
+  }
+});

package/src/validators/void.ts

@@ -0,0 +1,6 @@
+import { ValidatorOptions } from '../lib/types';
+import { createValidator } from '../lib/validator';
+
+export let voidType = createValidator<void, ValidatorOptions<void>>('void', (opts, value) => {
+  return { success: true, value: undefined };
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@lowerdeck/tsconfig/base.json",
+  "exclude": ["dist"],
+  "include": ["src"],
+  "compilerOptions": {
+    "outDir": "dist",
+  }
+}