@balena/pinejs 17.0.0-build-large-file-uploads-293e65ee371a69130834c50fef2f7f42cc18133f-1 → 17.0.0-build-17-x-0447fb6e94bafa136206d060acda2f2df4c00ad2-1

package/src/sbvr-api/sbvr-utils.ts

@@ -671,20 +671,20 @@ export const executeModels = async (
 					await validateModel(tx, apiRoot);
 				}
 
-				// TODO: Can we do this without the cast?
-				api[apiRoot] = new PinejsClient('/' + apiRoot + '/') as LoggingClient;
-				api[apiRoot].logger = { ...console };
+				api[apiRoot] = new PinejsClient('/' + apiRoot + '/');
+
+				logger[apiRoot] = { ...console };
 				if (model.logging != null) {
 					const defaultSetting = model.logging?.default ?? true;
-					const { logger } = api[apiRoot];
+					const log = logger[apiRoot];
 					for (const k of Object.keys(model.logging)) {
 						const key = k as keyof Console;
 						if (
 							key !== 'Console' &&
-							typeof logger[key] === 'function' &&
+							typeof log[key] === 'function' &&
 							!(model.logging?.[key] ?? defaultSetting)
 						) {
-							logger[key] = _.noop;
+							log[key] = _.noop;
 						}
 					}
 				}
