@creator.co/creatorco-prisma-client 1.0.22-alpha-c4b16cb → 1.0.22

package/runtime/library.d.ts

@@ -3,6 +3,24 @@
  */
 declare function $extends(this: Client, extension: ExtensionArgs | ((client: Client) => Client)): Client;
 
+declare type AccelerateEngineConfig = {
+    inlineSchema: EngineConfig['inlineSchema'];
+    inlineSchemaHash: EngineConfig['inlineSchemaHash'];
+    env: EngineConfig['env'];
+    generator?: {
+        previewFeatures: string[];
+    };
+    inlineDatasources: EngineConfig['inlineDatasources'];
+    overrideDatasources: EngineConfig['overrideDatasources'];
+    clientVersion: EngineConfig['clientVersion'];
+    engineVersion: EngineConfig['engineVersion'];
+    logEmitter: EngineConfig['logEmitter'];
+    logQueries?: EngineConfig['logQueries'];
+    logLevel?: EngineConfig['logLevel'];
+    tracingHelper: EngineConfig['tracingHelper'];
+    accelerateUtils?: EngineConfig['accelerateUtils'];
+};
+
 export declare type Action = keyof typeof DMMF.ModelAction | 'executeRaw' | 'queryRaw' | 'runCommandRaw';
 
 export declare type Aggregate = '_count' | '_max' | '_min' | '_avg' | '_sum';
