MythEclipse/TeleUploader
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor code for improved readability and consistency

Browse Source 
- Updated formatting in web-api.ts for better alignment and readability.
- Enhanced XML builders in xml.ts for clearer structure and maintainability.
- Improved test cases in s3-auth.test.ts and s3-operations.test.ts for better clarity and consistency.
- Refactored mock data in web-api.test.ts for improved readability.
This commit is contained in:
asepharyana
2026-07-06 22:36:15 +07:00
parent 2d3d7891a0
commit 245138e23a
8 changed files with 568 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/db/files-ext.ts
+1 -4
View File
@@ -111,10 +111,7 @@ export const softDeleteFile = async (bucketId: string, s3Key: string): Promise<b
return result.rows.length > 0;
};
export const softDeleteFilesBatch = async (
bucketId: string,
keys: string[],
): Promise<number> => {
export const softDeleteFilesBatch = async (bucketId: string, keys: string[]): Promise<number> => {
let deleted = 0;
for (const key of keys) {
const ok = await softDeleteFile(bucketId, key);
src/db/migrate.ts
+4 -4
View File
@@ -12,10 +12,10 @@ export const runMigration = async (): Promise<void> => {
// In source via bun --hot: import.meta.dir = .../src/db/
const dir = import.meta.dir || '';
const candidates = [
dir + '/../../schema.sql', // from dist/
dir + '/../schema.sql', // from src/ (bun --hot src/index.ts)
dir + '/../schema.sql', // from src/db/ (bun --hot src/db/migrate.ts)
dir + '/schema.sql', // from src/ (bun run db:migrate)
dir + '/../../schema.sql', // from dist/
dir + '/../schema.sql', // from src/ (bun --hot src/index.ts)
dir + '/../schema.sql', // from src/db/ (bun --hot src/db/migrate.ts)
dir + '/schema.sql', // from src/ (bun run db:migrate)
];
let schemaSql: string | null = null;
src/routes/s3.ts
+376 -62
View File
@@ -1,16 +1,31 @@
import { verifySignature, verifyPresignedUrl } from '../utils/s3/auth';
import {
listBucketsXml, s3ErrorResponse, listBucketResultXml, listBucketV2ResultXml,
initiateMultipartUploadXml, listPartsXml, completeMultipartUploadXml, deleteResultXml,
copyObjectResultXml, parseDeleteObjectsBody, parseCompleteMultipartBody,
listBucketsXml,
s3ErrorResponse,
listBucketResultXml,
listBucketV2ResultXml,
initiateMultipartUploadXml,
listPartsXml,
completeMultipartUploadXml,
deleteResultXml,
copyObjectResultXml,
parseDeleteObjectsBody,
parseCompleteMultipartBody,
} from '../utils/s3/xml';
import { createBucket, findBucketByName, listBuckets, deleteBucket } from '../db/buckets';
import {
createMultipartUpload, findMultipartUpload, completeMultipartUpload, abortMultipartUpload,
insertMultipartPart, listMultipartParts,
createMultipartUpload,
findMultipartUpload,
completeMultipartUpload,
abortMultipartUpload,
insertMultipartPart,
listMultipartParts,
} from '../db/multipart';
import {
findFileByBucketAndKey, listObjectsByPrefix, softDeleteFile, countBucketObjects,
findFileByBucketAndKey,
listObjectsByPrefix,
softDeleteFile,
countBucketObjects,
} from '../db/files-ext';
import type { File } from '../db/schema';
import { config } from '../env';
@@ -52,12 +67,32 @@ export const handleS3Request = async (req: Request): Promise<Response> => {
// Presigned URLs: only supported for GET (verified in handleGetObject)
if (searchParams.has('X-Amz-Signature')) {
if (method !== 'GET') {
return s3ErrorResponse('AccessDenied', 'Presigned URLs only supported for GET', pathname, 403, reqId);
return s3ErrorResponse(
'AccessDenied',
'Presigned URLs only supported for GET',
pathname,
403,
reqId,
);
}
} else {
const authResult = await verifySignature(method, req.url, headers, null, config.s3AccessKey, config.s3SecretKey, REGION);
const authResult = await verifySignature(
method,
req.url,
headers,
null,
config.s3AccessKey,
config.s3SecretKey,
REGION,
);
if (!authResult.isValid) {
return s3ErrorResponse(authResult.errorCode || 'AccessDenied', 'Authentication required', pathname, 403, reqId);
return s3ErrorResponse(
authResult.errorCode || 'AccessDenied',
'Authentication required',
pathname,
403,
reqId,
);
}
}
@@ -67,7 +102,13 @@ export const handleS3Request = async (req: Request): Promise<Response> => {
if (method === 'GET') {
return handleListBuckets(reqId);
}
return s3ErrorResponse('MethodNotAllowed', 'The specified method is not allowed against this resource.', '/', 405, reqId);
return s3ErrorResponse(
'MethodNotAllowed',
'The specified method is not allowed against this resource.',
'/',
405,
reqId,
);
}
// Bucket-level operations
@@ -91,7 +132,13 @@ export const handleS3Request = async (req: Request): Promise<Response> => {
return new Response(null, { status: 204 });
}
}
return s3ErrorResponse('MethodNotAllowed', 'The specified method is not allowed against this resource.', `/${bucket}`, 405, reqId);
return s3ErrorResponse(
'MethodNotAllowed',
'The specified method is not allowed against this resource.',
`/${bucket}`,
405,
reqId,
);
}
// Object-level: multipart checks
@@ -118,10 +165,22 @@ export const handleS3Request = async (req: Request): Promise<Response> => {
if (method === 'PUT') return handlePutObject(bucket, key, searchParams, headers, req, reqId);
if (method === 'DELETE') return handleDeleteObject(bucket, key, reqId);
return s3ErrorResponse('MethodNotAllowed', 'The specified method is not allowed against this resource.', `/${bucket}/${key}`, 405, reqId);
return s3ErrorResponse(
'MethodNotAllowed',
'The specified method is not allowed against this resource.',
`/${bucket}/${key}`,
405,
reqId,
);
} catch (error: unknown) {
logger.error('S3 operation error', { bucket, key, error: getErrorMessage(error) });
return s3ErrorResponse('InternalError', 'We encountered an internal error. Please try again.', pathname, 500, reqId);
return s3ErrorResponse(
'InternalError',
'We encountered an internal error. Please try again.',
pathname,
500,
reqId,
);
}
};
@@ -138,11 +197,23 @@ const handleListBuckets = async (reqId: string): Promise<Response> => {
const handleCreateBucket = async (bucketName: string, reqId: string): Promise<Response> => {
if (!/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(bucketName)) {
return s3ErrorResponse('InvalidBucketName', 'The specified bucket is not valid.', `/${bucketName}`, 400, reqId);
return s3ErrorResponse(
'InvalidBucketName',
'The specified bucket is not valid.',
`/${bucketName}`,
400,
reqId,
);
}
const existing = await findBucketByName(bucketName);
if (existing) {
return s3ErrorResponse('BucketAlreadyExists', 'The requested bucket name is not available.', `/${bucketName}`, 409, reqId);
return s3ErrorResponse(
'BucketAlreadyExists',
'The requested bucket name is not available.',
`/${bucketName}`,
409,
reqId,
);
}
await createBucket(bucketName);
return new Response(null, { status: 200, headers: { 'x-amz-request-id': reqId } });
@@ -151,7 +222,13 @@ const handleCreateBucket = async (bucketName: string, reqId: string): Promise<Re
const handleHeadBucket = async (bucketName: string, reqId: string): Promise<Response> => {
const bucket = await findBucketByName(bucketName);
if (!bucket) {
return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucketName}`, 404, reqId);
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucketName}`,
404,
reqId,
);
}
return new Response(null, { status: 200, headers: { 'x-amz-request-id': reqId } });
};
@@ -159,11 +236,23 @@ const handleHeadBucket = async (bucketName: string, reqId: string): Promise<Resp
const handleDeleteBucket = async (bucketName: string, reqId: string): Promise<Response> => {
const bucket = await findBucketByName(bucketName);
if (!bucket) {
return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucketName}`, 404, reqId);
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucketName}`,
404,
reqId,
);
}
const objCount = await countBucketObjects(bucket.id);
if (objCount > 0) {
return s3ErrorResponse('BucketNotEmpty', 'The bucket you tried to delete is not empty.', `/${bucketName}`, 409, reqId);
return s3ErrorResponse(
'BucketNotEmpty',
'The bucket you tried to delete is not empty.',
`/${bucketName}`,
409,
reqId,
);
}
await deleteBucket(bucketName);
return new Response(null, { status: 204, headers: { 'x-amz-request-id': reqId } });
@@ -171,20 +260,51 @@ const handleDeleteBucket = async (bucketName: string, reqId: string): Promise<Re
// ─────── Object Operations ───────
const handleGetObject = async (bucket: string, key: string, searchParams: URLSearchParams, reqId: string): Promise<Response> => {
const handleGetObject = async (
bucket: string,
key: string,
searchParams: URLSearchParams,
reqId: string,
): Promise<Response> => {
if (searchParams.has('X-Amz-Signature')) {
const fullUrl = `http://localhost/${bucket}/${key}?${searchParams.toString()}`;
const presignedResult = await verifyPresignedUrl(fullUrl, 'GET', config.s3AccessKey, config.s3SecretKey, REGION);
const presignedResult = await verifyPresignedUrl(
fullUrl,
'GET',
config.s3AccessKey,
config.s3SecretKey,
REGION,
);
if (!presignedResult.isValid) {
return s3ErrorResponse('AccessDenied', 'Request has expired', `/${bucket}/${key}`, 403, reqId);
return s3ErrorResponse(
'AccessDenied',
'Request has expired',
`/${bucket}/${key}`,
403,
reqId,
);
}
}
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
const file = await findFileByBucketAndKey(bucketRecord.id, key);
if (!file) return s3ErrorResponse('NoSuchKey', 'The specified key does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!file)
return s3ErrorResponse(
'NoSuchKey',
'The specified key does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
if (file.multipartUploadId) {
return handleGetMultipartObject(file, bucket, key, reqId);
@@ -202,12 +322,23 @@ const handleGetObject = async (bucket: string, key: string, searchParams: URLSea
});
};
const handleGetMultipartObject = async (file: File, bucket: string, key: string, reqId: string): Promise<Response> => {
const handleGetMultipartObject = async (
file: File,
bucket: string,
key: string,
reqId: string,
): Promise<Response> => {
const uploadId = file.multipartUploadId!;
const parts = await listMultipartParts(uploadId);
if (parts.length === 0) {
return s3ErrorResponse('InternalError', 'Multipart object has no parts.', `/${bucket}/${key}`, 500, reqId);
return s3ErrorResponse(
'InternalError',
'Multipart object has no parts.',
`/${bucket}/${key}`,
500,
reqId,
);
}
const fileInfo = await getFileInfo(parts[0].telegramFileId);
@@ -224,26 +355,55 @@ const handleGetMultipartObject = async (file: File, bucket: string, key: string,
const handleHeadObject = async (bucket: string, key: string, reqId: string): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
const file = await findFileByBucketAndKey(bucketRecord.id, key);
if (!file) return s3ErrorResponse('NoSuchKey', 'The specified key does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!file)
return s3ErrorResponse(
'NoSuchKey',
'The specified key does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
return new Response(null, {
status: 200,
headers: {
'content-type': file.mimeType,
'content-length': String(file.sizeBytes),
'etag': `"${file.fileHash || nanoid(16)}"`,
'last-modified': file.createdAt instanceof Date ? file.createdAt.toUTCString() : new Date().toUTCString(),
etag: `"${file.fileHash || nanoid(16)}"`,
'last-modified':
file.createdAt instanceof Date ? file.createdAt.toUTCString() : new Date().toUTCString(),
'x-amz-request-id': reqId,
},
});
};
const handlePutObject = async (bucket: string, key: string, searchParams: URLSearchParams, headers: Record<string, string>, req: Request, reqId: string): Promise<Response> => {
const handlePutObject = async (
bucket: string,
key: string,
searchParams: URLSearchParams,
headers: Record<string, string>,
req: Request,
reqId: string,
): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
if (searchParams.has('tagging')) {
return new Response(null, { status: 204 });
@@ -262,19 +422,33 @@ const handlePutObject = async (bucket: string, key: string, searchParams: URLSea
const existing = await findFileByBucketAndKey(bucketRecord.id, key);
if (existing) {
return new Response(null, { status: 200, headers: { 'etag': `"${hash}"`, 'x-amz-request-id': reqId } });
return new Response(null, {
status: 200,
headers: { etag: `"${hash}"`, 'x-amz-request-id': reqId },
});
}
return await storeFileToTelegram(fileBuffer, hash, key, bucketRecord, contentType, reqId);
};
const storeFileToTelegram = async (buffer: Buffer, hash: string, key: string, bucketRecord: { id: string; name: string }, contentType: string, reqId: string): Promise<Response> => {
const storeFileToTelegram = async (
buffer: Buffer,
hash: string,
key: string,
bucketRecord: { id: string; name: string },
contentType: string,
reqId: string,
): Promise<Response> => {
const tempPath = `/tmp/teleuploader-s3-${nanoid()}`;
await Bun.write(tempPath, buffer);
const signatureBuffer = buffer.subarray(0, 16);
const fileName = key.split('/').pop() || 'file';
const { fileName: finalFileName, mimeType } = ensureExtension(fileName, signatureBuffer, contentType);
const { fileName: finalFileName, mimeType } = ensureExtension(
fileName,
signatureBuffer,
contentType,
);
const forwardResult = await forwardToStorage(
createReadStream(tempPath),
@@ -309,21 +483,41 @@ const storeFileToTelegram = async (buffer: Buffer, hash: string, key: string, bu
return new Response(null, {
status: 200,
headers: { 'etag': `"${hash}"`, 'x-amz-request-id': reqId },
headers: { etag: `"${hash}"`, 'x-amz-request-id': reqId },
});
};
const handleCopyObject = async (_destBucket: string, destKey: string, copySource: string, destBucketId: string, reqId: string): Promise<Response> => {
const handleCopyObject = async (
_destBucket: string,
destKey: string,
copySource: string,
destBucketId: string,
reqId: string,
): Promise<Response> => {
const sourcePath = copySource.startsWith('/') ? copySource.slice(1) : copySource;
const parts = sourcePath.split('/');
const sourceBucket = parts[0];
const sourceKey = parts.slice(1).join('/');
const sourceBucketRecord = await findBucketByName(sourceBucket);
if (!sourceBucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', copySource, 404, reqId);
if (!sourceBucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
copySource,
404,
reqId,
);
const sourceFile = await findFileByBucketAndKey(sourceBucketRecord.id, sourceKey);
if (!sourceFile) return s3ErrorResponse('NoSuchKey', 'The specified key does not exist.', copySource, 404, reqId);
if (!sourceFile)
return s3ErrorResponse(
'NoSuchKey',
'The specified key does not exist.',
copySource,
404,
reqId,
);
const publicId = nanoid();
const { db, files: fileSchema } = await import('../db/index');
@@ -355,17 +549,39 @@ const handleCopyObject = async (_destBucket: string, destKey: string, copySource
});
};
const handleDeleteObject = async (bucket: string, key: string, reqId: string): Promise<Response> => {
const handleDeleteObject = async (
bucket: string,
key: string,
reqId: string,
): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
await softDeleteFile(bucketRecord.id, key);
return new Response(null, { status: 204, headers: { 'x-amz-request-id': reqId } });
};
const handleDeleteObjects = async (bucket: string, body: string, reqId: string): Promise<Response> => {
const handleDeleteObjects = async (
bucket: string,
body: string,
reqId: string,
): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}`,
404,
reqId,
);
const { keys } = parseDeleteObjectsBody(body);
const deletedKeys: string[] = [];
@@ -382,9 +598,20 @@ const handleDeleteObjects = async (bucket: string, body: string, reqId: string):
// ─────── Object Listing ───────
const handleListObjectsV1 = async (bucket: string, searchParams: URLSearchParams, reqId: string): Promise<Response> => {
const handleListObjectsV1 = async (
bucket: string,
searchParams: URLSearchParams,
reqId: string,
): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}`,
404,
reqId,
);
const prefix = searchParams.get('prefix') || '';
const delimiter = searchParams.get('delimiter') || null;
@@ -392,12 +619,18 @@ const handleListObjectsV1 = async (bucket: string, searchParams: URLSearchParams
const marker = searchParams.get('marker') || null;
const { objects, prefixes: commonPrefixes } = await listObjectsByPrefix(
bucketRecord.id, prefix, delimiter, maxKeys, marker,
bucketRecord.id,
prefix,
delimiter,
maxKeys,
marker,
);
const isTruncated = objects.length > maxKeys;
const displayObjects = objects.slice(0, maxKeys);
const nextMarker = isTruncated ? (displayObjects[displayObjects.length - 1]?.s3Key ?? null) : null;
const nextMarker = isTruncated
? (displayObjects[displayObjects.length - 1]?.s3Key ?? null)
: null;
const xml = listBucketResultXml(
bucket,
@@ -424,9 +657,20 @@ const handleListObjectsV1 = async (bucket: string, searchParams: URLSearchParams
});
};
const handleListObjectsV2 = async (bucket: string, searchParams: URLSearchParams, reqId: string): Promise<Response> => {
const handleListObjectsV2 = async (
bucket: string,
searchParams: URLSearchParams,
reqId: string,
): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}`,
404,
reqId,
);
const prefix = searchParams.get('prefix') || '';
const delimiter = searchParams.get('delimiter') || null;
@@ -435,12 +679,18 @@ const handleListObjectsV2 = async (bucket: string, searchParams: URLSearchParams
const startAfter = searchParams.get('start-after') || null;
const { objects, prefixes: commonPrefixes } = await listObjectsByPrefix(
bucketRecord.id, prefix, delimiter, maxKeys, continuationToken || startAfter,
bucketRecord.id,
prefix,
delimiter,
maxKeys,
continuationToken || startAfter,
);
const isTruncated = objects.length > maxKeys;
const displayObjects = objects.slice(0, maxKeys);
const nextContinuationToken = isTruncated ? (displayObjects[displayObjects.length - 1]?.s3Key ?? null) : null;
const nextContinuationToken = isTruncated
? (displayObjects[displayObjects.length - 1]?.s3Key ?? null)
: null;
const xml = listBucketV2ResultXml(
bucket,
@@ -470,9 +720,21 @@ const handleListObjectsV2 = async (bucket: string, searchParams: URLSearchParams
// ─────── Multipart Upload ───────
const handleCreateMultipartUpload = async (bucket: string, key: string, _searchParams: URLSearchParams, reqId: string): Promise<Response> => {
const handleCreateMultipartUpload = async (
bucket: string,
key: string,
_searchParams: URLSearchParams,
reqId: string,
): Promise<Response> => {
const bucketRecord = await findBucketByName(bucket);
if (!bucketRecord) return s3ErrorResponse('NoSuchBucket', 'The specified bucket does not exist.', `/${bucket}/${key}`, 404, reqId);
if (!bucketRecord)
return s3ErrorResponse(
'NoSuchBucket',
'The specified bucket does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
const uploadId = await createMultipartUpload(bucketRecord.id, key, 's3');
@@ -483,13 +745,25 @@ const handleCreateMultipartUpload = async (bucket: string, key: string, _searchP
});
};
const handleUploadPart = async (bucket: string, key: string, searchParams: URLSearchParams, req: Request, reqId: string): Promise<Response> => {
const handleUploadPart = async (
bucket: string,
key: string,
searchParams: URLSearchParams,
req: Request,
reqId: string,
): Promise<Response> => {
const uploadId = searchParams.get('uploadId')!;
const partNumber = parseInt(searchParams.get('partNumber')!, 10);
const multipart = await findMultipartUpload(uploadId);
if (!multipart || multipart.s3Key !== key) {
return s3ErrorResponse('NoSuchUpload', 'The specified upload does not exist.', `/${bucket}/${key}`, 404, reqId);
return s3ErrorResponse(
'NoSuchUpload',
'The specified upload does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
}
const body = await req.arrayBuffer();
@@ -519,22 +793,40 @@ const handleUploadPart = async (bucket: string, key: string, searchParams: URLSe
return new Response(null, {
status: 200,
headers: { 'etag': `"${etag}"`, 'x-amz-request-id': reqId },
headers: { etag: `"${etag}"`, 'x-amz-request-id': reqId },
});
};
const handleCompleteMultipartUpload = async (bucket: string, key: string, searchParams: URLSearchParams, body: string, reqId: string): Promise<Response> => {
const handleCompleteMultipartUpload = async (
bucket: string,
key: string,
searchParams: URLSearchParams,
body: string,
reqId: string,
): Promise<Response> => {
const uploadId = searchParams.get('uploadId')!;
const multipart = await findMultipartUpload(uploadId);
if (!multipart) {
return s3ErrorResponse('NoSuchUpload', 'The specified upload does not exist.', `/${bucket}/${key}`, 404, reqId);
return s3ErrorResponse(
'NoSuchUpload',
'The specified upload does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
}
const parts = parseCompleteMultipartBody(body);
const storedParts = await listMultipartParts(uploadId);
if (parts.length !== storedParts.length) {
return s3ErrorResponse('InvalidPart', 'One or more specified parts could not be found.', `/${bucket}/${key}`, 400, reqId);
return s3ErrorResponse(
'InvalidPart',
'One or more specified parts could not be found.',
`/${bucket}/${key}`,
400,
reqId,
);
}
const totalSize = storedParts.reduce((sum, p) => sum + p.sizeBytes, 0);
@@ -574,22 +866,44 @@ const handleCompleteMultipartUpload = async (bucket: string, key: string, search
});
};
const handleAbortMultipartUpload = async (bucket: string, key: string, searchParams: URLSearchParams, reqId: string): Promise<Response> => {
const handleAbortMultipartUpload = async (
bucket: string,
key: string,
searchParams: URLSearchParams,
reqId: string,
): Promise<Response> => {
const uploadId = searchParams.get('uploadId')!;
const multipart = await findMultipartUpload(uploadId);
if (!multipart) {
return s3ErrorResponse('NoSuchUpload', 'The specified upload does not exist.', `/${bucket}/${key}`, 404, reqId);
return s3ErrorResponse(
'NoSuchUpload',
'The specified upload does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
}
await abortMultipartUpload(uploadId);
return new Response(null, { status: 204, headers: { 'x-amz-request-id': reqId } });
};
const handleListParts = async (bucket: string, key: string, searchParams: URLSearchParams, reqId: string): Promise<Response> => {
const handleListParts = async (
bucket: string,
key: string,
searchParams: URLSearchParams,
reqId: string,
): Promise<Response> => {
const uploadId = searchParams.get('uploadId')!;
const multipart = await findMultipartUpload(uploadId);
if (!multipart) {
return s3ErrorResponse('NoSuchUpload', 'The specified upload does not exist.', `/${bucket}/${key}`, 404, reqId);
return s3ErrorResponse(
'NoSuchUpload',
'The specified upload does not exist.',
`/${bucket}/${key}`,
404,
reqId,
);
}
const parts = await listMultipartParts(uploadId);
src/routes/web-api.ts
+54 -20
View File
@@ -1,6 +1,9 @@
import { createBucket, findBucketByName, listBuckets, deleteBucket } from '../db/buckets';
import {
findFileByBucketAndKey, listObjectsByPrefix, softDeleteFile, countBucketObjects,
findFileByBucketAndKey,
listObjectsByPrefix,
softDeleteFile,
countBucketObjects,
} from '../db/files-ext';
import { createReadStream } from 'node:fs';
import { config } from '../env';
@@ -11,11 +14,9 @@ import logger from '../utils/logger';
type RouteParams = { bucket?: string; key?: string };
const json = (data: unknown, status = 200) =>
Response.json(data, { status });
const json = (data: unknown, status = 200) => Response.json(data, { status });
const jsonError = (error: string, status: number) =>
Response.json({ error }, { status });
const jsonError = (error: string, status: number) => Response.json({ error }, { status });
// ─────── Bucket endpoints ───────
@@ -43,7 +44,10 @@ export const handleCreateBucketV1 = async (req: Request): Promise<Response> => {
return json({ id: bucket.id, name: bucket.name }, 201);
};
export const handleDeleteBucketV1 = async (_req: Request, params: RouteParams): Promise<Response> => {
export const handleDeleteBucketV1 = async (
_req: Request,
params: RouteParams,
): Promise<Response> => {
const bucket = await findBucketByName(params.bucket!);
if (!bucket) return jsonError('Bucket not found', 404);
const count = await countBucketObjects(bucket.id);
@@ -65,7 +69,11 @@ export const handleListObjectsV1 = async (req: Request, params: RouteParams): Pr
const continuationToken = url.searchParams.get('continuation-token') || null;
const { objects, prefixes } = await listObjectsByPrefix(
bucket.id, prefix, delimiter, maxKeys, continuationToken,
bucket.id,
prefix,
delimiter,
maxKeys,
continuationToken,
);
const isTruncated = objects.length > maxKeys;
const displayObjects = objects.slice(0, maxKeys);
@@ -78,20 +86,22 @@ export const handleListObjectsV1 = async (req: Request, params: RouteParams): Pr
sizeBytes: o.sizeBytes,
fileType: o.fileType,
etag: o.fileHash,
lastModified: o.createdAt instanceof Date
? o.createdAt.toISOString()
: new Date(o.createdAt).toISOString(),
lastModified:
o.createdAt instanceof Date
? o.createdAt.toISOString()
: new Date(o.createdAt).toISOString(),
downloadUrl: `${config.baseUrl}/f/${o.publicId}`,
})),
prefixes,
isTruncated,
nextContinuationToken: isTruncated
? displayObjects[displayObjects.length - 1]?.s3Key
: null,
nextContinuationToken: isTruncated ? displayObjects[displayObjects.length - 1]?.s3Key : null,
});
};
export const handleUploadObjectV1 = async (req: Request, params: RouteParams): Promise<Response> => {
export const handleUploadObjectV1 = async (
req: Request,
params: RouteParams,
): Promise<Response> => {
const bucket = await findBucketByName(params.bucket!);
if (!bucket) return jsonError('Bucket not found', 404);
@@ -147,17 +157,26 @@ export const handleUploadObjectV1 = async (req: Request, params: RouteParams): P
await cleanupTempFile(tempPath);
return json({ key, size: buffer.byteLength, etag: hash, downloadUrl: `${config.baseUrl}/f/${publicId}` }, 201);
return json(
{ key, size: buffer.byteLength, etag: hash, downloadUrl: `${config.baseUrl}/f/${publicId}` },
201,
);
};
export const handleDeleteObjectV1 = async (_req: Request, params: RouteParams): Promise<Response> => {
export const handleDeleteObjectV1 = async (
_req: Request,
params: RouteParams,
): Promise<Response> => {
const bucket = await findBucketByName(params.bucket!);
if (!bucket) return jsonError('Bucket not found', 404);
await softDeleteFile(bucket.id, params.key!);
return json({ success: true });
};
export const handleDownloadObjectV1 = async (_req: Request, params: RouteParams): Promise<Response> => {
export const handleDownloadObjectV1 = async (
_req: Request,
params: RouteParams,
): Promise<Response> => {
const bucket = await findBucketByName(params.bucket!);
if (!bucket) return jsonError('Bucket not found', 404);
@@ -241,12 +260,22 @@ export const handleWebApiV1 = async (req: Request): Promise<Response> => {
}
// GET /api/v1/buckets/{name}/objects
if (parts.length === 3 && parts[0] === 'buckets' && parts[2] === 'objects' && method === 'GET') {
if (
parts.length === 3 &&
parts[0] === 'buckets' &&
parts[2] === 'objects' &&
method === 'GET'
) {
return await handleListObjectsV1(req, { bucket: parts[1] });
}
// POST /api/v1/buckets/{name}/upload
if (parts.length === 3 && parts[0] === 'buckets' && parts[2] === 'upload' && method === 'POST') {
if (
parts.length === 3 &&
parts[0] === 'buckets' &&
parts[2] === 'upload' &&
method === 'POST'
) {
return await handleUploadObjectV1(req, { bucket: parts[1] });
}
@@ -263,7 +292,12 @@ export const handleWebApiV1 = async (req: Request): Promise<Response> => {
}
// GET /api/v1/buckets/{name}/download/{key+}
if (parts.length >= 4 && parts[0] === 'buckets' && parts[2] === 'download' && method === 'GET') {
if (
parts.length >= 4 &&
parts[0] === 'buckets' &&
parts[2] === 'download' &&
method === 'GET'
) {
const bucket = parts[1];
const key = parts.slice(3).join('/');
return await handleDownloadObjectV1(req, { bucket, key });
src/utils/s3/xml.ts
+48 -16
View File
@@ -16,10 +16,14 @@ export const listBucketsXml = (
): string => `<?xml version="1.0" encoding="UTF-8"?>
<ListAllMyBucketsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Buckets>
${buckets.map((b) => `<Bucket>
${buckets
.map(
(b) => `<Bucket>
<Name>${escapeXml(b.name)}</Name>
<CreationDate>${isoDate(b.createdAt)}</CreationDate>
</Bucket>`).join('')}
</Bucket>`,
)
.join('')}
</Buckets>
</ListAllMyBucketsResult>`;
@@ -44,16 +48,24 @@ export const listBucketResultXml = (
<MaxKeys>${maxKeys}</MaxKeys>
<Delimiter>${escapeXml(delimiter || '')}</Delimiter>
<IsTruncated>${isTruncated}</IsTruncated>
${objects.map((o) => `<Contents>
${objects
.map(
(o) => `<Contents>
<Key>${escapeXml(o.key)}</Key>
<LastModified>${isoDate(o.lastModified)}</LastModified>
<ETag>"${o.etag}"</ETag>
<Size>${o.sizeBytes}</Size>
<StorageClass>STANDARD</StorageClass>
</Contents>`).join('')}
${prefixes.map((p) => `<CommonPrefixes>
</Contents>`,
)
.join('')}
${prefixes
.map(
(p) => `<CommonPrefixes>
<Prefix>${escapeXml(p)}</Prefix>
</CommonPrefixes>`).join('')}
</CommonPrefixes>`,
)
.join('')}
${nextMarker ? `<NextMarker>${escapeXml(nextMarker)}</NextMarker>` : ''}
</ListBucketResult>`;
@@ -78,16 +90,24 @@ export const listBucketV2ResultXml = (
${delimiter ? `<Delimiter>${escapeXml(delimiter)}</Delimiter>` : ''}
${continuationToken ? `<ContinuationToken>${escapeXml(continuationToken)}</ContinuationToken>` : ''}
<IsTruncated>${isTruncated}</IsTruncated>
${objects.map((o) => `<Contents>
${objects
.map(
(o) => `<Contents>
<Key>${escapeXml(o.key)}</Key>
<LastModified>${isoDate(o.lastModified)}</LastModified>
<ETag>"${o.etag}"</ETag>
<Size>${o.sizeBytes}</Size>
<StorageClass>STANDARD</StorageClass>
</Contents>`).join('')}
${prefixes.map((p) => `<CommonPrefixes>
</Contents>`,
)
.join('')}
${prefixes
.map(
(p) => `<CommonPrefixes>
<Prefix>${escapeXml(p)}</Prefix>
</CommonPrefixes>`).join('')}
</CommonPrefixes>`,
)
.join('')}
${nextContinuationToken ? `<NextContinuationToken>${escapeXml(nextContinuationToken)}</NextContinuationToken>` : ''}
</ListBucketResultV2>`;
@@ -119,12 +139,16 @@ export const listPartsXml = (
<UploadId>${uploadId}</UploadId>
<MaxParts>${maxParts}</MaxParts>
<IsTruncated>${isTruncated}</IsTruncated>
${parts.map((p) => `<Part>
${parts
.map(
(p) => `<Part>
<PartNumber>${p.partNumber}</PartNumber>
<LastModified>${isoDate(p.createdAt)}</LastModified>
<ETag>"${p.etag}"</ETag>
<Size>${p.sizeBytes}</Size>
</Part>`).join('')}
</Part>`,
)
.join('')}
</ListPartsResult>`;
export const completeMultipartUploadXml = (
@@ -147,14 +171,22 @@ export const deleteResultXml = (
errors: { key: string; code: string; message: string }[],
): string => `<?xml version="1.0" encoding="UTF-8"?>
<DeleteResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
${deleted.map((key) => `<Deleted>
${deleted
.map(
(key) => `<Deleted>
<Key>${escapeXml(key)}</Key>
</Deleted>`).join('')}
${errors.map((e) => `<Error>
</Deleted>`,
)
.join('')}
${errors
.map(
(e) => `<Error>
<Key>${escapeXml(e.key)}</Key>
<Code>${e.code}</Code>
<Message>${escapeXml(e.message)}</Message>
</Error>`).join('')}
</Error>`,
)
.join('')}
</DeleteResult>`;
// ─────── Copy ───────
test/s3-auth.test.ts
+38 -6
View File
@@ -19,35 +19,67 @@ describe('S3 Auth (SigV4)', () => {
});
it('rejects missing Authorization header', async () => {
const result = await verifySignature('GET', 'http://localhost/', {}, null, 'key', 'secret', 'us-east-1');
const result = await verifySignature(
'GET',
'http://localhost/',
{},
null,
'key',
'secret',
'us-east-1',
);
expect(result.isValid).toBe(false);
expect(result.errorCode).toBe('AccessDenied');
});
it('rejects wrong access key before signature calculation succeeds', async () => {
const headers = {
authorization: 'AWS4-HMAC-SHA256 Credential=wrongkey/20260706/us-east-1/s3/aws4_request, SignedHeaders=host, Signature=abc123',
authorization:
'AWS4-HMAC-SHA256 Credential=wrongkey/20260706/us-east-1/s3/aws4_request, SignedHeaders=host, Signature=abc123',
'x-amz-date': '20260706T120000Z',
host: 'localhost',
};
const result = await verifySignature('GET', 'http://localhost/', headers, null, 'correctkey', 'secret', 'us-east-1');
const result = await verifySignature(
'GET',
'http://localhost/',
headers,
null,
'correctkey',
'secret',
'us-east-1',
);
expect(result.isValid).toBe(false);
expect(result.errorCode).toBe('SignatureDoesNotMatch');
});
it('rejects region mismatch in Authorization credential scope', async () => {
const headers = {
authorization: 'AWS4-HMAC-SHA256 Credential=testkey/20260706/eu-west-1/s3/aws4_request, SignedHeaders=host;x-amz-date, Signature=abc123',
authorization:
'AWS4-HMAC-SHA256 Credential=testkey/20260706/eu-west-1/s3/aws4_request, SignedHeaders=host;x-amz-date, Signature=abc123',
'x-amz-date': '20260706T120000Z',
host: 'localhost',
};
const result = await verifySignature('GET', 'http://localhost/', headers, null, 'testkey', 'secret', 'us-east-1');
const result = await verifySignature(
'GET',
'http://localhost/',
headers,
null,
'testkey',
'secret',
'us-east-1',
);
expect(result.isValid).toBe(false);
expect(result.errorCode).toBe('SignatureDoesNotMatch');
});
it('rejects malformed presigned URLs', async () => {
const result = await verifyPresignedUrl('http://localhost/bucket/key', 'GET', 'key', 'secret', 'us-east-1');
const result = await verifyPresignedUrl(
'http://localhost/bucket/key',
'GET',
'key',
'secret',
'us-east-1',
);
expect(result.isValid).toBe(false);
expect(result.errorCode).toBe('AccessDenied');
});
test/s3-operations.test.ts
+37 -8
View File
@@ -17,7 +17,15 @@ describe('S3 XML Builders', () => {
const xml = await import('../src/utils/s3/xml');
const result = xml.listBucketResultXml(
'my-bucket',
[{ key: 'folder/a&b.txt', sizeBytes: 100, etag: 'abc', lastModified: new Date('2026-01-01T00:00:00Z'), mimeType: 'text/plain' }],
[
{
key: 'folder/a&b.txt',
sizeBytes: 100,
etag: 'abc',
lastModified: new Date('2026-01-01T00:00:00Z'),
mimeType: 'text/plain',
},
],
['photos/'],
false,
null,
@@ -37,7 +45,15 @@ describe('S3 XML Builders', () => {
const xml = await import('../src/utils/s3/xml');
const result = xml.listBucketV2ResultXml(
'my-bucket',
[{ key: 'a.txt', sizeBytes: 50, etag: 'def', lastModified: new Date('2026-01-01T00:00:00Z'), mimeType: 'text/plain' }],
[
{
key: 'a.txt',
sizeBytes: 50,
etag: 'def',
lastModified: new Date('2026-01-01T00:00:00Z'),
mimeType: 'text/plain',
},
],
[],
false,
1000,
@@ -55,14 +71,25 @@ describe('S3 XML Builders', () => {
it('builds multipart and copy XML responses', async () => {
const xml = await import('../src/utils/s3/xml');
expect(xml.initiateMultipartUploadXml('bucket', 'key', 'upload-123')).toContain('<UploadId>upload-123</UploadId>');
expect(xml.completeMultipartUploadXml('bucket', 'key', 'etag-abc', 'http://localhost/bucket/key')).toContain('<CompleteMultipartUploadResult');
expect(xml.copyObjectResultXml('etag-abc', new Date('2026-01-01T00:00:00Z'))).toContain('<CopyObjectResult');
expect(xml.initiateMultipartUploadXml('bucket', 'key', 'upload-123')).toContain(
'<UploadId>upload-123</UploadId>',
);
expect(
xml.completeMultipartUploadXml('bucket', 'key', 'etag-abc', 'http://localhost/bucket/key'),
).toContain('<CompleteMultipartUploadResult');
expect(xml.copyObjectResultXml('etag-abc', new Date('2026-01-01T00:00:00Z'))).toContain(
'<CopyObjectResult',
);
});
it('builds error XML and error Response', async () => {
const xml = await import('../src/utils/s3/xml');
const result = xml.s3ErrorXml('NoSuchBucket', 'The specified bucket does not exist', '/bucket', 'req-1');
const result = xml.s3ErrorXml(
'NoSuchBucket',
'The specified bucket does not exist',
'/bucket',
'req-1',
);
expect(result).toContain('<Code>NoSuchBucket</Code>');
expect(result).toContain('<RequestId>req-1</RequestId>');
@@ -73,7 +100,8 @@ describe('S3 XML Builders', () => {
it('parses DeleteObjects body', async () => {
const xml = await import('../src/utils/s3/xml');
const body = '<Delete><Object><Key>file1.txt</Key></Object><Object><Key>file2.txt</Key></Object><Quiet>true</Quiet></Delete>';
const body =
'<Delete><Object><Key>file1.txt</Key></Object><Object><Key>file2.txt</Key></Object><Quiet>true</Quiet></Delete>';
const { keys, quiet } = xml.parseDeleteObjectsBody(body);
expect(keys).toEqual(['file1.txt', 'file2.txt']);
expect(quiet).toBe(true);
@@ -81,7 +109,8 @@ describe('S3 XML Builders', () => {
it('parses CompleteMultipartUpload body', async () => {
const xml = await import('../src/utils/s3/xml');
const body = '<CompleteMultipartUpload><Part><PartNumber>1</PartNumber><ETag>"abc"</ETag></Part><Part><PartNumber>2</PartNumber><ETag>"def"</ETag></Part></CompleteMultipartUpload>';
const body =
'<CompleteMultipartUpload><Part><PartNumber>1</PartNumber><ETag>"abc"</ETag></Part><Part><PartNumber>2</PartNumber><ETag>"def"</ETag></Part></CompleteMultipartUpload>';
const parts = xml.parseCompleteMultipartBody(body);
expect(parts).toEqual([
{ partNumber: 1, etag: 'abc' },
test/web-api.test.ts
+10 -3
View File
@@ -1,13 +1,20 @@
import { afterAll, beforeAll, describe, expect, it, mock } from 'bun:test';
const mockBuckets = [
{ id: 'uuid-1', name: 'test-bucket', createdAt: new Date('2026-01-01'), updatedAt: new Date('2026-01-01') },
{
id: 'uuid-1',
name: 'test-bucket',
createdAt: new Date('2026-01-01'),
updatedAt: new Date('2026-01-01'),
},
];
mock.module('../src/db/buckets', () => ({
listBuckets: () => Promise.resolve(mockBuckets),
findBucketByName: (name: string) => Promise.resolve(mockBuckets.find((b) => b.name === name) || null),
createBucket: (name: string) => Promise.resolve({ id: 'new-uuid', name, createdAt: new Date(), updatedAt: new Date() }),
findBucketByName: (name: string) =>
Promise.resolve(mockBuckets.find((b) => b.name === name) || null),
createBucket: (name: string) =>
Promise.resolve({ id: 'new-uuid', name, createdAt: new Date(), updatedAt: new Date() }),
deleteBucket: () => Promise.resolve(true),
bucketExists: () => Promise.resolve(false),
}));