Skip to content

feat: add validationSchemaExportType to config #382

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

Closed
wants to merge 6 commits into from
Closed

feat: add validationSchemaExportType to config #382

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
0c5768c
feat: add `validationSchemaExportType` to config
elijaholmos Jun 2, 2023
bb516a2
feat(myzod): support `validationSchemaExportType`
elijaholmos Jun 2, 2023
2dde904
feat(yup): support `validationSchemaExportType`
elijaholmos Jun 2, 2023
7f078b0
feat(zod): support `validationSchemaExportType`
elijaholmos Jun 2, 2023
3ed4ebb
feat: support unions exporting
elijaholmos Jun 2, 2023
e0a9efd
fix: union declarations, regen schema
elijaholmos Jun 6, 2023
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
110 changes: 43 additions & 67 deletions example/myzod/schemas.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,108 +3,84 @@ import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownCom

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

export function AdminSchema(): myzod.Type<Admin> {
return myzod.object({
export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);

export const EventOptionTypeSchema = myzod.enum(EventOptionType);

export const HttpMethodSchema = myzod.enum(HttpMethod);

export const PageTypeSchema = myzod.enum(PageType);

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

export function AttributeInputSchema(): myzod.Type<AttributeInput> {
return myzod.object({
export const AttributeInputSchema: myzod.Type<AttributeInput> = myzod.object({
key: myzod.string().optional().nullable(),
val: myzod.string().optional().nullable()
})
}

export const ButtonComponentTypeSchema = myzod.enum(ButtonComponentType);
});

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()),
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()),
name: myzod.string(),
type: ButtonComponentTypeSchema
})
}

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({
});

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

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

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

export const EventOptionTypeSchema = myzod.enum(EventOptionType);
});

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

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

export const HttpMethodSchema = myzod.enum(HttpMethod);

export function LayoutInputSchema(): myzod.Type<LayoutInput> {
return myzod.object({
dropdown: myzod.lazy(() => DropDownComponentInputSchema().optional().nullable())
})
}
export const LayoutInputSchema: myzod.Type<LayoutInput> = 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(),
export const PageInputSchema: myzod.Type<PageInput> = 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 PageTypeSchema = myzod.enum(PageType);
});

export function UserSchema(): myzod.Type<User> {
return myzod.object({
export const UserSchema: myzod.Type<User> = 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()])
}
export const UserKindSchema = myzod.union([AdminSchema, GuestSchema]);
106 changes: 41 additions & 65 deletions example/yup/schemas.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,114 +1,90 @@
import * as yup from 'yup'
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User, UserKind } from '../types'

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 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 function AdminSchema(): yup.ObjectSchema<Admin> {
return yup.object({
export const AdminSchema: yup.ObjectSchema<Admin> = yup.object({
__typename: yup.string<'Admin'>().optional(),
lastModifiedAt: yup.mixed().nullable().optional()
})
}
});

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

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

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(),
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 function DropDownComponentInputSchema(): yup.ObjectSchema<DropDownComponentInput> {
return yup.object({
dropdownComponent: yup.lazy(() => ComponentInputSchema()).optional(),
getEvent: yup.lazy(() => EventInputSchema().nonNullable())
})
}
export const DropDownComponentInputSchema: yup.ObjectSchema<DropDownComponentInput> = yup.object({
dropdownComponent: yup.lazy(() => ComponentInputSchema).optional(),
getEvent: yup.lazy(() => EventInputSchema.nonNullable())
});

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

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

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

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

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

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

export function LayoutInputSchema(): yup.ObjectSchema<LayoutInput> {
return yup.object({
dropdown: yup.lazy(() => DropDownComponentInputSchema()).optional()
})
}
export const LayoutInputSchema: yup.ObjectSchema<LayoutInput> = yup.object({
dropdown: yup.lazy(() => DropDownComponentInputSchema).optional()
});

export function PageInputSchema(): yup.ObjectSchema<PageInput> {
return yup.object({
attributes: yup.array(yup.lazy(() => AttributeInputSchema().nonNullable())).defined().nullable().optional(),
export const PageInputSchema: yup.ObjectSchema<PageInput> = 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 PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();

export function UserSchema(): yup.ObjectSchema<User> {
return yup.object({
export const UserSchema: yup.ObjectSchema<User> = 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())
}
export const UserKindSchema: yup.MixedSchema<UserKind> = union<UserKind>(AdminSchema, GuestSchema);
Loading