Skip to content

Commit

Permalink
chore: cleanup
Browse files Browse the repository at this point in the history
  • Loading branch information
@timsuchanek
timsuchanek committed Dec 28, 2020
1 parent 053c5d1 commit df0c6cf
Showing 1 changed file with 1 addition and 309 deletions.
310 changes: 1 addition & 309 deletions src/packages/client/fixtures/blog/main.ts
View file
@@ -1,4 +1,4 @@
import { Prisma, PrismaClient } from './@prisma/client'
import { PrismaClient } from './@prisma/client'

const prisma = new PrismaClient({
log: [
Expand All @@ -19,15 +19,8 @@ async function main() {
avg: {
age: true,
},
take: 0,

// count: {
// _all: true,
// },
})

// res.count._all

console.log(res)

prisma.$disconnect()
Expand All @@ -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>

0 comments on commit df0c6cf

Please sign in to comment.