Skip to content

feat: add validationSchemaExportType to config w/ resolve deps #389

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 10 commits into from
Jun 8, 2023
Merged

feat: add validationSchemaExportType to config w/ resolve deps #389

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 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
ae6e5e9
added logic to sort GraphQL schemas based on dependencies
Code-Hex Jun 8, 2023
74b5ec5
added comment
Code-Hex Jun 8, 2023
088ac95
regen schema
Code-Hex Jun 8, 2023
9f1e2e0
filtered schema definition
Code-Hex Jun 8, 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
3 changes: 3 additions & 0 deletions codegen.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,7 @@ generates:
schema: yup
importFrom: ../types
withObjectType: true
validationSchemaExportType: const
directives:
required:
msg: required
Expand Down Expand Up @@ -49,6 +50,7 @@ generates:
schema: zod
importFrom: ../types
withObjectType: true
validationSchemaExportType: const
directives:
# Write directives like
#
Expand All @@ -72,6 +74,7 @@ generates:
schema: myzod
importFrom: ../types
withObjectType: true
validationSchemaExportType: const
directives:
constraint:
minLength: min
Expand Down
126 changes: 51 additions & 75 deletions example/myzod/schemas.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,110 +1,86 @@
import * as myzod from 'myzod'
import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User } from '../types'
import { PageType, HttpMethod, HttpInput, EventOptionType, EventArgumentInput, EventInput, ComponentInput, DropDownComponentInput, LayoutInput, ButtonComponentType, AttributeInput, PageInput, Guest, Admin, User } from '../types'

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

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

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

export const EventOptionTypeSchema = myzod.enum(EventOptionType);

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()),
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 HttpInputSchema: myzod.Type<HttpInput> = myzod.object({
method: HttpMethodSchema.optional().nullable(),
url: definedNonNullAnySchema
});

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({
__typename: myzod.literal('Guest').optional(),
lastLoggedIn: 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()),
name: myzod.string(),
type: ButtonComponentTypeSchema
});

export function HttpInputSchema(): myzod.Type<HttpInput> {
return myzod.object({
method: HttpMethodSchema.optional().nullable(),
url: definedNonNullAnySchema
})
}
export const DropDownComponentInputSchema: myzod.Type<DropDownComponentInput> = myzod.object({
dropdownComponent: myzod.lazy(() => ComponentInputSchema.optional().nullable()),
getEvent: myzod.lazy(() => EventInputSchema)
});

export const HttpMethodSchema = myzod.enum(HttpMethod);
export const LayoutInputSchema: myzod.Type<LayoutInput> = myzod.object({
dropdown: myzod.lazy(() => DropDownComponentInputSchema.optional().nullable())
});

export function LayoutInputSchema(): myzod.Type<LayoutInput> {
return myzod.object({
dropdown: myzod.lazy(() => DropDownComponentInputSchema().optional().nullable())
})
}
export const AttributeInputSchema: myzod.Type<AttributeInput> = myzod.object({
key: myzod.string().optional().nullable(),
val: myzod.string().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 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 function UserSchema(): myzod.Type<User> {
return myzod.object({
export const UserKindSchema = myzod.union([AdminSchema, GuestSchema]);

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()])
}
});
130 changes: 53 additions & 77 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'
import { PageType, HttpMethod, HttpInput, EventOptionType, EventArgumentInput, EventInput, ComponentInput, DropDownComponentInput, LayoutInput, ButtonComponentType, AttributeInput, PageInput, Guest, Admin, UserKind, User } from '../types'

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 PageTypeSchema = yup.string<PageType>().oneOf([PageType.BasicAuth, PageType.Lp, PageType.Restricted, PageType.Service]).defined();

export function AdminSchema(): yup.ObjectSchema<Admin> {
return yup.object({
__typename: yup.string<'Admin'>().optional(),
lastModifiedAt: yup.mixed().nullable().optional()
})
}
export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();

export function AttributeInputSchema(): yup.ObjectSchema<AttributeInput> {
return yup.object({
key: yup.string().defined().nullable().optional(),
val: yup.string().defined().nullable().optional()
})
}
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 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()
})
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 DropDownComponentInputSchema(): yup.ObjectSchema<DropDownComponentInput> {
return yup.object({
dropdownComponent: yup.lazy(() => ComponentInputSchema()).optional(),
getEvent: yup.lazy(() => EventInputSchema().nonNullable())
})
}
export const HttpInputSchema: yup.ObjectSchema<HttpInput> = yup.object({
method: HttpMethodSchema.nullable().optional(),
url: yup.mixed().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 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 GuestSchema(): yup.ObjectSchema<Guest> {
return yup.object({
__typename: yup.string<'Guest'>().optional(),
lastLoggedIn: yup.mixed().nullable().optional()
})
}
export const DropDownComponentInputSchema: yup.ObjectSchema<DropDownComponentInput> = yup.object({
dropdownComponent: yup.lazy(() => ComponentInputSchema).optional(),
getEvent: yup.lazy(() => EventInputSchema.nonNullable())
});

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

export const HttpMethodSchema = yup.string<HttpMethod>().oneOf([HttpMethod.Get, HttpMethod.Post]).defined();
export const LayoutInputSchema: yup.ObjectSchema<LayoutInput> = yup.object({
dropdown: yup.lazy(() => DropDownComponentInputSchema).optional()
});

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