@tulip-systems/core 0.6.1 → 0.8.0

package/src/modules/storage/lib/upload.client.ts

@@ -0,0 +1,156 @@
+import type { StorageRouterInputs, StorageRouterOutputs } from "./procedures.server";
+import type {
+  PresignUploadInput,
+  PresignUploadOutput,
+  SelectStorageAssetSchema,
+} from "./validators";
+
+/**
+ * Upload request
+ */
+export type UploadFileRequest = PresignUploadInput & { file: File };
+export type PrepareUploadInput = Omit<UploadFileRequest, "name" | "contentType" | "size">;
+export type UploadHooks = {
+  beforePresign?: (input: UploadFileRequest) => Promise<void> | void;
+  afterPresign?: (presignResult: PresignUploadOutput) => Promise<void> | void;
+  beforeConfirm?: (presignResult: PresignUploadOutput) => Promise<void> | void;
+  afterConfirm?: (asset: SelectStorageAssetSchema) => Promise<void> | void;
+};
+
+/**
+ * Upload client
+ */
+export type UploadClient = {
+  prepareUpload: (input: PrepareUploadInput) => UploadFileRequest;
+  upload: (input: UploadFileRequest, hooks?: UploadHooks) => Promise<SelectStorageAssetSchema>;
+  deleteAsset: (id: string) => Promise<SelectStorageAssetSchema | null>;
+  deleteAssets: (ids: string[]) => Promise<SelectStorageAssetSchema[]>;
+  restoreAsset: (id: string) => Promise<SelectStorageAssetSchema | null>;
+  restoreAssets: (ids: string[]) => Promise<SelectStorageAssetSchema[]>;
+  purgeAsset: (id: string) => Promise<SelectStorageAssetSchema | null>;
+  purgeAssets: (ids: string[]) => Promise<SelectStorageAssetSchema[]>;
+};
+
+/**
+ * Create upload client props
+ */
+type CreateStorageClientProps = {
+  endpoints: {
+    presign: (input: StorageRouterInputs["presign"]) => Promise<StorageRouterOutputs["presign"]>;
+    confirm: (uploadId: StorageRouterInputs["confirm"]) => Promise<StorageRouterOutputs["confirm"]>;
+    deleteAssets: (
+      ids: StorageRouterInputs["deleteAssets"],
+    ) => Promise<StorageRouterOutputs["deleteAssets"]>;
+    deleteAsset: (
+      id: StorageRouterInputs["deleteAsset"],
+    ) => Promise<StorageRouterOutputs["deleteAsset"]>;
+    restoreAsset: (
+      id: StorageRouterInputs["restoreAsset"],
+    ) => Promise<StorageRouterOutputs["restoreAsset"]>;
+    restoreAssets: (
+      ids: StorageRouterInputs["restoreAssets"],
+    ) => Promise<StorageRouterOutputs["restoreAssets"]>;
+    purgeAsset: (
+      id: StorageRouterInputs["purgeAsset"],
+    ) => Promise<StorageRouterOutputs["purgeAsset"]>;
+    purgeAssets: (
+      ids: StorageRouterInputs["purgeAssets"],
+    ) => Promise<StorageRouterOutputs["purgeAssets"]>;
+  };
+};
+
+/**
+ * Creates an upload client for the storage module.
+ *
+ * Flow:
+ * - Prepare upload payload with generated id and resolved key
+ * - Request presigned upload URL from server
+ * - Upload file bytes directly to object storage
+ * - Confirm upload and receive finalized storage asset
+ */
+export function createUploadClient(props: CreateStorageClientProps): UploadClient {
+  /**
+   * Create input schema for the upload method
+   * @param {PrepareUploadInput} input
+   * @returns {UploadFileRequest}
+   */
+  function prepareUpload(input: PrepareUploadInput): UploadFileRequest {
+    return {
+      ...input,
+      uploadId: input.uploadId ?? crypto.randomUUID(),
+      name: input.file.name,
+      size: input.file.size,
+      contentType: input.file.type || "application/octet-stream",
+    };
+  }
+
+  /**
+   * Upload file to the server
+   * @param {UploadFileRequest} input
+   * @returns {Promise<SelectStorageAssetSchema>}
+   */
+  async function upload(
+    input: UploadFileRequest,
+    hooks?: UploadHooks,
+  ): Promise<SelectStorageAssetSchema> {
+    let presignResult: PresignUploadOutput | null = null;
+
+    try {
+      /**
+       * Presign
+       */
+      await hooks?.beforePresign?.(input);
+      presignResult = await props.endpoints.presign(input);
+      await hooks?.afterPresign?.(presignResult);
+
+      /**
+       * Upload the file
+       */
+      const uploadResponse = await fetch(presignResult.presignedUrl, {
+        method: "PUT",
+        headers: { "Content-Type": input.contentType || "application/octet-stream" },
+        body: input.file,
+      });
+
+      if (!uploadResponse.ok) {
+        const message = await uploadResponse.text();
+        throw new Error(`Upload failed: ${message}`);
+      }
+
+      /**
+       * Confirm
+       */
+      await hooks?.beforeConfirm?.(presignResult);
+      const asset = await props.endpoints.confirm(presignResult.uploadId);
+      await hooks?.afterConfirm?.(asset);
+      /**
+       * Return
+       */
+      return asset;
+    } catch (err) {
+      console.error("Upload error: ", err);
+
+      /**
+       * Delete if upload failed
+       * */
+      if (presignResult) {
+        await props.endpoints.deleteAsset(presignResult.id).catch((deleteErr) => {
+          console.error("Failed to delete asset after upload error: ", deleteErr);
+        });
+      }
+
+      throw err;
+    }
+  }
+
+  return {
+    prepareUpload,
+    upload,
+    deleteAsset: props.endpoints.deleteAsset,
+    deleteAssets: props.endpoints.deleteAssets,
+    restoreAsset: props.endpoints.restoreAsset,
+    restoreAssets: props.endpoints.restoreAssets,
+    purgeAsset: props.endpoints.purgeAsset,
+    purgeAssets: props.endpoints.purgeAssets,
+  };
+}

