Skip to content

Commit ee78cf3

Browse files
Code-HexCode-Hex
authored
Merge pull request #389 from Code-Hex/add/sort-deps
feat: add `validationSchemaExportType` to config w/ resolve deps
2 parents 7a7e9ed + 9f1e2e0 commit ee78cf3

16 files changed

+1258
-438
lines changed

‎codegen.yml

+3
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ generates:
1313
schema: yup
1414
importFrom: ../types
1515
withObjectType: true
16+
validationSchemaExportType: const
1617
directives:
1718
required:
1819
msg: required
@@ -49,6 +50,7 @@ generates:
4950
schema: zod
5051
importFrom: ../types
5152
withObjectType: true
53+
validationSchemaExportType: const
5254
directives:
5355
# Write directives like
5456
#
@@ -72,6 +74,7 @@ generates:
7274
schema: myzod
7375
importFrom: ../types
7476
withObjectType: true
77+
validationSchemaExportType: const
7578
directives:
7679
constraint:
7780
minLength: min

‎example/myzod/schemas.ts

+51-75
Original file line numberDiff line numberDiff line change
@@ -1,110 +1,86 @@
11
import * as myzod from 'myzod'
2-
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User } from '../types'
2+
import { PageType, HttpMethod, HttpInput, EventOptionType, EventArgumentInput, EventInput, ComponentInput, DropDownComponentInput, LayoutInput, ButtonComponentType, AttributeInput, PageInput, Guest, Admin, User } from '../types'
33

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

6-
export function AdminSchema(): myzod.Type<Admin> {
7-
return myzod.object({
8-
__typename: myzod.literal('Admin').optional(),
9-
lastModifiedAt: definedNonNullAnySchema.optional().nullable()
10-
})
11-
}
6+
export const PageTypeSchema = myzod.enum(PageType);
127

13-
export function AttributeInputSchema(): myzod.Type<AttributeInput> {
14-
return myzod.object({
15-
key: myzod.string().optional().nullable(),
16-
val: myzod.string().optional().nullable()
17-
})
18-
}
8+
export const HttpMethodSchema = myzod.enum(HttpMethod);
9+
10+
export const EventOptionTypeSchema = myzod.enum(EventOptionType);
1911

2012
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);
2113

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()),
27-
name: myzod.string(),
28-
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({
14+
export const HttpInputSchema: myzod.Type<HttpInput> = myzod.object({
15+
method: HttpMethodSchema.optional().nullable(),
16+
url: definedNonNullAnySchema
17+
});
18+
19+
export const EventArgumentInputSchema: myzod.Type<EventArgumentInput> = myzod.object({
4120
name: myzod.string().min(5),
4221
value: myzod.string().pattern(/^foo/)
43-
})
44-
}
22+
});
4523

46-
export function EventInputSchema(): myzod.Type<EventInput> {
47-
return myzod.object({
48-
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema())),
24+
export const EventInputSchema: myzod.Type<EventInput> = myzod.object({
25+
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema)),
4926
options: myzod.array(EventOptionTypeSchema).optional().nullable()
50-
})
51-
}
52-
53-
export const EventOptionTypeSchema = myzod.enum(EventOptionType);
27+
});
5428

55-
export function GuestSchema(): myzod.Type<Guest> {
56-
return myzod.object({
57-
__typename: myzod.literal('Guest').optional(),
58-
lastLoggedIn: definedNonNullAnySchema.optional().nullable()
59-
})
60-
}
29+
export const ComponentInputSchema: myzod.Type<ComponentInput> = myzod.object({
30+
child: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
31+
childrens: myzod.array(myzod.lazy(() => ComponentInputSchema.nullable())).optional().nullable(),
32+
event: myzod.lazy(() => EventInputSchema.optional().nullable()),
33+
name: myzod.string(),
34+
type: ButtonComponentTypeSchema
35+
});
6136

62-
export function HttpInputSchema(): myzod.Type<HttpInput> {
63-
return myzod.object({
64-
method: HttpMethodSchema.optional().nullable(),
65-
url: definedNonNullAnySchema
66-
})
67-
}
37+
export const DropDownComponentInputSchema: myzod.Type<DropDownComponentInput> = myzod.object({
38+
dropdownComponent: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
39+
getEvent: myzod.lazy(() => EventInputSchema)
40+
});
6841

69-
export const HttpMethodSchema = myzod.enum(HttpMethod);
42+
export const LayoutInputSchema: myzod.Type<LayoutInput> = myzod.object({
43+
dropdown: myzod.lazy(() => DropDownComponentInputSchema.optional().nullable())
44+
});
7045

71-
export function LayoutInputSchema(): myzod.Type<LayoutInput> {
72-
return myzod.object({
73-
dropdown: myzod.lazy(() => DropDownComponentInputSchema().optional().nullable())
74-
})
75-
}
46+
export const AttributeInputSchema: myzod.Type<AttributeInput> = myzod.object({
47+
key: myzod.string().optional().nullable(),
48+
val: myzod.string().optional().nullable()
49+
});
7650

