@prisma/client-engine-runtime 6.4.0-dev.24

package/dist/index.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Original `quaint::ValueType` enum tag from Prisma's `quaint`.
+ * Query arguments marked with this type are sanitized before being sent to the database.
+ * Notice while a query argument may be `null`, `ArgType` is guaranteed to be defined.
+ */
+declare type ArgType = 'Int32' | 'Int64' | 'Float' | 'Double' | 'Text' | 'Enum' | 'EnumArray' | 'Bytes' | 'Boolean' | 'Char' | 'Array' | 'Numeric' | 'Json' | 'Xml' | 'Uuid' | 'DateTime' | 'Date' | 'Time';
+
+declare type ColumnType = (typeof ColumnTypeEnum)[keyof typeof ColumnTypeEnum];
+
+declare const ColumnTypeEnum: {
+    readonly Int32: 0;
+    readonly Int64: 1;
+    readonly Float: 2;
+    readonly Double: 3;
+    readonly Numeric: 4;
+    readonly Boolean: 5;
+    readonly Character: 6;
+    readonly Text: 7;
+    readonly Date: 8;
+    readonly Time: 9;
+    readonly DateTime: 10;
+    readonly Json: 11;
+    readonly Enum: 12;
+    readonly Bytes: 13;
+    readonly Set: 14;
+    readonly Uuid: 15;
+    readonly Int32Array: 64;
+    readonly Int64Array: 65;
+    readonly FloatArray: 66;
+    readonly DoubleArray: 67;
+    readonly NumericArray: 68;
+    readonly BooleanArray: 69;
+    readonly CharacterArray: 70;
+    readonly TextArray: 71;
+    readonly DateArray: 72;
+    readonly TimeArray: 73;
+    readonly DateTimeArray: 74;
+    readonly JsonArray: 75;
+    readonly EnumArray: 76;
+    readonly BytesArray: 77;
+    readonly UuidArray: 78;
+    readonly UnknownNumber: 128;
+};
+
+declare type ConnectionInfo = {
+    schemaName?: string;
+    maxBindValues?: number;
+};
+
+declare interface DriverAdapter extends Queryable {
+    /**
+     * Starts new transaction.
+     */
+    transactionContext(): Promise<Result<TransactionContext>>;
+    /**
+     * Optional method that returns extra connection info
+     */
+    getConnectionInfo?(): Result<ConnectionInfo>;
+}
+
+declare type Error_2 = {
+    kind: 'GenericJs';
+    id: number;
+} | {
+    kind: 'UnsupportedNativeDataType';
+    type: string;
+} | {
+    kind: 'postgres';
+    code: string;
+    severity: string;
+    message: string;
+    detail: string | undefined;
+    column: string | undefined;
+    hint: string | undefined;
+} | {
+    kind: 'mysql';
+    code: number;
+    message: string;
+    state: string;
+} | {
+    kind: 'sqlite';
+    /**
+     * Sqlite extended error code: https://www.sqlite.org/rescode.html
+     */
+    extendedCode: number;
+    message: string;
+};
+
+declare type InteractiveTransactionInfo<Payload = unknown> = {
+    /**
+     * Transaction ID returned by the query engine.
+     */
+    id: string;
+    /**
+     * Arbitrary payload the meaning of which depends on the `Engine` implementation.
+     * For example, `DataProxyEngine` needs to associate different API endpoints with transactions.
+     * In `LibraryEngine` and `BinaryEngine` it is currently not used.
+     */
+    payload: Payload;
+};
+
+export declare enum IsolationLevel {
+    ReadUncommitted = "ReadUncommitted",
+    ReadCommitted = "ReadCommitted",
+    RepeatableRead = "RepeatableRead",
+    Snapshot = "Snapshot",
+    Serializable = "Serializable"
+}
+
+export declare function isPrismaValuePlaceholder(value: unknown): value is PrismaValuePlaceholder;
+
+export declare type JoinExpression = {
+    child: QueryPlanNode;
+    on: [left: string, right: string][];
+    parentField: string;
+};
+
+declare const officialPrismaAdapters: readonly ["@prisma/adapter-planetscale", "@prisma/adapter-neon", "@prisma/adapter-libsql", "@prisma/adapter-d1", "@prisma/adapter-pg", "@prisma/adapter-pg-worker"];
+
+declare type Options = {
+    maxWait?: number;
+    timeout?: number;
+    isolationLevel?: IsolationLevel;
+};
+
+export declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder;
+
+export declare type PrismaValuePlaceholder = {
+    prisma__type: 'param';
+    prisma__value: {
+        name: string;
+        type: string;
+    };
+};
+
+declare type Provider = 'mysql' | 'postgres' | 'sqlite';
+
+declare type Query = {
+    sql: string;
+    args: Array<unknown>;
+    argTypes: Array<ArgType>;
+};
+
+declare interface Queryable {
+    readonly provider: Provider;
+    readonly adapterName: (typeof officialPrismaAdapters)[number] | (string & {});
+    /**
+     * Execute a query given as SQL, interpolating the given parameters,
+     * and returning the type-aware result set of the query.
+     *
+     * This is the preferred way of executing `SELECT` queries.
+     */
+    queryRaw(params: Query): Promise<Result<ResultSet>>;
+    /**
+     * Execute a query given as SQL, interpolating the given parameters,
+     * and returning the number of affected rows.
+     *
+     * This is the preferred way of executing `INSERT`, `UPDATE`, `DELETE` queries,
+     * as well as transactional queries.
+     */
+    executeRaw(params: Query): Promise<Result<number>>;
+}
+
+declare type QueryEvent = {
+    timestamp: Date;
+    query: string;
+    params: string;
+    duration: number;
+    target: string;
+};
+
+export declare class QueryInterpreter {
+    #private;
+    constructor({ queryable, placeholderValues, onQuery }: QueryInterpreterOptions);
+    run(queryPlan: QueryPlanNode): Promise<unknown>;
+    private interpretNode;
+}
+
+export declare type QueryInterpreterOptions = {
+    queryable: Queryable;
+    placeholderValues: Record<string, unknown>;
+    onQuery?: (event: QueryEvent) => void;
+};
+
+export declare type QueryPlanBinding = {
+    name: string;
+    expr: QueryPlanNode;
+};
+
+export declare type QueryPlanDbQuery = {
+    query: string;
+    params: PrismaValue[];
+};
+
+export declare type QueryPlanNode = {
+    type: 'seq';
+    args: QueryPlanNode[];
+} | {
+    type: 'get';
+    args: {
+        name: string;
+    };
+} | {
+    type: 'let';
+    args: {
+        bindings: QueryPlanBinding[];
+        expr: QueryPlanNode;
+    };
+} | {
+    type: 'getFirstNonEmpty';
+    args: {
+        names: string[];
+    };
+} | {
+    type: 'query';
+    args: QueryPlanDbQuery;
+} | {
+    type: 'execute';
+    args: QueryPlanDbQuery;
+} | {
+    type: 'reverse';
+    args: QueryPlanNode;
+} | {
+    type: 'sum';
+    args: QueryPlanNode[];
+} | {
+    type: 'concat';
+    args: QueryPlanNode[];
+} | {
+    type: 'unique';
+    args: QueryPlanNode;
+} | {
+    type: 'required';
+    args: QueryPlanNode;
+} | {
+    type: 'join';
+    args: {
+        parent: QueryPlanNode;
+        children: JoinExpression[];
+    };
+} | {
+    type: 'mapField';
+    args: {
+        field: string;
+        records: QueryPlanNode;
+    };
+};
+
+declare type Result<T> = {
+    map<U>(fn: (value: T) => U): Result<U>;
+    flatMap<U>(fn: (value: T) => Result<U>): Result<U>;
+} & ({
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: Error_2;
+});
+
+declare interface ResultSet {
+    /**
+     * List of column types appearing in a database query, in the same order as `columnNames`.
+     * They are used within the Query Engine to convert values from JS to Quaint values.
+     */
+    columnTypes: Array<ColumnType>;
+    /**
+     * List of column names appearing in a database query, in the same order as `columnTypes`.
+     */
+    columnNames: Array<string>;
+    /**
+     * List of rows retrieved from a database query.
+     * Each row is a list of values, whose length matches `columnNames` and `columnTypes`.
+     */
+    rows: Array<Array<unknown>>;
+    /**
+     * The last ID of an `INSERT` statement, if any.
+     * This is required for `AUTO_INCREMENT` columns in databases based on MySQL and SQLite.
+     */
+    lastInsertId?: string;
+}
+
+declare interface Transaction extends Queryable {
+    /**
+     * Transaction options.
+     */
+    readonly options: TransactionOptions;
+    /**
+     * Commit the transaction.
+     */
+    commit(): Promise<Result<void>>;
+    /**
+     * Rolls back the transaction.
+     */
+    rollback(): Promise<Result<void>>;
+}
+
+declare interface TransactionContext extends Queryable {
+    /**
+     * Starts new transaction.
+     */
+    startTransaction(): Promise<Result<Transaction>>;
+}
+
+declare type TransactionHeaders = {
+    traceparent?: string;
+};
+
+export declare class TransactionManager {
+    private transactions;
+    private closedTransactions;
+    private readonly driverAdapter;
+    private readonly clientVersion;
+    constructor({ driverAdapter, clientVersion }: {
+        driverAdapter: DriverAdapter;
+        clientVersion: string;
+    });
+    startTransaction(options: Tx.Options): Promise<Tx.InteractiveTransactionInfo<undefined>>;
+    commitTransaction(transactionId: string): Promise<void>;
+    rollbackTransaction(transactionId: string): Promise<void>;
+    getTransaction(txInfo: Tx.InteractiveTransactionInfo<unknown>, operation: string): Transaction;
+    private getActiveTransaction;
+    private startTransactionTimeout;
+    private closeTransaction;
+    private validateOptions;
+    private requiresSettingIsolationLevelFirst;
+}
+
+declare type TransactionOptions = {
+    usePhantomQuery: boolean;
+};
+
+declare namespace Tx {
+    export {
+        IsolationLevel,
+        Options,
+        InteractiveTransactionInfo,
+        TransactionHeaders
+    }
+}
+
+export { }