@dataql/prisma-adapter/dist/index.d.ts

Prisma adapter for DataQL with zero API changes

import { Data } from "@dataql/core";
export interface PrismaClientOptions {
    appToken?: string;
    dbName?: string;
    env?: "dev" | "prod";
    devPrefix?: string;
    customConnection?: any;
    log?: Array<"query" | "info" | "warn" | "error">;
    errorFormat?: "pretty" | "colorless" | "minimal";
    datasources?: {
        db?: {
            url?: string;
        };
    };
}
export type PrismaFieldType = "String" | "Boolean" | "Int" | "BigInt" | "Float" | "Decimal" | "DateTime" | "Json" | "Bytes" | "Uuid";
export interface FindManyArgs<T = any> {
    select?: any;
    include?: any;
    where?: WhereInput<T>;
    orderBy?: OrderByInput<T> | OrderByInput<T>[];
    cursor?: any;
    take?: number;
    skip?: number;
    distinct?: string | string[];
}
export interface FindUniqueArgs<T = any> {
    select?: any;
    include?: any;
    where: WhereUniqueInput<T>;
}
export interface FindFirstArgs<T = any> {
    select?: any;
    include?: any;
    where?: WhereInput<T>;
    orderBy?: OrderByInput<T> | OrderByInput<T>[];
    cursor?: any;
    take?: number;
    skip?: number;
    distinct?: string | string[];
}
export interface CreateArgs<T = any> {
    data: CreateInput<T>;
    select?: any;
    include?: any;
}
export interface CreateManyArgs<T = any> {
    data: CreateInput<T> | CreateInput<T>[];
    skipDuplicates?: boolean;
}
export interface UpdateArgs<T = any> {
    where: WhereUniqueInput<T>;
    data: UpdateInput<T>;
    select?: any;
    include?: any;
}
export interface UpdateManyArgs<T = any> {
    where?: WhereInput<T>;
    data: UpdateInput<T>;
}
export interface UpsertArgs<T = any> {
    where: WhereUniqueInput<T>;
    create: CreateInput<T>;
    update: UpdateInput<T>;
    select?: any;
    include?: any;
}
export interface DeleteArgs<T = any> {
    where: WhereUniqueInput<T>;
    select?: any;
    include?: any;
}
export interface DeleteManyArgs<T = any> {
    where?: WhereInput<T>;
}
export interface CountArgs<T = any> {
    select?: any;
    where?: WhereInput<T>;
}
export interface AggregateArgs<T = any> {
    where?: WhereInput<T>;
    orderBy?: OrderByInput<T> | OrderByInput<T>[];
    cursor?: any;
    take?: number;
    skip?: number;
    _count?: boolean | CountSelect<T>;
    _avg?: AverageSelect<T>;
    _sum?: SumSelect<T>;
    _min?: MinSelect<T>;
    _max?: MaxSelect<T>;
}
export type WhereInput<T> = {
    [K in keyof T]?: T[K] extends string ? StringFilter | T[K] : T[K] extends number ? NumberFilter | T[K] : T[K] extends boolean ? BooleanFilter | T[K] : T[K] extends Date ? DateTimeFilter | T[K] : any;
} & {
    AND?: WhereInput<T> | WhereInput<T>[];
    OR?: WhereInput<T>[];
    NOT?: WhereInput<T> | WhereInput<T>[];
};
export type WhereUniqueInput<T> = {
    [K in keyof T]?: T[K];
};
export interface StringFilter {
    equals?: string;
    in?: string[];
    notIn?: string[];
    lt?: string;
    lte?: string;
    gt?: string;
    gte?: string;
    contains?: string;
    startsWith?: string;
    endsWith?: string;
    mode?: "default" | "insensitive";
    not?: string | StringFilter;
}
export interface NumberFilter {
    equals?: number;
    in?: number[];
    notIn?: number[];
    lt?: number;
    lte?: number;
    gt?: number;
    gte?: number;
    not?: number | NumberFilter;
}
export interface BooleanFilter {
    equals?: boolean;
    not?: boolean | BooleanFilter;
}
export interface DateTimeFilter {
    equals?: Date | string;
    in?: (Date | string)[];
    notIn?: (Date | string)[];
    lt?: Date | string;
    lte?: Date | string;
    gt?: Date | string;
    gte?: Date | string;
    not?: Date | string | DateTimeFilter;
}
export type OrderByInput<T> = {
    [K in keyof T]?: "asc" | "desc";
};
export type CreateInput<T> = {
    [K in keyof T]?: T[K] extends Array<infer U> ? CreateNestedManyInput<U> : T[K];
};
export type UpdateInput<T> = {
    [K in keyof T]?: T[K] extends Array<infer U> ? UpdateNestedManyInput<U> : T[K];
};
export interface CreateNestedManyInput<T> {
    create?: CreateInput<T> | CreateInput<T>[];
    connect?: WhereUniqueInput<T> | WhereUniqueInput<T>[];
}
export interface UpdateNestedManyInput<T> {
    create?: CreateInput<T> | CreateInput<T>[];
    connect?: WhereUniqueInput<T> | WhereUniqueInput<T>[];
    set?: WhereUniqueInput<T>[];
    disconnect?: WhereUniqueInput<T> | WhereUniqueInput<T>[];
    delete?: WhereUniqueInput<T> | WhereUniqueInput<T>[];
    update?: UpdateWithWhereUniqueInput<T> | UpdateWithWhereUniqueInput<T>[];
    updateMany?: UpdateManyWithWhereInput<T> | UpdateManyWithWhereInput<T>[];
    deleteMany?: WhereInput<T> | WhereInput<T>[];
    upsert?: UpsertWithWhereUniqueInput<T> | UpsertWithWhereUniqueInput<T>[];
}
export interface UpdateWithWhereUniqueInput<T> {
    where: WhereUniqueInput<T>;
    data: UpdateInput<T>;
}
export interface UpdateManyWithWhereInput<T> {
    where: WhereInput<T>;
    data: UpdateInput<T>;
}
export interface UpsertWithWhereUniqueInput<T> {
    where: WhereUniqueInput<T>;
    create: CreateInput<T>;
    update: UpdateInput<T>;
}
export type CountSelect<T> = boolean | {
    [K in keyof T]?: boolean;
};
export type AverageSelect<T> = {
    [K in keyof T]?: T[K] extends number ? boolean : never;
};
export type SumSelect<T> = {
    [K in keyof T]?: T[K] extends number ? boolean : never;
};
export type MinSelect<T> = {
    [K in keyof T]?: boolean;
};
export type MaxSelect<T> = {
    [K in keyof T]?: boolean;
};
export interface BatchPayload {
    count: number;
}
export interface AggregateResult<T> {
    _count?: {
        [K in keyof T]?: number;
    } | number;
    _avg?: {
        [K in keyof T]?: number;
    };
    _sum?: {
        [K in keyof T]?: number;
    };
    _min?: {
        [K in keyof T]?: any;
    };
    _max?: {
        [K in keyof T]?: any;
    };
}
export declare class PrismaModelDelegate<T> {
    private _collection;
    private _modelName;
    private _data;
    constructor(data: Data, modelName: string, schema: any);
    findMany(args?: FindManyArgs<T>): Promise<T[]>;
    findUnique(args: FindUniqueArgs<T>): Promise<T | null>;
    findFirst(args?: FindFirstArgs<T>): Promise<T | null>;
    create(args: CreateArgs<T>): Promise<T>;
    createMany(args: CreateManyArgs<T>): Promise<BatchPayload>;
    update(args: UpdateArgs<T>): Promise<T>;
    updateMany(args: UpdateManyArgs<T>): Promise<BatchPayload>;
    upsert(args: UpsertArgs<T>): Promise<T>;
    delete(args: DeleteArgs<T>): Promise<T>;
    deleteMany(args?: DeleteManyArgs<T>): Promise<BatchPayload>;
    count(args?: CountArgs<T>): Promise<number>;
    aggregate(args?: AggregateArgs<T>): Promise<AggregateResult<T>>;
    private _convertWhereToDataQL;
    private _applyOrderBy;
    private _applySelect;
}
export declare class PrismaClient {
    private _data;
    private _models;
    private _schemas;
    constructor(options?: PrismaClientOptions);
    _registerModel<T>(name: string, schema: any): PrismaModelDelegate<T>;
    _getModel<T>(name: string): PrismaModelDelegate<T>;
    $transaction<T>(fn: (prisma: PrismaClient) => Promise<T>): Promise<T>;
    $transaction<T>(queries: any[]): Promise<any[]>;
    $queryRaw<T = any>(query: TemplateStringsArray, ...values: any[]): Promise<T>;
    $executeRaw(query: TemplateStringsArray, ...values: any[]): Promise<number>;
    $connect(): Promise<void>;
    $disconnect(): Promise<void>;
}
export declare function createPrismaClient<T extends Record<string, any>>(options?: PrismaClientOptions, schemas?: {
    [K in keyof T]: any;
}): PrismaClient & {
    [K in keyof T]: PrismaModelDelegate<T[K]>;
};
export declare class PrismaClientKnownRequestError extends Error {
    code: string;
    meta?: Record<string, any>;
    constructor(message: string, code: string, meta?: Record<string, any>);
}
export declare class PrismaClientUnknownRequestError extends Error {
    constructor(message: string);
}
export declare class PrismaClientRustPanicError extends Error {
    constructor(message: string);
}
export declare class PrismaClientInitializationError extends Error {
    constructor(message: string);
}
export declare class PrismaClientValidationError extends Error {
    constructor(message: string);
}
export default PrismaClient;
//# sourceMappingURL=index.d.ts.map