@kevisual/oss 0.0.13 → 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';