Skip to content

Commit 453d8e5

Browse files
Code-HexCode-Hex
authored
Merge pull request #392 from Code-Hex/fix/documents
fixed documents for validationSchemaExportType
2 parents 3fd4ed6 + ea3d975 commit 453d8e5

File tree

6 files changed

+254
-179
lines changed

6 files changed

+254
-179
lines changed

‎README.md

+6
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,12 @@ It is currently added for the purpose of using simple objects. See also [#20](ht
188188

189189
This option currently **does not support fragment** generation. If you are interested, send me PR would be greatly appreciated!
190190

191+
### `validationSchemaExportType`
192+
193+
type: `ValidationSchemaExportType` default: `'function'`
194+
195+
Specify validation schema export type.
196+
191197
### `directives`
192198

193199
type: `DirectiveConfig`

‎codegen.yml

-3
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,6 @@ generates:
1313
schema: yup
1414
importFrom: ../types
1515
withObjectType: true
16-
validationSchemaExportType: const
1716
directives:
1817
required:
1918
msg: required
@@ -50,7 +49,6 @@ generates:
5049
schema: zod
5150
importFrom: ../types
5251
withObjectType: true
53-
validationSchemaExportType: const
5452
directives:
5553
# Write directives like
5654
#
@@ -74,7 +72,6 @@ generates:
7472
schema: myzod
7573
importFrom: ../types
7674
withObjectType: true
77-
validationSchemaExportType: const
7875
directives:
7976
constraint:
8077
minLength: min

‎example/myzod/schemas.ts

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

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

6-
export const PageTypeSchema = myzod.enum(PageType);
7-
8-
export const HttpMethodSchema = myzod.enum(HttpMethod);
6+
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);
97

108
export const EventOptionTypeSchema = myzod.enum(EventOptionType);
119

12-
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);
13-
14-
export const HttpInputSchema: myzod.Type<HttpInput> = myzod.object({
15-
method: HttpMethodSchema.optional().nullable(),
16-
url: definedNonNullAnySchema
17-
});
10+
export const HttpMethodSchema = myzod.enum(HttpMethod);
1811

19-
export const EventArgumentInputSchema: myzod.Type<EventArgumentInput> = myzod.object({
20-
name: myzod.string().min(5),
21-
value: myzod.string().pattern(/^foo/)
22-
});
12+
export const PageTypeSchema = myzod.enum(PageType);
2313

24-
export const EventInputSchema: myzod.Type<EventInput> = myzod.object({
25-
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema)),
26-
options: myzod.array(EventOptionTypeSchema).optional().nullable()
27-
});
14+
export function AdminSchema(): myzod.Type<Admin> {
15+
return myzod.object({
16+
__typename: myzod.literal('Admin').optional(),
17+
lastModifiedAt: definedNonNullAnySchema.optional().nullable()
18+
})
19+
}
2820

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()),
21+
export function AttributeInputSchema(): myzod.Type<AttributeInput> {
22+
return myzod.object({
23+
key: myzod.string().optional().nullable(),
24+
val: myzod.string().optional().nullable()
25+
})
26+
}
27+
28+
export function ComponentInputSchema(): myzod.Type<ComponentInput> {
29+
return 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()),
3333
name: myzod.string(),
3434
type: ButtonComponentTypeSchema
35-
});
36-
37-
export const DropDownComponentInputSchema: myzod.Type<DropDownComponentInput> = myzod.object({
38-
dropdownComponent: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
39-
getEvent: myzod.lazy(() => EventInputSchema)
40-
});
35+
})
36+
}
37+
38+
export function DropDownComponentInputSchema(): myzod.Type<DropDownComponentInput> {
39+
return myzod.object({
40+
dropdownComponent: myzod.lazy(() => ComponentInputSchema().optional().nullable()),
41+
getEvent: myzod.lazy(() => EventInputSchema())
42+
})
43+
}
44+
45+
export function EventArgumentInputSchema(): myzod.Type<EventArgumentInput> {
46+
return myzod.object({
47+
name: myzod.string().min(5),
48+
value: myzod.string().pattern(/^foo/)
49+
})
50+
}
4151

