@prisma/extension-accelerate - npm Package Compare versions

Comparing version 0.0.0-experimental-8af16bf to 0.0.0-experimental-8b03dde

dist/cjs/index.d.ts

 /// <reference lib="dom" />
 import PrismaDefault, { type Prisma } from "@prisma/client/scripts/default-index.js";
-import type { Types } from "@prisma/client/runtime";
+import type { Types } from "@prisma/client/runtime/library.js";
 export interface PrismaCacheStrategy {
@@ -83,65 +83,27 @@ /**
 }
-declare const _default: (client: any) => PrismaDefault.PrismaClientExtends<Types.Extensions.InternalArgs<{}, {
+export declare function withAccelerate(): (client: any) => PrismaDefault.PrismaClientExtends<Types.Extensions.InternalArgs<{}, {
     $allModels: {
-        aggregate<T, A>(this: T, args: Prisma.Exact<A, Types.Public.Args<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T, A, "aggregate">>;
-        count<T_1, A_1>(this: T_1, args?: Prisma.Exact<A_1, Types.Public.Args<T_1, "count"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_1, A_1, "count">>;
-        findFirst<T_2, A_2>(this: T_2, args?: Prisma.Exact<A_2, Types.Public.Args<T_2, "findFirst"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_2, A_2, "findFirst"> | null>;
-        findFirstOrThrow<T_3, A_3>(this: T_3, args?: Prisma.Exact<A_3, Types.Public.Args<T_3, "findFirstOrThrow"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_3, A_3, "findFirstOrThrow">>;
-        findMany<T_4, A_4>(this: T_4, args?: Prisma.Exact<A_4, Types.Public.Args<T_4, "findMany"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_4, A_4, "findMany">>;
-        findUnique<T_5, A_5>(this: T_5, args: Prisma.Exact<A_5, Types.Public.Args<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_5, A_5, "findUnique"> | null>;
-        findUniqueOrThrow<T_6, A_6>(this: T_6, args: Prisma.Exact<A_6, Types.Public.Args<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_6, A_6, "findUniqueOrThrow">>;
-        groupBy<T_7, A_7>(this: T_7, args: Prisma.Exact<A_7, Types.Public.Args<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_7, A_7, "groupBy">>;
+        aggregate<T, A>(this: T, args: Prisma.Exact<A, Prisma.Args<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T, A, "aggregate">>;
+        count<T_1, A_1>(this: T_1, args?: Prisma.Exact<A_1, Prisma.Args<T_1, "count"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_1, A_1, "count">>;
+        findFirst<T_2, A_2>(this: T_2, args?: Prisma.Exact<A_2, Prisma.Args<T_2, "findFirst"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_2, A_2, "findFirst"> | null>;
+        findFirstOrThrow<T_3, A_3>(this: T_3, args?: Prisma.Exact<A_3, Prisma.Args<T_3, "findFirstOrThrow"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_3, A_3, "findFirstOrThrow">>;
+        findMany<T_4, A_4>(this: T_4, args?: Prisma.Exact<A_4, Prisma.Args<T_4, "findMany"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_4, A_4, "findMany">>;
+        findUnique<T_5, A_5>(this: T_5, args: Prisma.Exact<A_5, Prisma.Args<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_5, A_5, "findUnique"> | null>;
+        findUniqueOrThrow<T_6, A_6>(this: T_6, args: Prisma.Exact<A_6, Prisma.Args<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_6, A_6, "findUniqueOrThrow">>;
+        groupBy<T_7, A_7>(this: T_7, args: Prisma.Exact<A_7, Prisma.Args<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_7, A_7, "groupBy">>;
     };
-}, {}, {}> & Types.Extensions.InternalArgs<{}, {}, {
+}, {}, {}> & Types.Extensions.InternalArgs<{}, {}, {}, {}> & Types.Extensions.DefaultArgs>;
+/** @deprecated The default export has been replaced by `withAccelerate`. */
+declare const _default: (client: any) => PrismaDefault.PrismaClientExtends<Types.Extensions.InternalArgs<{}, {
     $allModels: {
-        aggregate: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        count: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findFirst: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findFirstOrThrow: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findMany: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findUnique: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findUniqueOrThrow: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        groupBy: (params: {
-            model?: string | undefined;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
+        aggregate<T, A>(this: T, args: Prisma.Exact<A, Prisma.Args<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T, A, "aggregate">>;
+        count<T_1, A_1>(this: T_1, args?: Prisma.Exact<A_1, Prisma.Args<T_1, "count"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_1, A_1, "count">>;
+        findFirst<T_2, A_2>(this: T_2, args?: Prisma.Exact<A_2, Prisma.Args<T_2, "findFirst"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_2, A_2, "findFirst"> | null>;
+        findFirstOrThrow<T_3, A_3>(this: T_3, args?: Prisma.Exact<A_3, Prisma.Args<T_3, "findFirstOrThrow"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_3, A_3, "findFirstOrThrow">>;
+        findMany<T_4, A_4>(this: T_4, args?: Prisma.Exact<A_4, Prisma.Args<T_4, "findMany"> & PrismaCacheStrategy> | undefined): AcceleratePromise<Prisma.Result<T_4, A_4, "findMany">>;
+        findUnique<T_5, A_5>(this: T_5, args: Prisma.Exact<A_5, Prisma.Args<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_5, A_5, "findUnique"> | null>;
+        findUniqueOrThrow<T_6, A_6>(this: T_6, args: Prisma.Exact<A_6, Prisma.Args<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_6, A_6, "findUniqueOrThrow">>;
+        groupBy<T_7, A_7>(this: T_7, args: Prisma.Exact<A_7, Prisma.Args<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_7, A_7, "groupBy">>;
     };
-}, {}> & Types.Extensions.DefaultArgs>;
+}, {}, {}> & Types.Extensions.InternalArgs<{}, {}, {}, {}> & Types.Extensions.DefaultArgs>;
 export default _default;

dist/cjs/index.js

@@ -6,2 +6,4 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAccelerate = void 0;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 /// <reference lib="dom" />
@@ -73,116 +75,121 @@ // importing default is needed for ESM compatibility
 }
-exports.default = default_index_js_1.default.Prisma.defineExtension((client) => {
-    const withCacheHeaders = makeWithCacheHeaders();
-    const xclient = client.$extends({
-        name: EXTENSION_NAME,
-        query: {
-            $allModels: {
-                aggregate: withCacheHeaders,
-                count: withCacheHeaders,
-                findFirst: withCacheHeaders,
-                findFirstOrThrow: withCacheHeaders,
-                findMany: withCacheHeaders,
-                findUnique: withCacheHeaders,
-                findUniqueOrThrow: withCacheHeaders,
-                groupBy: withCacheHeaders,
+function withAccelerate() {
+    return default_index_js_1.default.Prisma.defineExtension((client) => {
+        const withCacheHeaders = makeWithCacheHeaders();
+        const xclient = client.$extends({
+            name: EXTENSION_NAME,
+            query: {
+                $allModels: {
+                    aggregate: withCacheHeaders,
+                    count: withCacheHeaders,
+                    findFirst: withCacheHeaders,
+                    findFirstOrThrow: withCacheHeaders,
+                    findMany: withCacheHeaders,
+                    findUnique: withCacheHeaders,
+                    findUniqueOrThrow: withCacheHeaders,
+                    groupBy: withCacheHeaders,
+                },
             },
-        },
-    });
-    return xclient.$extends({
-        name: EXTENSION_NAME,
-        model: {
-            $allModels: {
-                // TODO: these functions are repetitive. Is there a type we can use to generic this?
-                // TODO: can we define these in a map that ensures query and model overrides stay in sync/
-                aggregate(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].aggregate(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].aggregate({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
+        });
+        return xclient.$extends({
+            name: EXTENSION_NAME,
+            model: {
+                $allModels: {
+                    // TODO: these functions are repetitive. Is there a type we can use to generic this?
+                    // TODO: can we define these in a map that ensures query and model overrides stay in sync/
+                    aggregate(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].aggregate(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].aggregate({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    count(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].count(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].count({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findFirst(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findFirst(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findFirst({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findFirstOrThrow(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findFirstOrThrow(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findFirstOrThrow({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findMany(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findMany(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findMany({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findUnique(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findUnique(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findUnique({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findUniqueOrThrow(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findUniqueOrThrow(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findUniqueOrThrow({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    groupBy(args) {
+                        const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].groupBy(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].groupBy({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
                 },
-                count(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].count(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].count({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findFirst(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findFirst(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findFirst({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findFirstOrThrow(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findFirstOrThrow(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findFirstOrThrow({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findMany(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findMany(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findMany({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findUnique(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findUnique(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findUnique({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findUniqueOrThrow(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findUniqueOrThrow(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findUniqueOrThrow({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                groupBy(args) {
-                    const ctx = default_index_js_1.default.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].groupBy(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].groupBy({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
             },
-        },
+        });
     });
-});
+}
+exports.withAccelerate = withAccelerate;
+/** @deprecated The default export has been replaced by `withAccelerate`. */
+exports.default = withAccelerate();

dist/esm/index.d.ts

 /// <reference lib="dom" />
 import PrismaDefault, { type Prisma } from "@prisma/client/scripts/default-index.js";
-import type { Types } from "@prisma/client/runtime";
+import type { Types } from "@prisma/client/runtime/library.js";
 export interface PrismaCacheStrategy {
@@ -83,65 +83,27 @@ /**
 }
-declare const _default: (client: any) => PrismaDefault.PrismaClientExtends<Types.Extensions.InternalArgs<{}, {
+export declare function withAccelerate(): (client: any) => PrismaDefault.PrismaClientExtends<Types.Extensions.InternalArgs<{}, {
     $allModels: {
-        aggregate<T, A>(this: T, args: Prisma.Exact<A, Types.Public.Args<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T, A, "aggregate">>;
-        count<T_1, A_1>(this: T_1, args?: Prisma.Exact<A_1, Types.Public.Args<T_1, "count"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_1, A_1, "count">>;
-        findFirst<T_2, A_2>(this: T_2, args?: Prisma.Exact<A_2, Types.Public.Args<T_2, "findFirst"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_2, A_2, "findFirst">>;
-        findFirstOrThrow<T_3, A_3>(this: T_3, args?: Prisma.Exact<A_3, Types.Public.Args<T_3, "findFirstOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_3, A_3, "findFirstOrThrow">>;
-        findMany<T_4, A_4>(this: T_4, args?: Prisma.Exact<A_4, Types.Public.Args<T_4, "findMany"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_4, A_4, "findMany">>;
-        findUnique<T_5, A_5>(this: T_5, args: Prisma.Exact<A_5, Types.Public.Args<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_5, A_5, "findUnique">>;
-        findUniqueOrThrow<T_6, A_6>(this: T_6, args: Prisma.Exact<A_6, Types.Public.Args<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_6, A_6, "findUniqueOrThrow">>;
-        groupBy<T_7, A_7>(this: T_7, args: Prisma.Exact<A_7, Types.Public.Args<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_7, A_7, "groupBy">>;
+        aggregate<T, A>(this: T, args: Prisma.Exact<A, Prisma.Args<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T, A, "aggregate">>;
+        count<T_1, A_1>(this: T_1, args?: Prisma.Exact<A_1, Prisma.Args<T_1, "count"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_1, A_1, "count">>;
+        findFirst<T_2, A_2>(this: T_2, args?: Prisma.Exact<A_2, Prisma.Args<T_2, "findFirst"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_2, A_2, "findFirst">>;
+        findFirstOrThrow<T_3, A_3>(this: T_3, args?: Prisma.Exact<A_3, Prisma.Args<T_3, "findFirstOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_3, A_3, "findFirstOrThrow">>;
+        findMany<T_4, A_4>(this: T_4, args?: Prisma.Exact<A_4, Prisma.Args<T_4, "findMany"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_4, A_4, "findMany">>;
+        findUnique<T_5, A_5>(this: T_5, args: Prisma.Exact<A_5, Prisma.Args<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_5, A_5, "findUnique">>;
+        findUniqueOrThrow<T_6, A_6>(this: T_6, args: Prisma.Exact<A_6, Prisma.Args<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_6, A_6, "findUniqueOrThrow">>;
+        groupBy<T_7, A_7>(this: T_7, args: Prisma.Exact<A_7, Prisma.Args<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_7, A_7, "groupBy">>;
     };
-}, {}, {}> & Types.Extensions.InternalArgs<{}, {}, {
+}, {}, {}> & Types.Extensions.InternalArgs<{}, {}, {}, {}> & Types.Extensions.DefaultArgs>;
+/** @deprecated The default export has been replaced by `withAccelerate`. */
+declare const _default: (client: any) => PrismaDefault.PrismaClientExtends<Types.Extensions.InternalArgs<{}, {
     $allModels: {
-        aggregate: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        count: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findFirst: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findFirstOrThrow: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findMany: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findUnique: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        findUniqueOrThrow: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
-        groupBy: (params: {
-            model?: string;
-            operation: string;
-            args: object;
-            query: (args: object) => Promise<unknown>;
-        }) => Promise<any>;
+        aggregate<T, A>(this: T, args: Prisma.Exact<A, Prisma.Args<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T, A, "aggregate">>;
+        count<T_1, A_1>(this: T_1, args?: Prisma.Exact<A_1, Prisma.Args<T_1, "count"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_1, A_1, "count">>;
+        findFirst<T_2, A_2>(this: T_2, args?: Prisma.Exact<A_2, Prisma.Args<T_2, "findFirst"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_2, A_2, "findFirst">>;
+        findFirstOrThrow<T_3, A_3>(this: T_3, args?: Prisma.Exact<A_3, Prisma.Args<T_3, "findFirstOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_3, A_3, "findFirstOrThrow">>;
+        findMany<T_4, A_4>(this: T_4, args?: Prisma.Exact<A_4, Prisma.Args<T_4, "findMany"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_4, A_4, "findMany">>;
+        findUnique<T_5, A_5>(this: T_5, args: Prisma.Exact<A_5, Prisma.Args<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_5, A_5, "findUnique">>;
+        findUniqueOrThrow<T_6, A_6>(this: T_6, args: Prisma.Exact<A_6, Prisma.Args<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_6, A_6, "findUniqueOrThrow">>;
+        groupBy<T_7, A_7>(this: T_7, args: Prisma.Exact<A_7, Prisma.Args<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<Prisma.Result<T_7, A_7, "groupBy">>;
     };
-}, {}> & Types.Extensions.DefaultArgs>;
+}, {}, {}> & Types.Extensions.InternalArgs<{}, {}, {}, {}> & Types.Extensions.DefaultArgs>;
 export default _default;

dist/esm/index.js

@@ -0,1 +1,2 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 /// <reference lib="dom" />
@@ -67,116 +68,120 @@ // importing default is needed for ESM compatibility
 }
-export default PrismaDefault.Prisma.defineExtension((client) => {
-    const withCacheHeaders = makeWithCacheHeaders();
-    const xclient = client.$extends({
-        name: EXTENSION_NAME,
-        query: {
-            $allModels: {
-                aggregate: withCacheHeaders,
-                count: withCacheHeaders,
-                findFirst: withCacheHeaders,
-                findFirstOrThrow: withCacheHeaders,
-                findMany: withCacheHeaders,
-                findUnique: withCacheHeaders,
-                findUniqueOrThrow: withCacheHeaders,
-                groupBy: withCacheHeaders,
+export function withAccelerate() {
+    return PrismaDefault.Prisma.defineExtension((client) => {
+        const withCacheHeaders = makeWithCacheHeaders();
+        const xclient = client.$extends({
+            name: EXTENSION_NAME,
+            query: {
+                $allModels: {
+                    aggregate: withCacheHeaders,
+                    count: withCacheHeaders,
+                    findFirst: withCacheHeaders,
+                    findFirstOrThrow: withCacheHeaders,
+                    findMany: withCacheHeaders,
+                    findUnique: withCacheHeaders,
+                    findUniqueOrThrow: withCacheHeaders,
+                    groupBy: withCacheHeaders,
+                },
             },
-        },
-    });
-    return xclient.$extends({
-        name: EXTENSION_NAME,
-        model: {
-            $allModels: {
-                // TODO: these functions are repetitive. Is there a type we can use to generic this?
-                // TODO: can we define these in a map that ensures query and model overrides stay in sync/
-                aggregate(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].aggregate(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].aggregate({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
+        });
+        return xclient.$extends({
+            name: EXTENSION_NAME,
+            model: {
+                $allModels: {
+                    // TODO: these functions are repetitive. Is there a type we can use to generic this?
+                    // TODO: can we define these in a map that ensures query and model overrides stay in sync/
+                    aggregate(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].aggregate(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].aggregate({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    count(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].count(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].count({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findFirst(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findFirst(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findFirst({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findFirstOrThrow(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findFirstOrThrow(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findFirstOrThrow({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findMany(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findMany(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findMany({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findUnique(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findUnique(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findUnique({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    findUniqueOrThrow(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].findUniqueOrThrow(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].findUniqueOrThrow({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
+                    groupBy(args) {
+                        const ctx = PrismaDefault.Prisma.getExtensionContext(this);
+                        return Object.assign(xclient[ctx.name].groupBy(args), {
+                            withAccelerateInfo() {
+                                return xclient[ctx.name].groupBy({
+                                    ...args,
+                                    __accelerateInfo: true,
+                                });
+                            },
+                        });
+                    },
                 },
-                count(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].count(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].count({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findFirst(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findFirst(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findFirst({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findFirstOrThrow(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findFirstOrThrow(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findFirstOrThrow({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findMany(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findMany(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findMany({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findUnique(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findUnique(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findUnique({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                findUniqueOrThrow(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].findUniqueOrThrow(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].findUniqueOrThrow({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
-                groupBy(args) {
-                    const ctx = PrismaDefault.Prisma.getExtensionContext(this);
-                    return Object.assign(xclient[ctx.name].groupBy(args), {
-                        withAccelerateInfo() {
-                            return xclient[ctx.name].groupBy({
-                                ...args,
-                                __accelerateInfo: true,
-                            });
-                        },
-                    });
-                },
             },
-        },
+        });
     });
-});
+}
+/** @deprecated The default export has been replaced by `withAccelerate`. */
+export default withAccelerate();

package.json

 {
   "name": "@prisma/extension-accelerate",
   "type": "module",
-  "version": "0.0.0-experimental-8af16bf",
+  "version": "0.0.0-experimental-8b03dde",
   "description": "Prisma Client extension for Accelerate",
@@ -26,4 +26,3 @@ "sideEffects": false,
   "devDependencies": {
-    "prisma": "^4.11.0",
-    "@prisma/client": "^4.11.0",
+    "@prisma/client": "^4.16.1",
     "@tsconfig/esm": "^1.0.2",
@@ -37,2 +36,3 @@ "@tsconfig/node14": "^1.0.3",
     "prettier": "2.8.1",
+    "prisma": "^4.16.1",
     "ts-node": "^10.9.1",
@@ -42,4 +42,4 @@ "typescript": "^4.9.4"
   "peerDependencies": {
-    "@prisma/client": ">=4.10.0"
+    "@prisma/client": ">=4.16.1"
   }
 }

No alert changes

Improved metrics

Total package byte prevSize

33725

increased by4.73%

Worsened metrics

Lines of code

595

decreased by-9.71%

No dependency changes