@kevisual/oss 0.0.12 → 0.0.14

package/src/test/common.ts

@@ -0,0 +1,103 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+import { S3Client, ListObjectsV2Command, GetBucketMetadataConfigurationCommand, HeadObjectCommand, CopyObjectCommand } from '@aws-sdk/client-s3';
+
+export const s3Client = new S3Client({
+  credentials: {
+    accessKeyId: process.env.S3_ACCESS_KEY_ID || '',
+    secretAccessKey: process.env.S3_SECRET_ACCESS_KEY || '',
+  },
+  region: process.env.S3_REGION,
+  endpoint: 'https://tos-s3-cn-shanghai.volces.com',
+});
+
+export const bucketName = process.env.S3_BUCKET_NAME;
+
+export async function listS3Objects() {
+  const command = new ListObjectsV2Command({
+    Bucket: process.env.S3_BUCKET_NAME,
+  });
+
+  try {
+    const result = await s3Client.send(command);
+    console.log('S3 Objects:', result.Contents);
+    return result.Contents;
+  } catch (error) {
+    console.error('Error listing S3 objects:', error);
+    throw error;
+  }
+}
+
+// listS3Objects();
+
+export async function getMetaData(key = 'readme.md') {
+  const command = new HeadObjectCommand({
+    Bucket: process.env.S3_BUCKET_NAME,
+    Key: key,
+  });
+
+  try {
+    const result = await s3Client.send(command);
+    // 解码 TOS 返回的 URL 编码的元数据值
+    const decodedMetadata: Record<string, string> = {};
+    if (result.Metadata) {
+      for (const [key, value] of Object.entries(result.Metadata)) {
+        decodedMetadata[key] = decodeURIComponent(value);
+      }
+    }
+    console.log('Metadata for', result);
+
+    return decodedMetadata;
+  } catch (error) {
+    console.error('Error getting metadata for', key, ':', error);
+    throw error;
+  }
+}
+
+// const metadata = await getMetaData();
+// console.log('metadata', metadata);
+
+export async function setMetaData(key = 'readme.md', metadata: Record<string, string>) {
+  // 注意：S3 不支持直接更新对象的元数据。必须通过复制对象到自身来实现元数据的更新。
+  const copySource = `${process.env.S3_BUCKET_NAME}/${key}`;
+
+  // 分离标准 HTTP 头和自定义元数据
+  // 标准头应作为顶层参数，自定义元数据才放在 Metadata 中
+  const standardHeaders: Record<string, any> = {};
+  const customMetadata: Record<string, string> = {};
+
+  const standardHeaderKeys = ['content-type', 'cache-control', 'content-disposition', 'content-encoding', 'content-language', 'expires'];
+
+  for (const [key, value] of Object.entries(metadata)) {
+    const lowerKey = key.toLowerCase();
+    if (standardHeaderKeys.includes(lowerKey)) {
+      // 使用驼峰命名
+      const camelKey = lowerKey.split('-').map((word, index) =>
+        index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
+      ).join('');
+      standardHeaders[camelKey] = value;
+    } else {
+      customMetadata[key] = value;
+    }
+  }
+
+  const command = new CopyObjectCommand({
+    Bucket: process.env.S3_BUCKET_NAME,
+    Key: key,
+    CopySource: copySource,
+    ...standardHeaders, // 标准头作为顶层参数
+    Metadata: customMetadata, // 只有自定义元数据放在这里
+    MetadataDirective: 'REPLACE', // 指定替换元数据
+  });
+
+  try {
+    const result = await s3Client.send(command);
+    console.log('Metadata updated successfully for', key);
+    return result;
+  } catch (error) {
+    console.error('Error setting metadata for', key, ':', error);
+    throw error;
+  }
+}
+// setMetaData('readme.md', { 'type': 'app', 'Content-Type': 'text/html' });

package/src/test/config-admin.ts

