Skip to content

Commit e0a9efd

Browse files
elijaholmoselijaholmos
committed
fix: union declarations, regen schema
1 parent 3ed4ebb commit e0a9efd

File tree

6 files changed

+135
-210
lines changed

6 files changed

+135
-210
lines changed

‎example/myzod/schemas.ts

Lines changed: 43 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -3,108 +3,84 @@ import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownCom
33

44
export const definedNonNullAnySchema = myzod.object({});
55

6-
export function AdminSchema(): myzod.Type<Admin> {
7-
return myzod.object({
6+
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);
7+
8+
export const EventOptionTypeSchema = myzod.enum(EventOptionType);
9+
10+
export const HttpMethodSchema = myzod.enum(HttpMethod);
11+
12+
export const PageTypeSchema = myzod.enum(PageType);
13+
14+
export const AdminSchema: myzod.Type<Admin> = myzod.object({
815
__typename: myzod.literal('Admin').optional(),
916
lastModifiedAt: definedNonNullAnySchema.optional().nullable()
10-
})
11-
}
17+
});
1218

13-
export function AttributeInputSchema(): myzod.Type<AttributeInput> {
14-
return myzod.object({
19+
export const AttributeInputSchema: myzod.Type<AttributeInput> = myzod.object({
1520
key: myzod.string().optional().nullable(),
1621
val: myzod.string().optional().nullable()
17-
})
18-
}
19-
20-
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);
22+
});
2123

22-
export function ComponentInputSchema(): myzod.Type<ComponentInput> {
23-
return myzod.object({
24-
child: myzod.lazy(() => ComponentInputSchema().optional().nullable()),
25-
childrens: myzod.array(myzod.lazy(() => ComponentInputSchema().nullable())).optional().nullable(),
26-
event: myzod.lazy(() => EventInputSchema().optional().nullable()),
24+
export const ComponentInputSchema: myzod.Type<ComponentInput> = myzod.object({
25+
child: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
26+
childrens: myzod.array(myzod.lazy(() => ComponentInputSchema.nullable())).optional().nullable(),
27+
event: myzod.lazy(() => EventInputSchema.optional().nullable()),
2728
name: myzod.string(),
2829
type: ButtonComponentTypeSchema
29-
})
30-
}
31-
32-
export function DropDownComponentInputSchema(): myzod.Type<DropDownComponentInput> {
33-
return myzod.object({
34-
dropdownComponent: myzod.lazy(() => ComponentInputSchema().optional().nullable()),
35-
getEvent: myzod.lazy(() => EventInputSchema())
36-
})
37-
}
38-
39-
export function EventArgumentInputSchema(): myzod.Type<EventArgumentInput> {
40-
return myzod.object({
30+
});
31+
32+
export const DropDownComponentInputSchema: myzod.Type<DropDownComponentInput> = myzod.object({
33+
dropdownComponent: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
34+
getEvent: myzod.lazy(() => EventInputSchema)
35+
});
36+
37+
export const EventArgumentInputSchema: myzod.Type<EventArgumentInput> = myzod.object({
4138
name: myzod.string().min(5),
4239
value: myzod.string().pattern(/^foo/)
43-
})
44-
}
40+
});
4541

46-
export function EventInputSchema(): myzod.Type<EventInput> {
47-
return myzod.object({
48-
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema())),
42+
export const EventInputSchema: myzod.Type<EventInput> = myzod.object({
43+
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema)),
4944
options: myzod.array(EventOptionTypeSchema).optional().nullable()
50-
})
51-
}
52-
53-
export const EventOptionTypeSchema = myzod.enum(EventOptionType);
45+
});
5446

55-
export function GuestSchema(): myzod.Type<Guest> {
56-
return myzod.object({
47+
export const GuestSchema: myzod.Type<Guest> = myzod.object({
5748
__typename: myzod.literal('Guest').optional(),
5849
lastLoggedIn: definedNonNullAnySchema.optional().nullable()
59-
})
60-
}
50+
});
6151

62-
export function HttpInputSchema(): myzod.Type<HttpInput> {
63-
return myzod.object({
52+
export const HttpInputSchema: myzod.Type<HttpInput> = myzod.object({
6453
method: HttpMethodSchema.optional().nullable(),
6554
url: definedNonNullAnySchema
66-
})
67-
}
55+
});
6856

69-
export const HttpMethodSchema = myzod.enum(HttpMethod);
70-
71-
export function LayoutInputSchema(): myzod.Type<LayoutInput> {
72-
return myzod.object({
73-
dropdown: myzod.lazy(() => DropDownComponentInputSchema().optional().nullable())
74-
})
75-
}
57+
export const LayoutInputSchema: myzod.Type<LayoutInput> = myzod.object({
58+
dropdown: myzod.lazy(() => DropDownComponentInputSchema.optional().nullable())
59+
});
7660

