@forklaunch/validator 0.3.1 → 0.3.2

package/lib/tests/typebox/schemaValidator.test.js

@@ -0,0 +1,219 @@
+import { Type } from '@sinclair/typebox';
+import { array, number, openapi, optional, parse, schemify, string, union, validate } from '../../src/typebox/staticSchemaValidator';
+import { compare } from '../utils/compare';
+describe('typebox schema validator tests', () => {
+    let schema;
+    let schemified;
+    let expectedSchema;
+    beforeAll(() => {
+        schema = {
+            hello: {
+                world: string
+            },
+            foo: {
+                bar: number
+            }
+        };
+        schemified = schemify(schema);
+        expectedSchema = Type.Object({
+            hello: Type.Object({
+                world: Type.String()
+            }),
+            foo: Type.Object({
+                bar: Type.Transform(Type.Union([
+                    Type.Number(),
+                    Type.String({ pattern: '^[0-9]+$' }),
+                    Type.Boolean(),
+                    Type.Null(),
+                    Type.Date(),
+                    Type.BigInt()
+                ], {
+                    errorType: 'number-like',
+                    openapiType: Type.Number()
+                }))
+                    .Decode((value) => {
+                    if (typeof value === 'string') {
+                        const num = Number(value);
+                        if (isNaN(num)) {
+                            throw new Error('Invalid number');
+                        }
+                        else {
+                            return num;
+                        }
+                    }
+                    return value;
+                })
+                    .Encode(Number)
+            })
+        });
+    });
+    test('schemify', async () => {
+        compare(schemified, expectedSchema);
+        compare(schemified, schemify({
+            hello: {
+                world: string
+            },
+            foo: {
+                bar: number
+            }
+        }));
+        compare(schemified, schemify({
+            hello: schemify({
+                world: string
+            }),
+            foo: {
+                bar: number
+            }
+        }));
+        compare(schemified, schemify({
+            hello: {
+                world: string
+            },
+            foo: schemify({
+                bar: number
+            })
+        }));
+        compare(schemified, schemify({
+            hello: schemify({
+                world: string
+            }),
+            foo: schemify({
+                bar: number
+            })
+        }));
+    });
+    test('optional', async () => {
+        const unboxSchemified = optional(schema);
+        const boxSchemified = optional(schemified);
+        const schemifiedExpected = Type.Optional(expectedSchema);
+        compare(unboxSchemified, schemifiedExpected);
+        compare(boxSchemified, schemifiedExpected);
+    });
+    test('array', async () => {
+        const unboxSchemified = array(schema);
+        const boxSchemified = array(schemified);
+        const schemifiedExpected = Type.Array(expectedSchema, {
+            errorType: 'array of object'
+        });
+        compare(unboxSchemified, schemifiedExpected);
+        compare(boxSchemified, schemifiedExpected);
+    });
+    test('union', async () => {
+        const unboxSchemified = union([
+            schema,
+            {
+                test: string
+            }
+        ]);
+        const unboxSchemified2 = union([
+            schema,
+            schemify({
+                test: string
+            })
+        ]);
+        const boxSchemified = union([
+            schemified,
+            schemify({
+                test: string
+            })
+        ]);
+        const boxSchemified2 = union([
+            schemified,
+            {
+                test: string
+            }
+        ]);
+        const schemifiedExpected = Type.Union([
+            expectedSchema,
+            Type.Object({
+                test: Type.String()
+            })
+        ], {
+            errorType: 'any of object, object',
+            errorSuffix: true
+        });
+        compare(unboxSchemified, schemifiedExpected);
+        compare(unboxSchemified2, schemifiedExpected);
+        compare(boxSchemified, schemifiedExpected);
+        compare(boxSchemified2, schemifiedExpected);
+    });
+    test('literal', async () => {
+        const schemified = schemify({
+            hello: 'world'
+        });
+        compare(schemified, Type.Object({
+            hello: Type.Literal('world')
+        }));
+    });
+    test('validate', async () => {
+        validate(schemified, {
+            hello: {
+                world: 'world'
+            },
+            foo: {
+                bar: 42
+            }
+        });
+        expect(validate(schemified, {
+            hello: {
+                world: 55
+            },
+            foo: {
+                bar: 42
+            }
+        })).toBe(false);
+    });
+    test('parse', () => {
+        const validParse = parse(schemified, {
+            hello: {
+                world: 'world'
+            },
+            foo: {
+                bar: 42
+            }
+        });
+        expect(validParse.ok).toBe(true);
+        if (validParse.ok) {
+            compare(validParse.value, {
+                hello: {
+                    world: 'world'
+                },
+                foo: {
+                    bar: 42
+                }
+            });
+        }
+        const failedParse = parse(schemified, {
+            hello: {
+                world: 55
+            },
+            foo: {}
+        });
+        expect(failedParse.ok).toBe(false);
+        if (!failedParse.ok) {
+            expect(failedParse.error)
+                .toBe(`Validation failed with the following errors:
+1. Path: hello > world
+   Message: Expected string
+
+2. Path: foo > bar
+   Message: Expected required property
+
+3. Path: foo > bar
+   Message: Expected number-like value`);
+        }
+    });
+    test('openapi', async () => {
+        const mutation = schemify(schema);
+        compare(openapi(schema), Type.Object({
+            hello: Type.Object({
+                world: Type.String()
+            }),
+            foo: Type.Object({
+                bar: Type.Number()
+            })
+        }));
+        // ensure that no mutation has occurred to schema
+        compare(schemify(schema), mutation);
+    });
+});