@@ -249,23 +267,31 @@ declare type Datasources = {
 declare class DbNull extends NullTypesEnumValue {
 }
 
-export declare interface Debug {
-    (namespace: string): Debugger;
-    disable: () => string;
-    enable: (namespace: string) => void;
-    enabled: (namespace: string) => boolean;
-    log: (...args: any[]) => any;
-    formatters: Record<string, ((value: any) => string) | undefined>;
-}
+export declare const Debug: typeof debugCreate & {
+    enable(namespace: any): void;
+    disable(): any;
+    enabled(namespace: string): boolean;
+    log: (...args: string[]) => void;
+    formatters: {};
+};
 
-declare interface Debugger {
-    (format: any, ...args: any[]): void;
-    log: (...args: any[]) => any;
-    extend: (namespace: string, delimiter?: string) => Debugger;
-    color: string | number;
+/**
+ * Create a new debug instance with the given namespace.
+ *
+ * @example
+ * ```ts
+ * import Debug from '@prisma/debug'
+ * const debug = Debug('prisma:client')
+ * debug('Hello World')
+ * ```
+ */
+declare function debugCreate(namespace: string): ((...args: any[]) => void) & {
+    color: string;
     enabled: boolean;
     namespace: string;
-}
+    log: (...args: string[]) => void;
+    extend: () => void;
+};
 
 export declare namespace Decimal {
     export type Constructor = typeof Decimal;
@@ -558,27 +584,6 @@ declare function defineExtension(ext: ExtensionArgs | ((client: Client) => Clien
 
 declare const denylist: readonly ["$connect", "$disconnect", "$on", "$transaction", "$use", "$extends"];
 
-/**
- * Detect the current JavaScript runtime following
- * the WinterCG Runtime Keys proposal:
- *
- * - `edge-routine` Alibaba Cloud Edge Routine
- * - `workerd` Cloudflare Workers
- * - `deno` Deno and Deno Deploy
- * - `lagon` Lagon
- * - `react-native` React Native
- * - `netlify` Netlify Edge Functions
- * - `electron` Electron
- * - `node` Node.js
- * - `bun` Bun
- * - `edge-light` Vercel Edge Functions
- * - `fastly` Fastly Compute@Edge
- *
- * @see https://runtime-keys.proposal.wintercg.org/
- * @returns {Runtime}
- */
-export declare function detectRuntime(): Runtime;
-
 export declare type DevTypeMapDef = {
     meta: {
         modelProps: string;
@@ -603,10 +608,6 @@ declare type Dictionary<T> = {
     [key: string]: T | undefined;
 };
 
-declare interface Dictionary_2<T> {
-    [key: string]: T;
-}
-
 export declare namespace DMMF {
     export type Document = ReadonlyDeep_2<{
         datamodel: Datamodel;
@@ -808,47 +809,13 @@ export declare namespace DMMF {
         delete = "delete",
         deleteMany = "deleteMany",
         groupBy = "groupBy",
-        count = "count",
+        count = "count",// TODO: count does not actually exist, why?
         aggregate = "aggregate",
         findRaw = "findRaw",
         aggregateRaw = "aggregateRaw"
     }
 }
 
-export declare class DMMFClass implements DMMF.Document {
-    document: DMMF.Document;
-    private _compositeNames?;
-    private _inputTypesByName?;
-    private _typeAndModelMap?;
-    private _mappingsMap?;
-    private _outputTypeMap?;
-    private _rootFieldMap?;
-    constructor(document: DMMF.Document);
-    private get compositeNames();
-    private get inputTypesByName();
-    get typeAndModelMap(): Dictionary_2<DMMF.Model>;
-    get mappingsMap(): Dictionary_2<DMMF.ModelMapping>;
-    get outputTypeMap(): NamespacedTypeMap<DMMF.OutputType>;
-    get rootFieldMap(): Dictionary_2<DMMF.SchemaField>;
-    get datamodel(): DMMF.Datamodel;
-    get mappings(): DMMF.Mappings;
-    get schema(): DMMF.Schema;
-    get inputObjectTypes(): DMMF.Schema['inputObjectTypes'];
-    get outputObjectTypes(): DMMF.Schema['outputObjectTypes'];
-    isComposite(modelOrTypeName: string): boolean;
-    getOtherOperationNames(): string[];
-    hasEnumInNamespace(enumName: string, namespace: DMMF.FieldNamespace): boolean;
-    resolveInputObjectType(ref: DMMF.InputTypeRef): DMMF.InputType | undefined;
-    resolveOutputObjectType(ref: DMMF.OutputTypeRef): DMMF.OutputType | undefined;
-    private buildModelMap;
-    private buildTypeMap;
-    private buildTypeModelMap;
-    private buildMappingsMap;
-    private buildMergedOutputTypeMap;
-    private buildRootFieldMap;
-    private buildInputTypesMap;
-}
-
 export declare interface DriverAdapter extends Queryable {
     /**
      * Starts new transation.
@@ -1005,18 +972,20 @@ export declare const empty: Sql;
 
 export declare type EmptyToUnknown<T> = T;
 
-declare abstract class Engine<InteractiveTransactionPayload = unknown> {
-    abstract onBeforeExit(callback: () => Promise<void>): void;
-    abstract start(): Promise<void>;
-    abstract stop(): Promise<void>;
-    abstract version(forceRun?: boolean): Promise<string> | string;
-    abstract request<T>(query: JsonQuery, options: RequestOptions_2<InteractiveTransactionPayload>): Promise<QueryEngineResult<T>>;
-    abstract requestBatch<T>(queries: JsonQuery[], options: RequestBatchOptions<InteractiveTransactionPayload>): Promise<BatchQueryEngineResult<T>[]>;
-    abstract transaction(action: 'start', headers: Transaction_2.TransactionHeaders, options?: Transaction_2.Options): Promise<Transaction_2.InteractiveTransactionInfo<unknown>>;
-    abstract transaction(action: 'commit', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
-    abstract transaction(action: 'rollback', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
-    abstract metrics(options: MetricsOptionsJson): Promise<Metrics>;
-    abstract metrics(options: MetricsOptionsPrometheus): Promise<string>;
+declare interface Engine<InteractiveTransactionPayload = unknown> {
+    /** The name of the engine. This is meant to be consumed externally */
+    readonly name: string;
+    onBeforeExit(callback: () => Promise<void>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    version(forceRun?: boolean): Promise<string> | string;
+    request<T>(query: JsonQuery, options: RequestOptions_2<InteractiveTransactionPayload>): Promise<QueryEngineResult<T>>;
+    requestBatch<T>(queries: JsonQuery[], options: RequestBatchOptions<InteractiveTransactionPayload>): Promise<BatchQueryEngineResult<T>[]>;
+    transaction(action: 'start', headers: Transaction_2.TransactionHeaders, options: Transaction_2.Options): Promise<Transaction_2.InteractiveTransactionInfo<unknown>>;
+    transaction(action: 'commit', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
+    transaction(action: 'rollback', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
+    metrics(options: MetricsOptionsJson): Promise<Metrics>;
+    metrics(options: MetricsOptionsPrometheus): Promise<string>;
 }
 
 declare interface EngineConfig {
@@ -1039,6 +1008,7 @@ declare interface EngineConfig {
     engineEndpoint?: string;
     activeProvider?: string;
     logEmitter: LogEmitter;
+    transactionOptions: Transaction_2.Options;
     /**
      * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`.
      * If set, this is only used in the library engine, and all queries would be performed through it,
@@ -1073,19 +1043,32 @@ declare interface EngineConfig {
      */
     isBundled?: boolean;
     /**
-     * Loads the raw wasm module for the wasm query engine. This configuration is
-     * generated specifically for each type of client, eg. Node.js client and Edge
-     * clients will have different implementations.
-     * @remarks this is a callback on purpose, we only load the wasm if needed.
-     * @remarks only used by LibraryEngine.ts
+     * Web Assembly module loading configuration
      */
-    getQueryEngineWasmModule?: () => Promise<unknown>;
+    engineWasm?: WasmLoadingConfig;
+    /**
+     * Allows Accelerate to use runtime utilities from the client. These are
+     * necessary for the AccelerateEngine to function correctly.
+     */
+    accelerateUtils?: {
+        resolveDatasourceUrl: typeof resolveDatasourceUrl;
+        getBatchRequestPayload: typeof getBatchRequestPayload;
+        prismaGraphQLToJSError: typeof prismaGraphQLToJSError;
+        PrismaClientUnknownRequestError: typeof PrismaClientUnknownRequestError;
+        PrismaClientInitializationError: typeof PrismaClientInitializationError;
+        PrismaClientKnownRequestError: typeof PrismaClientKnownRequestError;
+        debug: (...args: any[]) => void;
+        engineVersion: string;
+        clientVersion: string;
+    };
 }
 
 declare type EngineEvent<E extends EngineEventType> = E extends QueryEventType ? QueryEvent : LogEvent;
 
 declare type EngineEventType = QueryEventType | LogEventType;
 
+declare type EngineProtocol = 'graphql' | 'json';
+
 declare type EngineSpan = {
     span: boolean;
     name: string;
@@ -1322,6 +1305,8 @@ export declare type GetAggregateResult<P extends OperationPayload, A> = {
     };
 };
 
+declare function getBatchRequestPayload(batch: JsonQuery[], transaction?: TransactionOptions_2<unknown>): QueryEngineBatchRequest;
+
 export declare type GetBatchResult = {
     count: number;
 };
@@ -1364,11 +1349,13 @@ export declare type GetPayloadResult<Base extends Record<any, any>, R extends In
 
 export declare function getPrismaClient(config: GetPrismaClientConfig): {
     new (optionsArg?: PrismaClientOptions): {
+        _originalClient: any;
         _runtimeDataModel: RuntimeDataModel;
         _requestHandler: RequestHandler;
         _connectionPromise?: Promise<any> | undefined;
         _disconnectionPromise?: Promise<any> | undefined;
         _engineConfig: EngineConfig;
+        _accelerateEngineConfig: AccelerateEngineConfig;
         _clientVersion: string;
         _errorFormat: ErrorFormat;
         _tracingHelper: TracingHelper;
@@ -1560,17 +1547,14 @@ declare type GetPrismaClientConfig = {
      */
     isBundled?: boolean;
     /**
-     * A boolean that is `true` when the client was generated with --no-engine. At
+     * A boolean that is `false` when the client was generated with --no-engine. At
      * runtime, this means the client will be bound to be using the Data Proxy.
      */
-    noEngine?: boolean;
+    copyEngine?: boolean;
     /**
-     * Loads the raw wasm module for the wasm query engine. This configuration is
-     * generated specifically for each type of client, eg. Node.js client and Edge
-     * clients will have different implementations.
-     * @remarks this is a callback on purpose, we only load the wasm if needed.
+     * Optional wasm loading configuration
      */
-    getQueryEngineWasmModule?: () => Promise<unknown>;
+    engineWasm?: WasmLoadingConfig;
 };
 
 export declare type GetResult<P extends OperationPayload, A, O extends Operation = 'findUniqueOrThrow'> = {
@@ -1598,6 +1582,14 @@ export declare type GetResult<P extends OperationPayload, A, O extends Operation
     aggregateRaw: JsonObject;
 }[O];
 
+export declare function getRuntime(): GetRuntimeOutput;
+
+declare type GetRuntimeOutput = {
+    id: Runtime;
+    prettyName: string;
+    isEdge: boolean;
+};
+
 export declare type GetSelect<Base extends Record<any, any>, R extends InternalArgs['result'][string], KR extends keyof R = string extends keyof R ? never : keyof R> = {
     [K in KR | keyof Base]?: K extends KR ? boolean : Base[K];
 };
@@ -1740,6 +1732,13 @@ declare type JsonArgumentValue = number | string | boolean | null | RawTaggedVal
 export declare interface JsonArray extends Array<JsonValue> {
 }
 
+declare type JsonBatchQuery = {
+    batch: JsonQuery[];
+    transaction?: {
+        isolationLevel?: Transaction_2.IsolationLevel;
+    };
+};
+
 export declare interface JsonConvertible {
     toJSON(): unknown;
 }
@@ -1828,10 +1827,16 @@ declare type LogDefinition = {
     emit: 'stdout' | 'event';
 };
 
+/**
+ * Typings for the events we emit.
+ *
+ * @remarks
+ * If this is updated, our edge runtime shim needs to be updated as well.
+ */
 declare type LogEmitter = {
     on<E extends EngineEventType>(event: E, listener: (event: EngineEvent<E>) => void): LogEmitter;
-    emit(event: QueryEventType, payload: QueryEvent): void;
-    emit(event: LogEventType, payload: LogEvent): void;
+    emit(event: QueryEventType, payload: QueryEvent): boolean;
+    emit(event: LogEventType, payload: LogEvent): boolean;
 };
 
 declare type LogEvent = {
@@ -1986,11 +1991,6 @@ export declare type NameArgs = {
     name?: string;
 };
 
-declare type NamespacedTypeMap<T> = {
-    prisma: Record<string, T>;
-    model: Record<string, T>;
-};
-
 export declare type Narrow<A> = {
     [K in keyof A]: A[K] extends Function ? A[K] : Narrow<A[K]>;
 } | (A extends Narrowable ? A : never);
@@ -2095,10 +2095,6 @@ export declare type OptionalKeys<O> = {
     [K in keyof O]-?: {} extends Pick_2<O, K> ? K : never;
 }[keyof O];
 
-/**
- * maxWait ?= 2000
- * timeout ?= 5000
- */
 declare type Options = {
     maxWait?: number;
     timeout?: number;
@@ -2175,6 +2171,12 @@ export declare type PrismaClientOptions = {
      * @default "colorless"
      */
     errorFormat?: ErrorFormat;
+    /**
+     * The default values for Transaction options
+     * maxWait ?= 2000
+     * timeout ?= 5000
+     */
+    transactionOptions?: Transaction_2.Options;
     /**
      * @example
      * \`\`\`
@@ -2204,7 +2206,7 @@ export declare type PrismaClientOptions = {
             allowTriggerPanic?: boolean;
         };
         /** This can be used for testing purposes */
-        configOverride?: Partial<GetPrismaClientConfig>;
+        configOverride?: (config: GetPrismaClientConfig) => GetPrismaClientConfig;
     };
 };
 
@@ -2228,6 +2230,8 @@ export declare class PrismaClientValidationError extends Error {
     get [Symbol.toStringTag](): string;
 }
 
+declare function prismaGraphQLToJSError({ error, user_facing_error }: RequestError, clientVersion: string, activeProvider: string): PrismaClientKnownRequestError | PrismaClientUnknownRequestError;
+
 export declare interface PrismaPromise<T> extends Promise<T> {
     [Symbol.toStringTag]: 'PrismaPromise';
 }
@@ -2335,11 +2339,63 @@ declare interface Queryable {
     executeRaw(params: Query): Promise<Result_4<number>>;
 }
 
+declare type QueryEngineBatchGraphQLRequest = {
+    batch: QueryEngineRequest[];
+    transaction?: boolean;
+    isolationLevel?: Transaction_2.IsolationLevel;
+};
+
+declare type QueryEngineBatchRequest = QueryEngineBatchGraphQLRequest | JsonBatchQuery;
+
+declare type QueryEngineConfig = {
+    datamodel: string;
+    configDir: string;
+    logQueries: boolean;
+    ignoreEnvVarErrors: boolean;
+    datasourceOverrides: Record<string, string>;
+    env: Record<string, string | undefined>;
+    logLevel: QueryEngineLogLevel;
+    telemetry?: QueryEngineTelemetry;
+    engineProtocol: EngineProtocol;
+};
+
+declare interface QueryEngineConstructor {
+    new (config: QueryEngineConfig, logger: (log: string) => void, adapter?: ErrorCapturingDriverAdapter): QueryEngineInstance;
+}
+
+declare type QueryEngineInstance = {
+    connect(headers: string): Promise<void>;
+    disconnect(headers: string): Promise<void>;
+    /**
+     * @param requestStr JSON.stringified `QueryEngineRequest | QueryEngineBatchRequest`
+     * @param headersStr JSON.stringified `QueryEngineRequestHeaders`
+     */
+    query(requestStr: string, headersStr: string, transactionId?: string): Promise<string>;
+    sdlSchema(): Promise<string>;
+    dmmf(traceparent: string): Promise<string>;
+    startTransaction(options: string, traceHeaders: string): Promise<string>;
+    commitTransaction(id: string, traceHeaders: string): Promise<string>;
+    rollbackTransaction(id: string, traceHeaders: string): Promise<string>;
+    metrics(options: string): Promise<string>;
+};
+
+declare type QueryEngineLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'off';
+
+declare type QueryEngineRequest = {
+    query: string;
+    variables: Object;
+};
+
 declare type QueryEngineResult<T> = {
     data: T;
     elapsed: number;
 };
 
+declare type QueryEngineTelemetry = {
+    enabled: Boolean;
+    endpoint: string;
+};
+
 declare type QueryEvent = {
     timestamp: Date;
     query: string;
@@ -2428,6 +2484,17 @@ declare type RequestBatchOptions<InteractiveTransactionPayload> = {
     customDataProxyFetch?: (fetch: Fetch) => Fetch;
 };
 
+declare interface RequestError {
+    error: string;
+    user_facing_error: {
+        is_panic: boolean;
+        message: string;
+        meta?: Record<string, unknown>;
+        error_code?: string;
+        batch_request_idx?: number;
+    };
+}
+
 declare class RequestHandler {
     client: Client;
     dataloader: DataLoader<RequestParams>;
@@ -2495,6 +2562,13 @@ export declare type RequiredKeys<O> = {
     [K in keyof O]-?: {} extends Pick_2<O, K> ? never : K;
 }[keyof O];
 
+declare function resolveDatasourceUrl({ inlineDatasources, overrideDatasources, env, clientVersion, }: {
+    inlineDatasources: GetPrismaClientConfig['inlineDatasources'];
+    overrideDatasources: Datasources;
+    env: Record<string, string | undefined>;
+    clientVersion: string;
+}): string;
+
 export declare type Result<T, A, F extends Operation> = T extends {
     [K: symbol]: {
         types: {
@@ -3063,4 +3137,22 @@ export declare function warnEnvConflicts(envPaths: any): void;
 
 export declare const warnOnce: (key: string, message: string, ...args: unknown[]) => void;
 
+declare type WasmLoadingConfig = {
+    /**
+     * WASM-bindgen runtime for corresponding module
+     */
+    getRuntime: () => {
+        __wbg_set_wasm(exports: unknown): any;
+        QueryEngine: QueryEngineConstructor;
+    };
+    /**
+     * Loads the raw wasm module for the wasm query engine. This configuration is
+     * generated specifically for each type of client, eg. Node.js client and Edge
+     * clients will have different implementations.
+     * @remarks this is a callback on purpose, we only load the wasm if needed.
+     * @remarks only used by LibraryEngine.ts
+     */
+    getQueryEngineWasmModule: () => Promise<unknown>;
+};
+
 export { }