42-
export const LayoutInputSchema: myzod.Type<LayoutInput> = myzod.object({
43-
dropdown: myzod.lazy(() => DropDownComponentInputSchema.optional().nullable())
44-
});
52+
export function EventInputSchema(): myzod.Type<EventInput> {
53+
return myzod.object({
54+
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema())),
55+
options: myzod.array(EventOptionTypeSchema).optional().nullable()
56+
})
57+
}
4558

46-
export const AttributeInputSchema: myzod.Type<AttributeInput> = myzod.object({
47-
key: myzod.string().optional().nullable(),
48-
val: myzod.string().optional().nullable()
49-
});
59+
export function GuestSchema(): myzod.Type<Guest> {
60+
return myzod.object({
61+
__typename: myzod.literal('Guest').optional(),
62+
lastLoggedIn: definedNonNullAnySchema.optional().nullable()
63+
})
64+
}
5065

51-
export const PageInputSchema: myzod.Type<PageInput> = myzod.object({
52-
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema)).optional().nullable(),
66+
export function HttpInputSchema(): myzod.Type<HttpInput> {
67+
return myzod.object({
68+
method: HttpMethodSchema.optional().nullable(),
69+
url: definedNonNullAnySchema
70+
})
71+
}
72+
73+
export function LayoutInputSchema(): myzod.Type<LayoutInput> {
74+
return myzod.object({
75+
dropdown: myzod.lazy(() => DropDownComponentInputSchema().optional().nullable())
76+
})
77+
}
78+
79+
export function PageInputSchema(): myzod.Type<PageInput> {
80+
return myzod.object({
81+
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema())).optional().nullable(),
5382
date: definedNonNullAnySchema.optional().nullable(),
5483
height: myzod.number(),
5584
id: myzod.string(),
56-
layout: myzod.lazy(() => LayoutInputSchema),
85+
layout: myzod.lazy(() => LayoutInputSchema()),
5786
pageType: PageTypeSchema,
5887
postIDs: myzod.array(myzod.string()).optional().nullable(),
5988
show: myzod.boolean(),
6089
tags: myzod.array(myzod.string().nullable()).optional().nullable(),
6190
title: myzod.string(),
6291
width: myzod.number()
63-
});
92+
})
93+
}
6494

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-
});
74-
75-
export const UserKindSchema = myzod.union([AdminSchema, GuestSchema]);
76-
77-
export const UserSchema: myzod.Type<User> = myzod.object({
95+
export function UserSchema(): myzod.Type<User> {
96+
return myzod.object({
7897
__typename: myzod.literal('User').optional(),
7998
createdAt: definedNonNullAnySchema.optional().nullable(),
8099
email: myzod.string().optional().nullable(),
81100
id: myzod.string().optional().nullable(),
82-
kind: UserKindSchema.optional().nullable(),
101+
kind: UserKindSchema().optional().nullable(),
83102
name: myzod.string().optional().nullable(),
84103
password: myzod.string().optional().nullable(),
85104
updatedAt: definedNonNullAnySchema.optional().nullable()
86-
});
105+
})
106+
}
107+
108+
export function UserKindSchema() {
109+
return myzod.union([AdminSchema(), GuestSchema()])
110+
}

‎example/yup/schemas.ts

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

4-
export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();
5-
6-
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
4+
export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();
75

86
export const EventOptionTypeSchema = yup.string<EventOptionType>().oneOf([EventOptionType.Reload, EventOptionType.Retry]).defined();
97

10-
export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();
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();
1111

1212
function union<T extends {}>(...schemas: ReadonlyArray<yup.Schema<T>>): yup.MixedSchema<T> {
1313
return yup.mixed<T>().test({
1414
test: (value) => schemas.some((schema) => schema.isValidSync(value))
1515
}).defined()
1616
}
1717

18-
export const HttpInputSchema: yup.ObjectSchema<HttpInput> = yup.object({
19-
method: HttpMethodSchema.nullable().optional(),
20-
url: yup.mixed().nonNullable()
21-
});
18+
export function AdminSchema(): yup.ObjectSchema<Admin> {
19+
return yup.object({
20+
__typename: yup.string<'Admin'>().optional(),
21+
lastModifiedAt: yup.mixed().nullable().optional()
22+
})
23+
}
24+
25+
export function AttributeInputSchema(): yup.ObjectSchema<AttributeInput> {
26+
return yup.object({
27+
key: yup.string().defined().nullable().optional(),
28+
val: yup.string().defined().nullable().optional()
29+
})
30+
}
31+
32+
export function ComponentInputSchema(): yup.ObjectSchema<ComponentInput> {
33+
return 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+
})
40+
}
2241