package/{dist/tests/typebox/equality.test.d.ts → lib/tests/typebox/typeEquality.test.d.ts}

@@ -1 +1,2 @@
 export declare function assert<T extends never>(): void;
+//# sourceMappingURL=typeEquality.test.d.ts.map

package/lib/tests/typebox/typeEquality.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeEquality.test.d.ts","sourceRoot":"","sources":["../../../tests/typebox/typeEquality.test.ts"],"names":[],"mappings":"AAgHA,wBAAgB,MAAM,CAAC,CAAC,SAAS,KAAK,UAAM"}

package/lib/tests/typebox/typeEquality.test.js

@@ -0,0 +1,100 @@
+import { array, bigint, boolean, date, never, nullish, number, optional, schemify, string, symbol, union } from '../../src/typebox/staticSchemaValidator';
+const one = array({
+    name: {
+        j: union([string, number, date, boolean, bigint, nullish, symbol, never]),
+        t: optional(union([
+            array({
+                y: array(number)
+            }),
+            string
+        ])),
+        m: {
+            a: optional(string),
+            b: number,
+            c: {
+                d: string,
+                e: number
+            }
+        }
+    },
+    200: {
+        j: string
+    },
+    m: {
+        a: true
+    }
+});
+const two = array({
+    name: {
+        j: union([string, number, date, boolean, bigint, nullish, symbol, never]),
+        t: optional(union([
+            array({
+                y: array(number)
+            }),
+            string
+        ])),
+        m: schemify({
+            a: optional(string),
+            b: number,
+            c: {
+                d: string,
+                e: number
+            }
+        })
+    },
+    200: {
+        j: string
+    },
+    m: {
+        a: true
+    }
+});
+const three = schemify(array(schemify({
+    name: schemify({
+        j: union([
+            string,
+            number,
+            date,
+            boolean,
+            bigint,
+            nullish,
+            symbol,
+            never
+        ]),
+        t: optional(union([
+            array({
+                y: array(number)
+            }),
+            string
+        ])),
+        m: schemify({
+            a: optional(string),
+            b: number,
+            c: {
+                d: string,
+                e: number
+            }
+        })
+    }),
+    200: schemify({
+        j: string
+    }),
+    m: schemify({
+        a: true
+    })
+})));
+export function assert() { }
+assert();
+assert();
+assert();
+assert();
+const shortOne = {
+    s: string,
+    non: number
+};
+const shortTwo = schemify({
+    s: string,
+    non: number
+});
+assert();
+assert();

package/lib/tests/utils/compare.d.ts

@@ -0,0 +1,2 @@
+export declare const compare: (received: unknown, expected: unknown) => void;
+//# sourceMappingURL=compare.d.ts.map

package/lib/tests/utils/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../tests/utils/compare.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,aAAc,OAAO,YAAY,OAAO,SAO3D,CAAC"}

package/lib/tests/utils/compare.js

@@ -0,0 +1,8 @@
+export const compare = (received, expected) => {
+    switch (typeof received) {
+        case 'bigint':
+            return expect(received).toBe(expected);
+        default:
+            return expect(JSON.stringify(received)).toBe(JSON.stringify(expected));
+    }
+};

package/{dist/tests → lib/tests/utils}/mockSchemaValidator.d.ts

