Skip to content

fixed documents for validationSchemaExportType #392

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 9, 2023
Merged

fixed documents for validationSchemaExportType #392

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -188,6 +188,12 @@ It is currently added for the purpose of using simple objects. See also [#20](ht

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

### `validationSchemaExportType`

type: `ValidationSchemaExportType` default: `'function'`

Specify validation schema export type.

### `directives`

type: `DirectiveConfig`
Expand Down
3 changes: 0 additions & 3 deletions codegen.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,6 @@ generates:
schema: yup
importFrom: ../types
withObjectType: true
validationSchemaExportType: const
directives:
required:
msg: required
Expand Down Expand Up @@ -50,7 +49,6 @@ generates:
schema: zod
importFrom: ../types
withObjectType: true
validationSchemaExportType: const
directives:
# Write directives like
#
Expand All @@ -74,7 +72,6 @@ generates:
schema: myzod
importFrom: ../types
withObjectType: true
validationSchemaExportType: const
directives:
constraint:
minLength: min
Expand Down
132 changes: 78 additions & 54 deletions example/myzod/schemas.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,86 +1,110 @@
import * as myzod from 'myzod'
import { PageType, HttpMethod, HttpInput, EventOptionType, EventArgumentInput, EventInput, ComponentInput, DropDownComponentInput, LayoutInput, ButtonComponentType, AttributeInput, PageInput, Guest, Admin, User } from '../types'
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User } from '../types'

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

export const PageTypeSchema = myzod.enum(PageType);

export const HttpMethodSchema = myzod.enum(HttpMethod);
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);

export const EventOptionTypeSchema = myzod.enum(EventOptionType);

export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);

export const HttpInputSchema: myzod.Type<HttpInput> = myzod.object({
method: HttpMethodSchema.optional().nullable(),
url: definedNonNullAnySchema
});
export const HttpMethodSchema = myzod.enum(HttpMethod);

export const EventArgumentInputSchema: myzod.Type<EventArgumentInput> = myzod.object({
name: myzod.string().min(5),
value: myzod.string().pattern(/^foo/)
});
export const PageTypeSchema = myzod.enum(PageType);

export const EventInputSchema: myzod.Type<EventInput> = myzod.object({
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema)),
options: myzod.array(EventOptionTypeSchema).optional().nullable()
});
export function AdminSchema(): myzod.Type<Admin> {
return myzod.object({
__typename: myzod.literal('Admin').optional(),
lastModifiedAt: definedNonNullAnySchema.optional().nullable()
})
}

export const ComponentInputSchema: myzod.Type<ComponentInput> = myzod.object({
child: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
childrens: myzod.array(myzod.lazy(() => ComponentInputSchema.nullable())).optional().nullable(),
event: myzod.lazy(() => EventInputSchema.optional().nullable()),
export function AttributeInputSchema(): myzod.Type<AttributeInput> {
return myzod.object({
key: myzod.string().optional().nullable(),
val: myzod.string().optional().nullable()
})
}

export function ComponentInputSchema(): myzod.Type<ComponentInput> {
return myzod.object({
child: myzod.lazy(() => ComponentInputSchema().optional().nullable()),
childrens: myzod.array(myzod.lazy(() => ComponentInputSchema().nullable())).optional().nullable(),
event: myzod.lazy(() => EventInputSchema().optional().nullable()),
name: myzod.string(),
type: ButtonComponentTypeSchema
});

export const DropDownComponentInputSchema: myzod.Type<DropDownComponentInput> = myzod.object({
dropdownComponent: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
getEvent: myzod.lazy(() => EventInputSchema)
});
})
}

export function DropDownComponentInputSchema(): myzod.Type<DropDownComponentInput> {
return myzod.object({
dropdownComponent: myzod.lazy(() => ComponentInputSchema().optional().nullable()),
getEvent: myzod.lazy(() => EventInputSchema())
})
}

export function EventArgumentInputSchema(): myzod.Type<EventArgumentInput> {
return myzod.object({
name: myzod.string().min(5),
value: myzod.string().pattern(/^foo/)
})
}

export const LayoutInputSchema: myzod.Type<LayoutInput> = myzod.object({
dropdown: myzod.lazy(() => DropDownComponentInputSchema.optional().nullable())
});
export function EventInputSchema(): myzod.Type<EventInput> {
return myzod.object({
arguments: myzod.array(myzod.lazy(() => EventArgumentInputSchema())),
options: myzod.array(EventOptionTypeSchema).optional().nullable()
})
}

