feat: stats and update methods

packages/storage/src/lib/bucket/create.ts

@@ -32,6 +32,10 @@ export type CreateBucketOptions = {
   sourceBucketSnapshot?: string;
   access?: 'public' | 'private';
   defaultTier?: StorageClass;
+  /**
+   * @deprecated This property is deprecated and will be removed in the next major version
+   * @see https://www.tigrisdata.com/docs/buckets/create-bucket/#bucket-consistency
+   */
   consistency?: 'strict' | 'default';
   region?: string | string[];
   config?: Omit<TigrisStorageConfig, 'bucket'>;

packages/storage/src/lib/bucket/info.ts

@@ -1,86 +1,135 @@
-import { HeadBucketCommand } from '@aws-sdk/client-s3';
-import type { HttpResponse } from '@aws-sdk/types';
-import { TigrisHeaders } from '@shared/index';
-import { createTigrisClient } from '../tigris-client';
 import type { TigrisStorageConfig, TigrisStorageResponse } from '../types';
+import { StorageClass } from './create';
+import { createStorageClient } from '../http-client';
 
 export type GetBucketInfoOptions = {
   config?: TigrisStorageConfig;
 };
 
 export type BucketInfoResponse = {
   isSnapshotEnabled: boolean;
+  /**
+   * @deprecated
+   * @see forkInfo.hasChildren
+   * This property is deprecated and will be removed in the next major version
+   */
   hasForks: boolean;
+  /**
+   * @deprecated
+   * @see forkInfo.parents[0].bucketName
+   * This property is deprecated and will be removed in the next major version
+   */
   sourceBucketName?: string;
+  /**
+   * @deprecated
+   * @see forkInfo.parents[0].snapshot
+   * This property is deprecated and will be removed in the next major version
+   */
   sourceBucketSnapshot?: string;
+
+  forkInfo:
+    | {
+        hasChildren: boolean;
+        parents: Array<{
+          bucketName: string;
+          forkCreatedAt: Date;
+          snapshot: string;
+          snapshotCreatedAt: Date;
+        }>;
+      }
+    | undefined;
+  settings: {
+    allowObjectAcl: boolean;
+    defaultTier: StorageClass;
+  };
+  sizeInfo: {
+    numberOfObjects: number | undefined;
+    size: number | undefined;
+    numberOfObjectsAllVersions: number | undefined;
+  };
+};
+
+type BucketInfoApiResponse = {
+  ForkInfo?: {
+    HasChildren: boolean;
+    Parents: Array<{
+      BucketName: string;
+      ForkCreatedAt: string;
+      Snapshot: string;
+      SnapshotCreatedAt: string;
+    }>;
+  };
+  name: string;
+  storage_class: StorageClass;
+  type?: 1;
+  tier_sizes: Record<string, number>;
+  acl_settings?: {
+    allow_object_acl: boolean;
+  };
+  estimated_unique_rows?: number; // number of objects
+  estimated_size?: number; // estimated size of the bucket in bytes
+  estimated_rows?: number; // estimated number of objects in the bucket (all versions)
 };
 
 export async function getBucketInfo(
   bucketName: string,
   options?: GetBucketInfoOptions
 ): Promise<TigrisStorageResponse<BucketInfoResponse, Error>> {
-  const { data: tigrisClient, error } = createTigrisClient(
-    options?.config,
-    true
-  );
+  const { data: storageHttpClient, error: storageHttpClientError } =
+    createStorageClient(options?.config);
 
-  if (error) {
-    return { error };
+  if (storageHttpClientError) {
+    return { error: storageHttpClientError };
   }
 
-  const command = new HeadBucketCommand({ Bucket: bucketName });
+  try {
+    const response = await storageHttpClient.request<
+      unknown,
+      BucketInfoApiResponse
+    >({
+      method: 'GET',
+      path: `/${bucketName}?metadata&with-size=true`,
+      headers: {
+        Accept: 'application/json',
+      },
+    });
 
-  let headers: Record<string, string> = {};
+    if (response.error) {
+      return { error: response.error };
+    }
 
-  command.middlewareStack.add(
-    (next) => async (args) => {
-      const result = await next(args);
-      headers = (result.response as HttpResponse).headers;
+    const data = {
+      isSnapshotEnabled: response.data.type === 1,
+      hasForks: response.data.ForkInfo?.HasChildren ?? false,
+      sourceBucketName: response.data.ForkInfo?.Parents?.[0]?.BucketName,
+      sourceBucketSnapshot: response.data.ForkInfo?.Parents?.[0]?.Snapshot,
 
-      return result;
-    },
-    { step: 'deserialize' }
-  );
+      forkInfo: response.data.ForkInfo
+        ? {
+            hasChildren: response.data.ForkInfo.HasChildren,
+            parents: response.data.ForkInfo.Parents?.map((parent) => ({
+              bucketName: parent.BucketName,
+              forkCreatedAt: new Date(parent.ForkCreatedAt),
+              snapshot: parent.Snapshot,
+              snapshotCreatedAt: new Date(parent.SnapshotCreatedAt),
+            })) ?? [],
+          }
+        : undefined,
+      settings: {
+        allowObjectAcl: response.data.acl_settings?.allow_object_acl ?? false,
+        defaultTier: response.data.storage_class as StorageClass,
+      },
+      sizeInfo: {
+        numberOfObjects: response.data.estimated_unique_rows ?? undefined,
+        size: response.data.estimated_size ?? undefined,
+        numberOfObjectsAllVersions: response.data.estimated_rows ?? undefined,
+      },
+    };
 
-  try {
-    return tigrisClient
-      .send(command)
-      .then(() => {
-        return {
-          data: {
-            isSnapshotEnabled:
-              headers[TigrisHeaders.SNAPSHOT_ENABLED.toLowerCase()] !==
-                undefined &&
-              headers[TigrisHeaders.SNAPSHOT_ENABLED.toLowerCase()] === 'true',
-            hasForks:
-              headers[TigrisHeaders.HAS_FORKS.toLowerCase()] !== undefined &&
-              headers[TigrisHeaders.HAS_FORKS.toLowerCase()] === 'true',
-            ...(headers[TigrisHeaders.FORK_SOURCE_BUCKET.toLowerCase()] !==
-            undefined
-              ? {
-                  sourceBucketName:
-                    headers[TigrisHeaders.FORK_SOURCE_BUCKET.toLowerCase()],
-                }
-              : {}),
-            ...(headers[
-              TigrisHeaders.FORK_SOURCE_BUCKET_SNAPSHOT.toLowerCase()
-            ] !== undefined
-              ? {
-                  sourceBucketSnapshot:
-                    headers[
-                      TigrisHeaders.FORK_SOURCE_BUCKET_SNAPSHOT.toLowerCase()
-                    ],
-                }
-              : {}),
-          },
-        };
-      })
-      .catch((error) => {
-        return {
-          error: new Error(`Unable to get bucket info ${error.message}`),
-        };
-      });
-  } catch {
-    return { error: new Error('Unable to get bucket info') };
+    return { data };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error)),
+    };
   }
 }