@@ -0,0 +1,84 @@
+import { config } from 'dotenv';
+import { ConfigOssService } from '../services/index.ts';
+import { Client } from 'minio';
+import path from 'path';
+import { downloadObject } from '../util/download.ts';
+const cwd = process.cwd();
+config({ path: path.resolve(cwd, '..', '..', '.env.dev') });
+
+console.log(
+  'config',
+  process.env.MINIO_ENDPOINT,
+  process.env.MINIO_USE_SSL,
+  process.env.MINIO_ACCESS_KEY,
+  process.env.MINIO_SECRET_KEY,
+  process.env.MINIO_BUCKET_NAME,
+);
+const client = new Client({
+  endPoint: process.env.MINIO_ENDPOINT,
+  useSSL: process.env.MINIO_USE_SSL === 'true',
+  accessKey: process.env.MINIO_ACCESS_KEY,
+  secretKey: process.env.MINIO_SECRET_KEY,
+});
+const configOssService = new ConfigOssService({
+  client,
+  bucketName: process.env.MINIO_BUCKET_NAME,
+  owner: 'admin',
+});
+
+const main = async () => {
+  configOssService.setPrefix('root');
+  const config = await configOssService.statObject('avatar.png');
+  console.log(config);
+};
+
+main();
+const putJson = async () => {
+  const config = await configOssService.putObject(
+    'a.json',
+    {
+      a: 'a',
+    },
+    {
+      'content-type': 'application/json',
+      'cache-control': 'no-cache',
+    },
+  );
+  console.log(config);
+};
+// putJson();
+const downloadMain = async () => {
+  const stat = await configOssService.statObject('a.json'); // 582af9ef5cdc53d6628f45cb842f874a
+  console.log(stat);
+  const objectStream = await downloadObject({
+    objectName: 'a.json',
+    client: configOssService,
+    filePath: path.resolve(cwd, 'a.json'),
+  });
+  // console.log(objectStream);
+};
+// downloadMain();
+
+const statInfo = async () => {
+  try {
+    const stat = await configOssService.statObject('a.json');
+    // configOssService.setPrefix('root/');
+    // const stat = await configOssService.statObject('avatar.png');
+    // const stat = await configOssService.statObject('center/0.0.1/index.html');
+    console.log(stat);
+  } catch (e) {
+    if (e.code === 'NotFound') {
+      console.log('not found');
+    } else {
+      console.log('error', e);
+    }
+  }
+};
+// statInfo();
+
+const listObjects = async () => {
+  configOssService.setPrefix('root/avatar.png');
+  const list = await configOssService.listObjects('');
+  console.log(list);
+};
+// listObjects();

package/src/test/test-s3.ts

@@ -0,0 +1,23 @@
+import { OssBase } from "@/s3/core.ts";
+
+import { s3Client, bucketName } from './common.ts';
+
+const oss = new OssBase({
+  client: s3Client,
+  bucketName: bucketName,
+});
+
+// const list = await oss.listObjects('');
+
+// console.log(list);
+
+// const obj = await oss.getObjectAsString('readme.md');
+// console.log(obj);
+
+let putJson = {
+  name: 'test',
+  age: 18,
+}
+const objPut = await oss.putObject('a.json', putJson) 
+
+console.log(objPut);

package/src/util/download.ts

