@forklaunch/validator 0.3.12 → 0.4.0

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

@@ -1,205 +0,0 @@
-import { generateSchema } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import { array, enum_, isSchema, number, openapi, optional, parse, schemify, string, union, validate } from '../../src/zod';
-import { compare } from '../utils/compare';
-describe('zod schema validator tests', () => {
-    let schema;
-    let schemified;
-    let expectedSchema;
-    beforeAll(() => {
-        schema = {
-            hello: {
-                world: string
-            },
-            foo: {
-                bar: number
-            }
-        };
-        schemified = schemify(schema);
-        expectedSchema = z.object({
-            hello: z.object({
-                world: z.string()
-            }),
-            foo: z.object({
-                bar: z.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 = z.optional(expectedSchema);
-        compare(unboxSchemified, schemifiedExpected);
-        compare(boxSchemified, schemifiedExpected);
-    });
-    test('array', async () => {
-        const unboxSchemified = array(schema);
-        const boxSchemified = array(schemified);
-        const schemifiedExpected = z.array(expectedSchema);
-        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 = z.union([
-            expectedSchema,
-            z.object({
-                test: z.string()
-            })
-        ]);
-        compare(unboxSchemified, schemifiedExpected);
-        compare(unboxSchemified2, schemifiedExpected);
-        compare(boxSchemified, schemifiedExpected);
-        compare(boxSchemified2, schemifiedExpected);
-    });
-    test('literal', async () => {
-        const schemified = schemify({
-            hello: 'world'
-        });
-        compare(schemified, z.object({
-            hello: z.literal('world')
-        }));
-    });
-    test('enum', async () => {
-        let TestSingleEnum;
-        (function (TestSingleEnum) {
-            TestSingleEnum["WORLD"] = "world";
-        })(TestSingleEnum || (TestSingleEnum = {}));
-        const schemified = enum_(TestSingleEnum);
-        compare(schemified, z.union([z.literal('world')]));
-        let TestMultipleEnum;
-        (function (TestMultipleEnum) {
-            TestMultipleEnum["WORLD"] = "world";
-            TestMultipleEnum["HELLO"] = "hello";
-        })(TestMultipleEnum || (TestMultipleEnum = {}));
-        const schemifiedMultiple = enum_(TestMultipleEnum);
-        compare(schemifiedMultiple, z.union([z.literal('world'), z.literal('hello')]));
-    });
-    test('isSchema', () => {
-        expect(isSchema(z.string())).toBe(true);
-        expect(isSchema(z.number())).toBe(true);
-        expect(isSchema(z.object({ foo: z.string() }))).toBe(true);
-        expect(isSchema(schemified)).toBe(true);
-        expect(isSchema('not a schema')).toBe(false);
-        expect(isSchema(42)).toBe(false);
-        expect(isSchema({})).toBe(false);
-        expect(isSchema(null)).toBe(false);
-        expect(isSchema(undefined)).toBe(false);
-    });
-    test('validate', async () => {
-        validate(schemified, {
-            hello: {
-                world: 'world'
-            },
-            foo: {
-                bar: 42
-            }
-        });
-        expect(validate(schemified, {
-            hello: {
-                world: 55
-            },
-            foo: {}
-        })).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, received number
-
-2. Path: foo > bar
-   Message: Expected number, received nan`);
-        }
-    });
-    test('openapi', async () => {
-        const schemified = schemify(schema);
-        const openApi = openapi(schemified);
-        expect(openApi).toEqual(generateSchema(schemified));
-    });
-});

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

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

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

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

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

@@ -1,100 +0,0 @@
-import { array, bigint, boolean, date, never, nullish, number, optional, schemify, string, symbol, union } from '../../src/zod';
-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();