export const AttributeInputSchema: myzod.Type<AttributeInput> = myzod.object({
key: myzod.string().optional().nullable(),
val: myzod.string().optional().nullable()
});
export function GuestSchema(): myzod.Type<Guest> {
return myzod.object({
__typename: myzod.literal('Guest').optional(),
lastLoggedIn: definedNonNullAnySchema.optional().nullable()
})
}

export const PageInputSchema: myzod.Type<PageInput> = myzod.object({
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema)).optional().nullable(),
export function HttpInputSchema(): myzod.Type<HttpInput> {
return myzod.object({
method: HttpMethodSchema.optional().nullable(),
url: definedNonNullAnySchema
})
}

export function LayoutInputSchema(): myzod.Type<LayoutInput> {
return myzod.object({
dropdown: myzod.lazy(() => DropDownComponentInputSchema().optional().nullable())
})
}

export function PageInputSchema(): myzod.Type<PageInput> {
return myzod.object({
attributes: myzod.array(myzod.lazy(() => AttributeInputSchema())).optional().nullable(),
date: definedNonNullAnySchema.optional().nullable(),
height: myzod.number(),
id: myzod.string(),
layout: myzod.lazy(() => LayoutInputSchema),
layout: myzod.lazy(() => LayoutInputSchema()),
pageType: PageTypeSchema,
postIDs: myzod.array(myzod.string()).optional().nullable(),
show: myzod.boolean(),
tags: myzod.array(myzod.string().nullable()).optional().nullable(),
title: myzod.string(),
width: myzod.number()
});
})
}

export const GuestSchema: myzod.Type<Guest> = myzod.object({
__typename: myzod.literal('Guest').optional(),
lastLoggedIn: definedNonNullAnySchema.optional().nullable()
});

export const AdminSchema: myzod.Type<Admin> = myzod.object({
__typename: myzod.literal('Admin').optional(),
lastModifiedAt: definedNonNullAnySchema.optional().nullable()
});

export const UserKindSchema = myzod.union([AdminSchema, GuestSchema]);

export const UserSchema: myzod.Type<User> = myzod.object({
export function UserSchema(): myzod.Type<User> {
return myzod.object({
__typename: myzod.literal('User').optional(),
createdAt: definedNonNullAnySchema.optional().nullable(),
email: myzod.string().optional().nullable(),
id: myzod.string().optional().nullable(),
kind: UserKindSchema.optional().nullable(),
kind: UserKindSchema().optional().nullable(),
name: myzod.string().optional().nullable(),
password: myzod.string().optional().nullable(),
updatedAt: definedNonNullAnySchema.optional().nullable()
});
})
}

export function UserKindSchema() {
return myzod.union([AdminSchema(), GuestSchema()])
}
128 changes: 76 additions & 52 deletions example/yup/schemas.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,90 +1,114 @@
import * as yup from 'yup'
import { PageType, HttpMethod, HttpInput, EventOptionType, EventArgumentInput, EventInput, ComponentInput, DropDownComponentInput, LayoutInput, ButtonComponentType, AttributeInput, PageInput, Guest, Admin, UserKind, User } from '../types'
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User, UserKind } from '../types'

export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();

export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();

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

export const ButtonComponentTypeSchema = yup.string<ButtonComponentType>().oneOf([ButtonComponentType.Button, ButtonComponentType.Submit]).defined();
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();

export const PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();

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

export const HttpInputSchema: yup.ObjectSchema<HttpInput> = yup.object({
method: HttpMethodSchema.nullable().optional(),
url: yup.mixed().nonNullable()
});
export function AdminSchema(): yup.ObjectSchema<Admin> {
return yup.object({
__typename: yup.string<'Admin'>().optional(),
lastModifiedAt: yup.mixed().nullable().optional()
})
}

export function AttributeInputSchema(): yup.ObjectSchema<AttributeInput> {
return yup.object({
key: yup.string().defined().nullable().optional(),
val: yup.string().defined().nullable().optional()
})
}

export function ComponentInputSchema(): yup.ObjectSchema<ComponentInput> {
return yup.object({
child: yup.lazy(() => ComponentInputSchema()).optional(),
childrens: yup.array(yup.lazy(() => ComponentInputSchema())).defined().nullable().optional(),
event: yup.lazy(() => EventInputSchema()).optional(),
name: yup.string().defined().nonNullable(),
type: ButtonComponentTypeSchema.nonNullable()
})
}

export const EventArgumentInputSchema: yup.ObjectSchema<EventArgumentInput> = yup.object({
export function DropDownComponentInputSchema(): yup.ObjectSchema<DropDownComponentInput> {
return yup.object({
dropdownComponent: yup.lazy(() => ComponentInputSchema()).optional(),
getEvent: yup.lazy(() => EventInputSchema().nonNullable())
})
}

export function EventArgumentInputSchema(): yup.ObjectSchema<EventArgumentInput> {
return yup.object({
name: yup.string().defined().nonNullable().min(5),
value: yup.string().defined().nonNullable().matches(/^foo/)
});
})
}