@@ -0,0 +1,73 @@
+import { ServerResponse } from 'node:http';
+import { BucketItemStat } from 'minio';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const viewableExtensions = ['jpg', 'jpeg', 'png', 'gif', 'svg', 'webp', 'mp4', 'webm', 'mp3', 'wav', 'ogg', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx'];
+import { OssBase } from '../index.ts';
+/**
+ * 过滤 metaData 中的 key, 去除 password, accesskey, secretkey，
+ * 并返回过滤后的 metaData
+ * @param metaData
+ * @returns
+ */
+export const filterMetaDataKeys = (metaData: Record<string, string>, clearKeys: string[] = []) => {
+  const keys = Object.keys(metaData);
+  // remove X-Amz- meta data
+  const removeKeys = ['password', 'accesskey', 'secretkey', ...clearKeys];
+  const filteredKeys = keys.filter((key) => !removeKeys.includes(key));
+  return filteredKeys.reduce((acc, key) => {
+    acc[key] = metaData[key];
+    return acc;
+  }, {} as Record<string, string>);
+};
+type SendObjectOptions = {
+  res: ServerResponse;
+  client: OssBase;
+  objectName: string;
+  isDownload?: boolean;
+};
+export const NotFoundFile = (res: ServerResponse, msg?: string, code = 404) => {
+  res.writeHead(code, { 'Content-Type': 'text/plain' });
+  res.end(msg || 'Not Found File');
+  return;
+};
+export const sendObject = async ({ res, objectName, client, isDownload = false }: SendObjectOptions) => {
+  let stat: BucketItemStat;
+  try {
+    stat = await client.statObject(objectName);
+  } catch (e) {
+  } finally {
+    if (!stat || stat.size === 0) {
+      return NotFoundFile(res);
+    }
+    const contentLength = stat.size;
+    const etag = stat.etag;
+    const lastModified = stat.lastModified.toISOString();
+    const filename = objectName.split('/').pop() || 'no-file-name-download'; // Extract filename from objectName
+    const fileExtension = filename.split('.').pop()?.toLowerCase() || '';
+    const filteredMetaData = filterMetaDataKeys(stat.metaData, ['size', 'etag', 'last-modified']);
+    const contentDisposition = viewableExtensions.includes(fileExtension) && !isDownload ? 'inline' : `attachment; filename="${filename}"`;
+
+    res.writeHead(200, {
+      'Content-Length': contentLength,
+      etag,
+      'last-modified': lastModified,
+      'Content-Disposition': contentDisposition,
+      ...filteredMetaData,
+    });
+    const objectStream = await client.getObject(objectName);
+
+    objectStream.pipe(res, { end: true });
+  }
+};
+
+export const downloadObject = async ({ objectName, client, filePath }: Pick<SendObjectOptions, 'objectName' | 'client'> & { filePath: string }) => {
+  const objectStream = await client.getObject(objectName);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  objectStream.pipe(fs.createWriteStream(filePath));
+  return objectStream;
+};

package/src/util/extract-standard-headers.ts

@@ -0,0 +1,44 @@
+export const standardHeaderKeys = ['content-type', 'cache-control', 'content-disposition', 'content-encoding', 'content-language', 'expires'];
+
+export type StandardHeaders = {
+  ContentType?: string;
+  CacheControl?: string;
+  ContentDisposition?: string;
+  ContentEncoding?: string;
+  ContentLanguage?: string;
+  Expires?: Date;
+};
+
+/**
+ * 从元数据中提取标准头部和自定义元数据
+ * @param metaData 原始元数据
+ * @returns 标准头部和自定义元数据
+ */
+export function extractStandardHeaders(metaData: Record<string, string>): {
+  standardHeaders: StandardHeaders;
+  customMetadata: Record<string, string>;
+} {
+  const standardHeaders: StandardHeaders = {};
+  const customMetadata: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(metaData)) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey === 'content-type') {
+      standardHeaders.ContentType = value;
+    } else if (lowerKey === 'cache-control') {
+      standardHeaders.CacheControl = value;
+    } else if (lowerKey === 'content-disposition') {
+      standardHeaders.ContentDisposition = value;
+    } else if (lowerKey === 'content-encoding') {
+      standardHeaders.ContentEncoding = value;
+    } else if (lowerKey === 'content-language') {
+      standardHeaders.ContentLanguage = value;
+    } else if (lowerKey === 'expires') {
+      standardHeaders.Expires = new Date(value);
+    } else {
+      customMetadata[key] = value;
+    }
+  }
+
+  return { standardHeaders, customMetadata };
+}

package/src/util/get-content-type.ts