77-
export function PageInputSchema(): myzod.Type<PageInput> {
78-
return myzod.object({
79-
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema())).optional().nullable(),
51+
export const PageInputSchema: myzod.Type<PageInput> = myzod.object({
52+
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema)).optional().nullable(),
8053
date: definedNonNullAnySchema.optional().nullable(),
8154
height: myzod.number(),
8255
id: myzod.string(),
83-
layout: myzod.lazy(() => LayoutInputSchema()),
56+
layout: myzod.lazy(() => LayoutInputSchema),
8457
pageType: PageTypeSchema,
8558
postIDs: myzod.array(myzod.string()).optional().nullable(),
8659
show: myzod.boolean(),
8760
tags: myzod.array(myzod.string().nullable()).optional().nullable(),
8861
title: myzod.string(),
8962
width: myzod.number()
90-
})
91-
}
63+
});
9264

93-
export const PageTypeSchema = myzod.enum(PageType);
65+
export const GuestSchema: myzod.Type<Guest> = myzod.object({
66+
__typename: myzod.literal('Guest').optional(),
67+
lastLoggedIn: definedNonNullAnySchema.optional().nullable()
68+
});
69+
70+
export const AdminSchema: myzod.Type<Admin> = myzod.object({
71+
__typename: myzod.literal('Admin').optional(),
72+
lastModifiedAt: definedNonNullAnySchema.optional().nullable()
73+
});
9474

95-
export function UserSchema(): myzod.Type<User> {
96-
return myzod.object({
75+
export const UserKindSchema = myzod.union([AdminSchema, GuestSchema]);
76+
77+
export const UserSchema: myzod.Type<User> = myzod.object({
9778
__typename: myzod.literal('User').optional(),
9879
createdAt: definedNonNullAnySchema.optional().nullable(),
9980
email: myzod.string().optional().nullable(),
10081
id: myzod.string().optional().nullable(),
101-
kind: UserKindSchema().optional().nullable(),
82+
kind: UserKindSchema.optional().nullable(),
10283
name: myzod.string().optional().nullable(),
10384
password: myzod.string().optional().nullable(),
10485
updatedAt: definedNonNullAnySchema.optional().nullable()
105-
})
106-
}
107-
108-
export function UserKindSchema() {
109-
return myzod.union([AdminSchema(), GuestSchema()])
110-
}
86+
});

‎example/yup/schemas.ts

+53-77
Original file line numberDiff line numberDiff line change
@@ -1,114 +1,90 @@
11
import * as yup from 'yup'
2-
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User, UserKind } from '../types'
2+
import { PageType, HttpMethod, HttpInput, EventOptionType, EventArgumentInput, EventInput, ComponentInput, DropDownComponentInput, LayoutInput, ButtonComponentType, AttributeInput, PageInput, Guest, Admin, UserKind, User } from '../types'
33

4-
function union<T extends {}>(...schemas: ReadonlyArray<yup.Schema<T>>): yup.MixedSchema<T> {
5-
return yup.mixed<T>().test({
6-
test: (value) => schemas.some((schema) => schema.isValidSync(value))
7-
}).defined()
8-
}
4+
export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();
95

10-
export function AdminSchema(): yup.ObjectSchema<Admin> {
11-
return yup.object({
12-
__typename: yup.string<'Admin'>().optional(),
13-
lastModifiedAt: yup.mixed().nullable().optional()
14-
})
15-
}
6+
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
167

17-
export function AttributeInputSchema(): yup.ObjectSchema<AttributeInput> {
18-
return yup.object({
19-
key: yup.string().defined().nullable().optional(),
20-
val: yup.string().defined().nullable().optional()
21-
})
22-
}
8+
export const EventOptionTypeSchema = yup.string<EventOptionType>().oneOf([EventOptionType.Reload, EventOptionType.Retry]).defined();
239

2410
export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();
2511

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(),
31-
name: yup.string().defined().nonNullable(),
32-
type: ButtonComponentTypeSchema.nonNullable()
33-
})
12+
function union<T extends {}>(...schemas: ReadonlyArray<yup.Schema<T>>): yup.MixedSchema<T> {
13+
return yup.mixed<T>().test({
14+
test: (value) => schemas.some((schema) => schema.isValidSync(value))
15+
}).defined()
3416
}
3517

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-
}
18+
export const HttpInputSchema: yup.ObjectSchema<HttpInput> = yup.object({
19+
method: HttpMethodSchema.nullable().optional(),
20+
url: yup.mixed().nonNullable()
21+
});
4222

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

50-
export function EventInputSchema(): yup.ObjectSchema<EventInput> {
51-
return yup.object({
52-
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema().nonNullable())).defined(),
28+
export const EventInputSchema: yup.ObjectSchema<EventInput> = yup.object({
29+
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema.nonNullable())).defined(),
5330
options: yup.array(EventOptionTypeSchema.nonNullable()).defined().nullable().optional()
54-
})
55-
}
31+
});
5632

