@lowerdeck/validation 1.0.0

package/src/transformers/case.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'vitest';
+import { lowerCase, upperCase } from './case';
+
+describe('case transformers', () => {
+  describe('upperCase', () => {
+    test('should transform a string to uppercase', () => {
+      let input = 'hello world';
+      let expectedOutput = 'HELLO WORLD';
+      let output = upperCase(input);
+      expect(output).toEqual(expectedOutput);
+    });
+
+    test('should return an empty string if input is empty', () => {
+      let input = '';
+      let expectedOutput = '';
+      let output = upperCase(input);
+      expect(output).toEqual(expectedOutput);
+    });
+  });
+
+  describe('lowerCase', () => {
+    test('should transform a string to lowercase', () => {
+      let input = 'HELLO WORLD';
+      let expectedOutput = 'hello world';
+      let output = lowerCase(input);
+      expect(output).toEqual(expectedOutput);
+    });
+
+    test('should return an empty string if input is empty', () => {
+      let input = '';
+      let expectedOutput = '';
+      let output = lowerCase(input);
+      expect(output).toEqual(expectedOutput);
+    });
+  });
+});

package/src/transformers/case.ts

@@ -0,0 +1,5 @@
+import { Transformer } from '../lib/types';
+
+export let upperCase: Transformer<string> = value => value.toUpperCase();
+
+export let lowerCase: Transformer<string> = value => value.toLowerCase();

package/src/transformers/index.ts

@@ -0,0 +1,2 @@
+export * from './case';
+export * from './trim';

package/src/transformers/trim.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'vitest';
+import { trim, trimEnd, trimStart } from './trim';
+
+describe('trim', () => {
+  test('should trim whitespace from both ends of the string', () => {
+    expect(trim('  hello  ')).toBe('hello');
+  });
+
+  test('should return an empty string if given an empty string', () => {
+    expect(trim('')).toBe('');
+  });
+});
+
+describe('trimStart', () => {
+  test('should trim whitespace from the beginning of the string', () => {
+    expect(trimStart('  hello')).toBe('hello');
+  });
+
+  test('should return an empty string if given an empty string', () => {
+    expect(trimStart('')).toBe('');
+  });
+});
+
+describe('trimEnd', () => {
+  test('should trim whitespace from the end of the string', () => {
+    expect(trimEnd('hello  ')).toBe('hello');
+  });
+
+  test('should return an empty string if given an empty string', () => {
+    expect(trimEnd('')).toBe('');
+  });
+});

package/src/transformers/trim.ts

@@ -0,0 +1,7 @@
+import { Transformer } from '../lib/types';
+
+export let trim: Transformer<string> = value => value.trim();
+
+export let trimStart: Transformer<string> = value => value.trimStart();
+
+export let trimEnd: Transformer<string> = value => value.trimEnd();

package/src/validators/any.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, test } from 'vitest';
+import { any } from './any';
+
+describe('any', () => {
+  test('should always return success with the input value', () => {
+    let input = 'hello world';
+    let result: any = any({}).validate(input);
+    expect(result.success).toBe(true);
+    expect(result.value).toBe(input);
+  });
+});

package/src/validators/any.ts

@@ -0,0 +1,11 @@
+import { ValidatorOptions } from '../lib/types';
+import { createValidator } from '../lib/validator';
+
+export let any = createValidator<any, ValidatorOptions<any>>('any', (opts, value) => {
+  return { success: true, value };
+});
+
+export let typedAny = <T>(name: string) =>
+  createValidator<T, ValidatorOptions<T>>(name, (opts, value) => {
+    return { success: true, value };
+  })();

