@lowerdeck/validation 1.0.0

package/src/modifiers/length.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from 'vitest';
+import { length, maxLength, minLength } from './length';
+
+describe('length', () => {
+  test('returns an empty array if the value has the expected length', () => {
+    let validator = length(5);
+    let result = validator('hello');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value does not have the expected length', () => {
+    let validator = length(5);
+    let result = validator('longer');
+    expect(result).toEqual([
+      {
+        code: 'invalid_length',
+        message: 'Invalid length, expected 5',
+        expected: 5,
+        received: 6
+      }
+    ]);
+  });
+});
+
+describe('minLength', () => {
+  test('returns an empty array if the value has the minimum length', () => {
+    let validator = minLength(5);
+    let result = validator('hello');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an empty array if the value is longer than the minimum length', () => {
+    let validator = minLength(5);
+    let result = validator('world');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value is shorter than the minimum length', () => {
+    let validator = minLength(5);
+    let result = validator('hi');
+    expect(result).toEqual([
+      {
+        code: 'invalid_min_length',
+        message: 'Invalid min length, expected 5',
+        expected: 5,
+        received: 2,
+        min: 5
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let validator = minLength(5, { message: 'Too short!' });
+    let result = validator('hi');
+    expect(result).toEqual([
+      {
+        code: 'invalid_min_length',
+        message: 'Too short!',
+        expected: 5,
+        received: 2,
+        min: 5
+      }
+    ]);
+  });
+});
+
+describe('maxLength', () => {
+  test('returns an empty array if the value has the maximum length', () => {
+    let validator = maxLength(5);
+    let result = validator('hello');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an empty array if the value is shorter than the maximum length', () => {
+    let validator = maxLength(5);
+    let result = validator('hi');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value is longer than the maximum length', () => {
+    let validator = maxLength(5);
+    let result = validator('longer');
+    expect(result).toEqual([
+      {
+        code: 'invalid_max_length',
+        message: 'Invalid max length, expected 5',
+        expected: 5,
+        received: 6,
+        max: 5
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let validator = maxLength(5, { message: 'Too long!' });
+    let result = validator('longer');
+    expect(result).toEqual([
+      {
+        code: 'invalid_max_length',
+        message: 'Too long!',
+        expected: 5,
+        received: 6,
+        max: 5
+      }
+    ]);
+  });
+});

package/src/modifiers/length.ts

@@ -0,0 +1,54 @@
+import { ValidationModifier } from '../lib/types';
+
+export let length =
+  (length: number): ValidationModifier<string> =>
+  value => {
+    if (value.length !== length) {
+      return [
+        {
+          code: 'invalid_length',
+          message: `Invalid length, expected ${length}`,
+          expected: length,
+          received: value.length
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let minLength =
+  (length: number, opts?: { message?: string }): ValidationModifier<string | any[]> =>
+  value => {
+    if (value.length < length) {
+      return [
+        {
+          code: 'invalid_min_length',
+          message: opts?.message ?? `Invalid min length, expected ${length}`,
+          expected: length,
+          received: value.length,
+          min: length
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let maxLength =
+  (length: number, opts?: { message?: string }): ValidationModifier<string | any[]> =>
+  value => {
+    if (value.length > length) {
+      return [
+        {
+          code: 'invalid_max_length',
+          message: opts?.message ?? `Invalid max length, expected ${length}`,
+          expected: length,
+          received: value.length,
+          max: length
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/multipleOf.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from 'vitest';
+import { multipleOf } from './multipleOf';
+
+describe('multipleOf', () => {
+  test('should return an empty array if the value is a multiple of the given number', () => {
+    const modifier = multipleOf(3);
+    expect(modifier(9)).toEqual([]);
+    expect(modifier(12)).toEqual([]);
+    expect(modifier(0)).toEqual([]);
+  });
+
+  test('should return an error object if the value is not a multiple of the given number', () => {
+    const modifier = multipleOf(5);
+    expect(modifier(7)).toEqual([
+      {
+        code: 'invalid_multiple_of',
+        message: 'Invalid multiple of 5, expected 7',
+        received: 7,
+        multipleOf: 5
+      }
+    ]);
+    expect(modifier(11)).toEqual([
+      {
+        code: 'invalid_multiple_of',
+        message: 'Invalid multiple of 5, expected 11',
+        received: 11,
+        multipleOf: 5
+      }
+    ]);
+  });
+
+  test('should allow custom error message', () => {
+    const modifier = multipleOf(2, { message: 'Value must be an even number' });
+    expect(modifier(3)).toEqual([
+      {
+        code: 'invalid_multiple_of',
+        message: 'Value must be an even number',
+        received: 3,
+        multipleOf: 2
+      }
+    ]);
+    expect(modifier(5)).toEqual([
+      {
+        code: 'invalid_multiple_of',
+        message: 'Value must be an even number',
+        received: 5,
+        multipleOf: 2
+      }
+    ]);
+  });
+});

package/src/modifiers/multipleOf.ts

@@ -0,0 +1,18 @@
+import { ValidationModifier } from '../lib/types';
+
+export let multipleOf =
+  (multi: number, opts?: { message?: string }): ValidationModifier<number> =>
+  value => {
+    if (value % multi !== 0) {
+      return [
+        {
+          code: 'invalid_multiple_of',
+          message: opts?.message ?? `Invalid multiple of ${multi}, expected ${value}`,
+          received: value,
+          multipleOf: multi
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/oneOf.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from 'vitest';
+import { oneOf } from './oneOf';
+
+describe('oneOf', () => {
+  test('should return an empty array if the value is one of the allowed values', () => {
+    let allowed = ['apple', 'banana', 'orange'];
+    let modifier = oneOf(allowed);
+    let value = 'banana';
+    let result = modifier(value);
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object if the value is not one of the allowed values', () => {
+    let allowed = ['apple', 'banana', 'orange'];
+    let modifier = oneOf(allowed);
+    let value = 'grape';
+    let result = modifier(value);
+    expect(result).toEqual([
+      {
+        code: 'invalid_value',
+        message: 'Value must be one of: apple, banana, orange'
+      }
+    ]);
+  });
+
+  // Add more test cases if needed
+});

package/src/modifiers/oneOf.ts

@@ -0,0 +1,16 @@
+import { ValidationModifier } from '../lib/types';
+
+export let oneOf =
+  (allowed: string[], opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!allowed.includes(value)) {
+      return [
+        {
+          code: 'invalid_value',
+          message: opts?.message ?? `Value must be one of: ${allowed.join(', ')}`
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/positive.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'vitest';
+import { negative, positive } from './positive';
+
+describe('positive', () => {
+  test('should return an empty array for positive numbers', () => {
+    let result = positive()(1);
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object for non-positive numbers', () => {
+    let result = positive()(-1);
+    expect(result).toEqual([
+      {
+        code: 'invalid_positive',
+        message: 'Invalid positive, expected -1',
+        received: -1,
+        positive: true
+      }
+    ]);
+  });
+
+  test('should use the custom error message if provided', () => {
+    let result = positive({ message: 'Value must be positive' })(-1);
+    expect(result).toEqual([
+      {
+        code: 'invalid_positive',
+        message: 'Value must be positive',
+        received: -1,
+        positive: true
+      }
+    ]);
+  });
+});
+
+describe('negative', () => {
+  test('should return an empty array for negative numbers', () => {
+    let result = negative()(-1);
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object for non-negative numbers', () => {
+    let result = negative()(1);
+    expect(result).toEqual([
+      {
+        code: 'invalid_negative',
+        message: 'Invalid negative, expected 1',
+        received: 1,
+        negative: true
+      }
+    ]);
+  });
+
+  test('should use the custom error message if provided', () => {
+    let result = negative({ message: 'Value must be negative' })(1);
+    expect(result).toEqual([
+      {
+        code: 'invalid_negative',
+        message: 'Value must be negative',
+        received: 1,
+        negative: true
+      }
+    ]);
+  });
+});

package/src/modifiers/positive.ts

@@ -0,0 +1,35 @@
+import { ValidationModifier } from '../lib/types';
+
+export let positive =
+  (opts?: { message?: string }): ValidationModifier<number> =>
+  value => {
+    if (value <= 0) {
+      return [
+        {
+          code: 'invalid_positive',
+          message: opts?.message ?? `Invalid positive, expected ${value}`,
+          received: value,
+          positive: true
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let negative =
+  (opts?: { message?: string }): ValidationModifier<number> =>
+  value => {
+    if (value >= 0) {
+      return [
+        {
+          code: 'invalid_negative',
+          message: opts?.message ?? `Invalid negative, expected ${value}`,
+          received: value,
+          negative: true
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/regex.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest';
+import { regex } from './regex';
+
+describe('regex', () => {
+  test('returns an empty array if the value matches the pattern', () => {
+    let pattern = /^[a-z]+$/;
+    let validate = regex(pattern);
+    let result = validate('hello');
+
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value does not match the pattern', () => {
+    let pattern = /^[a-z]+$/;
+    let validate = regex(pattern);
+    let result = validate('123');
+
+    expect(result).toEqual([
+      {
+        code: 'invalid_regex',
+        message: 'Invalid regex, expected /^[a-z]+$/',
+        received: '123'
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let pattern = /^[a-z]+$/;
+    let validate = regex(pattern, { message: 'Must be all lowercase letters' });
+    let result = validate('123');
+
+    expect(result).toEqual([
+      {
+        code: 'invalid_regex',
+        message: 'Must be all lowercase letters',
+        received: '123'
+      }
+    ]);
+  });
+});

package/src/modifiers/regex.ts

@@ -0,0 +1,17 @@
+import { ValidationModifier } from '../lib/types';
+
+export let regex =
+  (pattern: RegExp, opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!pattern.test(value)) {
+      return [
+        {
+          code: 'invalid_regex',
+          message: opts?.message ?? `Invalid regex, expected ${pattern}`,
+          received: value
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/size.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from 'vitest';
+import { maxValue, minValue } from './size';
+
+describe('minValue', () => {
+  test('returns an empty array if the value is greater than or equal to the minimum', () => {
+    let min = 5;
+    let validate = minValue(min);
+
+    expect(validate(5)).toEqual([]);
+    expect(validate(10)).toEqual([]);
+  });
+
+  test('returns an array with an error object if the value is less than the minimum', () => {
+    let min = 5;
+    let validate = minValue(min);
+
+    expect(validate(4)).toEqual([
+      {
+        code: 'invalid_min',
+        message: `Invalid min, expected ${min}`,
+        expected: min,
+        received: 4,
+        min
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let min = 5;
+    let message = 'Value must be at least 5';
+    let validate = minValue(min, { message });
+
+    expect(validate(4)).toEqual([
+      {
+        code: 'invalid_min',
+        message,
+        expected: min,
+        received: 4,
+        min
+      }
+    ]);
+  });
+});
+
+describe('maxValue', () => {
+  test('returns an empty array if the value is less than or equal to the maximum', () => {
+    let max = 10;
+    let validate = maxValue(max);
+
+    expect(validate(10)).toEqual([]);
+    expect(validate(5)).toEqual([]);
+  });
+
+  test('returns an array with an error object if the value is greater than the maximum', () => {
+    let max = 10;
+    let validate = maxValue(max);
+
+    expect(validate(11)).toEqual([
+      {
+        code: 'invalid_max',
+        message: `Invalid max, expected ${max}`,
+        expected: max,
+        received: 11,
+        max
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let max = 10;
+    let message = 'Value must be at most 10';
+    let validate = maxValue(max, { message });
+
+    expect(validate(11)).toEqual([
+      {
+        code: 'invalid_max',
+        message,
+        expected: max,
+        received: 11,
+        max
+      }
+    ]);
+  });
+});

package/src/modifiers/size.ts

@@ -0,0 +1,37 @@
+import { ValidationModifier } from '../lib/types';
+
+export let minValue =
+  (min: number, opts?: { message?: string }): ValidationModifier<number> =>
+  value => {
+    if (value < min) {
+      return [
+        {
+          code: 'invalid_min',
+          message: opts?.message ?? `Invalid min, expected ${min}`,
+          expected: min,
+          received: value,
+          min
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let maxValue =
+  (max: number, opts?: { message?: string }): ValidationModifier<number> =>
+  value => {
+    if (value > max) {
+      return [
+        {
+          code: 'invalid_max',
+          message: opts?.message ?? `Invalid max, expected ${max}`,
+          expected: max,
+          received: value,
+          max
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/startsWith.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest';
+import { startsWith } from './startsWith';
+
+describe('startsWith', () => {
+  test('returns an empty array if the value starts with the prefix', () => {
+    let prefix = 'hello';
+    let value = 'hello world';
+    let result = startsWith(prefix)(value);
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value does not start with the prefix', () => {
+    let prefix = 'hello';
+    let value = 'world';
+    let result = startsWith(prefix)(value);
+    expect(result).toEqual([
+      {
+        code: 'invalid_prefix',
+        message: `Invalid prefix, expected ${prefix}`,
+        expected: prefix,
+        received: value
+      }
+    ]);
+  });
+
+  test('returns a custom error message if provided', () => {
+    let prefix = 'hello';
+    let value = 'world';
+    let message = 'Value must start with hello';
+    let result = startsWith(prefix, { message })(value);
+    expect(result).toEqual([
+      {
+        code: 'invalid_prefix',
+        message,
+        expected: prefix,
+        received: value
+      }
+    ]);
+  });
+});

package/src/modifiers/startsWith.ts

@@ -0,0 +1,18 @@
+import { ValidationModifier } from '../lib/types';
+
+export let startsWith =
+  (prefix: string, opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!value.startsWith(prefix)) {
+      return [
+        {
+          code: 'invalid_prefix',
+          message: opts?.message ?? `Invalid prefix, expected ${prefix}`,
+          expected: prefix,
+          received: value
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/url.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'vitest';
+import { url } from './url';
+
+describe('url', () => {
+  test('should return an empty array for a valid URL', () => {
+    let result = url()('https://example.com');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error for an invalid URL', () => {
+    let result = url()('not a url');
+    expect(result).toEqual([
+      {
+        code: 'invalid_url',
+        message: 'Invalid URL',
+        received: 'not a url'
+      }
+    ]);
+  });
+
+  test('should return an error for a URL with an invalid hostname', () => {
+    let result = url({ hostnames: ['example.com'] })('https://google.com');
+    expect(result).toEqual([
+      {
+        code: 'invalid_hostname',
+        message: 'Invalid hostname',
+        expected: ['example.com'],
+        received: 'google.com'
+      }
+    ]);
+  });
+
+  test('should return an empty array for a URL with a valid hostname', () => {
+    let result = url({ hostnames: ['example.com'] })('https://example.com');
+    expect(result).toEqual([]);
+  });
+
+  test('should use the provided error message', () => {
+    let result = url({ message: 'Custom error message' })('not a url');
+    expect(result).toEqual([
+      {
+        code: 'invalid_url',
+        message: 'Custom error message',
+        received: 'not a url'
+      }
+    ]);
+  });
+});

package/src/modifiers/url.ts

@@ -0,0 +1,30 @@
+import { ValidationModifier } from '../lib/types';
+
+export let url =
+  (opts?: { message?: string; hostnames?: string[] }): ValidationModifier<string> =>
+  value => {
+    try {
+      let url = new URL(value);
+
+      if (opts?.hostnames && !opts.hostnames.includes(url.hostname)) {
+        return [
+          {
+            code: 'invalid_hostname',
+            message: opts?.message ?? `Invalid hostname`,
+            expected: opts?.hostnames,
+            received: url.hostname
+          }
+        ];
+      }
+
+      return [];
+    } catch (err) {
+      return [
+        {
+          code: 'invalid_url',
+          message: opts?.message ?? `Invalid URL`,
+          received: value
+        }
+      ];
+    }
+  };