types.ts

import { Prisma, PrismaClient } from '@prisma/client'
import type {
    AppSyncIdentity,
    AppSyncIdentityCognito,
    AppSyncIdentityIAM,
    AppSyncIdentityLambda,
    AppSyncIdentityOIDC,
    AppSyncResolverEvent,
    AppSyncResolverHandler,
} from 'aws-lambda'
import type { Actions, ActionsAliases, Authorizations } from './consts'

export type logLevel = 'INFO' | 'WARN' | 'ERROR'

export type PrismaAppSyncOptionsType = {
    connectionString?: string
    sanitize?: boolean
    logLevel?: logLevel
    defaultPagination?: number | false
    maxDepth?: number
    maxReqPerUserMinute?: number | false
}

export type Options = Required<PrismaAppSyncOptionsType> & {
    modelsMapping: any
    fieldsMapping: any
}

export type InjectedConfig = {
    modelsMapping?: { [modelVariant: string]: { prismaRef: string; singular: string; plural: string } }
    fieldsMapping?: { [fieldPath: string]: { type: string; isRelation: boolean } }
    operations?: string
}

export type RuntimeConfig = {
    modelsMapping: { [modelVariant: string]: { prismaRef: string; singular: string; plural: string } }
    fieldsMapping: { [fieldPath: string]: { type: string; isRelation: boolean } }
    operations: string[]
}

export type Action = typeof Actions[keyof typeof Actions] | string

export type ActionsAlias = typeof ActionsAliases[keyof typeof ActionsAliases] | 'custom' | null

export type ActionsAliasStr = keyof typeof ActionsAliases

export type Context = {
    action: Action
    alias: ActionsAlias
    model: Model
}

export type Model = { prismaRef: string; singular: string; plural: string } | null

export type { AppSyncResolverHandler, AppSyncResolverEvent, AppSyncIdentity }

/**
 * ### QueryParams
 *
 * @example
 * ```
 * {
 *     type: 'Query',
 *     operation: 'getPost',
 *     context: { action: 'get', alias: 'access', model: 'Post' },
 *     fields: ['title', 'status'],
 *     paths: ['get/post/title', 'get/post/status'],
 *     args: { where: { id: 5 } },
 *     prismaArgs: {
 *         where: { id: 5 },
 *         select: { title: true, status: true },
 *     },
 *     authorization: 'API_KEY',
 *     identity: { ... },
 * }
 * ```
 */
export type QueryParams<T = any> = {
    type: GraphQLType
    operation: string
    context: Context
    fields: string[]
    paths: string[]
    args: T
    prismaArgs: PrismaArgs
    authorization: Authorization
    identity: Identity
    headers: any
}

export type Authorization = typeof Authorizations[keyof typeof Authorizations] | null

export type PrismaGet = Pick<Required<PrismaArgs>, 'where'> & Pick<PrismaArgs, 'select'>
export type PrismaList = Pick<PrismaArgs, 'where' | 'orderBy' | 'select' | 'skip' | 'take'>
export type PrismaCount = Pick<PrismaArgs, 'where' | 'orderBy' | 'select' | 'skip' | 'take'>
export type PrismaCreate = Pick<Required<PrismaArgs>, 'data'> & Pick<PrismaArgs, 'select'>
export type PrismaCreateMany = Pick<Required<PrismaArgs>, 'data'> & Pick<PrismaArgs, 'skipDuplicates'>
export type PrismaUpdate = Pick<Required<PrismaArgs>, 'data' | 'where'> & Pick<PrismaArgs, 'select'>
export type PrismaUpdateMany = Pick<Required<PrismaArgs>, 'data' | 'where'>
export type PrismaUpsert = Pick<Required<PrismaArgs>, 'where'> &
Pick<PrismaArgs, 'select'> & Pick<PrismaArgs, 'update'> & Pick<PrismaArgs, 'create'>
export type PrismaDelete = Pick<Required<PrismaArgs>, 'where'> & Pick<PrismaArgs, 'select'>
export type PrismaDeleteMany = Pick<Required<PrismaArgs>, 'where'>

