mythic-insight/calcom
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 5

Second go at removing Zod generated classes from our repo (#1946)

Browse source 
* Second go at removing Zod generated classes from our repo

* Directly reference the _EventTypeModel
This commit is contained in:
Alex van Andel 2022-02-22 23:19:22 +00:00 committed by GitHub
parent ecbdfea818
commit 652c2e342f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
25 changed files with 22 additions and 611 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.gitignore vendored
View file

@ -59,5 +59,9 @@ yarn-error.log*
# Typescript # Typescript
tsconfig.tsbuildinfo tsconfig.tsbuildinfo
# turbo # turbo
.turbo .turbo
# Prisma-Zod
packages/prisma/zod/*.ts

2
apps/web/components/eventtype/CreateEventType.tsx
View file

@ -6,7 +6,7 @@ import React, { useEffect } from "react";
import { useForm } from "react-hook-form"; import { useForm } from "react-hook-form";
import type { z } from "zod"; import type { z } from "zod";
import { createEventTypeInput } from "@calcom/prisma/zod/eventtypeCustom"; import { createEventTypeInput } from "@calcom/prisma/zod/custom/eventtype";
import { HttpError } from "@lib/core/http/error"; import { HttpError } from "@lib/core/http/error";
import { useLocale } from "@lib/hooks/useLocale"; import { useLocale } from "@lib/hooks/useLocale";

2
apps/web/server/routers/viewer/eventTypes.tsx
View file

@ -8,7 +8,7 @@ import {
_EventTypeModel, _EventTypeModel,
} from "@calcom/prisma/zod"; } from "@calcom/prisma/zod";
import { stringOrNumber } from "@calcom/prisma/zod-utils"; import { stringOrNumber } from "@calcom/prisma/zod-utils";
import { createEventTypeInput } from "@calcom/prisma/zod/eventtypeCustom"; import { createEventTypeInput } from "@calcom/prisma/zod/custom/eventtype";
import { createProtectedRouter } from "@server/createRouter"; import { createProtectedRouter } from "@server/createRouter";
import { viewerRouter } from "@server/routers/viewer"; import { viewerRouter } from "@server/routers/viewer";

25
packages/prisma/zod/attendee.ts
View file

@ -1,25 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteBooking, BookingModel } from "./index"
export const _AttendeeModel = z.object({
id: z.number().int(),
email: z.string(),
name: z.string(),
timeZone: z.string(),
locale: z.string().nullish(),
bookingId: z.number().int().nullish(),
})
export interface CompleteAttendee extends z.infer<typeof _AttendeeModel> {
booking?: CompleteBooking | null
}
/**
* AttendeeModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const AttendeeModel: z.ZodSchema<CompleteAttendee> = z.lazy(() => _AttendeeModel.extend({
booking: BookingModel.nullish(),
}))

29
packages/prisma/zod/availability.ts
View file

@ -1,29 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteUser, UserModel, CompleteEventType, EventTypeModel } from "./index"
export const _AvailabilityModel = z.object({
id: z.number().int(),
label: z.string().nullish(),
userId: z.number().int().nullish(),
eventTypeId: z.number().int().nullish(),
days: z.number().int().array(),
startTime: z.date(),
endTime: z.date(),
date: z.date().nullish(),
})
export interface CompleteAvailability extends z.infer<typeof _AvailabilityModel> {
user?: CompleteUser | null
eventType?: CompleteEventType | null
}
/**
* AvailabilityModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const AvailabilityModel: z.ZodSchema<CompleteAvailability> = z.lazy(() => _AvailabilityModel.extend({
user: UserModel.nullish(),
eventType: EventTypeModel.nullish(),
}))

49
packages/prisma/zod/booking.ts
View file

@ -1,49 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { BookingStatus } from "@prisma/client"
import { CompleteUser, UserModel, CompleteBookingReference, BookingReferenceModel, CompleteEventType, EventTypeModel, CompleteAttendee, AttendeeModel, CompleteDailyEventReference, DailyEventReferenceModel, CompletePayment, PaymentModel, CompleteDestinationCalendar, DestinationCalendarModel } from "./index"
export const _BookingModel = z.object({
id: z.number().int(),
uid: z.string(),
userId: z.number().int().nullish(),
eventTypeId: z.number().int().nullish(),
title: z.string(),
description: z.string().nullish(),
startTime: z.date(),
endTime: z.date(),
location: z.string().nullish(),
createdAt: z.date(),
updatedAt: z.date().nullish(),
confirmed: z.boolean(),
rejected: z.boolean(),
status: z.nativeEnum(BookingStatus),
paid: z.boolean(),
cancellationReason: z.string().nullish(),
rejectionReason: z.string().nullish(),
})
export interface CompleteBooking extends z.infer<typeof _BookingModel> {
user?: CompleteUser | null
references: CompleteBookingReference[]
eventType?: CompleteEventType | null
attendees: CompleteAttendee[]
dailyRef?: CompleteDailyEventReference | null
payment: CompletePayment[]
destinationCalendar?: CompleteDestinationCalendar | null
}
/**
* BookingModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const BookingModel: z.ZodSchema<CompleteBooking> = z.lazy(() => _BookingModel.extend({
user: UserModel.nullish(),
references: BookingReferenceModel.array(),
eventType: EventTypeModel.nullish(),
attendees: AttendeeModel.array(),
dailyRef: DailyEventReferenceModel.nullish(),
payment: PaymentModel.array(),
destinationCalendar: DestinationCalendarModel.nullish(),
}))

26
packages/prisma/zod/bookingreference.ts
View file

@ -1,26 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteBooking, BookingModel } from "./index"
export const _BookingReferenceModel = z.object({
id: z.number().int(),
type: z.string(),
uid: z.string(),
meetingId: z.string().nullish(),
meetingPassword: z.string().nullish(),
meetingUrl: z.string().nullish(),
bookingId: z.number().int().nullish(),
})
export interface CompleteBookingReference extends z.infer<typeof _BookingReferenceModel> {
booking?: CompleteBooking | null
}
/**
* BookingReferenceModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const BookingReferenceModel: z.ZodSchema<CompleteBookingReference> = z.lazy(() => _BookingReferenceModel.extend({
booking: BookingModel.nullish(),
}))

29
packages/prisma/zod/credential.ts
View file

@ -1,29 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteUser, UserModel } from "./index"
// Helper schema for JSON fields
type Literal = boolean | number | string
type Json = Literal | { [key: string]: Json } | Json[]
const literalSchema = z.union([z.string(), z.number(), z.boolean()])
const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))
export const _CredentialModel = z.object({
id: z.number().int(),
type: z.string(),
key: jsonSchema,
userId: z.number().int().nullish(),
})
export interface CompleteCredential extends z.infer<typeof _CredentialModel> {
user?: CompleteUser | null
}
/**
* CredentialModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const CredentialModel: z.ZodSchema<CompleteCredential> = z.lazy(() => _CredentialModel.extend({
user: UserModel.nullish(),
}))

15
packages/prisma/zod/custom/eventtype.ts Normal file
View file

@ -0,0 +1,15 @@
import { _EventTypeModel } from "../eventtype";
export const createEventTypeInput = _EventTypeModel
.pick({
title: true,
slug: true,
description: true,
length: true,
teamId: true,
schedulingType: true,
})
.refine((data) => (data.teamId ? data.teamId && data.schedulingType : true), {
path: ["schedulingType"],
message: "You must select a scheduling type for team events",
});

23
packages/prisma/zod/dailyeventreference.ts
View file

@ -1,23 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteBooking, BookingModel } from "./index"
export const _DailyEventReferenceModel = z.object({
id: z.number().int(),
dailyurl: z.string(),
dailytoken: z.string(),
bookingId: z.number().int().nullish(),
})
export interface CompleteDailyEventReference extends z.infer<typeof _DailyEventReferenceModel> {
booking?: CompleteBooking | null
}
/**
* DailyEventReferenceModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const DailyEventReferenceModel: z.ZodSchema<CompleteDailyEventReference> = z.lazy(() => _DailyEventReferenceModel.extend({
booking: BookingModel.nullish(),
}))

29
packages/prisma/zod/destinationcalendar.ts
View file

@ -1,29 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteUser, UserModel, CompleteBooking, BookingModel, CompleteEventType, EventTypeModel } from "./index"
export const _DestinationCalendarModel = z.object({
id: z.number().int(),
integration: z.string(),
externalId: z.string(),
userId: z.number().int().nullish(),
bookingId: z.number().int().nullish(),
eventTypeId: z.number().int().nullish(),
})
export interface CompleteDestinationCalendar extends z.infer<typeof _DestinationCalendarModel> {
user?: CompleteUser | null
booking?: CompleteBooking | null
eventType?: CompleteEventType | null
}
/**
* DestinationCalendarModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const DestinationCalendarModel: z.ZodSchema<CompleteDestinationCalendar> = z.lazy(() => _DestinationCalendarModel.extend({
user: UserModel.nullish(),
booking: BookingModel.nullish(),
eventType: EventTypeModel.nullish(),
}))

63
packages/prisma/zod/eventtype.ts
View file

@ -1,63 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { PeriodType, SchedulingType } from "@prisma/client"
import { CompleteUser, UserModel, CompleteTeam, TeamModel, CompleteBooking, BookingModel, CompleteAvailability, AvailabilityModel, CompleteDestinationCalendar, DestinationCalendarModel, CompleteEventTypeCustomInput, EventTypeCustomInputModel, CompleteSchedule, ScheduleModel } from "./index"
// Helper schema for JSON fields
type Literal = boolean | number | string
type Json = Literal | { [key: string]: Json } | Json[]
const literalSchema = z.union([z.string(), z.number(), z.boolean()])
const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))
export const _EventTypeModel = z.object({
id: z.number().int(),
title: z.string().nonempty(),
slug: imports.eventTypeSlug,
description: z.string().nullish(),
position: z.number().int(),
locations: imports.eventTypeLocations,
length: z.number().int(),
hidden: z.boolean(),
userId: z.number().int().nullish(),
teamId: z.number().int().nullish(),
eventName: z.string().nullish(),
timeZone: z.string().nullish(),
periodType: z.nativeEnum(PeriodType),
periodStartDate: z.date().nullish(),
periodEndDate: z.date().nullish(),
periodDays: z.number().int().nullish(),
periodCountCalendarDays: z.boolean().nullish(),
requiresConfirmation: z.boolean(),
disableGuests: z.boolean(),
minimumBookingNotice: z.number().int(),
schedulingType: z.nativeEnum(SchedulingType).nullish(),
price: z.number().int(),
currency: z.string(),
slotInterval: z.number().int().nullish(),
metadata: jsonSchema,
})
export interface CompleteEventType extends z.infer<typeof _EventTypeModel> {
users: CompleteUser[]
team?: CompleteTeam | null
bookings: CompleteBooking[]
availability: CompleteAvailability[]
destinationCalendar?: CompleteDestinationCalendar | null
customInputs: CompleteEventTypeCustomInput[]
Schedule: CompleteSchedule[]
}
/**
* EventTypeModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const EventTypeModel: z.ZodSchema<CompleteEventType> = z.lazy(() => _EventTypeModel.extend({
users: UserModel.array(),
team: TeamModel.nullish(),
bookings: BookingModel.array(),
availability: AvailabilityModel.array(),
destinationCalendar: DestinationCalendarModel.nullish(),
customInputs: EventTypeCustomInputModel.array(),
Schedule: ScheduleModel.array(),
}))

17
packages/prisma/zod/eventtypeCustom.ts
View file

@ -1,17 +0,0 @@
import { _EventTypeModel } from "./eventtype";
const createEventTypeBaseInput = _EventTypeModel
.pick({
title: true,
slug: true,
description: true,
length: true,
teamId: true,
schedulingType: true,
})
.refine((data) => (data.teamId ? data.teamId && data.schedulingType : true), {
path: ["schedulingType"],
message: "You must select a scheduling type for team events",
});
export const createEventTypeInput = createEventTypeBaseInput;

26
packages/prisma/zod/eventtypecustominput.ts
View file

@ -1,26 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { EventTypeCustomInputType } from "@prisma/client"
import { CompleteEventType, EventTypeModel } from "./index"
export const _EventTypeCustomInputModel = z.object({
id: z.number().int(),
eventTypeId: z.number().int(),
label: z.string(),
type: z.nativeEnum(EventTypeCustomInputType),
required: z.boolean(),
placeholder: z.string(),
})
export interface CompleteEventTypeCustomInput extends z.infer<typeof _EventTypeCustomInputModel> {
eventType: CompleteEventType
}
/**
* EventTypeCustomInputModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const EventTypeCustomInputModel: z.ZodSchema<CompleteEventTypeCustomInput> = z.lazy(() => _EventTypeCustomInputModel.extend({
eventType: EventTypeModel,
}))

19
packages/prisma/zod/index.ts
View file

@ -1,19 +0,0 @@
export * from "./eventtype"
export * from "./credential"
export * from "./destinationcalendar"
export * from "./user"
export * from "./team"
export * from "./membership"
export * from "./verificationrequest"
export * from "./bookingreference"
export * from "./attendee"
export * from "./dailyeventreference"
export * from "./booking"
export * from "./schedule"
export * from "./availability"
export * from "./selectedcalendar"
export * from "./eventtypecustominput"
export * from "./resetpasswordrequest"
export * from "./remindermail"
export * from "./payment"
export * from "./webhook"

26
packages/prisma/zod/membership.ts
View file

@ -1,26 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { MembershipRole } from "@prisma/client"
import { CompleteTeam, TeamModel, CompleteUser, UserModel } from "./index"
export const _MembershipModel = z.object({
teamId: z.number().int(),
userId: z.number().int(),
accepted: z.boolean(),
role: z.nativeEnum(MembershipRole),
})
export interface CompleteMembership extends z.infer<typeof _MembershipModel> {
team: CompleteTeam
user: CompleteUser
}
/**
* MembershipModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const MembershipModel: z.ZodSchema<CompleteMembership> = z.lazy(() => _MembershipModel.extend({
team: TeamModel,
user: UserModel,
}))

37
packages/prisma/zod/payment.ts
View file

@ -1,37 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { PaymentType } from "@prisma/client"
import { CompleteBooking, BookingModel } from "./index"
// Helper schema for JSON fields
type Literal = boolean | number | string
type Json = Literal | { [key: string]: Json } | Json[]
const literalSchema = z.union([z.string(), z.number(), z.boolean()])
const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))
export const _PaymentModel = z.object({
id: z.number().int(),
uid: z.string(),
type: z.nativeEnum(PaymentType),
bookingId: z.number().int(),
amount: z.number().int(),
fee: z.number().int(),
currency: z.string(),
success: z.boolean(),
refunded: z.boolean(),
data: jsonSchema,
externalId: z.string(),
})
export interface CompletePayment extends z.infer<typeof _PaymentModel> {
booking?: CompleteBooking | null
}
/**
* PaymentModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const PaymentModel: z.ZodSchema<CompletePayment> = z.lazy(() => _PaymentModel.extend({
booking: BookingModel.nullish(),
}))

11
packages/prisma/zod/remindermail.ts
View file

@ -1,11 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { ReminderType } from "@prisma/client"
export const _ReminderMailModel = z.object({
id: z.number().int(),
referenceId: z.number().int(),
reminderType: z.nativeEnum(ReminderType),
elapsedMinutes: z.number().int(),
createdAt: z.date(),
})

10
packages/prisma/zod/resetpasswordrequest.ts
View file

@ -1,10 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
export const _ResetPasswordRequestModel = z.object({
id: z.string(),
createdAt: z.date(),
updatedAt: z.date(),
email: z.string(),
expires: z.date(),
})

32
packages/prisma/zod/schedule.ts
View file

@ -1,32 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteUser, UserModel, CompleteEventType, EventTypeModel } from "./index"
// Helper schema for JSON fields
type Literal = boolean | number | string
type Json = Literal | { [key: string]: Json } | Json[]
const literalSchema = z.union([z.string(), z.number(), z.boolean()])
const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))
export const _ScheduleModel = z.object({
id: z.number().int(),
userId: z.number().int().nullish(),
eventTypeId: z.number().int().nullish(),
title: z.string().nullish(),
freeBusyTimes: jsonSchema,
})
export interface CompleteSchedule extends z.infer<typeof _ScheduleModel> {
user?: CompleteUser | null
eventType?: CompleteEventType | null
}
/**
* ScheduleModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const ScheduleModel: z.ZodSchema<CompleteSchedule> = z.lazy(() => _ScheduleModel.extend({
user: UserModel.nullish(),
eventType: EventTypeModel.nullish(),
}))

22
packages/prisma/zod/selectedcalendar.ts
View file

@ -1,22 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteUser, UserModel } from "./index"
export const _SelectedCalendarModel = z.object({
userId: z.number().int(),
integration: z.string(),
externalId: z.string(),
})
export interface CompleteSelectedCalendar extends z.infer<typeof _SelectedCalendarModel> {
user: CompleteUser
}
/**
* SelectedCalendarModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const SelectedCalendarModel: z.ZodSchema<CompleteSelectedCalendar> = z.lazy(() => _SelectedCalendarModel.extend({
user: UserModel,
}))

27
packages/prisma/zod/team.ts
View file

@ -1,27 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { CompleteMembership, MembershipModel, CompleteEventType, EventTypeModel } from "./index"
export const _TeamModel = z.object({
id: z.number().int(),
name: z.string().nullish(),
slug: z.string().nullish(),
logo: z.string().nullish(),
bio: z.string().nullish(),
hideBranding: z.boolean(),
})
export interface CompleteTeam extends z.infer<typeof _TeamModel> {
members: CompleteMembership[]
eventTypes: CompleteEventType[]
}
/**
* TeamModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const TeamModel: z.ZodSchema<CompleteTeam> = z.lazy(() => _TeamModel.extend({
members: MembershipModel.array(),
eventTypes: EventTypeModel.array(),
}))

70
packages/prisma/zod/user.ts
View file

@ -1,70 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { IdentityProvider, UserPlan } from "@prisma/client"
import { CompleteEventType, EventTypeModel, CompleteCredential, CredentialModel, CompleteMembership, MembershipModel, CompleteBooking, BookingModel, CompleteAvailability, AvailabilityModel, CompleteSelectedCalendar, SelectedCalendarModel, CompleteSchedule, ScheduleModel, CompleteWebhook, WebhookModel, CompleteDestinationCalendar, DestinationCalendarModel } from "./index"
// Helper schema for JSON fields
type Literal = boolean | number | string
type Json = Literal | { [key: string]: Json } | Json[]
const literalSchema = z.union([z.string(), z.number(), z.boolean()])
const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))
export const _UserModel = z.object({
id: z.number().int(),
username: z.string().nullish(),
name: z.string().nullish(),
email: z.string().email(),
emailVerified: z.date().nullish(),
password: z.string().nullish(),
bio: z.string().nullish(),
avatar: z.string().nullish(),
timeZone: z.string(),
weekStart: z.string(),
startTime: z.number().int(),
endTime: z.number().int(),
bufferTime: z.number().int(),
hideBranding: z.boolean(),
theme: z.string().nullish(),
createdDate: z.date(),
completedOnboarding: z.boolean(),
locale: z.string().nullish(),
twoFactorSecret: z.string().nullish(),
twoFactorEnabled: z.boolean(),
identityProvider: z.nativeEnum(IdentityProvider),
identityProviderId: z.string().nullish(),
invitedTo: z.number().int().nullish(),
plan: z.nativeEnum(UserPlan),
brandColor: z.string(),
away: z.boolean(),
metadata: jsonSchema,
verified: z.boolean().nullish(),
})
export interface CompleteUser extends z.infer<typeof _UserModel> {
eventTypes: CompleteEventType[]
credentials: CompleteCredential[]
teams: CompleteMembership[]
bookings: CompleteBooking[]
availability: CompleteAvailability[]
selectedCalendars: CompleteSelectedCalendar[]
Schedule: CompleteSchedule[]
webhooks: CompleteWebhook[]
destinationCalendar?: CompleteDestinationCalendar | null
}
/**
* UserModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const UserModel: z.ZodSchema<CompleteUser> = z.lazy(() => _UserModel.extend({
eventTypes: EventTypeModel.array(),
credentials: CredentialModel.array(),
teams: MembershipModel.array(),
bookings: BookingModel.array(),
availability: AvailabilityModel.array(),
selectedCalendars: SelectedCalendarModel.array(),
Schedule: ScheduleModel.array(),
webhooks: WebhookModel.array(),
destinationCalendar: DestinationCalendarModel.nullish(),
}))

11
packages/prisma/zod/verificationrequest.ts
View file

@ -1,11 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
export const _VerificationRequestModel = z.object({
id: z.number().int(),
identifier: z.string(),
token: z.string(),
expires: z.date(),
createdAt: z.date(),
updatedAt: z.date(),
})

27
packages/prisma/zod/webhook.ts
View file

@ -1,27 +0,0 @@
import * as z from "zod"
import * as imports from "../zod-utils"
import { WebhookTriggerEvents } from "@prisma/client"
import { CompleteUser, UserModel } from "./index"
export const _WebhookModel = z.object({
id: z.string(),
userId: z.number().int(),
subscriberUrl: z.string(),
payloadTemplate: z.string().nullish(),
createdAt: z.date(),
active: z.boolean(),
eventTriggers: z.nativeEnum(WebhookTriggerEvents).array(),
})
export interface CompleteWebhook extends z.infer<typeof _WebhookModel> {
user: CompleteUser
}
/**
* WebhookModel contains all relations on your model in addition to the scalars
*
* NOTE: Lazy required in case of potential circular dependencies within schema
*/
export const WebhookModel: z.ZodSchema<CompleteWebhook> = z.lazy(() => _WebhookModel.extend({
user: UserModel,
}))