56 | ? inferRaw
57 | : never;
58 |
59 | export type inferParsedPropertySchema
| Schema> = P extends Property<
60 | any,
61 | any,
62 | infer Parsed
63 | >
64 | ? Parsed
65 | : P extends Schema
66 | ? inferParsed
67 | : never;
68 |
69 | export type inferRawKey<
70 | ParsedKey extends string | number | symbol,
71 | P extends Property | Schema
72 | > = P extends Property ? Raw : ParsedKey;
73 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/primitives/any.ts:
--------------------------------------------------------------------------------
1 | import { SchemaType } from "../../Schema";
2 | import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
3 |
4 | export const any = createIdentitySchemaCreator(SchemaType.ANY, (value) => ({ ok: true, value }));
5 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/primitives/boolean.ts:
--------------------------------------------------------------------------------
1 | import { SchemaType } from "../../Schema";
2 | import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
3 | import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
4 |
5 | export const boolean = createIdentitySchemaCreator(
6 | SchemaType.BOOLEAN,
7 | (value, { breadcrumbsPrefix = [] } = {}) => {
8 | if (typeof value === "boolean") {
9 | return {
10 | ok: true,
11 | value,
12 | };
13 | } else {
14 | return {
15 | ok: false,
16 | errors: [
17 | {
18 | path: breadcrumbsPrefix,
19 | message: getErrorMessageForIncorrectType(value, "boolean"),
20 | },
21 | ],
22 | };
23 | }
24 | }
25 | );
26 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/primitives/index.ts:
--------------------------------------------------------------------------------
1 | export { any } from "./any";
2 | export { boolean } from "./boolean";
3 | export { number } from "./number";
4 | export { string } from "./string";
5 | export { unknown } from "./unknown";
6 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/primitives/number.ts:
--------------------------------------------------------------------------------
1 | import { SchemaType } from "../../Schema";
2 | import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
3 | import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
4 |
5 | export const number = createIdentitySchemaCreator(
6 | SchemaType.NUMBER,
7 | (value, { breadcrumbsPrefix = [] } = {}) => {
8 | if (typeof value === "number") {
9 | return {
10 | ok: true,
11 | value,
12 | };
13 | } else {
14 | return {
15 | ok: false,
16 | errors: [
17 | {
18 | path: breadcrumbsPrefix,
19 | message: getErrorMessageForIncorrectType(value, "number"),
20 | },
21 | ],
22 | };
23 | }
24 | }
25 | );
26 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/primitives/string.ts:
--------------------------------------------------------------------------------
1 | import { SchemaType } from "../../Schema";
2 | import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
3 | import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
4 |
5 | export const string = createIdentitySchemaCreator(
6 | SchemaType.STRING,
7 | (value, { breadcrumbsPrefix = [] } = {}) => {
8 | if (typeof value === "string") {
9 | return {
10 | ok: true,
11 | value,
12 | };
13 | } else {
14 | return {
15 | ok: false,
16 | errors: [
17 | {
18 | path: breadcrumbsPrefix,
19 | message: getErrorMessageForIncorrectType(value, "string"),
20 | },
21 | ],
22 | };
23 | }
24 | }
25 | );
26 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/primitives/unknown.ts:
--------------------------------------------------------------------------------
1 | import { SchemaType } from "../../Schema";
2 | import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
3 |
4 | export const unknown = createIdentitySchemaCreator(SchemaType.UNKNOWN, (value) => ({ ok: true, value }));
5 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/record/index.ts:
--------------------------------------------------------------------------------
1 | export { record } from "./record";
2 | export type { BaseRecordSchema, RecordSchema } from "./types";
3 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/record/record.ts:
--------------------------------------------------------------------------------
1 | import { MaybeValid, Schema, SchemaType, ValidationError } from "../../Schema";
2 | import { entries } from "../../utils/entries";
3 | import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
4 | import { isPlainObject } from "../../utils/isPlainObject";
5 | import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
6 | import { getSchemaUtils } from "../schema-utils";
7 | import { BaseRecordSchema, RecordSchema } from "./types";
8 |
9 | export function record(
10 | keySchema: Schema,
11 | valueSchema: Schema
12 | ): RecordSchema {
13 | const baseSchema: BaseRecordSchema = {
14 | parse: (raw, opts) => {
15 | return validateAndTransformRecord({
16 | value: raw,
17 | isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
18 | transformKey: (key) =>
19 | keySchema.parse(key, {
20 | ...opts,
21 | breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key} (key)`],
22 | }),
23 | transformValue: (value, key) =>
24 | valueSchema.parse(value, {
25 | ...opts,
26 | breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key}`],
27 | }),
28 | breadcrumbsPrefix: opts?.breadcrumbsPrefix,
29 | });
30 | },
31 | json: (parsed, opts) => {
32 | return validateAndTransformRecord({
33 | value: parsed,
34 | isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
35 | transformKey: (key) =>
36 | keySchema.json(key, {
37 | ...opts,
38 | breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key} (key)`],
39 | }),
40 | transformValue: (value, key) =>
41 | valueSchema.json(value, {
42 | ...opts,
43 | breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key}`],
44 | }),
45 | breadcrumbsPrefix: opts?.breadcrumbsPrefix,
46 | });
47 | },
48 | getType: () => SchemaType.RECORD,
49 | };
50 |
51 | return {
52 | ...maybeSkipValidation(baseSchema),
53 | ...getSchemaUtils(baseSchema),
54 | };
55 | }
56 |
57 | function validateAndTransformRecord({
58 | value,
59 | isKeyNumeric,
60 | transformKey,
61 | transformValue,
62 | breadcrumbsPrefix = [],
63 | }: {
64 | value: unknown;
65 | isKeyNumeric: boolean;
66 | transformKey: (key: string | number) => MaybeValid;
67 | transformValue: (value: unknown, key: string | number) => MaybeValid;
68 | breadcrumbsPrefix: string[] | undefined;
69 | }): MaybeValid> {
70 | if (!isPlainObject(value)) {
71 | return {
72 | ok: false,
73 | errors: [
74 | {
75 | path: breadcrumbsPrefix,
76 | message: getErrorMessageForIncorrectType(value, "object"),
77 | },
78 | ],
79 | };
80 | }
81 |
82 | return entries(value).reduce>>(
83 | (accPromise, [stringKey, value]) => {
84 | // skip nullish keys
85 | if (value == null) {
86 | return accPromise;
87 | }
88 |
89 | const acc = accPromise;
90 |
91 | let key: string | number = stringKey;
92 | if (isKeyNumeric) {
93 | const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
94 | if (!isNaN(numberKey)) {
95 | key = numberKey;
96 | }
97 | }
98 | const transformedKey = transformKey(key);
99 |
100 | const transformedValue = transformValue(value, key);
101 |
102 | if (acc.ok && transformedKey.ok && transformedValue.ok) {
103 | return {
104 | ok: true,
105 | value: {
106 | ...acc.value,
107 | [transformedKey.value]: transformedValue.value,
108 | },
109 | };
110 | }
111 |
112 | const errors: ValidationError[] = [];
113 | if (!acc.ok) {
114 | errors.push(...acc.errors);
115 | }
116 | if (!transformedKey.ok) {
117 | errors.push(...transformedKey.errors);
118 | }
119 | if (!transformedValue.ok) {
120 | errors.push(...transformedValue.errors);
121 | }
122 |
123 | return {
124 | ok: false,
125 | errors,
126 | };
127 | },
128 | { ok: true, value: {} as Record }
129 | );
130 | }
131 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/record/types.ts:
--------------------------------------------------------------------------------
1 | import { BaseSchema } from "../../Schema";
2 | import { SchemaUtils } from "../schema-utils";
3 |
4 | export type RecordSchema<
5 | RawKey extends string | number,
6 | RawValue,
7 | ParsedKey extends string | number,
8 | ParsedValue
9 | > = BaseRecordSchema &
10 | SchemaUtils, Record>;
11 |
12 | export type BaseRecordSchema<
13 | RawKey extends string | number,
14 | RawValue,
15 | ParsedKey extends string | number,
16 | ParsedValue
17 | > = BaseSchema, Record>;
18 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/schema-utils/JsonError.ts:
--------------------------------------------------------------------------------
1 | import { ValidationError } from "../../Schema";
2 | import { stringifyValidationError } from "./stringifyValidationErrors";
3 |
4 | export class JsonError extends Error {
5 | constructor(public readonly errors: ValidationError[]) {
6 | super(errors.map(stringifyValidationError).join("; "));
7 | Object.setPrototypeOf(this, JsonError.prototype);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/schema-utils/ParseError.ts:
--------------------------------------------------------------------------------
1 | import { ValidationError } from "../../Schema";
2 | import { stringifyValidationError } from "./stringifyValidationErrors";
3 |
4 | export class ParseError extends Error {
5 | constructor(public readonly errors: ValidationError[]) {
6 | super(errors.map(stringifyValidationError).join("; "));
7 | Object.setPrototypeOf(this, ParseError.prototype);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/schema-utils/getSchemaUtils.ts:
--------------------------------------------------------------------------------
1 | import { BaseSchema, Schema, SchemaOptions, SchemaType } from "../../Schema";
2 | import { JsonError } from "./JsonError";
3 | import { ParseError } from "./ParseError";
4 |
5 | export interface SchemaUtils {
6 | optional: () => Schema;
7 | transform: (transformer: SchemaTransformer) => Schema;
8 | parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
9 | jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Raw;
10 | }
11 |
12 | export interface SchemaTransformer {
13 | transform: (parsed: Parsed) => Transformed;
14 | untransform: (transformed: any) => Parsed;
15 | }
16 |
17 | export function getSchemaUtils(schema: BaseSchema): SchemaUtils {
18 | return {
19 | optional: () => optional(schema),
20 | transform: (transformer) => transform(schema, transformer),
21 | parseOrThrow: (raw, opts) => {
22 | const parsed = schema.parse(raw, opts);
23 | if (parsed.ok) {
24 | return parsed.value;
25 | }
26 | throw new ParseError(parsed.errors);
27 | },
28 | jsonOrThrow: (parsed, opts) => {
29 | const raw = schema.json(parsed, opts);
30 | if (raw.ok) {
31 | return raw.value;
32 | }
33 | throw new JsonError(raw.errors);
34 | },
35 | };
36 | }
37 |
38 | /**
39 | * schema utils are defined in one file to resolve issues with circular imports
40 | */
41 |
42 | export function optional(
43 | schema: BaseSchema
44 | ): Schema {
45 | const baseSchema: BaseSchema = {
46 | parse: (raw, opts) => {
47 | if (raw == null) {
48 | return {
49 | ok: true,
50 | value: undefined,
51 | };
52 | }
53 | return schema.parse(raw, opts);
54 | },
55 | json: (parsed, opts) => {
56 | if (opts?.omitUndefined && parsed === undefined) {
57 | return {
58 | ok: true,
59 | value: undefined,
60 | };
61 | }
62 | if (parsed == null) {
63 | return {
64 | ok: true,
65 | value: null,
66 | };
67 | }
68 | return schema.json(parsed, opts);
69 | },
70 | getType: () => SchemaType.OPTIONAL,
71 | };
72 |
73 | return {
74 | ...baseSchema,
75 | ...getSchemaUtils(baseSchema),
76 | };
77 | }
78 |
79 | export function transform(
80 | schema: BaseSchema,
81 | transformer: SchemaTransformer
82 | ): Schema {
83 | const baseSchema: BaseSchema = {
84 | parse: (raw, opts) => {
85 | const parsed = schema.parse(raw, opts);
86 | if (!parsed.ok) {
87 | return parsed;
88 | }
89 | return {
90 | ok: true,
91 | value: transformer.transform(parsed.value),
92 | };
93 | },
94 | json: (transformed, opts) => {
95 | const parsed = transformer.untransform(transformed);
96 | return schema.json(parsed, opts);
97 | },
98 | getType: () => schema.getType(),
99 | };
100 |
101 | return {
102 | ...baseSchema,
103 | ...getSchemaUtils(baseSchema),
104 | };
105 | }
106 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/schema-utils/index.ts:
--------------------------------------------------------------------------------
1 | export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
2 | export type { SchemaUtils } from "./getSchemaUtils";
3 | export { JsonError } from "./JsonError";
4 | export { ParseError } from "./ParseError";
5 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/schema-utils/stringifyValidationErrors.ts:
--------------------------------------------------------------------------------
1 | import { ValidationError } from "../../Schema";
2 |
3 | export function stringifyValidationError(error: ValidationError): string {
4 | if (error.path.length === 0) {
5 | return error.message;
6 | }
7 | return `${error.path.join(" -> ")}: ${error.message}`;
8 | }
9 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/set/index.ts:
--------------------------------------------------------------------------------
1 | export { set } from "./set";
2 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/set/set.ts:
--------------------------------------------------------------------------------
1 | import { BaseSchema, Schema, SchemaType } from "../../Schema";
2 | import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
3 | import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
4 | import { list } from "../list";
5 | import { getSchemaUtils } from "../schema-utils";
6 |
7 | export function set(schema: Schema): Schema> {
8 | const listSchema = list(schema);
9 | const baseSchema: BaseSchema> = {
10 | parse: (raw, opts) => {
11 | const parsedList = listSchema.parse(raw, opts);
12 | if (parsedList.ok) {
13 | return {
14 | ok: true,
15 | value: new Set(parsedList.value),
16 | };
17 | } else {
18 | return parsedList;
19 | }
20 | },
21 | json: (parsed, opts) => {
22 | if (!(parsed instanceof Set)) {
23 | return {
24 | ok: false,
25 | errors: [
26 | {
27 | path: opts?.breadcrumbsPrefix ?? [],
28 | message: getErrorMessageForIncorrectType(parsed, "Set"),
29 | },
30 | ],
31 | };
32 | }
33 | const jsonList = listSchema.json([...parsed], opts);
34 | return jsonList;
35 | },
36 | getType: () => SchemaType.SET,
37 | };
38 |
39 | return {
40 | ...maybeSkipValidation(baseSchema),
41 | ...getSchemaUtils(baseSchema),
42 | };
43 | }
44 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/undiscriminated-union/index.ts:
--------------------------------------------------------------------------------
1 | export type {
2 | inferParsedUnidiscriminatedUnionSchema,
3 | inferRawUnidiscriminatedUnionSchema,
4 | UndiscriminatedUnionSchema,
5 | } from "./types";
6 | export { undiscriminatedUnion } from "./undiscriminatedUnion";
7 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/undiscriminated-union/types.ts:
--------------------------------------------------------------------------------
1 | import { inferParsed, inferRaw, Schema } from "../../Schema";
2 |
3 | export type UndiscriminatedUnionSchema = Schema<
4 | inferRawUnidiscriminatedUnionSchema,
5 | inferParsedUnidiscriminatedUnionSchema
6 | >;
7 |
8 | export type inferRawUnidiscriminatedUnionSchema = inferRaw;
9 |
10 | export type inferParsedUnidiscriminatedUnionSchema = inferParsed;
11 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.ts:
--------------------------------------------------------------------------------
1 | import { BaseSchema, MaybeValid, Schema, SchemaOptions, SchemaType, ValidationError } from "../../Schema";
2 | import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
3 | import { getSchemaUtils } from "../schema-utils";
4 | import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
5 |
6 | export function undiscriminatedUnion, ...Schema[]]>(
7 | schemas: Schemas
8 | ): Schema, inferParsedUnidiscriminatedUnionSchema> {
9 | const baseSchema: BaseSchema<
10 | inferRawUnidiscriminatedUnionSchema,
11 | inferParsedUnidiscriminatedUnionSchema
12 | > = {
13 | parse: (raw, opts) => {
14 | return validateAndTransformUndiscriminatedUnion>(
15 | (schema, opts) => schema.parse(raw, opts),
16 | schemas,
17 | opts
18 | );
19 | },
20 | json: (parsed, opts) => {
21 | return validateAndTransformUndiscriminatedUnion>(
22 | (schema, opts) => schema.json(parsed, opts),
23 | schemas,
24 | opts
25 | );
26 | },
27 | getType: () => SchemaType.UNDISCRIMINATED_UNION,
28 | };
29 |
30 | return {
31 | ...maybeSkipValidation(baseSchema),
32 | ...getSchemaUtils(baseSchema),
33 | };
34 | }
35 |
36 | function validateAndTransformUndiscriminatedUnion(
37 | transform: (schema: Schema, opts: SchemaOptions) => MaybeValid,
38 | schemas: Schema[],
39 | opts: SchemaOptions | undefined
40 | ): MaybeValid {
41 | const errors: ValidationError[] = [];
42 | for (const [index, schema] of schemas.entries()) {
43 | const transformed = transform(schema, { ...opts, skipValidation: false });
44 | if (transformed.ok) {
45 | return transformed;
46 | } else {
47 | for (const error of transformed.errors) {
48 | errors.push({
49 | path: error.path,
50 | message: `[Variant ${index}] ${error.message}`,
51 | });
52 | }
53 | }
54 | }
55 |
56 | return {
57 | ok: false,
58 | errors,
59 | };
60 | }
61 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/union/discriminant.ts:
--------------------------------------------------------------------------------
1 | export function discriminant(
2 | parsedDiscriminant: ParsedDiscriminant,
3 | rawDiscriminant: RawDiscriminant
4 | ): Discriminant {
5 | return {
6 | parsedDiscriminant,
7 | rawDiscriminant,
8 | };
9 | }
10 |
11 | export interface Discriminant {
12 | parsedDiscriminant: ParsedDiscriminant;
13 | rawDiscriminant: RawDiscriminant;
14 | }
15 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/union/index.ts:
--------------------------------------------------------------------------------
1 | export { discriminant } from "./discriminant";
2 | export type { Discriminant } from "./discriminant";
3 | export type {
4 | inferParsedDiscriminant,
5 | inferParsedUnion,
6 | inferRawDiscriminant,
7 | inferRawUnion,
8 | UnionSubtypes,
9 | } from "./types";
10 | export { union } from "./union";
11 |
--------------------------------------------------------------------------------
/src/core/schemas/builders/union/types.ts:
--------------------------------------------------------------------------------
1 | import { inferParsedObject, inferRawObject, ObjectSchema } from "../object";
2 | import { Discriminant } from "./discriminant";
3 |
4 | export type UnionSubtypes = {
5 | [K in DiscriminantValues]: ObjectSchema;
6 | };
7 |
8 | export type inferRawUnion, U extends UnionSubtypes> = {
9 | [K in keyof U]: Record, K> & inferRawObject;
10 | }[keyof U];
11 |
12 | export type inferParsedUnion, U extends UnionSubtypes> = {
13 | [K in keyof U]: Record, K> & inferParsedObject;
14 | }[keyof U];
15 |
16 | export type inferRawDiscriminant> = D extends string
17 | ? D
18 | : D extends Discriminant
19 | ? Raw
20 | : never;
21 |
22 | export type inferParsedDiscriminant> = D extends string
23 | ? D
24 | : D extends Discriminant
25 | ? Parsed
26 | : never;
27 |
--------------------------------------------------------------------------------
/src/core/schemas/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./builders";
2 | export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";
3 |
--------------------------------------------------------------------------------
/src/core/schemas/utils/MaybePromise.ts:
--------------------------------------------------------------------------------
1 | export type MaybePromise = T | Promise;
2 |
--------------------------------------------------------------------------------
/src/core/schemas/utils/addQuestionMarksToNullableProperties.ts:
--------------------------------------------------------------------------------
1 | export type addQuestionMarksToNullableProperties = {
2 | [K in OptionalKeys]?: T[K];
3 | } & Pick>;
4 |
5 | export type OptionalKeys = {
6 | [K in keyof T]-?: undefined extends T[K]
7 | ? K
8 | : null extends T[K]
9 | ? K
10 | : 1 extends (any extends T[K] ? 0 : 1)
11 | ? never
12 | : K;
13 | }[keyof T];
14 |
15 | export type RequiredKeys = Exclude>;
16 |
--------------------------------------------------------------------------------
/src/core/schemas/utils/createIdentitySchemaCreator.ts:
--------------------------------------------------------------------------------
1 | import { getSchemaUtils } from "../builders/schema-utils";
2 | import { BaseSchema, MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
3 | import { maybeSkipValidation } from "./maybeSkipValidation";
4 |
5 | export function createIdentitySchemaCreator(
6 | schemaType: SchemaType,
7 | validate: (value: unknown, opts?: SchemaOptions) => MaybeValid
8 | ): () => Schema {
9 | return () => {
10 | const baseSchema: BaseSchema = {
11 | parse: validate,
12 | json: validate,
13 | getType: () => schemaType,
14 | };
15 |
16 | return {
17 | ...maybeSkipValidation(baseSchema),
18 | ...getSchemaUtils(baseSchema),
19 | };
20 | };
21 | }
22 |
--------------------------------------------------------------------------------
/src/core/schemas/utils/entries.ts:
--------------------------------------------------------------------------------
1 | export function entries(object: T): [keyof T, T[keyof T]][] {
2 | return Object.entries(object) as [keyof T, T[keyof T]][];
3 | }
4 |
--------------------------------------------------------------------------------
/src/core/schemas/utils/filterObject.ts:
--------------------------------------------------------------------------------
1 | export function filterObject