@lowerdeck/validation 1.0.0

package/src/modifiers/emoji.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'vitest';
+import { emoji } from './emoji';
+
+describe('emoji', () => {
+  let validate = emoji();
+
+  test('should return no errors for valid emoji', () => {
+    let result = validate('😀');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error for invalid emoji', () => {
+    let result = validate('not an emoji');
+    expect(result).toEqual([
+      {
+        code: 'invalid_emoji',
+        message: 'Invalid emoji'
+      }
+    ]);
+  });
+
+  test('should allow custom error messages', () => {
+    let result = emoji({ message: 'Custom error message' })('not an emoji');
+    expect(result).toEqual([
+      {
+        code: 'invalid_emoji',
+        message: 'Custom error message'
+      }
+    ]);
+  });
+});

package/src/modifiers/emoji.ts

@@ -0,0 +1,18 @@
+import { ValidationModifier } from '../lib/types';
+
+let emojiRegex = /^(\p{Extended_Pictographic}|\p{Emoji_Component})+$/u;
+
+export let emoji =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!emojiRegex.test(value)) {
+      return [
+        {
+          code: 'invalid_emoji',
+          message: opts?.message ?? 'Invalid emoji'
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/endsWith.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from 'vitest';
+import { endsWith } from './endsWith';
+
+describe('endsWith', () => {
+  test('returns an empty array if the value ends with the suffix', () => {
+    let suffix = 'world';
+    let validate = endsWith(suffix);
+
+    expect(validate('hello world')).toEqual([]);
+    expect(validate('goodbye world')).toEqual([]);
+  });
+
+  test('returns an error object if the value does not end with the suffix', () => {
+    let suffix = 'world';
+    let validate = endsWith(suffix);
+
+    expect(validate('hello')).toEqual([
+      {
+        code: 'invalid_suffix',
+        message: `Invalid suffix, expected ${suffix}`,
+        expected: suffix,
+        received: 'hello'
+      }
+    ]);
+
+    expect(validate('goodbye')).toEqual([
+      {
+        code: 'invalid_suffix',
+        message: `Invalid suffix, expected ${suffix}`,
+        expected: suffix,
+        received: 'goodbye'
+      }
+    ]);
+  });
+
+  test('uses the provided error message if one is given', () => {
+    let suffix = 'world';
+    let message = 'This value must end with "world"';
+    let validate = endsWith(suffix, { message });
+
+    expect(validate('hello')).toEqual([
+      {
+        code: 'invalid_suffix',
+        message,
+        expected: suffix,
+        received: 'hello'
+      }
+    ]);
+  });
+});

package/src/modifiers/endsWith.ts

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

package/src/modifiers/equals.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'vitest';
+import { equals, notEquals } from './equals';
+
+describe('equals', () => {
+  test('returns an empty array if the value equals the expected value', () => {
+    let validator = equals('hello');
+    let result = validator('hello');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value does not equal the expected value', () => {
+    let validator = equals('hello');
+    let result = validator('world');
+    expect(result).toEqual([
+      {
+        code: 'invalid_equals',
+        message: 'Invalid value, expected hello',
+        expected: 'hello',
+        received: 'world'
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let validator = equals('hello', { message: 'This is a custom error message' });
+    let result = validator('world');
+    expect(result).toEqual([
+      {
+        code: 'invalid_equals',
+        message: 'This is a custom error message',
+        expected: 'hello',
+        received: 'world'
+      }
+    ]);
+  });
+});
+
+describe('notEquals', () => {
+  test('returns an empty array if the value does not equal the expected value', () => {
+    let validator = notEquals('hello');
+    let result = validator('world');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value equals the expected value', () => {
+    let validator = notEquals('hello');
+    let result = validator('hello');
+    expect(result).toEqual([
+      {
+        code: 'invalid_not_equals',
+        message: 'Invalid value, expected not hello',
+        expected: 'hello',
+        received: 'hello'
+      }
+    ]);
+  });
+
+  test('uses the custom error message if provided', () => {
+    let validator = notEquals('hello', { message: 'This is a custom error message' });
+    let result = validator('hello');
+    expect(result).toEqual([
+      {
+        code: 'invalid_not_equals',
+        message: 'This is a custom error message',
+        expected: 'hello',
+        received: 'hello'
+      }
+    ]);
+  });
+});

package/src/modifiers/equals.ts

@@ -0,0 +1,41 @@
+import { ValidationModifier } from '../lib/types';
+
+export let equals =
+  (
+    expected: string | number | boolean,
+    opts?: { message?: string }
+  ): ValidationModifier<string> =>
+  value => {
+    if (value !== expected) {
+      return [
+        {
+          code: 'invalid_equals',
+          message: opts?.message ?? `Invalid value, expected ${expected}`,
+          expected: expected,
+          received: value
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let notEquals =
+  (
+    expected: string | number | boolean,
+    opts?: { message?: string }
+  ): ValidationModifier<string> =>
+  value => {
+    if (value === expected) {
+      return [
+        {
+          code: 'invalid_not_equals',
+          message: opts?.message ?? `Invalid value, expected not ${expected}`,
+          expected: expected,
+          received: value
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/includes.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'vitest';
+import { includes, notIncludes } from './includes';
+
+describe('includes modifier', () => {
+  test('returns an empty array if the value includes the substring', () => {
+    let result = includes('foo')('foobar');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value does not include the substring', () => {
+    let result = includes('foo')('bar');
+    expect(result).toEqual([
+      {
+        code: 'invalid_includes',
+        message: 'Invalid substring, expected foo',
+        expected: 'foo',
+        received: 'bar'
+      }
+    ]);
+  });
+
+  test('allows a custom error message to be provided', () => {
+    let result = includes('foo', { message: 'Custom error message' })('bar');
+    expect(result).toEqual([
+      {
+        code: 'invalid_includes',
+        message: 'Custom error message',
+        expected: 'foo',
+        received: 'bar'
+      }
+    ]);
+  });
+});
+
+describe('notIncludes modifier', () => {
+  test('returns an empty array if the value does not include the substring', () => {
+    let result = notIncludes('foo')('bar');
+    expect(result).toEqual([]);
+  });
+
+  test('returns an error object if the value includes the substring', () => {
+    let result = notIncludes('foo')('foobar');
+    expect(result).toEqual([
+      {
+        code: 'invalid_not_includes',
+        message: 'Invalid substring, expected not foo',
+        expected: 'foo',
+        received: 'foobar'
+      }
+    ]);
+  });
+
+  test('allows a custom error message to be provided', () => {
+    let result = notIncludes('foo', { message: 'Custom error message' })('foobar');
+    expect(result).toEqual([
+      {
+        code: 'invalid_not_includes',
+        message: 'Custom error message',
+        expected: 'foo',
+        received: 'foobar'
+      }
+    ]);
+  });
+});

package/src/modifiers/includes.ts

@@ -0,0 +1,35 @@
+import { ValidationModifier } from '../lib/types';
+
+export let includes =
+  (substring: string, opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!value.includes(substring)) {
+      return [
+        {
+          code: 'invalid_includes',
+          message: opts?.message ?? `Invalid substring, expected ${substring}`,
+          expected: substring,
+          received: value
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let notIncludes =
+  (substring: string, opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (value.includes(substring)) {
+      return [
+        {
+          code: 'invalid_not_includes',
+          message: opts?.message ?? `Invalid substring, expected not ${substring}`,
+          expected: substring,
+          received: value
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/index.ts

@@ -0,0 +1,17 @@
+export * from './color';
+export * from './email';
+export * from './emoji';
+export * from './endsWith';
+export * from './equals';
+export * from './includes';
+export * from './integer';
+export * from './ip';
+export * from './isoDate';
+export * from './length';
+export * from './multipleOf';
+export * from './oneOf';
+export * from './positive';
+export * from './regex';
+export * from './size';
+export * from './startsWith';
+export * from './url';

package/src/modifiers/integer.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from 'vitest';
+import { integer } from './integer';
+
+describe('integer', () => {
+  test('should return an empty array if the value is an integer', () => {
+    let result = integer()(42);
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object if the value is not an integer', () => {
+    let result = integer()(0.42);
+    expect(result).toEqual([
+      {
+        code: 'invalid_integer',
+        message: 'Invalid value, expected integer',
+        expected: 0.42,
+        received: 0.42
+      }
+    ]);
+  });
+
+  test('should return an error object if the value is not an integer', () => {
+    let result = integer()('not an integer' as any);
+    expect(result).toEqual([
+      {
+        code: 'invalid_integer',
+        message: 'Invalid value, expected integer',
+        expected: 'not an integer',
+        received: 'not an integer'
+      }
+    ]);
+  });
+
+  test('should use the provided error message if one is provided', () => {
+    let result = integer({ message: 'Custom error message' })('not an integer' as any);
+    expect(result).toEqual([
+      {
+        code: 'invalid_integer',
+        message: 'Custom error message',
+        expected: 'not an integer',
+        received: 'not an integer'
+      }
+    ]);
+  });
+});

package/src/modifiers/integer.ts

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

package/src/modifiers/ip.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from 'vitest';
+import { ip } from './ip';
+
+describe('ip', () => {
+  test('should return an empty array for a valid IPv4 address', () => {
+    let result = ip()('192.168.0.1');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an empty array for a valid IPv6 address', () => {
+    let result = ip()('2001:0db8:85a3:0000:0000:8a2e:0370:7334');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object for an invalid IP address', () => {
+    let result = ip()('invalid-ip-address');
+    expect(result).toEqual([
+      {
+        code: 'invalid_ip',
+        message: 'Invalid ip address'
+      }
+    ]);
+  });
+
+  test('should return a custom error message for an invalid IP address', () => {
+    let result = ip({ message: 'Invalid IP address format' })('invalid-ip-address');
+    expect(result).toEqual([
+      {
+        code: 'invalid_ip',
+        message: 'Invalid IP address format'
+      }
+    ]);
+  });
+});

package/src/modifiers/ip.ts

@@ -0,0 +1,50 @@
+import { ValidationModifier } from '../lib/types';
+
+let ipV4Regex = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/;
+let ipV6Regex =
+  /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+
+export let ip =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!ipV4Regex.test(value) && !ipV6Regex.test(value)) {
+      return [
+        {
+          code: 'invalid_ip',
+          message: opts?.message ?? 'Invalid ip address'
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let ipV4 =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!ipV4Regex.test(value)) {
+      return [
+        {
+          code: 'invalid_ip_v4',
+          message: opts?.message ?? 'Invalid ip v4 address'
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let ipV6 =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!ipV6Regex.test(value)) {
+      return [
+        {
+          code: 'invalid_ip_v6',
+          message: opts?.message ?? 'Invalid ip v6 address'
+        }
+      ];
+    }
+
+    return [];
+  };

package/src/modifiers/isoDate.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from 'vitest';
+import { isoDate, isoDateTime, isoTime } from './isoDate';
+
+describe('isoDate', () => {
+  test('should return an empty array if the value is a valid ISO date', () => {
+    let result = isoDate()('2022-01-01');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object if the value is not a valid ISO date', () => {
+    let result = isoDate()('2022-01-32');
+    expect(result).toEqual([
+      {
+        code: 'invalid_iso_date',
+        message: 'Invalid iso date'
+      }
+    ]);
+  });
+
+  test('should return a custom error message if provided', () => {
+    let result = isoDate({ message: 'Invalid date format' })('2022-01-32');
+    expect(result).toEqual([
+      {
+        code: 'invalid_iso_date',
+        message: 'Invalid date format'
+      }
+    ]);
+  });
+});
+
+describe('isoDateTime', () => {
+  test('should return an empty array if the value is a valid ISO date time', () => {
+    let result = isoDateTime()('2022-01-01T12:30');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object if the value is not a valid ISO date time', () => {
+    let result = isoDateTime()('2022-01-32T25:00');
+    expect(result).toEqual([
+      {
+        code: 'invalid_iso_date_time',
+        message: 'Invalid iso date time'
+      }
+    ]);
+  });
+
+  test('should return a custom error message if provided', () => {
+    let result = isoDateTime({ message: 'Invalid date time format' })('2022-01-32T25:00');
+    expect(result).toEqual([
+      {
+        code: 'invalid_iso_date_time',
+        message: 'Invalid date time format'
+      }
+    ]);
+  });
+});
+
+describe('isoTime', () => {
+  test('should return an empty array if the value is a valid ISO time', () => {
+    let result = isoTime()('12:30');
+    expect(result).toEqual([]);
+  });
+
+  test('should return an error object if the value is not a valid ISO time', () => {
+    let result = isoTime()('25:00');
+    expect(result).toEqual([
+      {
+        code: 'invalid_iso_time',
+        message: 'Invalid iso time'
+      }
+    ]);
+  });
+
+  test('should return a custom error message if provided', () => {
+    let result = isoTime({ message: 'Invalid time format' })('25:00');
+    expect(result).toEqual([
+      {
+        code: 'invalid_iso_time',
+        message: 'Invalid time format'
+      }
+    ]);
+  });
+});

package/src/modifiers/isoDate.ts

@@ -0,0 +1,51 @@
+import { ValidationModifier } from '../lib/types';
+
+let isoDateRegex = /^\d{4}-(0[1-9]|1[0-2])-([12]\d|0[1-9]|3[01])$/;
+let isoDateTimeRegex =
+  /^\d{4}-(0[1-9]|1[0-2])-([12]\d|0[1-9]|3[01])T(0[0-9]|1\d|2[0-3]):[0-5]\d$/;
+let isoTimeRegex = /^(0[0-9]|1\d|2[0-3]):[0-5]\d$/;
+
+export let isoDate =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!isoDateRegex.test(value)) {
+      return [
+        {
+          code: 'invalid_iso_date',
+          message: opts?.message ?? 'Invalid iso date'
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let isoDateTime =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!isoDateTimeRegex.test(value)) {
+      return [
+        {
+          code: 'invalid_iso_date_time',
+          message: opts?.message ?? 'Invalid iso date time'
+        }
+      ];
+    }
+
+    return [];
+  };
+
+export let isoTime =
+  (opts?: { message?: string }): ValidationModifier<string> =>
+  value => {
+    if (!isoTimeRegex.test(value)) {
+      return [
+        {
+          code: 'invalid_iso_time',
+          message: opts?.message ?? 'Invalid iso time'
+        }
+      ];
+    }
+
+    return [];
+  };