package/src/validators/array.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'vitest';
+import { error, success } from '../lib/result';
+import { array } from './array';
+import { string } from './string';
+
+describe('array', () => {
+  test('should validate an array of strings', () => {
+    let validator = array(string());
+    let result = validator.validate(['hello', 'world']);
+
+    expect(result).toEqual(success(['hello', 'world']));
+  });
+
+  test('should return an error for invalid input', () => {
+    let validator = array(string());
+    let result = validator.validate('not an array');
+
+    expect(result).toEqual(
+      error([
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected array, received string',
+          received: 'string',
+          expected: 'array'
+        }
+      ])
+    );
+  });
+
+  test('should return an error for invalid array items', () => {
+    let validator = array(string());
+    let result = validator.validate(['hello', 123]);
+
+    expect(result).toEqual(
+      error([
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected string, received number',
+          received: 'number',
+          expected: 'string',
+          path: ['1']
+        }
+      ])
+    );
+  });
+});

package/src/validators/array.ts

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

package/src/validators/boolean.test.ts

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

package/src/validators/boolean.ts

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

package/src/validators/date.test.ts

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

package/src/validators/date.ts

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

package/src/validators/enum.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from 'vitest';
+import { enumOf } from './enum';
+
+describe('enumOf', () => {
+  test('should validate a valid value', () => {
+    let validator = enumOf(['foo', 'bar', 'baz']);
+    let result: any = validator.validate('foo');
+    expect(result.success).toBe(true);
+    expect(result.value).toBe('foo');
+  });
+
+  test('should not validate an invalid value', () => {
+    let validator = enumOf(['foo', 'bar', 'baz']);
+    let result: any = validator.validate('qux');
+    expect(result.success).toBe(false);
+    expect(result.errors).toEqual([
+      {
+        code: 'invalid_enum',
+        message: 'Invalid input, expected one of foo, bar, baz, received qux',
+        received: 'qux',
+        expected: ['foo', 'bar', 'baz']
+      }
+    ]);
+  });
+});

package/src/validators/enum.ts

@@ -0,0 +1,56 @@
+import { error } from '../lib/result';
+import { ValidationType } from '../lib/types';
+
+// export let enumType = <
+//   A extends string | number | boolean,
+//   Rest extends (string | number | boolean)[]
+// >(
+//   ...values: [A, ...Rest]
+// ): ValidationType<A | Rest[number]> => ({
+//   type: 'enum',
+//   examples: values,
+//   validate: value => {
+//     if (!values.includes(value)) {
+//       return error([
+//         {
+//           code: 'invalid_enum',
+//           message: `Invalid input, expected one of ${values.join(', ')}, received ${value}`,
+//           received: value,
+//           expected: values
+//         }
+//       ]);
+//     }
+
+//     return { success: true, value };
+//   }
+// });
+
+export let enumOf = <
+  const A extends string | number | boolean,
+  Rest extends (string | number | boolean)[]
+>(
+  values: [A, ...Rest],
+  opts?: {
+    name?: string;
+    description?: string;
+  }
+): ValidationType<A | Rest[number]> => ({
+  type: 'enum',
+  examples: values,
+  name: opts?.name,
+  description: opts?.description,
+  validate: value => {
+    if (!values.includes(value)) {
+      return error([
+        {
+          code: 'invalid_enum',
+          message: `Invalid input, expected one of ${values.join(', ')}, received ${value}`,
+          received: value,
+          expected: values
+        }
+      ]);
+    }
+
+    return { success: true, value };
+  }
+});

package/src/validators/index.ts

@@ -0,0 +1,16 @@
+export * from './any';
+export * from './array';
+export * from './boolean';
+export * from './date';
+export * from './enum';
+export * from './intersection';
+export * from './literal';
+export * from './null';
+export * from './nullable';
+export * from './number';
+export * from './object';
+export * from './optional';
+export * from './record';
+export * from './string';
+export * from './union';
+export * from './void';

package/src/validators/intersection.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'vitest';
+import { success } from '../lib/result';
+import { number, object, string } from './index';
+import { intersection } from './intersection';
+
+describe('intersection', () => {
+  test('intersection - success', () => {
+    const validatorA = object({ name: string() });
+    const validatorB = object({ age: number() });
+
+    const validator = intersection([validatorA, validatorB]);
+
+    const value = { name: 'John', age: 30, email: 'john@example.com' };
+    const result = validator.validate(value);
+
+    expect(result).toEqual(
+      success({
+        name: 'John',
+        age: 30
+      })
+    );
+  });
+
+  test('intersection - failure', () => {
+    const validatorA = object({ name: string() });
+    const validatorB = object({ age: number() });
+
+    const validator = intersection([validatorA, validatorB]);
+
+    const value = { name: 'John', age: 'test', email: 'john@example.com' };
+    const result = validator.validate(value);
+
+    expect(result.success).toBe(false);
+  });
+});