export const EventInputSchema: yup.ObjectSchema<EventInput> = yup.object({
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema.nonNullable())).defined(),
export function EventInputSchema(): yup.ObjectSchema<EventInput> {
return yup.object({
arguments: yup.array(yup.lazy(() => EventArgumentInputSchema().nonNullable())).defined(),
options: yup.array(EventOptionTypeSchema.nonNullable()).defined().nullable().optional()
});

export const ComponentInputSchema: yup.ObjectSchema<ComponentInput> = yup.object({
child: yup.lazy(() => ComponentInputSchema).optional(),
childrens: yup.array(yup.lazy(() => ComponentInputSchema)).defined().nullable().optional(),
event: yup.lazy(() => EventInputSchema).optional(),
name: yup.string().defined().nonNullable(),
type: ButtonComponentTypeSchema.nonNullable()
});
})
}

export const DropDownComponentInputSchema: yup.ObjectSchema<DropDownComponentInput> = yup.object({
dropdownComponent: yup.lazy(() => ComponentInputSchema).optional(),
getEvent: yup.lazy(() => EventInputSchema.nonNullable())
});
export function GuestSchema(): yup.ObjectSchema<Guest> {
return yup.object({
__typename: yup.string<'Guest'>().optional(),
lastLoggedIn: yup.mixed().nullable().optional()
})
}

export const LayoutInputSchema: yup.ObjectSchema<LayoutInput> = yup.object({
dropdown: yup.lazy(() => DropDownComponentInputSchema).optional()
});
export function HttpInputSchema(): yup.ObjectSchema<HttpInput> {
return yup.object({
method: HttpMethodSchema.nullable().optional(),
url: yup.mixed().nonNullable()
})
}

export const AttributeInputSchema: yup.ObjectSchema<AttributeInput> = yup.object({
key: yup.string().defined().nullable().optional(),
val: yup.string().defined().nullable().optional()
});
export function LayoutInputSchema(): yup.ObjectSchema<LayoutInput> {
return yup.object({
dropdown: yup.lazy(() => DropDownComponentInputSchema()).optional()
})
}

export const PageInputSchema: yup.ObjectSchema<PageInput> = yup.object({
attributes: yup.array(yup.lazy(() => AttributeInputSchema.nonNullable())).defined().nullable().optional(),
export function PageInputSchema(): yup.ObjectSchema<PageInput> {
return yup.object({
attributes: yup.array(yup.lazy(() => AttributeInputSchema().nonNullable())).defined().nullable().optional(),
date: yup.mixed().nullable().optional(),
height: yup.number().defined().nonNullable(),
id: yup.string().defined().nonNullable(),
layout: yup.lazy(() => LayoutInputSchema.nonNullable()),
layout: yup.lazy(() => LayoutInputSchema().nonNullable()),
pageType: PageTypeSchema.nonNullable(),
postIDs: yup.array(yup.string().defined().nonNullable()).defined().nullable().optional(),
show: yup.boolean().defined().nonNullable(),
tags: yup.array(yup.string().defined().nullable()).defined().nullable().optional(),
title: yup.string().defined().nonNullable(),
width: yup.number().defined().nonNullable()
});

export const GuestSchema: yup.ObjectSchema<Guest> = yup.object({
__typename: yup.string<'Guest'>().optional(),
lastLoggedIn: yup.mixed().nullable().optional()
});

export const AdminSchema: yup.ObjectSchema<Admin> = yup.object({
__typename: yup.string<'Admin'>().optional(),
lastModifiedAt: yup.mixed().nullable().optional()
});

export const UserKindSchema: yup.MixedSchema<UserKind> = union<UserKind>(AdminSchema, GuestSchema);
})
}

export const UserSchema: yup.ObjectSchema<User> = yup.object({
export function UserSchema(): yup.ObjectSchema<User> {
return yup.object({
__typename: yup.string<'User'>().optional(),
createdAt: yup.mixed().nullable().optional(),
email: yup.string().defined().nullable().optional(),
id: yup.string().defined().nullable().optional(),
kind: UserKindSchema.nullable().optional(),
kind: UserKindSchema().nullable().optional(),
name: yup.string().defined().nullable().optional(),
password: yup.string().defined().nullable().optional(),
updatedAt: yup.mixed().nullable().optional()
});
})
}

export function UserKindSchema(): yup.MixedSchema<UserKind> {
return union<UserKind>(AdminSchema(), GuestSchema())
}
Loading