export type QueryBuilder = {
    prismaGet: (...prismaArgs: PrismaArgs[]) => PrismaGet
    prismaList: (...prismaArgs: PrismaArgs[]) => PrismaList
    prismaCount: (...prismaArgs: PrismaArgs[]) => PrismaCount
    prismaCreate: (...prismaArgs: PrismaArgs[]) => PrismaCreate
    prismaCreateMany: (...prismaArgs: PrismaArgs[]) => PrismaCreateMany
    prismaUpdate: (...prismaArgs: PrismaArgs[]) => PrismaUpdate
    prismaUpdateMany: (...prismaArgs: PrismaArgs[]) => PrismaUpdateMany
    prismaUpsert: (...prismaArgs: PrismaArgs[]) => PrismaUpsert
    prismaDelete: (...prismaArgs: PrismaArgs[]) => PrismaDelete
    prismaDeleteMany: (...prismaArgs: PrismaArgs[]) => PrismaDeleteMany
}

export type QueryParamsCustom<T = any> = QueryParams<T> & {
    prismaClient: PrismaClient
}

export type BeforeHookParams = QueryParams & {
    prismaClient: PrismaClient
}

/**
 * ### AfterHookParams
 *
 * @example
 * ```
 * {
 *     type: 'Query',
 *     operation: 'getPost',
 *     context: { action: 'get', alias: 'access', model: 'Post' },
 *     fields: ['title', 'status'],
 *     paths: ['get/post/title', 'get/post/status'],
 *     args: { where: { id: 5 } },
 *     prismaArgs: {
 *         where: { id: 5 },
 *         select: { title: true, status: true },
 *     },
 *     authorization: 'API_KEY',
 *     identity: { ... },
 *     result: { title: 'Hello World', status: 'PUBLISHED' }
 * }
 * ```
 */
export type AfterHookParams = QueryParams & {
    prismaClient: PrismaClient
    result: any | any[]
}

export type ShieldContext = {
    action: Action
    model: string
}

export type Reason = string | ((context: ShieldContext) => string)

export type ShieldRule = boolean | ((context: ShieldContext) => boolean | Promise<boolean>) | any

export type Shield = {
    [matcher: string]:
    | boolean
    | {
        rule: ShieldRule
        reason?: Reason
    }
}

export type HooksProps = {
    before: BeforeHookParams
    after: AfterHookParams
}

export type HooksReturn = {
    before: Promise<BeforeHookParams>
    after: Promise<AfterHookParams>
}

export type HookPath<Operations extends string, CustomResolvers> = Operations | CustomResolvers

export type HooksParameter<
    HookType extends 'before' | 'after',
    Operations extends string,
    CustomResolvers extends string,
> = `${HookType}:${HookPath<Operations, CustomResolvers>}` | `${HookType}:**`

export type HooksParameters<
    HookType extends 'before' | 'after',
    Operations extends string,
    CustomResolvers extends string,
> = {
    [matcher in HooksParameter<HookType, Operations, CustomResolvers>]?: (
        props: HooksProps[HookType],
    ) => HooksReturn[HookType]
}

export type Hooks<Operations extends string, CustomResolvers extends string> =
    | HooksParameters<'before', Operations, CustomResolvers>
    | HooksParameters<'after', Operations, CustomResolvers>

export type ShieldAuthorization = {
    canAccess: boolean
    reason: Reason
    prismaFilter: any
    matcher: string
    globPattern: string
}

export type ResolveParams<Operations extends string, CustomResolvers extends string> = {
    event: AppSyncEvent
    resolvers?: {
        [resolver in CustomResolvers]: ((props: QueryParamsCustom) => Promise<any>) | boolean
    }
    shield?: (props: QueryParams) => Shield
    hooks?: Hooks<Operations, CustomResolvers>
}

// Prisma-related Types

export { PrismaClient, Prisma }

export type PrismaArgs = {
    where?: any
    create?: any
    update?: any
    data?: any
    select?: any
    orderBy?: any
    skip?: number | undefined
    take?: number | undefined
    skipDuplicates?: boolean | undefined
}

export type PrismaOperator = keyof Required<PrismaArgs>

export type AppSyncEvent = AppSyncResolverEvent<any>

export type GraphQLType = 'Query' | 'Mutation' | 'Subscription'

export type API_KEY = null | {
    [key: string]: any
}

export type AWS_LAMBDA = AppSyncIdentityLambda

export type AWS_IAM = AppSyncIdentityIAM

export type AMAZON_COGNITO_USER_POOLS = AppSyncIdentityCognito

export type OPENID_CONNECT = AppSyncIdentityOIDC

export type Identity = API_KEY | AWS_LAMBDA | AWS_IAM | AMAZON_COGNITO_USER_POOLS | OPENID_CONNECT