packages/storage/src/lib/object/put.ts

@@ -112,10 +112,13 @@ export async function put(
 
   try {
     await upload.done();
-  } catch (error: any) {
+  } catch (error: unknown) {
+    const { message } = error as {
+      message: string;
+    };
     return {
-      error: error.message
-        ? new Error(error.message)
+      error: message
+        ? new Error(message)
         : new Error(`Unexpected error while uploading to Tigris Storage`),
     };
   }

packages/storage/src/lib/object/update.ts

@@ -0,0 +1,90 @@
+import { PutObjectAclCommand } from '@aws-sdk/client-s3';
+import { createTigrisClient } from '../tigris-client';
+import { TigrisHeaders } from '@shared/headers';
+import type { TigrisStorageConfig, TigrisStorageResponse } from '../types';
+import { config, missingConfigError } from '../config';
+import { handleError } from '../utils';
+import { createStorageClient } from '../http-client';
+
+export type UpdateObjectOptions = {
+  config?: TigrisStorageConfig;
+  key?: string;
+  access?: 'public' | 'private';
+};
+
+export type UpdateObjectResponse = {
+  path: string;
+};
+
+export async function updateObject(
+  path: string,
+  options?: UpdateObjectOptions
+): Promise<TigrisStorageResponse<UpdateObjectResponse, Error>> {
+  if (!options?.key && !options?.access) {
+    return { error: new Error('No update options provided') };
+  }
+
+  const bucket = options?.config?.bucket ?? config.bucket;
+
+  if (!bucket) {
+    return missingConfigError('bucket');
+  }
+
+  let currentKey = path;
+
+  // Rename first, so the ACL update targets the correct key
+  if (options?.key) {
+    const key = options.key;
+    const { data: storageHttpClient, error: storageHttpClientError } =
+      createStorageClient(options?.config);
+
+    if (storageHttpClientError) {
+      return { error: storageHttpClientError };
+    }
+
+    try {
+      const response = await storageHttpClient.request({
+        method: 'PUT',
+        path: `/${bucket}/${encodeURIComponent(key)}?x-id=CopyObject`,
+        headers: {
+          [TigrisHeaders.COPY_SOURCE]: `${bucket}/${encodeURIComponent(path)}`,
+          [TigrisHeaders.RENAME]: 'true',
+        },
+      });
+
+      if (response.error) {
+        return { error: response.error };
+      }
+
+      currentKey = key;
+    } catch (error) {
+      return handleError(error as Error);
+    }
+  }
+
+  if (options?.access) {
+    const { data: tigrisClient, error } = createTigrisClient(options?.config);
+
+    if (error) {
+      return { error };
+    }
+
+    try {
+      await tigrisClient.send(
+        new PutObjectAclCommand({
+          Bucket: bucket,
+          Key: currentKey,
+          ACL: options.access === 'public' ? 'public-read' : 'private',
+        })
+      );
+    } catch (error) {
+      return handleError(error as Error);
+    }
+  }
+
+  return {
+    data: {
+      path: currentKey,
+    },
+  };
+}