@@ -1,7 +1,7 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { SchemaValidator } from '../index';
-import { LiteralSchema } from '../types/schema.types';
-declare module '../types/schema.types' {
+import { SchemaValidator } from '../../index';
+import { LiteralSchema, ParseResult } from '../../src/shared/types/schema.types';
+declare module '../../src/shared/types/schema.types' {
     interface SchemaResolve<T> {
         Mock: T;
     }
@@ -13,26 +13,31 @@ type RecursiveUnion<T extends readonly string[]> = T extends readonly [
     infer F extends string,
     ...infer R extends readonly string[]
 ] ? R extends [] ? F : `${F} | ${RecursiveUnion<R>}` : '';
-export declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T) => SchemaObject> {
+export declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
     _Type: 'Mock';
     _SchemaCatchall: string;
     _ValidSchemaObject: string;
     string: string;
+    uuid: string;
+    email: string;
+    uri: string;
     number: string;
     bigint: string;
     boolean: string;
     date: string;
     symbol: string;
-    empty: string;
+    nullish: string;
     any: string;
     unknown: string;
     never: string;
-    schemify<T>(schema: T): T;
+    compile<T extends string>(schema: T): T;
+    schemify<T extends string>(schema: T): T;
     optional<T extends string>(schema: T): `optional ${T}`;
     array<T extends string>(schema: T): `array ${T}`;
     union<T extends readonly string[]>(schemas: T): RecursiveUnion<T>;
     literal<T extends LiteralSchema>(schema: T): `literal ${T}`;
     validate<T extends string>(schema: T, value: string): boolean;
+    parse<T extends string>(schema: T, value: string): ParseResult<T>;
     openapi<T extends string>(_schema: T): SchemaObject;
 }
 export declare const mockSchemaValidator: MockSchemaValidator;
@@ -42,11 +47,11 @@ export declare const bigint: string;
 export declare const boolean: string;
 export declare const date: string;
 export declare const symbol: string;
-export declare const empty: string;
+export declare const nullish: string;
 export declare const any: string;
 export declare const unknown: string;
 export declare const never: string;
-export declare const schemify: <T>(schema: T) => T;
+export declare const schemify: <T extends string>(schema: T) => T;
 export declare const optional: <T extends string>(schema: T) => `optional ${T}`;
 export declare const array: <T extends string>(schema: T) => `array ${T}`;
 export declare const union: <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>;
@@ -54,3 +59,4 @@ export declare const literal: <T extends LiteralSchema>(schema: T) => `literal $
 export declare const validate: <T extends string>(schema: T, value: string) => boolean;
 export declare const openapi: <T extends string>(_schema: T) => SchemaObject;
 export {};
+//# sourceMappingURL=mockSchemaValidator.d.ts.map

package/lib/tests/utils/mockSchemaValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockSchemaValidator.d.ts","sourceRoot":"","sources":["../../../tests/utils/mockSchemaValidator.ts"],"names":[],"mappings":"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"}

package/lib/tests/utils/mockSchemaValidator.js

@@ -0,0 +1,72 @@
+export class MockSchemaValidator {
+    _Type;
+    _SchemaCatchall;
+    _ValidSchemaObject;
+    string = 'string';
+    uuid = 'uuid';
+    email = 'email';
+    uri = 'uri';
+    number = 'number';
+    bigint = 'bigint';
+    boolean = 'boolean';
+    date = 'date';
+    symbol = 'symbol';
+    nullish = 'nullish';
+    any = 'any';
+    unknown = 'unknown';
+    never = 'never';
+    compile(schema) {
+        return schema;
+    }
+    schemify(schema) {
+        return schema;
+    }
+    optional(schema) {
+        return ('optional ' + schema);
+    }
+    array(schema) {
+        return ('array ' + schema);
+    }
+    union(schemas) {
+        return schemas.join(' | ');
+    }
+    literal(schema) {
+        return `literal ${schema}`;
+    }
+    validate(schema, value) {
+        return schema === value;
+    }
+    parse(schema, value) {
+        return JSON.stringify(schema) === JSON.stringify(value)
+            ? {
+                ok: true,
+                value: schema
+            }
+            : {
+                ok: false,
+                error: 'Some error'
+            };
+    }
+    openapi(_schema) {
+        return {};
+    }
+}
+export const mockSchemaValidator = new MockSchemaValidator();
+export const string = mockSchemaValidator.string;
+export const number = mockSchemaValidator.number;
+export const bigint = mockSchemaValidator.bigint;
+export const boolean = mockSchemaValidator.boolean;
+export const date = mockSchemaValidator.date;
+export const symbol = mockSchemaValidator.symbol;
+export const nullish = mockSchemaValidator.nullish;
+export const any = mockSchemaValidator.any;
+export const unknown = mockSchemaValidator.unknown;
+export const never = mockSchemaValidator.never;
+export const schemify = mockSchemaValidator.schemify.bind(mockSchemaValidator);
+export const optional = mockSchemaValidator.optional.bind(mockSchemaValidator);
+export const array = mockSchemaValidator.array.bind(mockSchemaValidator);
+// note, use 'as const' when calling on the input array, for proper type parsing
+export const union = mockSchemaValidator.union.bind(mockSchemaValidator);
+export const literal = mockSchemaValidator.literal.bind(mockSchemaValidator);
+export const validate = mockSchemaValidator.validate.bind(mockSchemaValidator);
+export const openapi = mockSchemaValidator.openapi.bind(mockSchemaValidator);

package/lib/tests/zod/advancedParse.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=advancedParse.test.d.ts.map

package/lib/tests/zod/advancedParse.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advancedParse.test.d.ts","sourceRoot":"","sources":["../../../tests/zod/advancedParse.test.ts"],"names":[],"mappings":""}