77-
export function PageInputSchema(): myzod.Type<PageInput> {
78-
return myzod.object({
79-
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema())).optional().nullable(),
61+
export const PageInputSchema: myzod.Type<PageInput> = myzod.object({
62+
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema)).optional().nullable(),
8063
date: definedNonNullAnySchema.optional().nullable(),
8164
height: myzod.number(),
8265
id: myzod.string(),
83-
layout: myzod.lazy(() => LayoutInputSchema()),
66+
layout: myzod.lazy(() => LayoutInputSchema),
8467
pageType: PageTypeSchema,
8568
postIDs: myzod.array(myzod.string()).optional().nullable(),
8669
show: myzod.boolean(),
8770
tags: myzod.array(myzod.string().nullable()).optional().nullable(),
8871
title: myzod.string(),
8972
width: myzod.number()
90-
})
91-
}
92-
93-
export const PageTypeSchema = myzod.enum(PageType);
73+
});
9474

95-
export function UserSchema(): myzod.Type<User> {
96-
return myzod.object({
75+
export const UserSchema: myzod.Type<User> = myzod.object({
9776
__typename: myzod.literal('User').optional(),
9877
createdAt: definedNonNullAnySchema.optional().nullable(),
9978
email: myzod.string().optional().nullable(),
10079
id: myzod.string().optional().nullable(),
101-
kind: UserKindSchema().optional().nullable(),
80+
kind: UserKindSchema.optional().nullable(),
10281
name: myzod.string().optional().nullable(),
10382
password: myzod.string().optional().nullable(),
10483
updatedAt: definedNonNullAnySchema.optional().nullable()
105-
})
106-
}
84+
});
10785

108-
export function UserKindSchema() {
109-
return myzod.union([AdminSchema(), GuestSchema()])
110-
}
86+
export const UserKindSchema = myzod.union([AdminSchema, GuestSchema]);

‎example/yup/schemas.ts

Lines changed: 41 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -1,114 +1,90 @@
11
import * as yup from 'yup'
22
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User, UserKind } from '../types'
33

4+
export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();
5+
6+
export const EventOptionTypeSchema = yup.string<EventOptionType>().oneOf([EventOptionType.Reload, EventOptionType.Retry]).defined();
7+
8+
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
9+
10+
export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();
11+
412
function union<T extends {}>(...schemas: ReadonlyArray<yup.Schema<T>>): yup.MixedSchema<T> {
513
return yup.mixed<T>().test({
614
test: (value) => schemas.some((schema) => schema.isValidSync(value))
715
}).defined()
816
}
917

10-
export function AdminSchema(): yup.ObjectSchema<Admin> {
11-
return yup.object({
18+
export const AdminSchema: yup.ObjectSchema<Admin> = yup.object({
1219
__typename: yup.string<'Admin'>().optional(),
1320
lastModifiedAt: yup.mixed().nullable().optional()
14-
})
15-
}
21+
});
1622

17-
export function AttributeInputSchema(): yup.ObjectSchema<AttributeInput> {
18-
return yup.object({
23+
export const AttributeInputSchema: yup.ObjectSchema<AttributeInput> = yup.object({
1924
key: yup.string().defined().nullable().optional(),
2025
val: yup.string().defined().nullable().optional()
21-
})
22-
}
26+
});
2327

24-
export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();
25-
26-
export function ComponentInputSchema(): yup.ObjectSchema<ComponentInput> {
27-
return yup.object({
28-
child: yup.lazy(() => ComponentInputSchema()).optional(),
29-
childrens: yup.array(yup.lazy(() => ComponentInputSchema())).defined().nullable().optional(),
30-
event: yup.lazy(() => EventInputSchema()).optional(),
28+
export const ComponentInputSchema: yup.ObjectSchema<ComponentInput> = yup.object({
29+
child: yup.lazy(() => ComponentInputSchema).optional(),
30+
childrens: yup.array(yup.lazy(() => ComponentInputSchema)).defined().nullable().optional(),
31+
event: yup.lazy(() => EventInputSchema).optional(),
3132
name: yup.string().defined().nonNullable(),
3233
type: ButtonComponentTypeSchema.nonNullable()
33-
})
34-
}
34+
});
3535

36-
export function DropDownComponentInputSchema(): yup.ObjectSchema<DropDownComponentInput> {
37-
return yup.object({
38-
dropdownComponent: yup.lazy(() => ComponentInputSchema()).optional(),
39-
getEvent: yup.lazy(() => EventInputSchema().nonNullable())
40-
})
41-
}
36+
export const DropDownComponentInputSchema: yup.ObjectSchema<DropDownComponentInput> = yup.object({
37+
dropdownComponent: yup.lazy(() => ComponentInputSchema).optional(),
38+
getEvent: yup.lazy(() => EventInputSchema.nonNullable())
39+
});
4240