@@ -856,7 +856,7 @@ export const runRule = (() => {
 	translator.addTypes(sbvrTypes);
 	return async (vocab: string, rule: string) => {
 		const seModel = models[vocab].se;
-		const { logger } = api[vocab];
+		const log = logger[vocab];
 		let lfModel: LFModel;
 		let slfModel: LFModel;
 		let abstractSqlModel: AbstractSQLCompiler.AbstractSqlModel;
@@ -867,7 +867,7 @@ export const runRule = (() => {
 				'Process',
 			);
 		} catch (e) {
-			logger.error('Error parsing rule', rule, e);
+			log.error('Error parsing rule', rule, e);
 			throw new Error(`Error parsing rule'${rule}': ${e}`);
 		}
 
@@ -881,7 +881,7 @@ export const runRule = (() => {
 			translator.reset();
 			abstractSqlModel = translator.match(slfModel, 'Process');
 		} catch (e) {
-			logger.error('Error compiling rule', rule, e);
+			log.error('Error compiling rule', rule, e);
 			throw new Error(`Error compiling rule '${rule}': ${e}`);
 		}
 
@@ -992,6 +992,9 @@ export const runRule = (() => {
 	};
 })();
 
+/**
+ * This type shows the passthrough properties that the internal pinejs client instance accepts
+ */
 export type Passthrough = AnyObject & {
 	req?: {
 		user?: User;
@@ -999,9 +1002,7 @@ export type Passthrough = AnyObject & {
 	tx?: Db.Tx;
 };
 
-export class PinejsClient extends PinejsClientCore<PinejsClient> {
-	// @ts-expect-error This is actually assigned by `super` so it is always declared but that isn't detected here
-	public passthrough: Passthrough;
+export class PinejsClient extends PinejsClientCore {
 	public async _request({
 		method,
 		url,
@@ -1021,11 +1022,11 @@ export class PinejsClient extends PinejsClientCore<PinejsClient> {
 	}
 }
 
-export type LoggingClient = PinejsClient & {
-	logger: Console;
-};
 export const api: {
-	[vocab: string]: LoggingClient;
+	[vocab: string]: PinejsClient;
+} = {};
+export const logger: {
+	[vocab: string]: Console;
 } = {};
 
 // We default to guest only permissions if no req object is passed in
@@ -1224,7 +1225,7 @@ export const getModel = (vocabulary: string) => {
 
 const runODataRequest = (req: Express.Request, vocabulary: string) => {
 	if (env.DEBUG) {
-		api[vocabulary].logger.log('Parsing', req.method, req.url);
+		logger[vocabulary].log('Parsing', req.method, req.url);
 	}
 
 	// Get the hooks for the current method/vocabulary as we know it,
@@ -1535,10 +1536,10 @@ const runRequest = async (
 	tx: Db.Tx,
 	request: uriParser.ODataRequest,
 ): Promise<Response> => {
-	const { logger } = api[request.vocabulary];
+	const log = logger[request.vocabulary];
 
 	if (env.DEBUG) {
-		logger.log('Running', req.method, req.url);
+		log.log('Running', req.method, req.url);
 	}
 	let result: Db.Result | number | undefined;
 
@@ -1566,7 +1567,7 @@ const runRequest = async (
 		} catch (err: any) {
 			if (err instanceof db.DatabaseError) {
 				prettifyConstraintError(err, request);
-				logger.error(err);
+				log.error(err);
 				// Override the error message so we don't leak any internal db info
 				err.message = 'Database error';
 				throw err;
@@ -1580,7 +1581,7 @@ const runRequest = async (
 				err instanceof TypeError ||
 				err instanceof URIError
 			) {
-				logger.error(err);
+				log.error(err);
 				throw new InternalRequestError();
 			}
 			throw err;
@@ -1740,7 +1741,7 @@ const runQuery = async (
 	);
 
 	if (env.DEBUG) {
-		api[vocabulary].logger.log(query, values);
+		logger[vocabulary].log(query, values);
 	}
 
 	// We only add the returning clause if it's been requested and `affectedIds` hasn't been populated yet
@@ -1848,7 +1849,7 @@ const respondPost = async (
 		id,
 	);
 	if (env.DEBUG) {
-		api[vocab].logger.log('Insert ID: ', request.resourceName, id);
+		logger[vocab].log('Insert ID: ', request.resourceName, id);
 	}
 
 	let result: AnyObject = { d: [{ id }] };

package/src/sbvr-api/uri-parser.ts

@@ -421,7 +421,7 @@ export const translateUri = <
 		request.values = new Proxy(request.values, {
 			set: (obj: ODataRequest['values'], prop: string, value) => {
 				if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
-					sbvrUtils.api[request.vocabulary].logger.warn(
+					sbvrUtils.logger[request.vocabulary].warn(
 						`Assigning a new request.values property '${prop}' however it will be ignored`,
 					);
 				}

package/src/server-glue/module.ts

@@ -5,7 +5,6 @@ import './sbvr-loader';
 import * as dbModule from '../database-layer/db';
 import * as configLoader from '../config-loader/config-loader';
 import * as migrator from '../migrator/sync';
-import * as webResourceHandler from '../webresource-handler';
 import type * as migratorUtils from '../migrator/utils';
 
 import * as sbvrUtils from '../sbvr-api/sbvr-utils';
@@ -64,7 +63,6 @@ export const init = async <T extends string>(
 		await sbvrUtils.setup(app, db);
 		const cfgLoader = await configLoader.setup(app);
 		await cfgLoader.loadConfig(migrator.config);
-		await cfgLoader.loadConfig(webResourceHandler.config);
 
 		const promises: Array<Promise<void>> = [];
 		if (process.env.SBVR_SERVER_ENABLED) {

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,8 +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 { multipartUploadHooks } from './multipartUpload';
+import { TypedError } from 'typed-error';
 
 export * from './handlers';
 
@@ -31,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 = {
@@ -77,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;
 };
@@ -219,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);
 			}
 		});
 
@@ -237,7 +216,7 @@ export const getUploaderMiddlware = (
 	};
 };
 
-export const getWebResourceFields = (
+const getWebResourceFields = (
 	request: uriParser.ODataRequest,
 	useTranslations = true,
 ): string[] => {
@@ -270,8 +249,6 @@ const throwIfWebresourceNotInMultipart = (
 	{ req, request }: HookArgs,
 ) => {
 	if (
-		request.custom.isAction !== 'beginUpload' &&
-		request.custom.isAction !== 'commitUpload' &&
 		!req.is?.('multipart') &&
 		webResourceFields.some((field) => request.values[field] != null)
 	) {
@@ -470,23 +447,4 @@ export const setupUploadHooks = (
 		resourceName,
 		getCreateWebResourceHooks(handler),
 	);
-
-	sbvrUtils.addPureHook(
-		'POST',
-		apiRoot,
-		resourceName,
-		multipartUploadHooks(handler),
-	);
-};
-
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const webresourceModel: string = require('./webresource.sbvr');
-export const config = {
-	models: [
-		{
-			apiRoot: 'webresource',
-			modelText: webresourceModel,
-			modelName: 'webresource',
-		},
-	] as sbvrUtils.ExecutableModel[],
 };

package/tsconfig.json

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

package/out/webresource-handler/multipartUpload.d.ts

@@ -1,16 +0,0 @@
-import type { BeginMultipartUploadPayload, UploadPart, WebResourceHandler } from '.';
-import type { ODataRequest } from '../sbvr-api/uri-parser';
-import { sbvrUtils } from '../server-glue/module';
-export interface PendingUpload extends BeginMultipartUploadPayload {
-    fieldName: string;
-    fileKey: string;
-    uploadId: string;
-}
-export interface BeginUploadResponse {
-    [fieldName: string]: {
-        uuid: string;
-        uploadParts: UploadPart[];
-    };
-}
-export declare const multipartUploadHooks: (webResourceHandler: WebResourceHandler) => sbvrUtils.Hooks;
-export declare const beginUpload: (webResourceHandler: WebResourceHandler, odataRequest: ODataRequest, actorId?: number) => Promise<BeginUploadResponse>;

package/out/webresource-handler/multipartUpload.js

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.beginUpload = exports.multipartUploadHooks = void 0;
-const node_crypto_1 = require("node:crypto");
-const _1 = require(".");
-const sbvr_utils_1 = require("../sbvr-api/sbvr-utils");
-const module_1 = require("../server-glue/module");
-const MB = 1024 * 1024;
-const multipartUploadHooks = (webResourceHandler) => {
-    return {
-        POSTPARSE: async ({ req, request, tx, api: applicationApi }) => {
-            if (request.odataQuery.property?.resource === 'beginUpload') {
-                const uploadParams = await validateBeginUpload(request, applicationApi);
-                tx = await module_1.sbvrUtils.db.transaction();
-                req.tx = tx;
-                request.tx = tx;
-                request.method = 'PATCH';
-                request.values = uploadParams;
-                request.odataQuery.resource = request.resourceName;
-                delete request.odataQuery.property;
-                request.custom.isAction = 'beginUpload';
-            }
-            else if (request.odataQuery.property?.resource === 'commitUpload') {
-                const commitPayload = await validateCommitUpload(request, applicationApi);
-                const webresource = await webResourceHandler.commitMultipartUpload({
-                    fileKey: commitPayload.metadata.fileKey,
-                    uploadId: commitPayload.metadata.uploadId,
-                    filename: commitPayload.metadata.filename,
-                    providerCommitData: commitPayload.providerCommitData,
-                });
-                await sbvr_utils_1.api.webresource.patch({
-                    resource: 'multipart_upload',
-                    body: {
-                        status: 'completed',
-                    },
-                    options: {
-                        $filter: {
-                            uuid: commitPayload.uuid,
-                        },
-                    },
-                    passthrough: {
-                        tx: tx,
-                    },
-                });
-                request.method = 'PATCH';
-                request.values = {
-                    [commitPayload.metadata.fieldName]: webresource,
-                };
-                request.odataQuery.resource = request.resourceName;
-                delete request.odataQuery.property;
-                request.custom.isAction = 'commitUpload';
-                request.custom.commitUploadPayload = webresource;
-            }
-        },
-        PRERESPOND: async ({ req, request, response, tx }) => {
-            if (request.custom.isAction === 'beginUpload') {
-                await tx.rollback();
-                response.statusCode = 200;
-                response.body = await (0, exports.beginUpload)(webResourceHandler, request, req.user?.actor);
-            }
-            else if (request.custom.isAction === 'commitUpload') {
-                response.body = await webResourceHandler.onPreRespond(request.custom.commitUploadPayload);
-            }
-        },
-    };
-};
-exports.multipartUploadHooks = multipartUploadHooks;
-const beginUpload = async (webResourceHandler, odataRequest, actorId) => {
-    const payload = odataRequest.values;
-    const fieldName = Object.keys(payload)[0];
-    const metadata = payload[fieldName];
-    const { fileKey, uploadId, uploadParts } = await webResourceHandler.beginMultipartUpload(fieldName, metadata);
-    const uuid = (0, node_crypto_1.randomUUID)();
-    try {
-        await sbvr_utils_1.api.webresource.post({
-            resource: 'multipart_upload',
-            body: {
-                uuid,
-                resource_name: odataRequest.resourceName,
-                field_name: fieldName,
-                resource_id: odataRequest.affectedIds?.[0],
-                upload_id: uploadId,
-                file_key: fileKey,
-                status: 'pending',
-                filename: metadata.filename,
-                content_type: metadata.content_type,
-                size: metadata.size,
-                chunk_size: metadata.chunk_size,
-                expiry_date: Date.now() + 7 * 24 * 60 * 60 * 1000,
-                is_created_by__actor: actorId,
-            },
-        });
-    }
-    catch (err) {
-        console.error('failed to start multipart upload', err);
-        throw new module_1.errors.BadRequestError('Failed to start multipart upload');
-    }
-    return { [fieldName]: { uuid, uploadParts } };
-};
-exports.beginUpload = beginUpload;
-const validateBeginUpload = async (request, applicationApi) => {
-    if (request.odataQuery.key == null) {
-        throw new module_1.errors.BadRequestError();
-    }
-    await applicationApi.post({
-        url: request.url.substring(1).replace('beginUpload', 'canAccess'),
-        body: { method: 'PATCH' },
-    });
-    const fieldNames = Object.keys(request.values);
-    if (fieldNames.length !== 1) {
-        throw new module_1.errors.BadRequestError('You can only get upload url for one field at a time');
-    }
-    const [fieldName] = fieldNames;
-    const webResourceFields = (0, _1.getWebResourceFields)(request, false);
-    if (!webResourceFields.includes(fieldName)) {
-        throw new module_1.errors.BadRequestError(`You must provide a valid webresource field from: ${JSON.stringify(webResourceFields)}`);
-    }
-    const beginUploadPayload = parseBeginUploadPayload(request.values[fieldName]);
-    if (beginUploadPayload == null) {
-        throw new module_1.errors.BadRequestError('Invalid file metadata');
-    }
-    const uploadMetadataCheck = {
-        ...beginUploadPayload,
-        href: 'metadata_check',
-    };
-    return { [fieldName]: uploadMetadataCheck };
-};
-const parseBeginUploadPayload = (payload) => {
-    if (typeof payload !== 'object') {
-        return null;
-    }
-    let { filename, content_type, size, chunk_size } = payload;
-    if (typeof filename !== 'string' ||
-        typeof content_type !== 'string' ||
-        typeof size !== 'number' ||
-        (chunk_size != null && typeof chunk_size !== 'number') ||
-        (chunk_size != null && chunk_size < 5 * MB)) {
-        return null;
-    }
-    if (chunk_size == null) {
-        chunk_size = 5 * MB;
-    }
-    return { filename, content_type, size, chunk_size };
-};
-const validateCommitUpload = async (request, applicationApi) => {
-    if (request.odataQuery.key == null) {
-        throw new module_1.errors.BadRequestError();
-    }
-    await applicationApi.post({
-        url: request.url.substring(1).replace('commitUpload', 'canAccess'),
-        body: { method: 'PATCH' },
-    });
-    const { uuid, providerCommitData } = request.values;
-    if (typeof uuid !== 'string') {
-        throw new module_1.errors.BadRequestError('Invalid uuid type');
-    }
-    const [multipartUpload] = (await sbvr_utils_1.api.webresource.get({
-        resource: 'multipart_upload',
-        options: {
-            $select: ['id', 'file_key', 'upload_id', 'field_name', 'filename'],
-            $filter: {
-                uuid,
-                status: 'pending',
-                expiry_date: { $gt: { $now: {} } },
-            },
-        },
-        passthrough: {
-            tx: request.tx,
-        },
-    }));
-    if (multipartUpload == null) {
-        throw new module_1.errors.BadRequestError(`Invalid upload for uuid ${uuid}`);
-    }
-    const metadata = {
-        fileKey: multipartUpload.file_key,
-        uploadId: multipartUpload.upload_id,
-        filename: multipartUpload.filename,
-        fieldName: multipartUpload.field_name,
-    };
-    return { uuid, providerCommitData, metadata };
-};
-//# sourceMappingURL=multipartUpload.js.map