package/src/modules/storage/lib/validators.ts

@@ -1,146 +1,85 @@
-import type { PutObjectCommandInput } from "@aws-sdk/client-s3";
 import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
 import { z } from "zod";
-import { tableQuerySchema } from "@/modules/data-tables/entry";
-import { resolveFiltersSchema } from "@/modules/data-tables/lib/filters/resolvers";
-import { nodesTableFilters } from "../config/filters";
-import { imageDispositions, imageVariants } from "./constants";
-import { nodeModeEnum, nodes } from "./schema";
+import { getObjectOptionsDefaults, objectBodyInputSchema } from "../providers/lib/validators";
+import { imageDispositions } from "./constants";
+import { storageAssets, storageAssetVisibilityEnum } from "./schema";
 
 /**
- * Nodes
+ * StorageAssets
  */
-export type Node = typeof nodes.$inferSelect;
-export type FileNode = typeof nodes.$inferSelect & { type: "file" };
-export type FolderNode = typeof nodes.$inferSelect & { type: "folder" };
+export type StorageAsset = typeof storageAssets.$inferSelect;
 
 /**
- * Node mode
+ * StorageAsset visibility enum
  */
-export const nodeModeSchema = z.enum(nodeModeEnum.enumValues);
-export type NodeMode = z.infer<typeof nodeModeSchema>;
+export const storageAssetVisibilitySchema = z.enum(storageAssetVisibilityEnum.enumValues);
+export type StorageAssetVisibility = z.infer<typeof storageAssetVisibilitySchema>;
 
 /**
- * Create node
+ * Create storageAsset
  */
-export const createNodeSchema = createInsertSchema(nodes, {
-  namespace: z.string(),
-});
+export const createStorageAssetSchema = createInsertSchema(storageAssets);
 
-export type CreateNodeInput = z.input<typeof createNodeSchema>;
-export type CreateNodeSchema = z.infer<typeof createNodeSchema>;
+export type CreateStorageAssetInput = z.input<typeof createStorageAssetSchema>;
+export type CreateStorageAssetSchema = z.infer<typeof createStorageAssetSchema>;
 
 /**
- * Update node
+ * Update storageAsset
  */
-export const updateNodeSchema = createUpdateSchema(nodes);
+export const updateStorageAssetSchema = createUpdateSchema(storageAssets);
 