23-
export const EventArgumentInputSchema: yup.ObjectSchema<EventArgumentInput> = yup.object({
42+
export function DropDownComponentInputSchema(): yup.ObjectSchema<DropDownComponentInput> {
43+
return yup.object({
44+
dropdownComponent: yup.lazy(() => ComponentInputSchema()).optional(),
45+
getEvent: yup.lazy(() => EventInputSchema().nonNullable())
46+
})
47+
}
48+
49+
export function EventArgumentInputSchema(): yup.ObjectSchema<EventArgumentInput> {
50+
return yup.object({
2451
name: yup.string().defined().nonNullable().min(5),
2552
value: yup.string().defined().nonNullable().matches(/^foo/)
26-
});
53+
})
54+
}
2755

28-
export const EventInputSchema: yup.ObjectSchema<EventInput> = yup.object({
29-
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema.nonNullable())).defined(),
56+
export function EventInputSchema(): yup.ObjectSchema<EventInput> {
57+
return yup.object({
58+
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema().nonNullable())).defined(),
3059
options: yup.array(EventOptionTypeSchema.nonNullable()).defined().nullable().optional()
31-
});
32-
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-
});
60+
})
61+
}
4062

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

46-
export const LayoutInputSchema: yup.ObjectSchema<LayoutInput> = yup.object({
47-
dropdown: yup.lazy(() => DropDownComponentInputSchema).optional()
48-
});
70+
export function HttpInputSchema(): yup.ObjectSchema<HttpInput> {
71+
return yup.object({
72+
method: HttpMethodSchema.nullable().optional(),
73+
url: yup.mixed().nonNullable()
74+
})
75+
}
4976

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

55-
export const PageInputSchema: yup.ObjectSchema<PageInput> = yup.object({
56-
attributes: yup.array(yup.lazy(() => AttributeInputSchema.nonNullable())).defined().nullable().optional(),
83+
export function PageInputSchema(): yup.ObjectSchema<PageInput> {
84+
return yup.object({
85+
attributes: yup.array(yup.lazy(() => AttributeInputSchema().nonNullable())).defined().nullable().optional(),
5786
date: yup.mixed().nullable().optional(),
5887
height: yup.number().defined().nonNullable(),
5988
id: yup.string().defined().nonNullable(),
60-
layout: yup.lazy(() => LayoutInputSchema.nonNullable()),
89+
layout: yup.lazy(() => LayoutInputSchema().nonNullable()),
6190
pageType: PageTypeSchema.nonNullable(),
6291
postIDs: yup.array(yup.string().defined().nonNullable()).defined().nullable().optional(),
6392
show: yup.boolean().defined().nonNullable(),
6493
tags: yup.array(yup.string().defined().nullable()).defined().nullable().optional(),
6594
title: yup.string().defined().nonNullable(),
6695
width: yup.number().defined().nonNullable()
67-
});
68-
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);
96+
})
97+
}
8098

81-
export const UserSchema: yup.ObjectSchema<User> = yup.object({
99+
export function UserSchema(): yup.ObjectSchema<User> {
100+
return yup.object({
82101
__typename: yup.string<'User'>().optional(),
83102
createdAt: yup.mixed().nullable().optional(),
84103
email: yup.string().defined().nullable().optional(),
85104
id: yup.string().defined().nullable().optional(),
86-
kind: UserKindSchema.nullable().optional(),
105+
kind: UserKindSchema().nullable().optional(),
87106
name: yup.string().defined().nullable().optional(),
88107
password: yup.string().defined().nullable().optional(),
89108
updatedAt: yup.mixed().nullable().optional()
90-
});
109+
})
110+
}
111+
112+
export function UserKindSchema(): yup.MixedSchema<UserKind> {
113+
return union<UserKind>(AdminSchema(), GuestSchema())
114+
}

0 commit comments

Comments
 (0)