@@ -0,0 +1,49 @@
+import path from 'node:path';
+// 获取文件的 content-type
+export const getContentType = (filePath: string) => {
+  const extname = path.extname(filePath);
+  const contentType = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.txt': 'text/plain; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.md': 'text/markdown; charset=utf-8', // utf-8配置
+    '.ico': 'image/x-icon', // Favicon 图标
+    '.webp': 'image/webp', // WebP 图像格式
+    '.webm': 'video/webm', // WebM 视频格式
+    '.ogg': 'audio/ogg', // Ogg 音频格式
+    '.mp3': 'audio/mpeg', // MP3 音频格式
+    '.m4a': 'audio/mp4', // M4A 音频格式
+    '.m3u8': 'application/vnd.apple.mpegurl', // HLS 播放列表
+    '.ts': 'video/mp2t', // MPEG Transport Stream
+    '.pdf': 'application/pdf', // PDF 文档
+    '.doc': 'application/msword', // Word 文档
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', // Word 文档 (新版)
+    '.ppt': 'application/vnd.ms-powerpoint', // PowerPoint 演示文稿
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation', // PowerPoint (新版)
+    '.xls': 'application/vnd.ms-excel', // Excel 表格
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // Excel 表格 (新版)
+    '.csv': 'text/csv; charset=utf-8', // CSV 文件
+    '.xml': 'application/xml; charset=utf-8', // XML 文件
+    '.rtf': 'application/rtf', // RTF 文本文件
+    '.eot': 'application/vnd.ms-fontobject', // Embedded OpenType 字体
+    '.ttf': 'font/ttf', // TrueType 字体
+    '.woff': 'font/woff', // Web Open Font Format 1.0
+    '.woff2': 'font/woff2', // Web Open Font Format 2.0
+    '.otf': 'font/otf', // OpenType 字体
+    '.wasm': 'application/wasm', // WebAssembly 文件
+    '.pem': 'application/x-pem-file', // PEM 证书文件
+    '.crt': 'application/x-x509-ca-cert', // CRT 证书文件
+    '.yaml': 'application/x-yaml; charset=utf-8', // YAML 文件
+    '.yml': 'application/x-yaml; charset=utf-8', // YAML 文件（别名）
+    '.zip': 'application/octet-stream',
+  };
+  return contentType[extname] || 'application/octet-stream';
+};

package/src/util/hash.ts

@@ -0,0 +1,26 @@
+import crypto from 'node:crypto';
+// 582af9ef5cdc53d6628f45cb842f874a
+// const hashStr = '{"a":"a"}';
+// const hash = crypto.createHash('md5').update(hashStr).digest('hex');
+// console.log(hash);
+
+/**
+ * 计算字符串的md5值
+ * @param str
+ * @returns
+ */
+export const hash = (str: string | Buffer | Object) => {
+  let hashStr: string | Buffer;
+  if (str instanceof Buffer) {
+    hashStr = str;
+  } else if (str instanceof Object) {
+    hashStr = JSON.stringify(str, null, 2);
+  } else {
+    hashStr = str;
+  }
+  return crypto.createHash('md5').update(hashStr).digest('hex');
+};
+
+export const hashSringify = (str: Object) => {
+  return JSON.stringify(str, null, 2);
+};

package/src/util/index.ts

@@ -0,0 +1,5 @@
+export * from './hash.ts';
+
+export * from './get-content-type.ts';
+
+export * from './extract-standard-headers.ts';

package/dist/index-BGsBfWH-.d.ts