-export type UpdateNodeInput = z.input<typeof updateNodeSchema>;
-export type UpdateNodeSchema = z.infer<typeof updateNodeSchema>;
+export type UpdateStorageAssetInput = z.input<typeof updateStorageAssetSchema>;
+export type UpdateStorageAssetSchema = z.infer<typeof updateStorageAssetSchema>;
 
 /**
- * Select node
+ * Select storageAsset
  */
-export const selectNodeSchema = createSelectSchema(nodes);
-export const selectNodeWithChildrenSchema = selectNodeSchema.extend({
-  children: z.array(selectNodeSchema),
-});
+export const selectStorageAssetSchema = createSelectSchema(storageAssets);
 
-export type SelectNodeSchema = z.infer<typeof selectNodeSchema>;
-export type SelectNodeWithChildrenSchema = z.infer<typeof selectNodeWithChildrenSchema>;
+export type SelectStorageAssetSchema = z.infer<typeof selectStorageAssetSchema>;
 
-/**
- * Where input
- */
-export const nodesTableFiltersSchema = resolveFiltersSchema(nodesTableFilters)
-  .partial()
-  .extend({
-    namespace: z.string(),
-    parentId: z.string().nullable(),
-  })
-  .transform((input) => ({
-    ...input,
-    hidden: input?.hidden ?? false,
-    isDeleted: input?.isDeleted ?? false,
-    orphanedAt: input?.isOrphaned ?? false,
-  }));
-
-export type NodesTableFilters = z.input<typeof nodesTableFiltersSchema>;
+const assetMetadataSchema = z.record(z.string(), z.string()).optional();
 
 /**
- * Create folder node
+ * Upload schema
  */
