From df0c6cf7c0c75155831877b1e63731c92a00b75a Mon Sep 17 00:00:00 2001
From: timsuchanek <tim.suchanek@gmail.com>
Date: Mon, 28 Dec 2020 15:27:20 +0100
Subject: [PATCH] chore: cleanup

---
 src/packages/client/fixtures/blog/main.ts | 310 +---------------------
 1 file changed, 1 insertion(+), 309 deletions(-)

diff --git a/src/packages/client/fixtures/blog/main.ts b/src/packages/client/fixtures/blog/main.ts
index f28b7512d6ea..c0125d3d5b72 100644
--- a/src/packages/client/fixtures/blog/main.ts
+++ b/src/packages/client/fixtures/blog/main.ts
@@ -1,4 +1,4 @@
-import { Prisma, PrismaClient } from './@prisma/client'
+import { PrismaClient } from './@prisma/client'
 
 const prisma = new PrismaClient({
   log: [
@@ -19,15 +19,8 @@ async function main() {
     avg: {
       age: true,
     },
-    take: 0,
-
-    // count: {
-    //   _all: true,
-    // },
   })
 
-  // res.count._all
-
   console.log(res)
 
   prisma.$disconnect()
@@ -36,304 +29,3 @@ async function main() {
 main().catch((e) => {
   console.error(e)
 })
-
-export type Key = string | number | symbol
-
-type MergeProp<OK, O1K, K extends Key, OOK extends Key> = K extends OOK
-  ? Exclude<OK, undefined> | O1K
-  : [OK] extends [never]
-  ? O1K
-  : OK extends undefined
-  ? O1K
-  : OK
-
-export type AtBasic<O extends object, K extends Key> = K extends keyof O
-  ? O[K]
-  : never
-
-export type _OptionalKeys<O extends object> = {
-  [K in keyof O]-?: {} extends Pick<O, K> ? K : never
-}[keyof O]
-
-type Merge<
-  O extends object,
-  O1 extends object,
-  OOK extends Key = _OptionalKeys<O>
-> = {
-  [K in keyof (O & O1)]: MergeProp<AtBasic<O, K>, AtBasic<O1, K>, K, OOK>
-}
-
-export type Spread<L extends object, R extends object> = Id<
-  // Merge the properties of L and R into a partial (preserving order).
-  Partial<{ [P in keyof (L & R)]: SpreadProp<L, R, P> }> &
-    // Restore any required L-exclusive properties.
-    Pick<L, Exclude<keyof L, keyof R>> &
-    // Restore any required R properties.
-    Pick<R, RequiredProps<R>>
->
-
-/** Merge a property from `R` to `L` like the spread operator. */
-type SpreadProp<
-  L extends object,
-  R extends object,
-  P extends keyof (L & R)
-> = P extends keyof R
-  ? undefined extends R[P]
-    ? L[Extract<P, keyof L>] | R[P]
-    : R[P]
-  : L[Extract<P, keyof L>]
-
-/** Property names that are always defined */
-type RequiredProps<T extends object> = {
-  [P in keyof T]-?: undefined extends T[P] ? never : P
-}[keyof T]
-
-type Id<T> = { [P in keyof T]: T[P] }
-
-type ReqOrderBy = { orderBy: Prisma.GroupByUserArgs['orderBy'] }
-
-export type Tail<T extends any[]> = T['length'] extends 0
-  ? never
-  : T extends [any, ...infer Tail]
-  ? Tail
-  : T
-
-type GetFieldsFromOrderBy<
-  T extends Prisma.Enumerable<Prisma.UserOrderByInput> | undefined
-> = T extends Record<string, 'asc' | 'desc'>
-  ? keyof T
-  : T extends [infer U]
-  ? keyof U
-  : T extends [infer U, infer K]
-  ? keyof U | keyof K
-  : T extends [infer U, infer K, infer D]
-  ? keyof U | keyof K | keyof D
-  : T extends [infer U, infer K, infer D, infer N]
-  ? keyof U | keyof K | keyof D | keyof N
-  : T extends [infer U, infer K, infer D, infer N, infer B]
-  ? keyof U | keyof K | keyof D | keyof N | keyof B
-  : T extends [infer U, infer K, infer D, infer N, infer B, infer Y]
-  ? keyof U | keyof K | keyof D | keyof N | keyof B | keyof Y
-  : T extends [infer U, infer K, infer D, infer N, infer B, infer Y, infer Z]
-  ? keyof U | keyof K | keyof D | keyof N | keyof B | keyof Y | keyof Z
-  : never
-
-type Yess = GetFieldsFromOrderBy<
-  [{ age: 'desc' }, { email: 'asc' }, { propertyId: 'asc' }]
->
-
-/**
- * Subset
- * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
- */
-export type Subset<T, U, K> = {
-  [key in keyof T]: key extends keyof U ? T[key] : never
-} &
-  K
-
-/**
- * Convert tuple to union
- */
-type _TupleToUnion<T> = T extends (infer E)[] ? E : never
-type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
-type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
-
-/**
- * Like `Pick`, but with an array
- */
-type PickArray<T, K extends Array<keyof T>> = Pick<T, TupleToUnion<K>>
-
-type GetUserGroupByPayload<T extends Prisma.GroupByUserArgs> = PickArray<
-  Prisma.UserGroupByOutputType,
-  T['by']
->
-
-export type RequiredKeys<T> = {
-  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
-}[keyof T]
-
-export type Union = any
-export type IntersectOf<U extends Union> = (
-  U extends unknown ? (k: U) => void : never
-) extends (k: infer I) => void
-  ? I
-  : never
-
-/**
-A [[Boolean]]
-*/
-export type Boolean = True | False
-
-// /**
-// 1
-// */
-export type True = 1
-
-/**
-0
-*/
-export type False = 0
-
-export type Not<B extends Boolean> = {
-  0: 1
-  1: 0
-}[B]
-
-export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
-  ? 0 // anything `never` is false
-  : A1 extends A2
-  ? 1
-  : 0
-
-export type Has<U extends Union, U1 extends Union> = Not<
-  Extends<Exclude<U1, U>, U1>
->
-
-export type Or<B1 extends Boolean, B2 extends Boolean> = {
-  0: {
-    0: 0
-    1: 1
-  }
-  1: {
-    0: 1
-    1: 1
-  }
-}[B1][B2]
-
-declare function groupBy<
-  T extends Prisma.GroupByUserArgs,
-  HasSelectOrTake extends Or<
-    Extends<'skip', Keys<T>>,
-    Extends<'take', Keys<T>>
-  >,
-  U extends True extends HasSelectOrTake
-    ? ReqOrderBy
-    : { orderBy?: Prisma.GroupByUserArgs['orderBy'] },
-  OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
-  ByFields extends TupleToUnion<T['by']>,
-  ByValid extends Has<ByFields, OrderFields>
->(
-  args: Subset<T, Prisma.GroupByUserArgs, U>,
-): 'take' extends Keys<T>
-  ? 'orderBy' extends Keys<T>
-    ? ByValid extends True
-      ? Prisma.GetUserGroupByPayload<T>
-      : {
-          [P in OrderFields]: P extends ByFields
-            ? never
-            : [Error, `Field "${P}" in "orderBy" needs to be provided in "by"`]
-        }[OrderFields]
-    : [Error, 'If you provide "take", you also need to provide "orderBy"']
-  : 'skip' extends Keys<T>
-  ? 'orderBy' extends Keys<T>
-    ? ByValid extends True
-      ? Prisma.GetUserGroupByPayload<T>
-      : {
-          [P in OrderFields]: P extends ByFields
-            ? never
-            : [Error, `Field "${P}" in "orderBy" needs to be provided in "by"`]
-        }[OrderFields]
-    : [Error, 'If you provide "skip", you also need to provide "orderBy"']
-  : Prisma.GetUserGroupByPayload<T>
-
-//GetMissingOrT<Keys<MaybeTupleToUnion<T['orderBy']>>, TupleToUnion<T['by']>, {hello: 'world'}>
-
-type MyKeyOf<T> = keyof T
-export type Keys<U extends Union> = U extends unknown ? keyof U : never
-
-type X = { a: 1 } | { b: 2 }
-
-type XZ = IntersectOf<X>
-
-const xz: XZ = null as any
-
-async function gain() {
-  const res = await groupBy({
-    by: ['id', 'email', 'age'],
-    // skip: 0,
-    take: 10,
-    orderBy: [
-      {
-        age: 'desc',
-      },
-      {
-        email: 'asc',
-      },
-      // {
-      //   propertyId: 'asc',
-      // },
-    ],
-
-    // orderBy: {
-    //   age: 'asc',
-    // },
-
-    // blue: 'string',
-    max: {
-      age: true,
-    },
-  })
-
-  res.max.age
-
-  type xxx = keyof typeof res
-
-  // res.skip
-
-  // res.id
-}
-
-type RequiredSet = 'b'
-
-type GivenSet = 'b' | 'c'
-
-type CleanupNever<T> = {
-  [P in RequiredKeys<T>]: T[P] extends never ? never : T[P]
-}
-
-export type KnownKeys<T> = {
-  [K in keyof T]: string extends K ? never : number extends K ? never : K
-  // eslint-disable-next-line @typescript-eslint/ban-types
-} extends { [_ in keyof T]: infer U }
-  ? {} extends U
-    ? never
-    : U
-  : never
-
-type GetMissing<Required extends any, Given extends any> = {
-  [P in Keys<Required>]: P extends Given
-    ? never
-    : [`Error: Field "{P}" in "orderBy" needs to be provided in "by"`, P]
-} //[Required]
-
-type GetMissingOrT<Required, Given, T, U = GetMissing<Required, Given>> = U //{req: Required, giv: Given} //never extends U ? T : U
-
-// type Missi = GetMissingOrT<RequiredSet, GivenSet, {blub: 1}>
-
-type TT = {
-  skip: 0
-}
-
-type Mu = TT extends Record<'skip' | 'mip', any> ? 'yes' : 'no'
-
-type MySoloMerge<T> = {
-  [P in keyof T]: T[P]
-}
-
-type MyMerge<T, U> = {
-  [P in keyof T | keyof U]: P extends keyof T
-    ? T[P]
-    : P extends keyof U
-    ? U[P]
-    : never
-}
-
-type A = {
-  id?: number
-}
-
-type B = {
-  name: string
-}
-
-type C = MyMerge<A, B>