generated union type in examples

Author: Code-Hex

example/myzod/schemas.ts

@@ -1,8 +1,15 @@
 import * as myzod from 'myzod'
-import { AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, 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 function AdminSchema(): myzod.Type<Admin> {
+  return myzod.object({
+    __typename: myzod.literal('Admin').optional(),
+    lastModifiedAt: definedNonNullAnySchema.optional().nullable()
+  })
+}
+
 export function AttributeInputSchema(): myzod.Type<AttributeInput> {
   return myzod.object({
     key: myzod.string().optional().nullable(),
@@ -45,6 +52,13 @@ export function EventInputSchema(): myzod.Type<EventInput> {
 
 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 function HttpInputSchema(): myzod.Type<HttpInput> {
   return myzod.object({
     method: HttpMethodSchema.optional().nullable(),
@@ -84,8 +98,11 @@ export function UserSchema(): myzod.Type<User> {
     createdAt: definedNonNullAnySchema.optional().nullable(),
     email: myzod.string().optional().nullable(),
     id: myzod.string().optional().nullable(),
+    kind: UserKindSchema.optional().nullable(),
     name: myzod.string().optional().nullable(),
     password: myzod.string().optional().nullable(),
     updatedAt: definedNonNullAnySchema.optional().nullable()
   })
 }
+
+export const UserKindSchema = myzod.union([AdminSchema(), GuestSchema()]);

example/test.graphql

@@ -5,11 +5,22 @@ enum PageType {
   BASIC_AUTH
 }
 
+type Admin {
+  lastModifiedAt: Date
+}
+
+type Guest {
+  lastLoggedIn: Date
+}
+
+union UserKind = Admin | Guest
+
 type User {
   id: ID
   name: String
   email: String
   password: String
+  kind: UserKind
   createdAt: Date
   updatedAt: Date
 }

example/types.ts

@@ -14,6 +14,11 @@ export type Scalars = {
   URL: any;
 };
 
+export type Admin = {
+  __typename?: 'Admin';
+  lastModifiedAt?: Maybe<Scalars['Date']>;
+};
+
 export type AttributeInput = {
   key?: InputMaybe<Scalars['String']>;
   val?: InputMaybe<Scalars['String']>;
@@ -52,6 +57,11 @@ export enum EventOptionType {
   Retry = 'RETRY'
 }
 
+export type Guest = {
+  __typename?: 'Guest';
+  lastLoggedIn?: Maybe<Scalars['Date']>;
+};
+
 export type HttpInput = {
   method?: InputMaybe<HttpMethod>;
   url: Scalars['URL'];
@@ -92,7 +102,10 @@ export type User = {
   createdAt?: Maybe<Scalars['Date']>;
   email?: Maybe<Scalars['String']>;
   id?: Maybe<Scalars['ID']>;
+  kind?: Maybe<UserKind>;
   name?: Maybe<Scalars['String']>;
   password?: Maybe<Scalars['String']>;
   updatedAt?: Maybe<Scalars['Date']>;
 };
+
+export type UserKind = Admin | Guest;

example/yup/schemas.ts

@@ -1,5 +1,18 @@
 import * as yup from 'yup'
-import { AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User } from '../types'
+import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User, UserKind } from '../types'
+
+function union<T>(...schemas: ReadonlyArray<yup.SchemaOf<T>>): yup.BaseSchema<T> {
+  return yup.mixed().test({
+    test: (value) => schemas.some((schema) => schema.isValidSync(value))
+  })
+}
+
+export function AdminSchema(): yup.SchemaOf<Admin> {
+  return yup.object({
+    __typename: yup.mixed().oneOf(['Admin', undefined]),
+    lastModifiedAt: yup.mixed()
+  })
+}
 
 export function AttributeInputSchema(): yup.SchemaOf<AttributeInput> {
   return yup.object({
@@ -43,6 +56,13 @@ export function EventInputSchema(): yup.SchemaOf<EventInput> {
 
 export const EventOptionTypeSchema = yup.mixed().oneOf([EventOptionType.Reload, EventOptionType.Retry]);
 
+export function GuestSchema(): yup.SchemaOf<Guest> {
+  return yup.object({
+    __typename: yup.mixed().oneOf(['Guest', undefined]),
+    lastLoggedIn: yup.mixed()
+  })
+}
+
 export function HttpInputSchema(): yup.SchemaOf<HttpInput> {
   return yup.object({
     method: HttpMethodSchema,
@@ -82,8 +102,11 @@ export function UserSchema(): yup.SchemaOf<User> {
     createdAt: yup.mixed(),
     email: yup.string(),
     id: yup.string(),
+    kind: UserKindSchema,
     name: yup.string(),
     password: yup.string(),
     updatedAt: yup.mixed()
   })
 }
+
+export const UserKindSchema: yup.BaseSchema<UserKind> = union<UserKind>(AdminSchema(), GuestSchema());

example/zod/schemas.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User } from '../types'
+import { Admin, AttributeInput, ButtonComponentType, ComponentInput, DropDownComponentInput, EventArgumentInput, EventInput, EventOptionType, Guest, HttpInput, HttpMethod, LayoutInput, PageInput, PageType, User } from '../types'
 
 type Properties<T> = Required<{
   [K in keyof T]: z.ZodType<T[K], any, T[K]>;
@@ -11,6 +11,13 @@ export const isDefinedNonNullAny = (v: any): v is definedNonNullAny => v !== und
 
 export const definedNonNullAnySchema = z.any().refine((v) => isDefinedNonNullAny(v));
 
+export function AdminSchema(): z.ZodObject<Properties<Admin>> {
+  return z.object<Properties<Admin>>({
+    __typename: z.literal('Admin').optional(),
+    lastModifiedAt: definedNonNullAnySchema.nullish()
+  })
+}
+
 export function AttributeInputSchema(): z.ZodObject<Properties<AttributeInput>> {
   return z.object<Properties<AttributeInput>>({
     key: z.string().nullish(),
@@ -53,6 +60,13 @@ export function EventInputSchema(): z.ZodObject<Properties<EventInput>> {
 
 export const EventOptionTypeSchema = z.nativeEnum(EventOptionType);
 
+export function GuestSchema(): z.ZodObject<Properties<Guest>> {
+  return z.object<Properties<Guest>>({
+    __typename: z.literal('Guest').optional(),
+    lastLoggedIn: definedNonNullAnySchema.nullish()
+  })
+}
+
 export function HttpInputSchema(): z.ZodObject<Properties<HttpInput>> {
   return z.object<Properties<HttpInput>>({
     method: HttpMethodSchema.nullish(),
@@ -92,8 +106,11 @@ export function UserSchema(): z.ZodObject<Properties<User>> {
     createdAt: definedNonNullAnySchema.nullish(),
     email: z.string().nullish(),
     id: z.string().nullish(),
+    kind: UserKindSchema.nullish(),
     name: z.string().nullish(),
     password: z.string().nullish(),
     updatedAt: definedNonNullAnySchema.nullish()
   })
 }
+
+export const UserKindSchema = z.union([AdminSchema(), GuestSchema()]);