-export const createFolderNodeSchema = createNodeSchema.omit({
-  type: true,
-  contentType: true,
-  size: true,
-  subtype: true,
+export const uploadInputSchema = z.object({
+  name: z.string().min(1),
+  visibility: storageAssetVisibilitySchema.optional().default("private"),
+  size: z.number().int().nonnegative().nullable().optional(),
+  contentType: z.string().nullable().optional(),
+  metadata: assetMetadataSchema,
+  body: objectBodyInputSchema,
 });
 
-export type CreateFolderNodeSchema = z.infer<typeof createFolderNodeSchema>;
-
-/**
- * Upload file schema
- */
-export const uploadFileSchema = createNodeSchema.omit({ type: true });
-
-export type UploadFileSchema = z.infer<typeof uploadFileSchema>;
-
-/**
- * Presign file schema
- */
-export const presignFileSchema = uploadFileSchema.extend({ id: z.uuid() });
-
-export type PresignFileSchema = z.infer<typeof presignFileSchema>;
-
-/**
- * Get file url schema
- */
-export const getFileURLSchemaDefaults = { variant: "main", disposition: "inline" } as const;
-
-export const getFileURLSchema = z.object({
-  variant: z.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),
-  disposition: z.enum(imageDispositions).optional().default(getFileURLSchemaDefaults.disposition),
+export const presignUploadInputSchema = z.object({
+  uploadId: z.uuid().optional(),
+  name: z.string().min(1),
+  visibility: storageAssetVisibilitySchema.optional().default("private"),
+  size: z.number().int().nonnegative().nullable().optional(),
+  contentType: z.string().nullable().optional(),
+  metadata: assetMetadataSchema,
 });
 
-export type GetFileUrlInput = z.input<typeof getFileURLSchema>;
-export type GetFileURLSchema = z.infer<typeof getFileURLSchema>;
-
-/**
- * Get by parent id input
- */
-export const getNodesByParentIdSchema = tableQuerySchema
-  .pick({ order: true, sort: true, search: true })
-  .extend({ filters: nodesTableFiltersSchema });
-
-export type GetNodesByParentIdInput = z.input<typeof getNodesByParentIdSchema>;
-
-/**
- * Get object input
- */
-export const getObjectSchema = z.object({
-  id: z.string(),
-  variant: z.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),
-  disposition: z.string().optional().default(getFileURLSchemaDefaults.disposition),
+export const presignUploadOutputSchema = selectStorageAssetSchema.extend({
+  presignedUrl: z.string(),
 });
 
-export type GetObjectInput = z.input<typeof getObjectSchema>;
-export type GetObjectSchema = z.infer<typeof getObjectSchema>;
+export const confirmUploadInputSchema = z
+  .uuid()
+  .describe("The upload id of the pending upload to confirm, returned from the presign endpoint");
+
+export type UploadInput = z.input<typeof uploadInputSchema>;
+export type PresignUploadInput = z.input<typeof presignUploadInputSchema>;
+export type PresignUploadOutput = z.infer<typeof presignUploadOutputSchema>;
+export type ConfirmUploadInput = z.input<typeof confirmUploadInputSchema>;
 
 /**
- * Put object input
+ * Get file url schema
  */
-export const putObjectSchema = z.object({
-  id: z.string(),
-  name: z.string().optional().default(""),
-  variant: z.enum(imageVariants).optional().default("main"),
-  body: z.any().optional(),
-  contentType: z.string().nullable().optional(),
-  size: z.number().nullable().optional(),
+export const getAssetURLSchema = z.object({
+  disposition: z.enum(imageDispositions).optional().default(getObjectOptionsDefaults.disposition),
 });
 
-export type PutObjectInput = z.input<typeof putObjectSchema> & {
-  body?: PutObjectCommandInput["Body"];
-};
-
-export type PutObjectSchema = z.infer<typeof putObjectSchema>;
+export type GetAssetURLInput = z.input<typeof getAssetURLSchema>;
+export type GetAssetURLSchema = z.infer<typeof getAssetURLSchema>;

package/src/modules/storage/providers/adapters/s3.server.ts

@@ -0,0 +1,281 @@
+import { Readable } from "node:stream";
+import type { ReadableStream } from "node:stream/web";
+import {
+  DeleteObjectCommand,
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+  type S3ClientConfig,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import z from "zod";
+import type { StorageProvider } from "../lib/constants";
+import { StorageAdapterError } from "../lib/errors";
+import type { StorageAdapter } from "../lib/types";
+import {
+  type GetObjectInput,
+  type GetObjectOptions,
+  type GetObjectOutput,
+  type GetObjectURLOptions,
+  getObjectInputSchema,
+  getObjectOptionsSchema,
+  getObjectOutputSchema,
+  getObjectURLOptionsSchema,
+  type HeadObjectInput,
+  type HeadObjectOutput,
+  headObjectInputSchema,
+  headObjectOutputSchema,
+  type PutObjectInput,
+  type PutObjectOutput,
+  type PutObjectURLInput,
+  type PutObjectURLOptions,
+  putObjectInputSchema,
+  putObjectOutputSchema,
+  putObjectURLInputSchema,
+  putObjectURLOptionsSchema,
+} from "../lib/validators";
+
+export type StorageS3AdapterConfig = S3ClientConfig & {
+  bucketName: string;
+};
+
+/**
+ * S3 Storage Adapter
+ * This adapter implements the storage service interface using AWS S3 as the backend.
+ * It provides methods for uploading, retrieving, and managing files in an S3 bucket.
+ */
+class StorageS3Adapter implements StorageAdapter {
+  /**
+   * S3 Client
+   */
+  key: StorageProvider = "s3";
+  client: S3Client;
+  bucketName: string;
+
+  /**
+   * Constructor
+   */
+  constructor({ bucketName, ...config }: StorageS3AdapterConfig) {
+    this.client = new S3Client(config);
+    this.bucketName = bucketName;
+  }
+
+  /**
+   * Create get command
+   */
+  #createGetCommand(input: GetObjectInput, options: GetObjectOptions = {}) {
+    const key = getObjectInputSchema.parse(input);
+    const { disposition } = getObjectOptionsSchema.parse(options);
+
+    return new GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      ResponseContentDisposition: disposition,
+    });
+  }
+
+  /**
+   * Get object
+   */
+  async getObject(input: GetObjectInput, options: GetObjectOptions = {}): Promise<GetObjectOutput> {
+    const getCommand = this.#createGetCommand(input, options);
+
+    const result = await this.client.send(getCommand);
+
+    if (result.Body == null) {
+      throw new StorageAdapterError("OBJECT_NOT_READABLE", "Object body is missing", {
+        cause: new Error(
+          `ContentLength: ${result.ContentLength}, ContentType: ${result.ContentType}, Body: ${result.Body}`,
+        ),
+      });
+    }
+
+    return getObjectOutputSchema.parse({
+      contentType: result.ContentType,
+      size: result.ContentLength,
+      metadata: result.Metadata,
+      body: this.#toReadable(result.Body),
+    });
+  }
+
+  /**
+   * Get object URL
+   */
+  async getObjectURL(input: GetObjectInput, options: GetObjectURLOptions = {}) {
+    const { expiresIn } = getObjectURLOptionsSchema.parse(options);
+
+    // Validate input and create get command
+    const getCommand = this.#createGetCommand(input, options);
+
+    // Generate the presigned url
+    return await getSignedUrl(this.client, getCommand, { expiresIn });
+  }
+
+  /**
+   * Create head command
+   */
+  #createHeadCommand(input: HeadObjectInput) {
+    const { key } = headObjectInputSchema.parse(input);
+
+    return new HeadObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+    });
+  }
+
+  /**
+   * Head object
+   */
+  async headObject(input: HeadObjectInput): Promise<HeadObjectOutput> {
+    const headCommand = this.#createHeadCommand(input);
+
+    const result = await this.client.send(headCommand);
+
+    if (result.ContentLength == null || result.ContentType == null) {
+      throw new StorageAdapterError("OBJECT_NOT_FOUND", "Object metadata could not be resolved", {
+        cause: new Error(
+          `ContentLength: ${result.ContentLength}, ContentType: ${result.ContentType}`,
+        ),
+      });
+    }
+
+    return headObjectOutputSchema.parse({
+      contentType: result.ContentType,
+      size: result.ContentLength,
+      metadata: result.Metadata,
+    });
+  }
+
+  /**
+   * Create put command
+   */
+  #createPutCommand(
+    data: z.infer<typeof putObjectInputSchema> | z.infer<typeof putObjectURLInputSchema>,
+  ) {
+    return new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: data.key,
+      Body: "body" in data ? data.body : undefined,
+      ContentType: data.contentType ?? undefined,
+      ContentLength: data.size ?? undefined,
+      Metadata: data.metadata ?? undefined,
+    });
+  }
+
+  /**
+   * Put object
+   */
+  async putObject(input: PutObjectInput): Promise<PutObjectOutput> {
+    const data = putObjectInputSchema.parse(input);
+    const putCommand = this.#createPutCommand(data);
+
+    const result = await this.client.send(putCommand);
+
+    return putObjectOutputSchema.parse({ size: result.Size });
+  }
+
+  /**
+   * Get signed URL
+   */
+  async putObjectURL(input: PutObjectURLInput, options: PutObjectURLOptions = {}) {
+    const { expiresIn } = putObjectURLOptionsSchema.parse(options);
+
+    // Validate input and create put command
+    const data = putObjectURLInputSchema.parse(input);
+    const putCommand = this.#createPutCommand(data);
+
+    // Generate the presigned url
+    return await getSignedUrl(this.client, putCommand, { expiresIn });
+  }
+
+  /**
+   * Delete object
+   */
+  async deleteObject(input: string): Promise<void> {
+    const key = z.string().parse(input);
+
+    const deleteCommand = new DeleteObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+    });
+
+    const response = await this.client.send(deleteCommand);
+
+    if (response.DeleteMarker !== true && response.VersionId) {
+      throw new StorageAdapterError("OBJECT_DELETE_FAILED", "Failed to delete object", {
+        cause: new Error(
+          `DeleteMarker: ${response.DeleteMarker}, VersionId: ${response.VersionId}`,
+        ),
+      });
+    }
+  }
+
+  /**
+   * Delete multiple objects
+   */
+  async deleteObjects(input: string[]): Promise<void> {
+    const keys = z.array(z.string()).parse(input);
+
+    const deleteCommand = new DeleteObjectsCommand({
+      Bucket: this.bucketName,
+      Delete: { Objects: keys.map((Key) => ({ Key })) },
+    });
+
+    const response = await this.client.send(deleteCommand);
+
+    if (response.Errors && response.Errors.length > 0) {
+      throw new StorageAdapterError("OBJECT_DELETE_FAILED", "Failed to delete objects", {
+        cause: new Error(JSON.stringify(response.Errors)),
+      });
+    }
+  }
+
+  /**
+   * Transform the GetObjectCommandOutput Body into a normalized Readable stream
+   * S3 can return the Body in different formats depending on the environment and AWS SDK version:
+   * - In Node.js, it may return a Readable stream.
+   * - In newer AWS SDK versions in Node 18+, it may return a web ReadableStream with transformToWebStream method.
+   * - In older AWS SDK versions in Node 16, it may return a web ReadableStream without transformToWebStream.
+   * - It may also return a string, Buffer, or Uint8Array for small objects.
+   *
+   * This method normalizes all these cases into a Node.js Readable stream for consistent handling in the application.
+   */
+  #toReadable(body: GetObjectCommandOutput["Body"]): Readable {
+    if (!body) throw new StorageAdapterError("OBJECT_NOT_READABLE", "S3 object body is empty");
+
+    // If it's already a Node Readable, return as is
+    if (body instanceof Readable) return body;
+
+    if (typeof body.transformToWebStream === "function") {
+      // biome-ignore lint/suspicious/noExplicitAny: The AWS SDK v3 in Node 18+ returns a web ReadableStream with a transformToWebStream method, but the types don't reflect this correctly, so we need to use 'any' here.
+      return Readable.fromWeb((body as any).transformToWebStream());
+    }
+
+    // biome-ignore lint/suspicious/noExplicitAny: The AWS SDK v3 in Node 16 returns a web ReadableStream without a transformToWebStream method, but the types don't reflect this correctly, so we need to use 'any' here.
+    if (typeof (body as any).getReader === "function") {
+      return Readable.fromWeb(body as unknown as ReadableStream);
+    }
+
+    // If it's a string, Buffer, or Uint8Array, convert to Readable
+    if (typeof body === "string" || body instanceof Uint8Array || Buffer.isBuffer(body)) {
+      return Readable.from([body]);
+    }
+
+    throw new StorageAdapterError("UNSUPPORTED_BODY_TYPE", "Unsupported object body type");
+  }
+}
+
+/**
+ * S3 Storage Adapter
+ *
+ * This adapter implements the storage service interface using AWS S3 as the backend.
+ * It provides methods for uploading, retrieving, and managing files in an S3 bucket.
+ *
+ * @returns An instance of the S3StorageAdapter class.
+ */
+export function storageS3Adapter(config: StorageS3AdapterConfig): StorageAdapter {
+  return new StorageS3Adapter(config);
+}