43-
export function EventArgumentInputSchema(): yup.ObjectSchema<EventArgumentInput> {
44-
return yup.object({
41+
export const EventArgumentInputSchema: yup.ObjectSchema<EventArgumentInput> = yup.object({
4542
name: yup.string().defined().nonNullable().min(5),
4643
value: yup.string().defined().nonNullable().matches(/^foo/)
47-
})
48-
}
44+
});
4945

50-
export function EventInputSchema(): yup.ObjectSchema<EventInput> {
51-
return yup.object({
52-
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema().nonNullable())).defined(),
46+
export const EventInputSchema: yup.ObjectSchema<EventInput> = yup.object({
47+
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema.nonNullable())).defined(),
5348
options: yup.array(EventOptionTypeSchema.nonNullable()).defined().nullable().optional()
54-
})
55-
}
56-
57-
export const EventOptionTypeSchema = yup.string<EventOptionType>().oneOf([EventOptionType.Reload, EventOptionType.Retry]).defined();
49+
});
5850

59-
export function GuestSchema(): yup.ObjectSchema<Guest> {
60-
return yup.object({
51+
export const GuestSchema: yup.ObjectSchema<Guest> = yup.object({
6152
__typename: yup.string<'Guest'>().optional(),
6253
lastLoggedIn: yup.mixed().nullable().optional()
63-
})
64-
}
54+
});
6555

66-
export function HttpInputSchema(): yup.ObjectSchema<HttpInput> {
67-
return yup.object({
56+
export const HttpInputSchema: yup.ObjectSchema<HttpInput> = yup.object({
6857
method: HttpMethodSchema.nullable().optional(),
6958
url: yup.mixed().nonNullable()
70-
})
71-
}
72-
73-
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
59+
});
7460

75-
export function LayoutInputSchema(): yup.ObjectSchema<LayoutInput> {
76-
return yup.object({
77-
dropdown: yup.lazy(() => DropDownComponentInputSchema()).optional()
78-
})
79-
}
61+
export const LayoutInputSchema: yup.ObjectSchema<LayoutInput> = yup.object({
62+
dropdown: yup.lazy(() => DropDownComponentInputSchema).optional()
63+
});
8064

81-
export function PageInputSchema(): yup.ObjectSchema<PageInput> {
82-
return yup.object({
83-
attributes: yup.array(yup.lazy(() => AttributeInputSchema().nonNullable())).defined().nullable().optional(),
65+
export const PageInputSchema: yup.ObjectSchema<PageInput> = yup.object({
66+
attributes: yup.array(yup.lazy(() => AttributeInputSchema.nonNullable())).defined().nullable().optional(),
8467
date: yup.mixed().nullable().optional(),
8568
height: yup.number().defined().nonNullable(),
8669
id: yup.string().defined().nonNullable(),
87-
layout: yup.lazy(() => LayoutInputSchema().nonNullable()),
70+
layout: yup.lazy(() => LayoutInputSchema.nonNullable()),
8871
pageType: PageTypeSchema.nonNullable(),
8972
postIDs: yup.array(yup.string().defined().nonNullable()).defined().nullable().optional(),
9073
show: yup.boolean().defined().nonNullable(),
9174
tags: yup.array(yup.string().defined().nullable()).defined().nullable().optional(),
9275
title: yup.string().defined().nonNullable(),
9376
width: yup.number().defined().nonNullable()
94-
})
95-
}
77+
});
9678

97-
export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();
98-
99-
export function UserSchema(): yup.ObjectSchema<User> {
100-
return yup.object({
79+
export const UserSchema: yup.ObjectSchema<User> = yup.object({
10180
__typename: yup.string<'User'>().optional(),
10281
createdAt: yup.mixed().nullable().optional(),
10382
email: yup.string().defined().nullable().optional(),
10483
id: yup.string().defined().nullable().optional(),
105-
kind: UserKindSchema().nullable().optional(),
84+
kind: UserKindSchema.nullable().optional(),
10685
name: yup.string().defined().nullable().optional(),
10786
password: yup.string().defined().nullable().optional(),
10887
updatedAt: yup.mixed().nullable().optional()
109-
})
110-
}
88+
});
11189

112-
export function UserKindSchema(): yup.MixedSchema<UserKind> {
113-
return union<UserKind>(AdminSchema(), GuestSchema())
114-
}
90+
export const UserKindSchema: yup.MixedSchema<UserKind> = union<UserKind>(AdminSchema, GuestSchema);

0 commit comments

Comments
 (0)