@balena/pinejs 17.0.0-build-v17-a23172f0d3c5aa4169ebb0f29d4939508c9074cf-2 → 17.0.0-build-17-x-74b0e8403edbd7922c684e3ce19bdb42ac41846b-1

package/src/webresource-handler/handlers/NoopHandler.ts

@@ -1,10 +1,5 @@
 import type { WebResourceType as WebResource } from '@balena/sbvr-types';
-import type {
-	BeginMultipartUploadHandlerResponse,
-	IncomingFile,
-	UploadResponse,
-	WebResourceHandler,
-} from '..';
+import type { IncomingFile, UploadResponse, WebResourceHandler } from '..';
 
 export class NoopHandler implements WebResourceHandler {
 	public async handleFile(resource: IncomingFile): Promise<UploadResponse> {
@@ -23,12 +18,4 @@ export class NoopHandler implements WebResourceHandler {
 	public async onPreRespond(webResource: WebResource): Promise<WebResource> {
 		return webResource;
 	}
-
-	public async beginMultipartUpload(): Promise<BeginMultipartUploadHandlerResponse> {
-		return { fileKey: 'noop', uploadId: 'noop', uploadParts: [] };
-	}
-
-	public async commitMultipartUpload(): Promise<WebResource> {
-		return { filename: 'noop', href: 'noop' };
-	}
 }

package/src/webresource-handler/handlers/S3Handler.ts

@@ -0,0 +1,143 @@
+import {
+	FileSizeExceededError,
+	type IncomingFile,
+	normalizeHref,
+	type UploadResponse,
+	WebResourceError,
+	type WebResourceHandler,
+} from '..';
+import {
+	S3Client,
+	type S3ClientConfig,
+	DeleteObjectCommand,
+	type PutObjectCommandInput,
+	GetObjectCommand,
+} from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+import { randomUUID } from 'crypto';
+import type { WebResourceType as WebResource } from '@balena/sbvr-types';
+import memoize from 'memoizee';
+
+export interface S3HandlerProps {
+	region: string;
+	accessKey: string;
+	secretKey: string;
+	endpoint: string;
+	bucket: string;
+	maxSize?: number;
+	signedUrlExpireTimeSeconds?: number;
+	signedUrlCacheExpireTimeSeconds?: number;
+}
+
+export class S3Handler implements WebResourceHandler {
+	private readonly config: S3ClientConfig;
+	private readonly bucket: string;
+	private readonly maxFileSize: number;
+
+	protected readonly signedUrlExpireTimeSeconds: number;
+	protected readonly signedUrlCacheExpireTimeSeconds: number;
+	protected cachedGetSignedUrl: (fileKey: string) => Promise<string>;
+
+	private client: S3Client;
+
+	constructor(config: S3HandlerProps) {
+		this.config = {
+			region: config.region,
+			credentials: {
+				accessKeyId: config.accessKey,
+				secretAccessKey: config.secretKey,
+			},
+			endpoint: config.endpoint,
+			forcePathStyle: true,
+		};
+
+		this.signedUrlExpireTimeSeconds =
+			config.signedUrlExpireTimeSeconds ?? 86400; // 24h
+		this.signedUrlCacheExpireTimeSeconds =
+			config.signedUrlCacheExpireTimeSeconds ?? 82800; // 22h
+
+		this.maxFileSize = config.maxSize ?? 52428800;
+		this.bucket = config.bucket;
+		this.client = new S3Client(this.config);
+
+		// Memoize expects maxAge in MS and s3 signing method in seconds.
+		// Normalization to use only seconds and therefore convert here from seconds to MS
+		this.cachedGetSignedUrl = memoize(this.s3SignUrl, {
+			maxAge: this.signedUrlCacheExpireTimeSeconds * 1000,
+		});
+	}
+
+	public async handleFile(resource: IncomingFile): Promise<UploadResponse> {
+		let size = 0;
+		const key = `${resource.fieldname}_${randomUUID()}_${
+			resource.originalname
+		}`;
+		const params: PutObjectCommandInput = {
+			Bucket: this.bucket,
+			Key: key,
+			Body: resource.stream,
+			ContentType: resource.mimetype,
+		};
+		const upload = new Upload({ client: this.client, params });
+
+		upload.on('httpUploadProgress', async (ev) => {
+			size = ev.total ?? ev.loaded!;
+			if (size > this.maxFileSize) {
+				await upload.abort();
+			}
+		});
+
+		try {
+			await upload.done();
+		} catch (err: any) {
+			resource.stream.resume();
+			if (size > this.maxFileSize) {
+				throw new FileSizeExceededError(this.maxFileSize);
+			}
+			throw new WebResourceError(err);
+		}
+
+		const filename = this.getS3URL(key);
+		return { size, filename };
+	}
+
+	public async removeFile(href: string): Promise<void> {
+		const fileKey = this.getKeyFromHref(href);
+
+		const command = new DeleteObjectCommand({
+			Bucket: this.bucket,
+			Key: fileKey,
+		});
+
+		await this.client.send(command);
+	}
+
+	public async onPreRespond(webResource: WebResource): Promise<WebResource> {
+		if (webResource.href != null) {
+			const fileKey = this.getKeyFromHref(webResource.href);
+			webResource.href = await this.cachedGetSignedUrl(fileKey);
+		}
+		return webResource;
+	}
+
+	private s3SignUrl(fileKey: string): Promise<string> {
+		const command = new GetObjectCommand({
+			Bucket: this.bucket,
+			Key: fileKey,
+		});
+		return getSignedUrl(this.client, command, {
+			expiresIn: this.signedUrlExpireTimeSeconds,
+		});
+	}
+
+	private getS3URL(key: string): string {
+		return `${this.config.endpoint}/${this.bucket}/${key}`;
+	}
+
+	private getKeyFromHref(href: string): string {
+		const hrefWithoutParams = normalizeHref(href);
+		return hrefWithoutParams.substring(hrefWithoutParams.lastIndexOf('/') + 1);
+	}
+}

package/src/webresource-handler/handlers/index.ts

@@ -1 +1,2 @@
 export * from './NoopHandler';
+export * from './S3Handler';

package/src/webresource-handler/index.ts

@@ -13,7 +13,7 @@ import {
 } from '@balena/odata-to-abstract-sql';
 import { errors, permissions } from '../server-glue/module';
 import type { WebResourceType as WebResource } from '@balena/sbvr-types';
-import type { AnyObject } from 'pinejs-client-core';
+import { TypedError } from 'typed-error';
 
 export * from './handlers';
 
@@ -30,44 +30,19 @@ export interface UploadResponse {
 	filename: string;
 }
 
-export interface BeginMultipartUploadPayload {
-	filename: string;
-	content_type: string;
-	size: number;
-	chunk_size: number;
-}
-
-export interface UploadPart {
-	url: string;
-	chunkSize: number;
-	partNumber: number;
-}
-
-export interface BeginMultipartUploadHandlerResponse {
-	uploadParts: UploadPart[];
-	fileKey: string;
-	uploadId: string;
-}
-
-export interface CommitMultipartUploadPayload {
-	fileKey: string;
-	uploadId: string;
-	filename: string;
-	providerCommitData?: AnyObject;
-}
-
 export interface WebResourceHandler {
 	handleFile: (resource: IncomingFile) => Promise<UploadResponse>;
 	removeFile: (fileReference: string) => Promise<void>;
 	onPreRespond: (webResource: WebResource) => Promise<WebResource>;
+}
+
+export class WebResourceError extends TypedError {}
 
-	beginMultipartUpload: (
-		fieldName: string,
-		payload: BeginMultipartUploadPayload,
-	) => Promise<BeginMultipartUploadHandlerResponse>;
-	commitMultipartUpload: (
-		commitInfo: CommitMultipartUploadPayload,
-	) => Promise<WebResource>;
+export class FileSizeExceededError extends WebResourceError {
+	name = 'FileSizeExceededError';
+	constructor(maxSize: number) {
+		super(`File size exceeded the limit of ${maxSize} bytes.`);
+	}
 }
 
 type WebResourcesDbResponse = {
@@ -76,7 +51,7 @@ type WebResourcesDbResponse = {
 
 const getLogger = (vocab?: string): Console => {
 	if (vocab) {
-		return sbvrUtils.api[vocab]?.logger ?? console;
+		return sbvrUtils.logger[vocab] ?? console;
 	}
 	return console;
 };
@@ -218,12 +193,17 @@ export const getUploaderMiddlware = (
 				next();
 			} catch (err: any) {
 				await clearFiles();
-				getLogger(getApiRoot(req)).warn('Error uploading file', err);
-				return sbvrUtils.handleHttpErrors(
-					req,
-					res,
-					new errors.BadRequestError(err),
-				);
+
+				if (err instanceof FileSizeExceededError) {
+					return sbvrUtils.handleHttpErrors(
+						req,
+						res,
+						new errors.BadRequestError(err.message),
+					);
+				}
+
+				getLogger(getApiRoot(req)).error('Error uploading file', err);
+				next(err);
 			}
 		});
 

package/tsconfig.json

@@ -11,7 +11,7 @@
 		"removeComments": true,
 		"rootDir": "src",
 		"sourceMap": true,
-		"target": "es2021",
+		"target": "es2022",
 		"declaration": true,
 		"skipLibCheck": true,
 		"resolveJsonModule": true,