@forklaunch/validator 0.3.0 → 0.3.2

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

@@ -0,0 +1,179 @@
+import { generateSchema } from '@anatine/zod-openapi';
+import { z } from 'zod';
+import { array, 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('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/{dist/tests/zod/equality.test.d.ts → lib/tests/zod/typeEquality.test.d.ts}

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,100 @@
+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();