rustfs-console/composables/useBucket.ts

import {
  CreateBucketCommand,
  HeadBucketCommand,
  DeleteBucketCommand,
  ListBucketsCommand,
  GetBucketTaggingCommand,
  PutBucketTaggingCommand,
  DeleteBucketTaggingCommand,
  PutBucketVersioningCommand,
  GetBucketVersioningCommand,
  MFADelete,
  BucketVersioningStatus,
  GetBucketPolicyCommand,
  PutBucketPolicyCommand,
  GetBucketPolicyStatusCommand,
  GetObjectLockConfigurationCommand,
  PutObjectLockConfigurationCommand,
  PutObjectRetentionCommand,
  GetObjectRetentionCommand,
  GetBucketEncryptionCommand,
  PutBucketEncryptionCommand,
  DeleteBucketEncryptionCommand,
  GetBucketLifecycleConfigurationCommand,
  PutBucketLifecycleConfigurationCommand,
  DeleteBucketLifecycleCommand,
  GetBucketReplicationCommand,
  PutBucketReplicationCommand,
  DeleteBucketReplicationCommand,
  PutBucketNotificationConfigurationCommand,
  GetBucketNotificationConfigurationCommand,
} from '@aws-sdk/client-s3'

export function useBucket({ region }: { region?: string }) {
  const $client = useNuxtApp().$s3Client

  const listBuckets = async () => {
    return await $client.send(new ListBucketsCommand({}))
  }

  const createBucket = async (params: any) => {
    return await $client.send(new CreateBucketCommand(params))
  }

  const headBucket = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new HeadBucketCommand(params))
  }

  const deleteBucket = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new DeleteBucketCommand(params))
  }

  const getBucketTagging = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new GetBucketTaggingCommand(params))
  }

  const putBucketTagging = async (bucket: string, tagging: any) => {
    const params = {
      Bucket: bucket,
      Tagging: tagging,
    }

    return await $client.send(new PutBucketTaggingCommand(params))
  }

  const deleteBucketTagging = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new DeleteBucketTaggingCommand(params))
  }

  const putBucketVersioning = async (bucket: string, status: string) => {
    const params = {
      Bucket: bucket,
      VersioningConfiguration: {
        Status: status == 'Enabled' ? BucketVersioningStatus.Enabled : BucketVersioningStatus.Suspended,
        MFADelete: MFADelete.Enabled,
      },
    }

    return await $client.send(new PutBucketVersioningCommand(params))
  }

  const getBucketVersioning = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new GetBucketVersioningCommand(params))
  }

  const getBucketPolicy = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new GetBucketPolicyCommand(params))
  }

  const getBucketPolicyStatus = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new GetBucketPolicyStatusCommand(params))
  }

  const putBucketPolicy = async (bucket: string, policy: string) => {
    const params = {
      Bucket: bucket,
      Policy: policy,
    }

    return await $client.send(new PutBucketPolicyCommand(params))
  }

  const getObjectLockConfiguration = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }

    return await $client.send(new GetObjectLockConfigurationCommand(params))
  }

  const putObjectLockConfiguration = async (bucket: string, objectLockConfiguration: any) => {
    const params = {
      Bucket: bucket,
      ObjectLockConfiguration: objectLockConfiguration,
    }

    return await $client.send(new PutObjectLockConfigurationCommand(params))
  }

  const getBucketLifecycleConfiguration = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new GetBucketLifecycleConfigurationCommand(params))
  }
  const putBucketLifecycleConfiguration = async (bucket: string, lifecycleConfiguration: any) => {
    const params = {
      Bucket: bucket,
      LifecycleConfiguration: lifecycleConfiguration,
    }
    return await $client.send(new PutBucketLifecycleConfigurationCommand(params))
  }
  const deleteBucketLifecycle = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new DeleteBucketLifecycleCommand(params))
  }

  const putObjectRetention = async (bucket: string, key: string, retention: any) => {
    const params = {
      Bucket: bucket,
      Key: key,
      Retention: retention,
    }
    return await $client.send(new PutObjectRetentionCommand(params))
  }
  const getObjectRetention = async (bucket: string, key: string) => {
    const params = {
      Bucket: bucket,
      Key: key,
    }
    return await $client.send(new GetObjectRetentionCommand(params))
  }

  const getBucketEncryption = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new GetBucketEncryptionCommand(params))
  }
  const putBucketEncryption = async (bucket: string, encryption: any) => {
    const params = {
      Bucket: bucket,
      ServerSideEncryptionConfiguration: encryption,
    }
    return await $client.send(new PutBucketEncryptionCommand(params))
  }
  const deleteBucketEncryption = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new DeleteBucketEncryptionCommand(params))
  }

  /********************S3 Replication********************/
  const getBucketReplication = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new GetBucketReplicationCommand(params))
  }
  const putBucketReplication = async (bucket: string, replication: any) => {
    const params = {
      Bucket: bucket,
      ReplicationConfiguration: replication,
    }
    return await $client.send(new PutBucketReplicationCommand(params))
  }
  const deleteBucketReplication = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new DeleteBucketReplicationCommand(params))
  }

  /********************S3 Replication********************/

  /********************rustfs Replication target********************/
  const { $api } = useNuxtApp()
  const message = useMessage()
  const setRemoteReplicationTarget = async (bucket: string, data: any) => {
    try {
      return await $api.put(`/set-remote-target?bucket=${bucket}`, data)
    } catch (error: any) {
      message.error(error.message as string)
      console.log(error)
    }
    // return await $api.put(`/set-remote-target?bucket=${bucket}`, data);
  }

  const listRemoteReplicationTarget = async (bucket: string) => {
    return await $api.get(`/list-remote-targets?bucket=${bucket}&type=`)
  }

  const deleteRemoteReplicationTarget = async (bucket: string, arn: string) => {
    return await $api.delete(`/remove-remote-target?bucket=${bucket}&arn=${arn}`)
  }

  // Bucket notifications
  const listBucketNotifications = async (bucket: string) => {
    const params = {
      Bucket: bucket,
    }
    return await $client.send(new GetBucketNotificationConfigurationCommand(params))
  }

  const putBucketNotifications = async (bucket: string, data: any) => {
    const params = {
      Bucket: bucket,
      NotificationConfiguration: data,
    }
    return await $client.send(new PutBucketNotificationConfigurationCommand(params))
  }

  /********************rustfs Replication target  end********************/

  /************************* bucket quota start********************************* */
  const getBucketQuota = async (bucket: string) => {
    return await $api.get(`/quota/${bucket}`)
  }

  const putBucketQuota = async (bucket: string, quota: any) => {
    return await $api.put(`/quota/${bucket}`, quota)
  }

  const deleteBucketQuota = async (bucket: string) => {
    return await $api.delete(`/quota/${bucket}`)
  }
  const getBucketQuotaUsage = async (bucket: string) => {
    return await $api.get(`/quota-stats/${bucket}`)
  }

  const checkBucketQuota = async (bucket: string) => {
    return await $api.get(`/quota-check/${bucket}`)
  }

  /************************* bucket quota End********************************* */

  return {
    listBuckets,
    createBucket,
    headBucket,
    deleteBucket,
    getBucketTagging,
    putBucketTagging,
    deleteBucketTagging,
    putBucketVersioning,
    getBucketVersioning,
    getBucketPolicyStatus,
    getBucketPolicy,
    putBucketPolicy,
    getObjectLockConfiguration,
    putObjectLockConfiguration,
    getBucketLifecycleConfiguration,
    putBucketLifecycleConfiguration,
    deleteBucketLifecycle,
    putObjectRetention,
    getObjectRetention,
    getBucketEncryption,
    putBucketEncryption,
    deleteBucketEncryption,
    getBucketReplication,
    putBucketReplication,
    deleteBucketReplication,
    setRemoteReplicationTarget,
    listRemoteReplicationTarget,
    deleteRemoteReplicationTarget,
    listBucketNotifications,
    putBucketNotifications,
    getBucketQuota,
    putBucketQuota,
    deleteBucketQuota,
    getBucketQuotaUsage,
    checkBucketQuota,
  }
}