@@ -1,161 +0,0 @@
-import * as minio from 'minio';
-import { ItemBucketMetadata, Client } from 'minio';
-import * as minio_dist_esm_internal_type_mjs from 'minio/dist/esm/internal/type.mjs';
-import * as stream from 'stream';
-
-type UploadedObjectInfo = {
-    etag: string;
-    lastModified?: Date;
-    size?: number;
-    versionId: string;
-    metadata?: ItemBucketMetadata;
-};
-type StatObjectResult = {
-    size: number;
-    etag: string;
-    lastModified: Date;
-    metaData: ItemBucketMetadata;
-    versionId?: string | null;
-};
-type ListFileObject = {
-    name: string;
-    size: number;
-    lastModified: Date;
-    etag: string;
-};
-type ListDirectoryObject = {
-    prefix: string;
-    size: number;
-};
-type ListObjectResult = ListFileObject | ListDirectoryObject;
-interface OssBaseOperation {
-    prefix: string;
-    setPrefix(prefix: string): void;
-    /**
-     * 获取对象
-     * @param objectName 对象名
-     */
-    getObject(objectName: string): Promise<any>;
-    /**
-     * 上传对象
-     * @param objectName 对象名
-     * @param data 数据
-     */
-    putObject(objectName: string, data: Buffer | string, metaData?: ItemBucketMetadata): Promise<UploadedObjectInfo>;
-    /**
-     * 上传文件
-     * @param objectName 对象名
-     * @param filePath 文件路径
-     */
-    fPutObject(objectName: string, filePath: string, metaData?: ItemBucketMetadata): Promise<UploadedObjectInfo>;
-    /**
-     * 获取对象信息
-     * @param objectName 对象名
-     */
-    statObject(objectName: string): Promise<StatObjectResult>;
-    /**
-     * 删除对象
-     * @param objectName 对象名
-     */
-    deleteObject(objectName: string): Promise<any>;
-    /**
-     * 列出对象
-     * @param objectName 对象名
-     * @param opts 选项
-     * @param opts.recursive 是否递归
-     * @param opts.startAfter 开始位置
-     */
-    listObjects(objectName: string, opts?: {
-        /**
-         * 是否递归
-         */
-        recursive?: boolean;
-        /**
-         * 开始位置
-         */
-        startAfter?: string;
-    }): Promise<ListObjectResult[]>;
-    /**
-     * 复制对象
-     * @param sourceObject 源对象
-     * @param targetObject 目标对象
-     */
-    copyObject: Client['copyObject'];
-}
-interface OssService extends OssBaseOperation {
-    owner: string;
-}
-
-type OssBaseOptions<T = {
-    [key: string]: any;
-}> = {
-    /**
-     * 已经初始化好的minio client
-     */
-    client: Client;
-    /**
-     * 桶名
-     */
-    bucketName: string;
-    /**
-     * 前缀
-     */
-    prefix?: string;
-} & T;
-declare class OssBase implements OssBaseOperation {
-    client?: Client;
-    bucketName: string;
-    prefix: string;
-    /**
-     * 计算字符串或者对象的的md5值
-     */
-    hash: (str: string | Buffer | Object) => string;
-    constructor(opts: OssBaseOptions);
-    setPrefix(prefix: string): void;
-    getObject(objectName: string): Promise<stream.Readable>;
-    getJson(objectName: string): Promise<Record<string, any>>;
-    /**
-     * 上传文件, 当是流的时候，中断之后的etag会变，所以传递的时候不要嵌套async await，例如 busboy 监听文件流内部的时候，不要用check
-     * @param objectName
-     * @param data
-     * @param metaData
-     * @param options 如果文件本身存在，则复制原有的meta的内容
-     * @returns
-     */
-    putObject(objectName: string, data: Buffer | string | Object, metaData?: ItemBucketMetadata, opts?: {
-        check?: boolean;
-        isStream?: boolean;
-        size?: number;
-    }): Promise<minio_dist_esm_internal_type_mjs.UploadedObjectInfo>;
-    deleteObject(objectName: string): Promise<void>;
-    listObjects<IS_FILE = false>(objectName: string, opts?: {
-        recursive?: boolean;
-        startAfter?: string;
-    }): Promise<IS_FILE extends true ? ListFileObject[] : ListObjectResult[]>;
-    fPutObject(objectName: string, filePath: string, metaData?: ItemBucketMetadata): Promise<any>;
-    statObject(objectName: string, checkFile?: boolean): Promise<minio.BucketItemStat>;
-    /**
-     * 检查文件hash是否一致
-     * @param objectName
-     * @param hash
-     * @returns
-     */
-    checkObjectHash(objectName: string, hash: string, meta?: ItemBucketMetadata): Promise<{
-        success: boolean;
-        metaData: ItemBucketMetadata | null;
-        obj: any;
-        equalMeta?: boolean;
-    }>;
-    getMetadata(pathname: string, meta?: ItemBucketMetadata): ItemBucketMetadata;
-    copyObject(sourceObject: any, targetObject: any): Promise<minio_dist_esm_internal_type_mjs.CopyObjectResult>;
-    replaceObject(objectName: string, meta: {
-        [key: string]: string;
-    }): Promise<minio_dist_esm_internal_type_mjs.CopyObjectResult>;
-    static create<T extends OssBase, U>(this: new (opts: OssBaseOptions<U>) => T, opts: OssBaseOptions<U>): T;
-    static fromBase<T extends OssBase, U>(this: new (opts: OssBaseOptions<U>) => T, createOpts: {
-        oss: OssBase;
-        opts: Partial<OssBaseOptions<U>>;
-    }): T;
-}
-
-export { type ListFileObject as L, OssBase as O, type StatObjectResult as S, type UploadedObjectInfo as U, type OssBaseOptions as a, type ListDirectoryObject as b, type ListObjectResult as c, type OssBaseOperation as d, type OssService as e };