57-
export const EventOptionTypeSchema = yup.string<EventOptionType>().oneOf([EventOptionType.Reload, EventOptionType.Retry]).defined();
33+
export const ComponentInputSchema: yup.ObjectSchema<ComponentInput> = yup.object({
34+
child: yup.lazy(() => ComponentInputSchema).optional(),
35+
childrens: yup.array(yup.lazy(() => ComponentInputSchema)).defined().nullable().optional(),
36+
event: yup.lazy(() => EventInputSchema).optional(),
37+
name: yup.string().defined().nonNullable(),
38+
type: ButtonComponentTypeSchema.nonNullable()
39+
});
5840

59-
export function GuestSchema(): yup.ObjectSchema<Guest> {
60-
return yup.object({
61-
__typename: yup.string<'Guest'>().optional(),
62-
lastLoggedIn: yup.mixed().nullable().optional()
63-
})
64-
}
41+
export const DropDownComponentInputSchema: yup.ObjectSchema<DropDownComponentInput> = yup.object({
42+
dropdownComponent: yup.lazy(() => ComponentInputSchema).optional(),
43+
getEvent: yup.lazy(() => EventInputSchema.nonNullable())
44+
});
6545

66-
export function HttpInputSchema(): yup.ObjectSchema<HttpInput> {
67-
return yup.object({
68-
method: HttpMethodSchema.nullable().optional(),
69-
url: yup.mixed().nonNullable()
70-
})
71-
}
72-
73-
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
46+
export const LayoutInputSchema: yup.ObjectSchema<LayoutInput> = yup.object({
47+
dropdown: yup.lazy(() => DropDownComponentInputSchema).optional()
48+
});
7449

75-
export function LayoutInputSchema(): yup.ObjectSchema<LayoutInput> {
76-
return yup.object({
77-
dropdown: yup.lazy(() => DropDownComponentInputSchema()).optional()
78-
})
79-
}
50+
export const AttributeInputSchema: yup.ObjectSchema<AttributeInput> = yup.object({
51+
key: yup.string().defined().nullable().optional(),
52+
val: yup.string().defined().nullable().optional()
53+
});
8054

81-
export function PageInputSchema(): yup.ObjectSchema<PageInput> {
82-
return yup.object({
83-
attributes: yup.array(yup.lazy(() => AttributeInputSchema().nonNullable())).defined().nullable().optional(),
55+
export const PageInputSchema: yup.ObjectSchema<PageInput> = yup.object({
56+
attributes: yup.array(yup.lazy(() => AttributeInputSchema.nonNullable())).defined().nullable().optional(),
8457
date: yup.mixed().nullable().optional(),
8558
height: yup.number().defined().nonNullable(),
8659
id: yup.string().defined().nonNullable(),
87-
layout: yup.lazy(() => LayoutInputSchema().nonNullable()),
60+
layout: yup.lazy(() => LayoutInputSchema.nonNullable()),
8861
pageType: PageTypeSchema.nonNullable(),
8962
postIDs: yup.array(yup.string().defined().nonNullable()).defined().nullable().optional(),
9063
show: yup.boolean().defined().nonNullable(),
9164
tags: yup.array(yup.string().defined().nullable()).defined().nullable().optional(),
9265
title: yup.string().defined().nonNullable(),
9366
width: yup.number().defined().nonNullable()
94-
})
95-
}
67+
});
9668

97-
export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();
69+
export const GuestSchema: yup.ObjectSchema<Guest> = yup.object({
70+
__typename: yup.string<'Guest'>().optional(),
71+
lastLoggedIn: yup.mixed().nullable().optional()
72+
});
73+
74+
export const AdminSchema: yup.ObjectSchema<Admin> = yup.object({
75+
__typename: yup.string<'Admin'>().optional(),
76+
lastModifiedAt: yup.mixed().nullable().optional()
77+
});
78+
79+
export const UserKindSchema: yup.MixedSchema<UserKind> = union<UserKind>(AdminSchema, GuestSchema);
9880

99-
export function UserSchema(): yup.ObjectSchema<User> {
100-
return yup.object({
81+
export const UserSchema: yup.ObjectSchema<User> = yup.object({
10182
__typename: yup.string<'User'>().optional(),
10283
createdAt: yup.mixed().nullable().optional(),
10384
email: yup.string().defined().nullable().optional(),
10485
id: yup.string().defined().nullable().optional(),
105-
kind: UserKindSchema().nullable().optional(),
86+
kind: UserKindSchema.nullable().optional(),
10687
name: yup.string().defined().nullable().optional(),
10788
password: yup.string().defined().nullable().optional(),
10889
updatedAt: yup.mixed().nullable().optional()
109-
})
110-
}
111-
112-
export function UserKindSchema(): yup.MixedSchema<UserKind> {
113-
return union<UserKind>(AdminSchema(), GuestSchema())
114-
}
90+
});

0 commit comments

Comments
 (0)