Encapsulate storage database transaction APIs

src/storage/database/adapter.ts

@@ -54,6 +54,41 @@ export interface ListBucketOptions {
   search?: string
 }
 
+type ObjectWriteData = Pick<Obj, 'owner' | 'metadata' | 'user_metadata'> & {
+  bucket_id: string
+  name: string
+  version: string
+}
+
+type ObjectMoveData = Pick<Obj, 'owner' | 'metadata' | 'user_metadata'> & { version: string }
+
+type DeletedObject = Pick<Obj, 'name' | 'version' | 'metadata'>
+
+type LockedDeletedObject = Pick<Obj, 'version' | 'metadata'>
+
+type UploadObject = Pick<
+  Obj,
+  | 'id'
+  | 'name'
+  | 'bucket_id'
+  | 'owner'
+  | 'owner_id'
+  | 'metadata'
+  | 'user_metadata'
+  | 'version'
+  | 'created_at'
+  | 'updated_at'
+  | 'last_accessed_at'
+>
+
+type PreviousUploadObject = Pick<Obj, 'id' | 'version' | 'metadata'>
+
+type ReplacedObject = Pick<Obj, 'name' | 'bucket_id' | 'version'>
+
+type MovedObject = Pick<Obj, 'id' | 'name' | 'bucket_id' | 'version' | 'owner' | 'metadata'>
+
+type SourceMoveObject = Pick<Obj, 'id' | 'version' | 'metadata' | 'user_metadata'>
+
 export interface Database {
   tenantHost: string
   tenantId: string
@@ -66,12 +101,61 @@ export interface Database {
 
   asSuperUser(): Database
 
-  withTransaction<T>(
-    fn: (db: Database) => Promise<T>,
+  testObjectPermission(data: ObjectWriteData, isUpsert?: boolean): Promise<void>
+
+  testMoveObjectPermission(
+    sourceBucketId: string,
+    sourceObjectName: string,
+    data: Pick<Obj, 'name' | 'bucket_id' | 'owner' | 'version'>
+  ): Promise<void>
+
+  testDeleteObjectPermission(bucketId: string, objectName: string): Promise<void>
+
+  createAnalyticsBucketTransaction(data: Pick<Bucket, 'name'>): Promise<IcebergCatalog>
+
+  deleteEmptyBucket(bucketId: string): Promise<number>
+
+  deleteObjectWithLock(bucketId: string, objectName: string): Promise<LockedDeletedObject>
+
+  deleteObjectsTransaction(
+    bucketId: string,
+    objectNames: string[],
+    by: keyof Obj
+  ): Promise<DeletedObject[]>
+
+  completeUploadTransaction(
+    data: ObjectWriteData
+  ): Promise<{ obj: UploadObject; isNew: boolean; previousObject?: PreviousUploadObject }>
+
+  upsertCopyDestination(
+    data: ObjectWriteData
+  ): Promise<{ destinationObject: UploadObject; replacedObject?: ReplacedObject }>
+
+  moveObjectDestination(
+    sourceBucketId: string,
+    sourceObjectName: string,
+    destinationBucketId: string,
+    destinationObjectName: string,
+    data: ObjectMoveData
+  ): Promise<{
+    destObject: MovedObject
+    sourceObject: SourceMoveObject
+  }>
+
+  acquireObjectLockForTransaction(
+    bucketId: string,
+    objectName: string,
+    version: string | undefined,
     transactionOptions?: TransactionOptions
-  ): Promise<T>
+  ): Promise<void>
 
-  testPermission<T>(fn: (db: Database) => T | Promise<T>): Promise<Awaited<T>>
+  adjustMultipartUploadProgress(uploadId: string, diff: number): Promise<void>
+
+  prepareMultipartUploadPart(
+    uploadId: string,
+    contentLength: number,
+    maxFileSize: number
+  ): Promise<S3MultipartUpload>
 
   createBucket(
     data: Pick<
@@ -194,7 +278,6 @@ export interface Database {
     bucketId: string,
     objectName: string,
     version: string,
-    signature: string,
     owner?: string,
     userMetadata?: Record<string, string | null>,
     metadata?: Partial<ObjectMetadata>

src/storage/database/knex.test.ts

@@ -34,8 +34,9 @@ function createStorageKnexTestHarness() {
 describe('StorageKnexDB.testPermission', () => {
   it('returns the callback result after rolling back the transaction', async () => {
     const { db, connection, transaction } = createStorageKnexTestHarness()
+    const testPermission = db['testPermission'].bind(db)
 
-    const result = await db.testPermission(async (txDb) => {
+    const result = await testPermission(async (txDb) => {
       expect(txDb).toBeInstanceOf(StorageKnexDB)
       expect(txDb).not.toBe(db)
       return 'allowed'
@@ -52,8 +53,10 @@ describe('StorageKnexDB.testPermission', () => {
     const { db, transaction } = createStorageKnexTestHarness()
     const error = new Error('permission denied')
 
+    const testPermission = db['testPermission'].bind(db)
+
     await expect(
-      db.testPermission(async () => {
+      testPermission(async () => {
         throw error
       })
     ).rejects.toBe(error)