@casual-simulation/aux-records 3.4.6-alpha.14601027727 → 3.5.0-alpha.15117651144

package/FileRecordsController.js

@@ -4,18 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { getExtension } from 'mime';
 import { getMarkerResourcesForCreation, getMarkerResourcesForUpdate, } from './PolicyController';
-import { ACCOUNT_MARKER, } from '@casual-simulation/aux-common';
+import { ACCOUNT_MARKER } from '@casual-simulation/aux-common';
 import { getMarkersOrDefault, getRootMarkersOrDefault } from './Utils';
 import { getSubscriptionFeatures } from './SubscriptionConfiguration';
 import { traced } from './tracing/TracingDecorators';
@@ -36,196 +27,221 @@ export class FileRecordsController {
      * @param recordNameOrKey The name of the record or the record key of the record.
      * @param userId The ID of the user that is logged in. Should be null if the user is not logged in.
      * @param request The request.
+     * @param userRole the role of the user that is requesting the file.
      * @returns
      */
-    recordFile(recordKeyOrRecordName, userId, request) {
+    async recordFile(recordKeyOrRecordName, userId, request) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const markers = getMarkersOrDefault(request.markers);
-                const rootMarkers = getRootMarkersOrDefault(markers);
-                const contextResult = yield this._policies.constructAuthorizationContext({
-                    recordKeyOrRecordName,
-                    userId,
-                });
-                if (contextResult.success === false) {
-                    return contextResult;
-                }
-                const extension = getExtension(request.fileMimeType);
-                const fileName = extension
-                    ? `${request.fileSha256Hex}.${extension}`
-                    : request.fileSha256Hex;
-                const authorization = yield this._policies.authorizeUserAndInstancesForResources(contextResult.context, {
-                    userId,
-                    instances: request.instances,
-                    resources: [
-                        {
-                            resourceKind: 'file',
-                            resourceId: fileName,
-                            action: 'create',
-                            markers: rootMarkers,
-                        },
-                        ...getMarkerResourcesForCreation(rootMarkers),
-                    ],
-                });
-                // const result = await this._policies.authorizeRequest({
-                //     action: 'file.create',
-                //     recordKeyOrRecordName: recordKeyOrRecordName,
-                //     userId,
-                //     resourceMarkers: markers,
-                //     fileSizeInBytes: request.fileByteLength,
-                //     fileMimeType: request.fileMimeType,
-                //     instances: request.instances,
-                // });
-                if (authorization.success === false) {
-                    return authorization;
-                }
-                const createAuthorization = authorization.results[0];
-                for (let result of createAuthorization.results) {
-                    const options = result.permission.options;
-                    if ('maxFileSizeInBytes' in options &&
-                        options.maxFileSizeInBytes > 0) {
-                        if (request.fileByteLength > options.maxFileSizeInBytes) {
-                            return {
-                                success: false,
-                                errorCode: 'unacceptable_request',
-                                errorMessage: 'The file is too large.',
-                            };
-                        }
+        try {
+            let markers = getMarkersOrDefault(request.markers);
+            let rootMarkers = getRootMarkersOrDefault(markers);
+            const contextResult = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName,
+                userId,
+                userRole: request.userRole,
+            });
+            if (contextResult.success === false) {
+                return contextResult;
+            }
+            const extension = getExtension(request.fileMimeType);
+            const fileName = extension
+                ? `${request.fileSha256Hex}.${extension}`
+                : request.fileSha256Hex;
+            const authorization = await this._policies.authorizeUserAndInstancesForResources(contextResult.context, {
+                userId,
+                instances: request.instances,
+                resources: [
+                    {
+                        resourceKind: 'file',
+                        resourceId: fileName,
+                        action: 'create',
+                        markers: rootMarkers,
+                    },
+                    ...getMarkerResourcesForCreation(rootMarkers),
+                ],
+            });
+            // const result = await this._policies.authorizeRequest({
+            //     action: 'file.create',
+            //     recordKeyOrRecordName: recordKeyOrRecordName,
+            //     userId,
+            //     resourceMarkers: markers,
+            //     fileSizeInBytes: request.fileByteLength,
+            //     fileMimeType: request.fileMimeType,
+            //     instances: request.instances,
+            // });
+            if (authorization.success === false) {
+                return authorization;
+            }
+            const createAuthorization = authorization.results[0];
+            for (let result of createAuthorization.results) {
+                const options = result.permission.options;
+                if ('maxFileSizeInBytes' in options &&
+                    options.maxFileSizeInBytes > 0) {
+                    if (request.fileByteLength > options.maxFileSizeInBytes) {
+                        return {
+                            success: false,
+                            errorCode: 'unacceptable_request',
+                            errorMessage: 'The file is too large.',
+                        };
                     }
-                    else if ('allowedMimeTypes' in options &&
-                        Array.isArray(options.allowedMimeTypes)) {
-                        if (!options.allowedMimeTypes.includes(request.fileMimeType)) {
-                            return {
-                                success: false,
-                                errorCode: 'unacceptable_request',
-                                errorMessage: 'The file type is not allowed.',
-                            };
-                        }
+                }
+                else if ('allowedMimeTypes' in options &&
+                    Array.isArray(options.allowedMimeTypes)) {
+                    if (!options.allowedMimeTypes.includes(request.fileMimeType)) {
+                        return {
+                            success: false,
+                            errorCode: 'unacceptable_request',
+                            errorMessage: 'The file type is not allowed.',
+                        };
                     }
                 }
-                const policy = contextResult.context.subjectPolicy;
-                userId = contextResult.context.userId;
-                if (!userId && policy !== 'subjectless') {
+            }
+            const policy = contextResult.context.subjectPolicy;
+            userId = contextResult.context.userId;
+            const userRole = contextResult.context.userRole;
+            if (!userId && userRole === 'none' && policy !== 'subjectless') {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in in order to record files.',
+                };
+            }
+            if (policy === 'subjectless') {
+                userId = null;
+            }
+            const publisherId = (_b = (_a = contextResult.context.recordKeyCreatorId) !== null && _a !== void 0 ? _a : userId) !== null && _b !== void 0 ? _b : contextResult.context.recordOwnerId;
+            const recordName = authorization.recordName;
+            const subjectId = userId;
+            const metricsResult = await this._metrics.getSubscriptionFileMetricsByRecordName(recordName);
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getSubscriptionFeatures(config, metricsResult.subscriptionStatus, metricsResult.subscriptionId, metricsResult.ownerId ? 'user' : 'studio');
+            if (!features.files.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'The subscription does not permit the recording of files.',
+                };
+            }
+            if (features.files.maxBytesPerFile > 0) {
+                if (request.fileByteLength > features.files.maxBytesPerFile) {
                     return {
                         success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in in order to record files.',
+                        errorCode: 'unacceptable_request',
+                        errorMessage: 'The file is too large.',
                     };
                 }
-                if (policy === 'subjectless') {
-                    userId = null;
+            }
+            if (features.files.maxBytesTotal > 0) {
+                const newSize = metricsResult.totalFileBytesReserved +
+                    request.fileByteLength;
+                if (newSize > features.files.maxBytesTotal) {
+                    return {
+                        success: false,
+                        errorCode: 'subscription_limit_reached',
+                        errorMessage: 'The file storage limit has been reached for the subscription.',
+                    };
                 }
-                const publisherId = (_b = (_a = contextResult.context.recordKeyCreatorId) !== null && _a !== void 0 ? _a : userId) !== null && _b !== void 0 ? _b : contextResult.context.recordOwnerId;
-                const recordName = authorization.recordName;
-                const subjectId = userId;
-                const metricsResult = yield this._metrics.getSubscriptionFileMetricsByRecordName(recordName);
-                const config = yield this._config.getSubscriptionConfiguration();
-                const features = getSubscriptionFeatures(config, metricsResult.subscriptionStatus, metricsResult.subscriptionId, metricsResult.ownerId ? 'user' : 'studio');
-                if (!features.files.allowed) {
+            }
+            if (features.files.maxFiles > 0) {
+                const newCount = metricsResult.totalFiles + 1;
+                if (newCount > features.files.maxFiles) {
                     return {
                         success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'The subscription does not permit the recording of files.',
+                        errorCode: 'subscription_limit_reached',
+                        errorMessage: 'The file count limit has been reached for the subscription.',
                     };
                 }
-                if (features.files.maxBytesPerFile > 0) {
-                    if (request.fileByteLength > features.files.maxBytesPerFile) {
+            }
+            const addFileResult = await this._store.addFileRecord(recordName, fileName, publisherId, subjectId, request.fileByteLength, request.fileDescription, markers);
+            if (addFileResult.success === false) {
+                if (addFileResult.errorCode === 'file_already_exists') {
+                    const fileResult = await this._store.getFileRecord(recordName, fileName);
+                    if (fileResult.success === false) {
+                        console.error('[FileRecordsController] Error getting file record even though it should exist:', fileResult);
                         return {
                             success: false,
-                            errorCode: 'unacceptable_request',
-                            errorMessage: 'The file is too large.',
+                            errorCode: 'server_error',
+                            errorMessage: fileResult.errorMessage,
                         };
                     }
-                }
-                if (features.files.maxBytesTotal > 0) {
-                    const newSize = metricsResult.totalFileBytesReserved +
-                        request.fileByteLength;
-                    if (newSize > features.files.maxBytesTotal) {
-                        return {
-                            success: false,
-                            errorCode: 'subscription_limit_reached',
-                            errorMessage: 'The file storage limit has been reached for the subscription.',
-                        };
+                    if (!fileResult.uploaded) {
+                        if (!fileResult.markers.some((m) => markers.includes(m))) {
+                            // re-check permissions because none of the markers match up
+                            // with the markers that the file actually has
+                            markers = fileResult.markers;
+                            rootMarkers = getRootMarkersOrDefault(markers);
+                            const authorization = await this._policies.authorizeUserAndInstancesForResources(contextResult.context, {
+                                userId: subjectId,
+                                instances: request.instances,
+                                resources: [
+                                    {
+                                        resourceKind: 'file',
+                                        resourceId: fileName,
+                                        action: 'create',
+                                        markers: markers,
+                                    },
+                                    ...getMarkerResourcesForCreation(markers),
+                                ],
+                            });
+                            if (authorization.success === false) {
+                                return authorization;
+                            }
+                        }
+                        else {
+                            // allow the request to be successful
+                            // because at least one of the markers is the same
+                            // we just need to grab the real markers from the file
+                            markers = fileResult.markers;
+                            rootMarkers = getRootMarkersOrDefault(markers);
+                        }
                     }
-                }
-                if (features.files.maxFiles > 0) {
-                    const newCount = metricsResult.totalFiles + 1;
-                    if (newCount > features.files.maxFiles) {
+                    else {
                         return {
                             success: false,
-                            errorCode: 'subscription_limit_reached',
-                            errorMessage: 'The file count limit has been reached for the subscription.',
+                            errorCode: 'file_already_exists',
+                            errorMessage: 'The file has already been uploaded to ' +
+                                fileResult.url,
+                            existingFileUrl: fileResult.url,
+                            existingFileName: fileResult.fileName,
                         };
                     }
                 }
-                const presignResult = yield this._store.presignFileUpload({
-                    recordName,
-                    fileName: fileName,
-                    fileSha256Hex: request.fileSha256Hex,
-                    fileMimeType: request.fileMimeType,
-                    fileByteLength: request.fileByteLength,
-                    markers: rootMarkers,
-                    headers: request.headers,
-                });
-                if (presignResult.success === false) {
-                    return presignResult;
-                }
-                const addFileResult = yield this._store.addFileRecord(recordName, fileName, publisherId, subjectId, request.fileByteLength, request.fileDescription, markers);
-                if (addFileResult.success === false) {
-                    if (addFileResult.errorCode === 'file_already_exists') {
-                        const fileResult = yield this._store.getFileRecord(recordName, fileName);
-                        if (fileResult.success === false) {
-                            console.error('[FileRecordsController] Error getting file record even though it should exist:', fileResult);
-                            return {
-                                success: false,
-                                errorCode: 'server_error',
-                                errorMessage: fileResult.errorMessage,
-                            };
-                        }
-                        if (!fileResult.uploaded) {
-                            return {
-                                success: true,
-                                fileName,
-                                uploadUrl: presignResult.uploadUrl,
-                                uploadHeaders: presignResult.uploadHeaders,
-                                uploadMethod: presignResult.uploadMethod,
-                                markers,
-                            };
-                        }
-                        else {
-                            return {
-                                success: false,
-                                errorCode: 'file_already_exists',
-                                errorMessage: 'The file has already been uploaded to ' +
-                                    fileResult.url,
-                                existingFileUrl: fileResult.url,
-                            };
-                        }
-                    }
+                else {
                     return addFileResult;
                 }
-                return {
-                    success: true,
-                    fileName,
-                    uploadUrl: presignResult.uploadUrl,
-                    uploadHeaders: presignResult.uploadHeaders,
-                    uploadMethod: presignResult.uploadMethod,
-                    markers,
-                };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while recording a file:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
+            const presignResult = await this._store.presignFileUpload({
+                recordName,
+                fileName: fileName,
+                fileSha256Hex: request.fileSha256Hex,
+                fileMimeType: request.fileMimeType,
+                fileByteLength: request.fileByteLength,
+                markers: rootMarkers,
+                headers: request.headers,
+            });
+            if (presignResult.success === false) {
+                return presignResult;
             }
-        });
+            return {
+                success: true,
+                fileName,
+                uploadUrl: presignResult.uploadUrl,
+                uploadHeaders: presignResult.uploadHeaders,
+                uploadMethod: presignResult.uploadMethod,
+                markers,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while recording a file:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to erase the given file using the given record key and subject.
@@ -234,80 +250,78 @@ export class FileRecordsController {
      * @param subjectId The ID of the user that is making this request. Null if the user is not logged in.
      * @param instances The instances that are loaded.
      */
-    eraseFile(recordKeyOrRecordName, fileName, subjectId, instances) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const baseRequest = {
-                    recordKeyOrRecordName,
-                    userId: subjectId,
-                    instances,
-                };
-                const context = yield this._policies.constructAuthorizationContext(baseRequest);
-                if (context.success === false) {
-                    return context;
-                }
-                const fileResult = yield this._store.getFileRecord(context.context.recordName, fileName);
-                if (fileResult.success === false) {
-                    return fileResult;
-                }
-                const markers = getRootMarkersOrDefault(fileResult.markers);
-                const authorization = yield this._policies.authorizeUserAndInstances(context.context, {
-                    userId: subjectId,
-                    instances: instances,
-                    resourceKind: 'file',
-                    resourceId: fileName,
-                    action: 'delete',
-                    markers: markers,
-                });
-                // const result = await this._policies.authorizeRequestUsingContext(
-                //     context.context,
-                //     {
-                //         action: 'file.delete',
-                //         ...baseRequest,
-                //         fileSizeInBytes: fileResult.sizeInBytes,
-                //         fileMimeType: getType(fileResult.fileName),
-                //         resourceMarkers: markers,
-                //     }
-                // );
-                if (authorization.success === false) {
-                    return authorization;
-                }
-                const policy = context.context.subjectPolicy;
-                subjectId = authorization.user.subjectId;
-                if (!subjectId && policy !== 'subjectless') {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in in order to erase files.',
-                    };
-                }
-                const recordName = authorization.recordName;
-                const eraseResult = yield this._store.eraseFileRecord(recordName, fileName);
-                if (eraseResult.success === false) {
-                    return {
-                        success: false,
-                        errorCode: eraseResult.errorCode,
-                        errorMessage: eraseResult.errorMessage,
-                    };
-                }
+    async eraseFile(recordKeyOrRecordName, fileName, subjectId, instances) {
+        try {
+            const baseRequest = {
+                recordKeyOrRecordName,
+                userId: subjectId,
+                instances,
+            };
+            const context = await this._policies.constructAuthorizationContext(baseRequest);
+            if (context.success === false) {
+                return context;
+            }
+            const fileResult = await this._store.getFileRecord(context.context.recordName, fileName);
+            if (fileResult.success === false) {
+                return fileResult;
+            }
+            const markers = getRootMarkersOrDefault(fileResult.markers);
+            const authorization = await this._policies.authorizeUserAndInstances(context.context, {
+                userId: subjectId,
+                instances: instances,
+                resourceKind: 'file',
+                resourceId: fileName,
+                action: 'delete',
+                markers: markers,
+            });
+            // const result = await this._policies.authorizeRequestUsingContext(
+            //     context.context,
+            //     {
+            //         action: 'file.delete',
+            //         ...baseRequest,
+            //         fileSizeInBytes: fileResult.sizeInBytes,
+            //         fileMimeType: getType(fileResult.fileName),
+            //         resourceMarkers: markers,
+            //     }
+            // );
+            if (authorization.success === false) {
+                return authorization;
+            }
+            const policy = context.context.subjectPolicy;
+            subjectId = authorization.user.subjectId;
+            if (!subjectId && policy !== 'subjectless') {
                 return {
-                    success: true,
-                    recordName,
-                    fileName,
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in in order to erase files.',
                 };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while erasing a file:', err);
+            const recordName = authorization.recordName;
+            const eraseResult = await this._store.eraseFileRecord(recordName, fileName);
+            if (eraseResult.success === false) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: eraseResult.errorCode,
+                    errorMessage: eraseResult.errorMessage,
                 };
             }
-        });
+            return {
+                success: true,
+                recordName,
+                fileName,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while erasing a file:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to retrieve a URL that allows the client to read the given file.
@@ -315,86 +329,88 @@ export class FileRecordsController {
      * @param fileName The name of the file.
      * @param subjectId The ID of the user that is making this request. Null if the user is not logged in.
      * @param instances The instances that are loaded.
+     * @param userRole The role of the user that is making the request.
      */
-    readFile(recordKeyOrRecordName, fileName, subjectId, instances) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const baseRequest = {
-                    recordKeyOrRecordName,
-                    userId: subjectId,
-                    instances,
-                };
-                const context = yield this._policies.constructAuthorizationContext(baseRequest);
-                if (context.success === false) {
-                    return context;
-                }
-                const fileResult = yield this._store.getFileRecord(context.context.recordName, fileName);
-                if (fileResult.success === false) {
-                    return fileResult;
-                }
-                const markers = getRootMarkersOrDefault(fileResult.markers);
-                const result = yield this._policies.authorizeUserAndInstances(context.context, {
-                    userId: subjectId,
-                    instances: instances,
-                    resourceKind: 'file',
-                    resourceId: fileName,
-                    action: 'read',
-                    markers: markers,
-                });
-                // const result = await this._policies.authorizeRequestUsingContext(
-                //     context.context,
-                //     {
-                //         action: 'file.read',
-                //         ...baseRequest,
-                //         fileSizeInBytes: fileResult.sizeInBytes,
-                //         fileMimeType: getType(fileResult.fileName),
-                //         resourceMarkers: markers,
-                //     }
-                // );
-                if (result.success === false) {
-                    return result;
-                }
-                const policy = context.context.subjectPolicy;
-                subjectId = result.user.subjectId;
-                if (!subjectId && policy !== 'subjectless') {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in in order to read files.',
-                    };
-                }
-                const recordName = result.recordName;
-                const readResult = yield this._store.presignFileRead({
-                    recordName,
-                    fileName,
-                    headers: {},
-                });
-                if (readResult.success === false) {
-                    return {
-                        success: false,
-                        errorCode: readResult.errorCode,
-                        errorMessage: readResult.errorMessage,
-                    };
-                }
+    async readFile(recordKeyOrRecordName, fileName, subjectId, instances, userRole) {
+        try {
+            const baseRequest = {
+                recordKeyOrRecordName,
+                userId: subjectId,
+                instances,
+                userRole,
+            };
+            const context = await this._policies.constructAuthorizationContext(baseRequest);
+            if (context.success === false) {
+                return context;
+            }
+            const fileResult = await this._store.getFileRecord(context.context.recordName, fileName);
+            if (fileResult.success === false) {
+                return fileResult;
+            }
+            const markers = getRootMarkersOrDefault(fileResult.markers);
+            const result = await this._policies.authorizeUserAndInstances(context.context, {
+                userId: subjectId,
+                instances: instances,
+                resourceKind: 'file',
+                resourceId: fileName,
+                action: 'read',
+                markers: markers,
+            });
+            // const result = await this._policies.authorizeRequestUsingContext(
+            //     context.context,
+            //     {
+            //         action: 'file.read',
+            //         ...baseRequest,
+            //         fileSizeInBytes: fileResult.sizeInBytes,
+            //         fileMimeType: getType(fileResult.fileName),
+            //         resourceMarkers: markers,
+            //     }
+            // );
+            if (result.success === false) {
+                return result;
+            }
+            const policy = context.context.subjectPolicy;
+            subjectId = result.user.subjectId;
+            if (!subjectId &&
+                context.context.userRole === 'none' &&
+                policy !== 'subjectless') {
                 return {
-                    success: true,
-                    requestUrl: readResult.requestUrl,
-                    requestMethod: readResult.requestMethod,
-                    requestHeaders: readResult.requestHeaders,
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in in order to read files.',
                 };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while reading a file:', err);
+            const recordName = result.recordName;
+            const readResult = await this._store.presignFileRead({
+                recordName,
+                fileName,
+                headers: {},
+            });
+            if (readResult.success === false) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: readResult.errorCode,
+                    errorMessage: readResult.errorMessage,
                 };
             }
-        });
+            return {
+                success: true,
+                requestUrl: readResult.requestUrl,
+                requestMethod: readResult.requestMethod,
+                requestHeaders: readResult.requestHeaders,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while reading a file:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to list the files that are available in the given record.
@@ -403,160 +419,152 @@ export class FileRecordsController {
      * @param userId The ID of the user who is retrieving the data. If null, then it is assumed that the user is not logged in.
      * @param instances The instances that are loaded.
      */
-    listFiles(recordKeyOrRecordName, fileName, userId, instances) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._store.listUploadedFiles) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                const baseRequest = {
-                    recordKeyOrRecordName,
-                    userId: userId,
-                    instances,
-                };
-                const context = yield this._policies.constructAuthorizationContext(baseRequest);
-                if (context.success === false) {
-                    return context;
-                }
-                const authorizeResult = yield this._policies.authorizeUserAndInstances(context.context, {
-                    userId: userId,
-                    instances,
-                    resourceKind: 'file',
-                    action: 'list',
-                    markers: [ACCOUNT_MARKER],
-                });
-                if (authorizeResult.success === false) {
-                    return authorizeResult;
-                }
-                const result2 = yield this._store.listUploadedFiles(context.context.recordName, fileName);
-                if (result2.success === false) {
-                    return {
-                        success: false,
-                        errorCode: result2.errorCode,
-                        errorMessage: result2.errorMessage,
-                    };
-                }
-                return {
-                    success: true,
-                    recordName: context.context.recordName,
-                    files: result2.files,
-                    totalCount: result2.totalCount,
-                };
-            }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while listing files:', err);
+    async listFiles(recordKeyOrRecordName, fileName, userId, instances) {
+        try {
+            if (!this._store.listUploadedFiles) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
                 };
             }
-        });
-    }
-    updateFile(recordKeyOrRecordName, fileName, subjectId, markers, instances) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const baseRequest = {
-                    recordKeyOrRecordName,
-                    userId: subjectId,
-                    instances,
-                };
-                const context = yield this._policies.constructAuthorizationContext(baseRequest);
-                if (context.success === false) {
-                    return context;
-                }
-                const fileResult = yield this._store.getFileRecord(context.context.recordName, fileName);
-                if (fileResult.success === false) {
-                    return fileResult;
-                }
-                const existingMarkers = getRootMarkersOrDefault(fileResult.markers);
-                const resourceMarkers = markers !== null && markers !== void 0 ? markers : existingMarkers;
-                const result = yield this._policies.authorizeUserAndInstancesForResources(context.context, {
-                    userId: subjectId,
-                    instances: instances,
-                    resources: [
-                        {
-                            resourceKind: 'file',
-                            resourceId: fileName,
-                            action: 'update',
-                            markers: resourceMarkers,
-                        },
-                        ...getMarkerResourcesForUpdate(existingMarkers, markers),
-                    ],
-                });
-                if (result.success === false) {
-                    return result;
-                }
-                subjectId = context.context.userId;
-                const updateResult = yield this._store.updateFileRecord(result.recordName, fileName, resourceMarkers);
-                if (updateResult.success === false) {
-                    return updateResult;
-                }
-                return {
-                    success: true,
-                };
+            const baseRequest = {
+                recordKeyOrRecordName,
+                userId: userId,
+                instances,
+            };
+            const context = await this._policies.constructAuthorizationContext(baseRequest);
+            if (context.success === false) {
+                return context;
+            }
+            const authorizeResult = await this._policies.authorizeUserAndInstances(context.context, {
+                userId: userId,
+                instances,
+                resourceKind: 'file',
+                action: 'list',
+                markers: [ACCOUNT_MARKER],
+            });
+            if (authorizeResult.success === false) {
+                return authorizeResult;
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while reading a file:', err);
+            const result2 = await this._store.listUploadedFiles(context.context.recordName, fileName);
+            if (result2.success === false) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: result2.errorCode,
+                    errorMessage: result2.errorMessage,
                 };
             }
-        });
+            return {
+                success: true,
+                recordName: context.context.recordName,
+                files: result2.files,
+                totalCount: result2.totalCount,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while listing files:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
-    markFileAsUploaded(recordName, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const result = yield this._store.setFileRecordAsUploaded(recordName, fileName);
-                if (result.success === false) {
-                    return result;
-                }
-                return {
-                    success: true,
-                };
+    async updateFile(recordKeyOrRecordName, fileName, subjectId, markers, instances) {
+        try {
+            const baseRequest = {
+                recordKeyOrRecordName,
+                userId: subjectId,
+                instances,
+            };
+            const context = await this._policies.constructAuthorizationContext(baseRequest);
+            if (context.success === false) {
+                return context;
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while marking a file as uploaded:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
+            const fileResult = await this._store.getFileRecord(context.context.recordName, fileName);
+            if (fileResult.success === false) {
+                return fileResult;
             }
-        });
-    }
-    getFileNameFromUrl(fileUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this._store.getFileNameFromUrl(fileUrl);
+            const existingMarkers = getRootMarkersOrDefault(fileResult.markers);
+            const resourceMarkers = markers !== null && markers !== void 0 ? markers : existingMarkers;
+            const result = await this._policies.authorizeUserAndInstancesForResources(context.context, {
+                userId: subjectId,
+                instances: instances,
+                resources: [
+                    {
+                        resourceKind: 'file',
+                        resourceId: fileName,
+                        action: 'update',
+                        markers: resourceMarkers,
+                    },
+                    ...getMarkerResourcesForUpdate(existingMarkers, markers),
+                ],
+            });
+            if (result.success === false) {
+                return result;
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[FileRecordsController] An error occurred while getting a file name:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
+            subjectId = context.context.userId;
+            const updateResult = await this._store.updateFileRecord(result.recordName, fileName, resourceMarkers);
+            if (updateResult.success === false) {
+                return updateResult;
             }
-        });
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while reading a file:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async markFileAsUploaded(recordName, fileName) {
+        try {
+            const result = await this._store.setFileRecordAsUploaded(recordName, fileName);
+            if (result.success === false) {
+                return result;
+            }
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while marking a file as uploaded:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async getFileNameFromUrl(fileUrl) {
+        try {
+            return await this._store.getFileNameFromUrl(fileUrl);
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span === null || span === void 0 ? void 0 : span.recordException(err);
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[FileRecordsController] An error occurred while getting a file name:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     getAllowedUploadHeaders() {
         return this._store.getAllowedUploadHeaders();