package/src/modules/storage/providers/lib/constants.ts

@@ -0,0 +1,3 @@
+// Storage providers
+export const storageProviders = ["s3"] as const;
+export type StorageProvider = (typeof storageProviders)[number];

package/src/modules/storage/providers/lib/errors.ts

@@ -0,0 +1,21 @@
+/**
+ * Storage adapter error codes and class
+ */
+export type StorageAdapterErrorCode =
+  | "OBJECT_NOT_FOUND"
+  | "OBJECT_NOT_READABLE"
+  | "OBJECT_DELETE_FAILED"
+  | "OBJECT_HEAD_FAILED"
+  | "OBJECT_UPLOAD_FAILED"
+  | "OBJECT_URL_FAILED"
+  | "UNSUPPORTED_BODY_TYPE";
+
+export class StorageAdapterError extends Error {
+  code: StorageAdapterErrorCode;
+
+  constructor(code: StorageAdapterErrorCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "StorageError";
+    this.code = code;
+  }
+}

package/src/modules/storage/providers/lib/types.ts

@@ -0,0 +1,28 @@
+import type { StorageProvider } from "./constants";
+import type {
+  GetObjectInput,
+  GetObjectOptions,
+  GetObjectOutput,
+  GetObjectURLOptions,
+  HeadObjectInput,
+  HeadObjectOutput,
+  PutObjectInput,
+  PutObjectOutput,
+  PutObjectURLInput,
+  PutObjectURLOptions,
+} from "./validators";
+
+/**
+ * Storage adapter interface
+ */
+export interface StorageAdapter {
+  key: StorageProvider;
+  bucketName: string;
+  getObject: (input: GetObjectInput, options?: GetObjectOptions) => Promise<GetObjectOutput>;
+  getObjectURL: (input: GetObjectInput, options?: GetObjectURLOptions) => Promise<string>;
+  headObject: (input: HeadObjectInput) => Promise<HeadObjectOutput>;
+  putObject: (props: PutObjectInput) => Promise<PutObjectOutput>;
+  putObjectURL: (props: PutObjectURLInput, options?: PutObjectURLOptions) => Promise<string>;
+  deleteObject: (key: string) => Promise<void>;
+  deleteObjects: (keys: string[]) => Promise<void>;
+}