package/src/validators/intersection.ts

@@ -0,0 +1,24 @@
+import { ValidationType, ValidationTypeValue, ValidatorOptions } from '../lib/types';
+
+export let intersection = <A extends ValidationType<object>, B extends ValidationType<object>>(
+  validators: [A, B],
+  opts?: ValidatorOptions<ValidationTypeValue<A> & ValidationTypeValue<B>>
+): ValidationType<ValidationTypeValue<A> & ValidationTypeValue<B>> => ({
+  type: 'intersection',
+  name: opts?.name,
+  items: validators,
+  description: opts?.description,
+  examples: [],
+  validate: value => {
+    let fullValue: any = {};
+
+    for (let validator of validators) {
+      let result = validator.validate(value);
+      if (!result.success) return result;
+
+      fullValue = { ...fullValue, ...result.value };
+    }
+
+    return { success: true, value: fullValue };
+  }
+});

package/src/validators/literal.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { literal } from './literal';
+
+describe('literal', () => {
+  test('should return success when the value matches the literal', () => {
+    let validator = literal('foo');
+    let result = validator.validate('foo');
+    expect(result).toEqual({ success: true, value: 'foo' });
+  });
+
+  test('should return an error when the value does not match the literal', () => {
+    let validator = literal('foo');
+    let result = validator.validate('bar');
+    expect(result).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_literal',
+          message: 'Invalid input, expected foo, received bar',
+          received: 'bar',
+          expected: 'foo'
+        }
+      ]
+    });
+  });
+
+  test('should use the provided error message', () => {
+    let validator = literal('foo', { message: 'Custom error message' });
+    let result = validator.validate('bar');
+    expect(result).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_literal',
+          message: 'Custom error message',
+          received: 'bar',
+          expected: 'foo'
+        }
+      ]
+    });
+  });
+});

package/src/validators/literal.ts

@@ -0,0 +1,26 @@
+import { error } from '../lib/result';
+import { ValidationType, ValidatorOptions } from '../lib/types';
+
+export let literal = <A extends string | number | boolean>(
+  value: A,
+  opts?: ValidatorOptions<A>
+): ValidationType<A> => ({
+  type: 'literal',
+  examples: [value],
+  name: opts?.name,
+  description: opts?.description,
+  validate: input => {
+    if (input != value) {
+      return error([
+        {
+          code: 'invalid_literal',
+          message: opts?.message ?? `Invalid input, expected ${value}, received ${input}`,
+          received: input,
+          expected: value
+        }
+      ]);
+    }
+
+    return { success: true, value };
+  }
+});

package/src/validators/null.test.ts

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

package/src/validators/null.ts

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

package/src/validators/nullable.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from 'vitest';
+import { nullable } from './nullable';
+import { string } from './string';
+
+describe('nullable', () => {
+  test('should return a validator that allows null values', () => {
+    let validator = nullable(string());
+
+    expect(validator.validate(null)).toEqual({ success: true, value: null });
+  });
+
+  test('should return a validator that delegates to the input validator for non-null values', () => {
+    let validator = nullable(string());
+
+    expect(validator.validate('hello')).toEqual({ success: true, value: 'hello' });
+    expect(validator.validate(42)).toEqual({
+      success: false,
+      errors: [
+        {
+          code: 'invalid_type',
+          message: 'Invalid input, expected string, received number',
+          received: 'number',
+          expected: 'string'
+        }
+      ]
+    });
+  });
+
+  test('should return a validator with the correct type and optional flag', () => {
+    let validator = nullable(string());
+
+    expect(validator.type).toBe('string');
+  });
+});