@cedarjs/storage 0.0.4

package/dist/cjs/prismaExtension.js

@@ -0,0 +1,240 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prismaExtension_exports = {};
+__export(prismaExtension_exports, {
+  createUploadsExtension: () => createUploadsExtension
+});
+module.exports = __toCommonJS(prismaExtension_exports);
+var import_client = require("@prisma/client");
+var import_extension = require("@prisma/client/extension");
+var import_fileToDataUri = require("./fileToDataUri.js");
+const createUploadsExtension = (config, storageAdapter, urlSigner) => {
+  const prismaInstance = new import_client.PrismaClient();
+  const queryExtends = {};
+  const resultExtends = {};
+  for (const modelName in config) {
+    const modelConfig = config[modelName];
+    if (!modelConfig) {
+      continue;
+    }
+    const uploadFields = Array.isArray(modelConfig.fields) ? modelConfig.fields : [modelConfig.fields];
+    queryExtends[modelName] = {
+      async create({ query, args }) {
+        try {
+          const result = await query(args);
+          return result;
+        } catch (e) {
+          await removeUploadedFiles(
+            uploadFields,
+            args.data
+          );
+          throw e;
+        }
+      },
+      async createMany({ query, args }) {
+        try {
+          const result = await query(args);
+          return result;
+        } catch (e) {
+          const createDatas = args.data;
+          for (const createData of createDatas) {
+            await removeUploadedFiles(uploadFields, createData);
+          }
+          throw e;
+        }
+      },
+      async update({ query, model, args }) {
+        const uploadFieldsToUpdate = uploadFields.filter(
+          (field) => (
+            // All of this non-sense is to make typescript happy. I'm not sure how data could be anything but an object
+            typeof args.data === "object" && args.data !== null && field in args.data
+          )
+        );
+        if (uploadFieldsToUpdate.length == 0) {
+          return query(args);
+        } else {
+          const originalRecord = await prismaInstance[
+            model
+            // @ts-expect-error TS in strict mode will error due to union type. We cannot narrow it down here.
+          ].findFirstOrThrow({
+            where: args.where
+            // @TODO: should we select here to reduce the amount of data we're handling
+          });
+          try {
+            const result = await query(args);
+            await removeUploadedFiles(uploadFieldsToUpdate, originalRecord);
+            return result;
+          } catch (e) {
+            await removeUploadedFiles(
+              uploadFieldsToUpdate,
+              args.data
+            );
+            throw e;
+          }
+        }
+      },
+      async updateMany({ query, model, args }) {
+        const uploadFieldsToUpdate = uploadFields.filter(
+          (field) => (
+            // All of this non-sense is to make typescript happy. I'm not sure how data could be anything but an object
+            typeof args.data === "object" && args.data !== null && field in args.data
+          )
+        );
+        if (uploadFieldsToUpdate.length == 0) {
+          return query(args);
+        } else {
+          const originalRecords = await prismaInstance[
+            model
+            // @ts-expect-error TS in strict mode will error due to union type. We cannot narrow it down here.
+          ].findMany({
+            where: args.where
+            // @TODO: should we select here to reduce the amount of data we're handling
+          });
+          try {
+            const result = await query(args);
+            for await (const originalRecord of originalRecords) {
+              await removeUploadedFiles(uploadFieldsToUpdate, originalRecord);
+            }
+            return result;
+          } catch (e) {
+            await removeUploadedFiles(
+              uploadFieldsToUpdate,
+              args.data
+            );
+            throw e;
+          }
+        }
+      },
+      async upsert({ query, model, args }) {
+        let isUpdate;
+        const uploadFieldsToUpdate = uploadFields.filter(
+          (field) => typeof args.update === "object" && args.update !== null && field in args.update
+        );
+        try {
+          let existingRecord;
+          if (args.update) {
+            existingRecord = await prismaInstance[
+              model
+              // @ts-expect-error TS in strict mode will error due to union type. We cannot narrow it down here.
+            ].findUnique({
+              where: args.where
+            });
+            isUpdate = !!existingRecord;
+          }
+          const result = await query(args);
+          if (isUpdate && existingRecord) {
+            await removeUploadedFiles(uploadFieldsToUpdate, existingRecord);
+          }
+          return result;
+        } catch (e) {
+          await removeUploadedFiles(
+            // Only delete files we're updating on update
+            isUpdate ? uploadFieldsToUpdate : uploadFields,
+            isUpdate ? args.update : args.create
+          );
+          throw e;
+        }
+      },
+      async delete({ query, args }) {
+        const deleteResult = await query(args);
+        await removeUploadedFiles(
+          uploadFields,
+          // We don't know the exact type here
+          deleteResult
+        );
+        return deleteResult;
+      }
+    };
+    const needs = Object.fromEntries(uploadFields.map((field) => [field, true]));
+    resultExtends[modelName] = {
+      withDataUri: {
+        needs,
+        compute(modelData) {
+          return async () => {
+            const base64UploadFields = {};
+            for (const field of uploadFields) {
+              base64UploadFields[field] = await (0, import_fileToDataUri.fileToDataUri)(
+                modelData[field],
+                storageAdapter
+              );
+            }
+            return {
+              // modelData is of type unknown at this point
+              ...modelData,
+              ...base64UploadFields
+            };
+          };
+        }
+      },
+      withSignedUrl: {
+        needs,
+        compute(modelData) {
+          return ({ expiresIn } = {}) => {
+            if (!urlSigner) {
+              throw new Error(
+                "Please supply signed url settings in setupUpload()"
+              );
+            }
+            const signedUrlFields = {};
+            for (const field of uploadFields) {
+              if (!modelData[field]) {
+                continue;
+              }
+              signedUrlFields[field] = urlSigner.generateSignedUrl(
+                modelData[field],
+                expiresIn
+              );
+            }
+            return {
+              // modelData is of type unknown at this point
+              ...modelData,
+              ...signedUrlFields
+            };
+          };
+        }
+      }
+    };
+  }
+  return import_extension.Prisma.defineExtension((client) => {
+    return client.$extends({
+      name: "redwood-upload-prisma-plugin",
+      query: queryExtends,
+      result: resultExtends
+    });
+  });
+  async function removeUploadedFiles(fieldsToDelete, data) {
+    if (!data) {
+      console.warn("Empty data object passed to removeUploadedFiles");
+      return;
+    }
+    for (const field of fieldsToDelete) {
+      const uploadLocation = data?.[field];
+      if (uploadLocation) {
+        try {
+          await storageAdapter.remove(uploadLocation);
+        } catch {
+        }
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUploadsExtension
+});

package/dist/createSavers.d.ts

@@ -0,0 +1,15 @@
+import type { SaveOptionsOverride, BaseStorageAdapter } from './adapters/BaseStorageAdapter.js';
+import type { ModelNames, UploadsConfig } from './prismaExtension.js';
+type MakeFilesString<T> = {
+    [K in keyof T]: T[K] extends File ? string : T[K];
+};
+export declare const createFileListSaver: (storage: BaseStorageAdapter) => (files?: File[], pathOverrideOnly?: {
+    path?: string;
+}) => Promise<string[]>;
+export declare const createUploadSavers: <MNames extends ModelNames = ModelNames>(uploadConfig: UploadsConfig<MNames>, storage: BaseStorageAdapter) => { [K in `for${Capitalize<MNames>}`]: <T extends Record<string, any>>(data: T, overrideSaveOptions?: SaveOptionsOverride) => Promise<MakeFilesString<T>>; } & {
+    inList: (files?: File[], pathOverrideOnly?: {
+        path?: string;
+    }) => Promise<string[]>;
+};
+export {};
+//# sourceMappingURL=createSavers.d.ts.map

package/dist/createSavers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSavers.d.ts","sourceRoot":"","sources":["../src/createSavers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAGrE,KAAK,eAAe,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;CAClD,CAAA;AAED,eAAO,MAAM,mBAAmB,YAAa,kBAAkB,cACxC,IAAI,EAAE,qBAA0B;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,sBAUvE,CAAA;AAMD,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,UAAU,6BAC5C,aAAa,CAAC,MAAM,CAAC,WAC1B,kBAAkB,QAMxB,CAAC,kCAAwB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QAC/C,CAAC,wBACe,mBAAmB,KACtC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;qBA3Bb,IAAI,EAAE,qBAA0B;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;CA2EvE,CAAA"}

package/dist/createSavers.js

@@ -0,0 +1,50 @@
+import { ulid } from "ulid";
+const createFileListSaver = (storage) => {
+  return async (files = [], pathOverrideOnly) => {
+    const locations = await Promise.all(
+      files.map(async (file) => {
+        const { location } = await storage.save(file, pathOverrideOnly);
+        return location;
+      })
+    );
+    return locations;
+  };
+};
+const createUploadSavers = (uploadConfig, storage) => {
+  const savers = {};
+  Object.keys(uploadConfig).forEach((model) => {
+    const modelKey = model;
+    const currentModelConfig = uploadConfig[modelKey];
+    if (!currentModelConfig) {
+      return;
+    }
+    const currentModelUploadFields = Array.isArray(currentModelConfig.fields) ? currentModelConfig.fields : [currentModelConfig.fields];
+    const capitalCaseModel = `${model.charAt(0).toUpperCase() + model.slice(1)}`;
+    const saverKey = `for${capitalCaseModel}`;
+    savers[saverKey] = async (data, overrideSaveOptions) => {
+      const updatedFields = {};
+      for (const field of currentModelUploadFields) {
+        if (data[field]) {
+          const file = data[field];
+          const saveOptions = overrideSaveOptions || {
+            fileName: `${model}-${field}-${ulid()}`
+          };
+          const { location } = await storage.save(file, saveOptions);
+          updatedFields[field] = location;
+        }
+      }
+      return {
+        ...data,
+        ...updatedFields
+      };
+    };
+  });
+  return {
+    ...savers,
+    inList: createFileListSaver(storage)
+  };
+};
+export {
+  createFileListSaver,
+  createUploadSavers
+};

package/dist/fileToDataUri.d.ts

@@ -0,0 +1,3 @@
+import type { BaseStorageAdapter } from './adapters/BaseStorageAdapter.js';
+export declare function fileToDataUri(filePath: string, storage: BaseStorageAdapter): Promise<string>;
+//# sourceMappingURL=fileToDataUri.d.ts.map

package/dist/fileToDataUri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileToDataUri.d.ts","sourceRoot":"","sources":["../src/fileToDataUri.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAE1E,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,mBAO5B"}

package/dist/fileToDataUri.js

@@ -0,0 +1,8 @@
+async function fileToDataUri(filePath, storage) {
+  const { contents, type: mimeType } = await storage.read(filePath);
+  const base64Data = Buffer.from(contents).toString("base64");
+  return `data:${mimeType};base64,${base64Data}`;
+}
+export {
+  fileToDataUri
+};

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import type { BaseStorageAdapter } from './adapters/BaseStorageAdapter.js';
+import type { ModelNames, UploadConfigForModel, UploadsConfig } from './prismaExtension.js';
+import type { UrlSigner } from './UrlSigner.js';
+type SetupStorageOptions<MNames extends ModelNames> = {
+    uploadsConfig: UploadsConfig<MNames>;
+    storageAdapter: BaseStorageAdapter;
+    urlSigner?: UrlSigner;
+};
+export declare const setupStorage: <MNames extends ModelNames>({ uploadsConfig, storageAdapter, urlSigner, }: SetupStorageOptions<MNames>) => {
+    storagePrismaExtension: (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{ [K in MNames]: {
+        withDataUri: {
+            needs: Record<string, boolean>;
+            compute: (modelData: Record<string, unknown>) => <T>(this: T) => Promise<T>;
+        };
+        withSignedUrl: {
+            needs: Record<string, boolean>;
+            compute: (modelData: Record<string, unknown>) => <T>(this: T, signArgs?: {
+                expiresIn?: number;
+            }) => T;
+        };
+    }; }, {}, {}, {}> & import("@prisma/client/runtime/library").DefaultArgs>;
+    saveFiles: { [K in `for${Capitalize<MNames>}`]: <T extends Record<string, any>>(data: T, overrideSaveOptions?: import("./adapters/BaseStorageAdapter.js").SaveOptionsOverride) => Promise<{ [K_1 in keyof T]: T[K_1] extends File ? string : T[K_1]; }>; } & {
+        inList: (files?: File[], pathOverrideOnly?: {
+            path?: string;
+        }) => Promise<string[]>;
+    };
+};
+/**
+ * This utility function ensures that you receive accurate type suggestions for your savers.
+ * If you use the type UploadsConfig directly, you may receive suggestions for saveFiles.forY where Y hasn't been configured.
+ * By using this utility function, you will only receive suggestions for the models that you have configured.
+ *
+ * @param uploadsConfig The uploads configuration object.
+ * @returns The same uploads configuration object, but with filtered types
+ */
+export declare function createUploadsConfig<T extends Partial<{
+    [K in ModelNames]?: UploadConfigForModel<K>;
+}>>(uploadsConfig: T): T;
+export type { ModelNames, UploadsConfig } from './prismaExtension.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAE1E,OAAO,KAAK,EACV,UAAU,EACV,oBAAoB,EACpB,aAAa,EACd,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,KAAK,mBAAmB,CAAC,MAAM,SAAS,UAAU,IAAI;IACpD,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACpC,cAAc,EAAE,kBAAkB,CAAA;IAClC,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,MAAM,SAAS,UAAU,iDAInD,mBAAmB,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;gBARV,CAAC;;;CAqBpB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,SAAS,OAAO,CAAC;KACf,CAAC,IAAI,UAAU,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC;CAC5C,CAAC,EACF,aAAa,EAAE,CAAC,GAAG,CAAC,CAErB;AAED,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,25 @@
+import { createUploadSavers } from "./createSavers.js";
+import { createUploadsExtension } from "./prismaExtension.js";
+const setupStorage = ({
+  uploadsConfig,
+  storageAdapter,
+  urlSigner
+}) => {
+  const prismaExtension = createUploadsExtension(
+    uploadsConfig,
+    storageAdapter,
+    urlSigner
+  );
+  const saveFiles = createUploadSavers(uploadsConfig, storageAdapter);
+  return {
+    storagePrismaExtension: prismaExtension,
+    saveFiles
+  };
+};
+function createUploadsConfig(uploadsConfig) {
+  return uploadsConfig;
+}
+export {
+  createUploadsConfig,
+  setupStorage
+};

package/dist/prismaExtension.d.ts

@@ -0,0 +1,29 @@
+import { PrismaClient } from '@prisma/client';
+import type { Prisma } from '@prisma/client';
+import type * as runtime from '@prisma/client/runtime/library';
+import type { BaseStorageAdapter } from './adapters/BaseStorageAdapter.js';
+import type { UrlSigner } from './UrlSigner.js';
+type FilterOutDollarPrefixed<T> = T extends `$${string}` ? never : T extends symbol ? never : T;
+export type ModelNames = FilterOutDollarPrefixed<keyof PrismaClient>;
+type PrismaModelFields<MName extends ModelNames> = keyof Prisma.Result<PrismaClient[MName], any, 'findFirstOrThrow'>;
+export type UploadConfigForModel<TPrismaModelName extends ModelNames> = {
+    fields: PrismaModelFields<TPrismaModelName> | PrismaModelFields<TPrismaModelName>[];
+};
+export type UploadsConfig<MNames extends ModelNames = ModelNames> = {
+    [K in MNames]?: UploadConfigForModel<K>;
+};
+type WithSignedUrlArgs = {
+    expiresIn?: number;
+};
+export declare const createUploadsExtension: <MNames extends ModelNames = ModelNames>(config: UploadsConfig<MNames>, storageAdapter: BaseStorageAdapter, urlSigner?: UrlSigner) => (client: any) => import("@prisma/client/extension").PrismaClientExtends<runtime.InternalArgs<{ [K in MNames]: {
+    withDataUri: {
+        needs: Record<string, boolean>;
+        compute: (modelData: Record<string, unknown>) => <T>(this: T) => Promise<T>;
+    };
+    withSignedUrl: {
+        needs: Record<string, boolean>;
+        compute: (modelData: Record<string, unknown>) => <T>(this: T, signArgs?: WithSignedUrlArgs) => T;
+    };
+}; }, {}, {}, {}> & runtime.DefaultArgs>;
+export {};
+//# sourceMappingURL=prismaExtension.d.ts.map

package/dist/prismaExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prismaExtension.d.ts","sourceRoot":"","sources":["../src/prismaExtension.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAO,KAAK,KAAK,OAAO,MAAM,gCAAgC,CAAA;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAE1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,EAAE,GACpD,KAAK,GACL,CAAC,SAAS,MAAM,GACd,KAAK,GACL,CAAC,CAAA;AAGP,MAAM,MAAM,UAAU,GAAG,uBAAuB,CAAC,MAAM,YAAY,CAAC,CAAA;AAEpE,KAAK,iBAAiB,CAAC,KAAK,SAAS,UAAU,IAAI,MAAM,MAAM,CAAC,MAAM,CACpE,YAAY,CAAC,KAAK,CAAC,EACnB,GAAG,EACH,kBAAkB,CACnB,CAAA;AAED,MAAM,MAAM,oBAAoB,CAAC,gBAAgB,SAAS,UAAU,IAAI;IACtE,MAAM,EACF,iBAAiB,CAAC,gBAAgB,CAAC,GACnC,iBAAiB,CAAC,gBAAgB,CAAC,EAAE,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,aAAa,CAAC,MAAM,SAAS,UAAU,GAAG,UAAU,IAAI;KACjE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC;CACxC,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,MAAM,SAAS,UAAU,uBACtD,aAAa,CAAC,MAAM,CAAC,kBACb,kBAAkB,cACtB,SAAS,qGAOlB,CAAC;iBACa;QACX,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC9B,OAAO,EAAE,CACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC/B,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;KAChC;mBACc;QACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC9B,OAAO,EAAE,CACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC/B,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,iBAAiB,KAAK,CAAC,CAAA;KACrD;wCA4RN,CAAA"}

package/dist/prismaExtension.js

@@ -0,0 +1,216 @@
+import { PrismaClient } from "@prisma/client";
+import { Prisma as PrismaExtension } from "@prisma/client/extension";
+import { fileToDataUri } from "./fileToDataUri.js";
+const createUploadsExtension = (config, storageAdapter, urlSigner) => {
+  const prismaInstance = new PrismaClient();
+  const queryExtends = {};
+  const resultExtends = {};
+  for (const modelName in config) {
+    const modelConfig = config[modelName];
+    if (!modelConfig) {
+      continue;
+    }
+    const uploadFields = Array.isArray(modelConfig.fields) ? modelConfig.fields : [modelConfig.fields];
+    queryExtends[modelName] = {
+      async create({ query, args }) {
+        try {
+          const result = await query(args);
+          return result;
+        } catch (e) {
+          await removeUploadedFiles(
+            uploadFields,
+            args.data
+          );
+          throw e;
+        }
+      },
+      async createMany({ query, args }) {
+        try {
+          const result = await query(args);
+          return result;
+        } catch (e) {
+          const createDatas = args.data;
+          for (const createData of createDatas) {
+            await removeUploadedFiles(uploadFields, createData);
+          }
+          throw e;
+        }
+      },
+      async update({ query, model, args }) {
+        const uploadFieldsToUpdate = uploadFields.filter(
+          (field) => (
+            // All of this non-sense is to make typescript happy. I'm not sure how data could be anything but an object
+            typeof args.data === "object" && args.data !== null && field in args.data
+          )
+        );
+        if (uploadFieldsToUpdate.length == 0) {
+          return query(args);
+        } else {
+          const originalRecord = await prismaInstance[
+            model
+            // @ts-expect-error TS in strict mode will error due to union type. We cannot narrow it down here.
+          ].findFirstOrThrow({
+            where: args.where
+            // @TODO: should we select here to reduce the amount of data we're handling
+          });
+          try {
+            const result = await query(args);
+            await removeUploadedFiles(uploadFieldsToUpdate, originalRecord);
+            return result;
+          } catch (e) {
+            await removeUploadedFiles(
+              uploadFieldsToUpdate,
+              args.data
+            );
+            throw e;
+          }
+        }
+      },
+      async updateMany({ query, model, args }) {
+        const uploadFieldsToUpdate = uploadFields.filter(
+          (field) => (
+            // All of this non-sense is to make typescript happy. I'm not sure how data could be anything but an object
+            typeof args.data === "object" && args.data !== null && field in args.data
+          )
+        );
+        if (uploadFieldsToUpdate.length == 0) {
+          return query(args);
+        } else {
+          const originalRecords = await prismaInstance[
+            model
+            // @ts-expect-error TS in strict mode will error due to union type. We cannot narrow it down here.
+          ].findMany({
+            where: args.where
+            // @TODO: should we select here to reduce the amount of data we're handling
+          });
+          try {
+            const result = await query(args);
+            for await (const originalRecord of originalRecords) {
+              await removeUploadedFiles(uploadFieldsToUpdate, originalRecord);
+            }
+            return result;
+          } catch (e) {
+            await removeUploadedFiles(
+              uploadFieldsToUpdate,
+              args.data
+            );
+            throw e;
+          }
+        }
+      },
+      async upsert({ query, model, args }) {
+        let isUpdate;
+        const uploadFieldsToUpdate = uploadFields.filter(
+          (field) => typeof args.update === "object" && args.update !== null && field in args.update
+        );
+        try {
+          let existingRecord;
+          if (args.update) {
+            existingRecord = await prismaInstance[
+              model
+              // @ts-expect-error TS in strict mode will error due to union type. We cannot narrow it down here.
+            ].findUnique({
+              where: args.where
+            });
+            isUpdate = !!existingRecord;
+          }
+          const result = await query(args);
+          if (isUpdate && existingRecord) {
+            await removeUploadedFiles(uploadFieldsToUpdate, existingRecord);
+          }
+          return result;
+        } catch (e) {
+          await removeUploadedFiles(
+            // Only delete files we're updating on update
+            isUpdate ? uploadFieldsToUpdate : uploadFields,
+            isUpdate ? args.update : args.create
+          );
+          throw e;
+        }
+      },
+      async delete({ query, args }) {
+        const deleteResult = await query(args);
+        await removeUploadedFiles(
+          uploadFields,
+          // We don't know the exact type here
+          deleteResult
+        );
+        return deleteResult;
+      }
+    };
+    const needs = Object.fromEntries(uploadFields.map((field) => [field, true]));
+    resultExtends[modelName] = {
+      withDataUri: {
+        needs,
+        compute(modelData) {
+          return async () => {
+            const base64UploadFields = {};
+            for (const field of uploadFields) {
+              base64UploadFields[field] = await fileToDataUri(
+                modelData[field],
+                storageAdapter
+              );
+            }
+            return {
+              // modelData is of type unknown at this point
+              ...modelData,
+              ...base64UploadFields
+            };
+          };
+        }
+      },
+      withSignedUrl: {
+        needs,
+        compute(modelData) {
+          return ({ expiresIn } = {}) => {
+            if (!urlSigner) {
+              throw new Error(
+                "Please supply signed url settings in setupUpload()"
+              );
+            }
+            const signedUrlFields = {};
+            for (const field of uploadFields) {
+              if (!modelData[field]) {
+                continue;
+              }
+              signedUrlFields[field] = urlSigner.generateSignedUrl(
+                modelData[field],
+                expiresIn
+              );
+            }
+            return {
+              // modelData is of type unknown at this point
+              ...modelData,
+              ...signedUrlFields
+            };
+          };
+        }
+      }
+    };
+  }
+  return PrismaExtension.defineExtension((client) => {
+    return client.$extends({
+      name: "redwood-upload-prisma-plugin",
+      query: queryExtends,
+      result: resultExtends
+    });
+  });
+  async function removeUploadedFiles(fieldsToDelete, data) {
+    if (!data) {
+      console.warn("Empty data object passed to removeUploadedFiles");
+      return;
+    }
+    for (const field of fieldsToDelete) {
+      const uploadLocation = data?.[field];
+      if (uploadLocation) {
+        try {
+          await storageAdapter.remove(uploadLocation);
+        } catch {
+        }
+      }
+    }
+  }
+};
+export {
+  createUploadsExtension
+};