fix: incorrect config load timing

Author: xqvvu

lib/s3/index.ts

@@ -6,54 +6,54 @@ import {
   type IAwsS3CompatibleStorageOptions,
   type ICosStorageOptions,
   type IOssStorageOptions,
-  type IStorage
+  type IStorage,
+  type IStorageOptions
 } from '@fastgpt-sdk/storage';
 
-let config: any = {};
-let externalConfig: any = {};
+type StorageConfigWithoutBucket = Omit<IStorageOptions, 'bucket'>;
 
-const { vendor, publicBucket, privateBucket, externalBaseUrl, credentials, region, ...options } =
-  createDefaultStorageOptions();
+const getConfig = () => {
+  const { vendor, externalBaseUrl, publicBucket, privateBucket, credentials, region, ...options } =
+    createDefaultStorageOptions();
 
-const setConfig = () => {
-  if (vendor === 'minio') {
-    config = {
+  const buildResult = <T extends StorageConfigWithoutBucket>(config: T, externalConfig?: T) => ({
+    vendor,
+    config,
+    externalConfig,
+    externalBaseUrl,
+    privateBucket,
+    publicBucket
+  });
+
+  if (vendor === 'minio' || vendor === 'aws-s3') {
+    const config: Omit<IAwsS3CompatibleStorageOptions, 'bucket'> = {
       region,
       vendor,
       credentials,
-      forcePathStyle: true,
+      forcePathStyle: vendor === 'minio' ? true : options.forcePathStyle,
       endpoint: options.endpoint!,
       maxRetries: options.maxRetries!
-    } as Omit<IAwsS3CompatibleStorageOptions, 'bucket'>;
-    externalConfig = {
-      ...config,
-      endpoint: externalBaseUrl
     };
-  } else if (vendor === 'aws-s3') {
-    config = {
-      region,
-      vendor,
-      credentials,
-      endpoint: options.endpoint!,
-      maxRetries: options.maxRetries!,
-      forcePathStyle: options.forcePathStyle
-    } as Omit<IAwsS3CompatibleStorageOptions, 'bucket'>;
-    externalConfig = {
-      ...config,
-      endpoint: externalBaseUrl
-    };
-  } else if (vendor === 'cos') {
-    config = {
+
+    return buildResult(config, { ...config, endpoint: externalBaseUrl });
+  }
+
+  if (vendor === 'cos') {
+    const config: Omit<ICosStorageOptions, 'bucket'> = {
       region,
       vendor,
       credentials,
       proxy: options.proxy,
       domain: options.domain,
       protocol: options.protocol,
       useAccelerate: options.useAccelerate
-    } as Omit<ICosStorageOptions, 'bucket'>;
-  } else if (vendor === 'oss') {
-    config = {
+    };
+
+    return buildResult(config);
+  }
+
+  if (vendor === 'oss') {
+    const config: Omit<IOssStorageOptions, 'bucket'> = {
       region,
       vendor,
       credentials,
@@ -62,60 +62,55 @@ const setConfig = () => {
       internal: options.internal,
       secure: options.secure,
       enableProxy: options.enableProxy
-    } as Omit<IOssStorageOptions, 'bucket'>;
+    };
+
+    return buildResult(config);
   }
-};
 
-export const publicS3Server = (() => {
-  if (!global._publicS3Server) {
-    setConfig();
+  throw new Error(`Not supported vendor: ${vendor}`);
+};
 
-    const client = createStorage({ bucket: publicBucket, ...config });
+const createS3Service = (bucket: string, isPublic: boolean) => {
+  const { config, externalConfig, externalBaseUrl } = getConfig();
 
-    let externalClient: IStorage | undefined = undefined;
-    if (externalBaseUrl) {
-      externalClient = createStorage({ bucket: publicBucket, ...externalConfig });
-    }
+  const client = createStorage({ bucket, ...config } as IStorageOptions);
 
-    global._publicS3Server = new S3Service(client, externalClient);
+  let externalClient: IStorage | undefined;
+  if (externalBaseUrl && externalConfig) {
+    externalClient = createStorage({ bucket, ...externalConfig } as IStorageOptions);
+  }
 
-    client.ensureBucket();
-    if (externalClient) {
-      externalClient.ensureBucket();
+  const ensurePublicPolicy = (storage: IStorage) => {
+    if (storage instanceof MinioStorageAdapter) {
+      storage.ensurePublicBucketPolicy();
     }
+  };
+
+  client.ensureBucket().then(() => {
+    if (isPublic) ensurePublicPolicy(client);
+  });
 
-    client.ensureBucket().then(() => {
-      if (vendor !== 'minio') return;
-      (client as MinioStorageAdapter).ensurePublicBucketPolicy();
+  if (externalClient) {
+    externalClient.ensureBucket().then(() => {
+      if (isPublic) ensurePublicPolicy(externalClient);
     });
+  }
 
-    if (externalClient) {
-      externalClient.ensureBucket().then(() => {
-        if (vendor !== 'minio') return;
-        (externalClient as MinioStorageAdapter).ensurePublicBucketPolicy();
-      });
-    }
+  return new S3Service(client, externalClient);
+};
+
+export const publicS3Server = (() => {
+  if (!global._publicS3Server) {
+    const { publicBucket } = getConfig();
+    global._publicS3Server = createS3Service(publicBucket, true);
   }
   return global._publicS3Server;
 })();
 
 export const privateS3Server = (() => {
   if (!global._privateS3Server) {
-    setConfig();
-
-    const client = createStorage({ bucket: privateBucket, ...config });
-
-    let externalClient: IStorage | undefined = undefined;
-    if (externalBaseUrl) {
-      externalClient = createStorage({ bucket: privateBucket, ...externalConfig });
-    }
-
-    global._privateS3Server = new S3Service(client, externalClient);
-
-    client.ensureBucket();
-    if (externalClient) {
-      externalClient.ensureBucket();
-    }
+    const { privateBucket } = getConfig();
+    global._privateS3Server = createS3Service(privateBucket, false);
   }
   return global._privateS3Server;
 })();