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

package/RecordsController.js

@@ -4,36 +4,16 @@ 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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { toBase64String, fromBase64String, } from '@casual-simulation/aux-common';
 import { hashHighEntropyPasswordWithSalt, hashLowEntropyPasswordWithSalt, } from './InstrumentedHashHelpers';
 import { randomBytes } from 'tweetnacl';
 import { fromByteArray } from 'base64-js';
 import { v4 as uuid } from 'uuid';
 import { getComIdFeatures, getHumeAiFeatures, getLoomFeatures, getSubscriptionFeatures, getSubscriptionTier, } from './SubscriptionConfiguration';
 import { isActiveSubscription } from './Utils';
-import { isSuperUserRole } from './AuthUtils';
+import { isSuperUserRole } from '@casual-simulation/aux-common';
 import { traced } from './tracing/TracingDecorators';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
+import { DEFAULT_RECORD_KEY_POLICY, formatV2RecordKey, parseRecordKey, } from '@casual-simulation/aux-common/records/RecordKeys';
 const TRACE_NAME = 'RecordsController';
 /**
  * Defines a class that manages records and their keys.
@@ -51,149 +31,151 @@ export class RecordsController {
      * Creates a new record.
      * @param request The request that should be used to create the record.
      */
-    createRecord(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!request.userId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in in order to create a record.',
-                    };
-                }
-                const record = yield this._store.getRecordByName(request.recordName);
-                if (record) {
-                    if (record.name === request.userId &&
-                        record.ownerId !== request.userId &&
-                        request.ownerId === request.userId) {
-                        const allowed = yield this._doesSubscriptionAllowToCreateRecord({
-                            ownerId: request.userId,
-                        });
-                        if (!allowed.success) {
-                            return allowed;
-                        }
-                        console.log(`[RecordsController] [action: record.create recordName: ${record.name}, userId: ${request.userId}] Fixing record owner to match actual owner.`);
-                        record.ownerId = request.userId;
-                        record.studioId = null;
-                        // Clear the hashes and re-create the salt so that access to the record is revoked for any record key that was created before.
-                        record.secretHashes = [];
-                        record.secretSalt = this._createSalt();
-                        yield this._store.updateRecord(Object.assign({}, record));
-                        return {
-                            success: true,
-                        };
-                    }
-                    let existingStudioMembers = yield this._store.listStudioAssignments(record.name);
-                    if (existingStudioMembers.length > 0 &&
-                        record.studioId !== record.name &&
-                        request.studioId === record.name) {
-                        const allowed = yield this._doesSubscriptionAllowToCreateRecord({
-                            studioId: request.studioId,
-                        });
-                        if (!allowed.success) {
-                            return allowed;
-                        }
-                        console.log(`[RecordsController] [action: record.create recordName: ${record.name}, userId: ${request.userId}, studioId: ${request.studioId}] Fixing record owner to match actual owner.`);
-                        record.ownerId = null;
-                        record.studioId = request.studioId;
-                        // Clear the hashes and re-create the salt so that access to the record is revoked for any record key that was created before.
-                        record.secretHashes = [];
-                        record.secretSalt = this._createSalt();
-                        yield this._store.updateRecord(Object.assign({}, record));
-                        return {
-                            success: true,
-                        };
-                    }
-                    return {
-                        success: false,
-                        errorCode: 'record_already_exists',
-                        errorMessage: 'A record with that name already exists.',
-                    };
-                }
-                if (request.recordName !== request.ownerId &&
-                    request.recordName !== request.studioId) {
-                    const existingUser = yield this._auth.findUser(request.recordName);
-                    if (existingUser) {
-                        return {
-                            success: false,
-                            errorCode: 'record_already_exists',
-                            errorMessage: 'A record with that name already exists.',
-                        };
-                    }
-                }
-                if (!request.ownerId && !request.studioId) {
-                    return {
-                        success: false,
-                        errorCode: 'unacceptable_request',
-                        errorMessage: 'You must provide an owner ID or a studio ID.',
-                    };
-                }
-                if (request.ownerId) {
-                    if (request.ownerId !== request.userId) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'You are not authorized to create a record for another user.',
-                        };
-                    }
-                    const allowed = yield this._doesSubscriptionAllowToCreateRecord({
+    async createRecord(request) {
+        try {
+            if (!request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in in order to create a record.',
+                };
+            }
+            const record = await this._store.getRecordByName(request.recordName);
+            if (record) {
+                if (record.name === request.userId &&
+                    record.ownerId !== request.userId &&
+                    request.ownerId === request.userId) {
+                    const allowed = await this._doesSubscriptionAllowToCreateRecord({
                         ownerId: request.userId,
                     });
                     if (!allowed.success) {
                         return allowed;
                     }
-                    console.log(`[RecordsController] [action: record.create recordName: ${request.recordName}, userId: ${request.userId}, ownerId: ${request.ownerId}] Creating record.`);
-                    yield this._store.addRecord({
-                        name: request.recordName,
-                        ownerId: request.ownerId,
-                        secretHashes: [],
-                        secretSalt: this._createSalt(),
-                        studioId: null,
+                    console.log(`[RecordsController] [action: record.create recordName: ${record.name}, userId: ${request.userId}] Fixing record owner to match actual owner.`);
+                    record.ownerId = request.userId;
+                    record.studioId = null;
+                    // Clear the hashes and re-create the salt so that access to the record is revoked for any record key that was created before.
+                    record.secretHashes = [];
+                    record.secretSalt = this._createSalt();
+                    await this._store.updateRecord({
+                        ...record,
                     });
+                    return {
+                        success: true,
+                    };
                 }
-                else {
-                    const assignments = yield this._store.listStudioAssignments(request.studioId, {
-                        userId: request.userId,
-                        role: 'admin',
-                    });
-                    if (assignments.length <= 0) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'You are not authorized to create a record for this studio.',
-                        };
-                    }
-                    const allowed = yield this._doesSubscriptionAllowToCreateRecord({
+                let existingStudioMembers = await this._store.listStudioAssignments(record.name);
+                if (existingStudioMembers.length > 0 &&
+                    record.studioId !== record.name &&
+                    request.studioId === record.name) {
+                    const allowed = await this._doesSubscriptionAllowToCreateRecord({
                         studioId: request.studioId,
                     });
                     if (!allowed.success) {
                         return allowed;
                     }
-                    console.log(`[RecordsController] [action: record.create recordName: ${request.recordName}, userId: ${request.userId}, studioId: ${request.studioId}] Creating record.`);
-                    yield this._store.addRecord({
-                        name: request.recordName,
-                        ownerId: null,
-                        secretHashes: [],
-                        secretSalt: this._createSalt(),
-                        studioId: request.studioId,
+                    console.log(`[RecordsController] [action: record.create recordName: ${record.name}, userId: ${request.userId}, studioId: ${request.studioId}] Fixing record owner to match actual owner.`);
+                    record.ownerId = null;
+                    record.studioId = request.studioId;
+                    // Clear the hashes and re-create the salt so that access to the record is revoked for any record key that was created before.
+                    record.secretHashes = [];
+                    record.secretSalt = this._createSalt();
+                    await this._store.updateRecord({
+                        ...record,
                     });
+                    return {
+                        success: true,
+                    };
                 }
                 return {
-                    success: true,
+                    success: false,
+                    errorCode: 'record_already_exists',
+                    errorMessage: 'A record with that name already exists.',
                 };
             }
-            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('[RecordsController] [createRecord] An error occurred while creating a record:', err);
+            if (request.recordName !== request.ownerId &&
+                request.recordName !== request.studioId) {
+                const existingUser = await this._auth.findUser(request.recordName);
+                if (existingUser) {
+                    return {
+                        success: false,
+                        errorCode: 'record_already_exists',
+                        errorMessage: 'A record with that name already exists.',
+                    };
+                }
+            }
+            if (!request.ownerId && !request.studioId) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'unacceptable_request',
+                    errorMessage: 'You must provide an owner ID or a studio ID.',
                 };
             }
-        });
+            if (request.ownerId) {
+                if (request.ownerId !== request.userId) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'You are not authorized to create a record for another user.',
+                    };
+                }
+                const allowed = await this._doesSubscriptionAllowToCreateRecord({
+                    ownerId: request.userId,
+                });
+                if (!allowed.success) {
+                    return allowed;
+                }
+                console.log(`[RecordsController] [action: record.create recordName: ${request.recordName}, userId: ${request.userId}, ownerId: ${request.ownerId}] Creating record.`);
+                await this._store.addRecord({
+                    name: request.recordName,
+                    ownerId: request.ownerId,
+                    secretHashes: [],
+                    secretSalt: this._createSalt(),
+                    studioId: null,
+                });
+            }
+            else {
+                const assignments = await this._store.listStudioAssignments(request.studioId, {
+                    userId: request.userId,
+                    role: 'admin',
+                });
+                if (assignments.length <= 0) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'You are not authorized to create a record for this studio.',
+                    };
+                }
+                const allowed = await this._doesSubscriptionAllowToCreateRecord({
+                    studioId: request.studioId,
+                });
+                if (!allowed.success) {
+                    return allowed;
+                }
+                console.log(`[RecordsController] [action: record.create recordName: ${request.recordName}, userId: ${request.userId}, studioId: ${request.studioId}] Creating record.`);
+                await this._store.addRecord({
+                    name: request.recordName,
+                    ownerId: null,
+                    secretHashes: [],
+                    secretSalt: this._createSalt(),
+                    studioId: request.studioId,
+                });
+            }
+            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('[RecordsController] [createRecord] An error occurred while creating a record:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Creates a new public record key for the given bucket name.
@@ -202,62 +184,74 @@ export class RecordsController {
      * @param userId The ID of the user that is creating the public record.
      * @returns
      */
-    createPublicRecordKey(name, policy, userId) {
+    async createPublicRecordKey(name, policy, userId) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!userId) {
+        try {
+            if (!userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user must be logged in in order to create a record key.',
+                    errorReason: 'not_logged_in',
+                };
+            }
+            if (!!policy &&
+                policy !== 'subjectfull' &&
+                policy !== 'subjectless') {
+                return {
+                    success: false,
+                    errorCode: 'invalid_policy',
+                    errorMessage: 'The record key policy must be either "subjectfull" or "subjectless".',
+                    errorReason: 'invalid_policy',
+                };
+            }
+            let existingStudioMembers = await this._store.listStudioAssignments(name);
+            let createResult;
+            // recordName matches studioId
+            if (existingStudioMembers.length > 0) {
+                createResult = await this.createRecord({
+                    recordName: name,
+                    userId: userId,
+                    studioId: name,
+                });
+            }
+            else {
+                createResult = await this.createRecord({
+                    recordName: name,
+                    userId: userId,
+                    ownerId: userId,
+                });
+            }
+            if (createResult.success === false) {
+                if (createResult.errorCode !== 'record_already_exists') {
                     return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'The user must be logged in in order to create a record key.',
-                        errorReason: 'not_logged_in',
+                        ...createResult,
+                        errorReason: 'not_authorized',
                     };
                 }
-                if (!!policy &&
-                    policy !== 'subjectfull' &&
-                    policy !== 'subjectless') {
+            }
+            const record = await this._store.getRecordByName(name);
+            if (!record) {
+                if (createResult.success === false &&
+                    createResult.errorCode === 'record_already_exists') {
                     return {
                         success: false,
-                        errorCode: 'invalid_policy',
-                        errorMessage: 'The record key policy must be either "subjectfull" or "subjectless".',
-                        errorReason: 'invalid_policy',
+                        errorCode: 'unauthorized_to_create_record_key',
+                        errorMessage: 'Another user has already created this record.',
+                        errorReason: 'record_owned_by_different_user',
                     };
                 }
-                let existingStudioMembers = yield this._store.listStudioAssignments(name);
-                let createResult;
-                // recordName matches studioId
+                console.error(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Unable to find record that was just created!`);
+                return {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'A server error occurred.',
+                    errorReason: 'server_error',
+                };
+            }
+            if (record.ownerId) {
                 if (existingStudioMembers.length > 0) {
-                    createResult = yield this.createRecord({
-                        recordName: name,
-                        userId: userId,
-                        studioId: name,
-                    });
-                }
-                else {
-                    createResult = yield this.createRecord({
-                        recordName: name,
-                        userId: userId,
-                        ownerId: userId,
-                    });
-                }
-                if (createResult.success === false) {
-                    if (createResult.errorCode !== 'record_already_exists') {
-                        return Object.assign(Object.assign({}, createResult), { errorReason: 'not_authorized' });
-                    }
-                }
-                const record = yield this._store.getRecordByName(name);
-                if (!record) {
-                    if (createResult.success === false &&
-                        createResult.errorCode === 'record_already_exists') {
-                        return {
-                            success: false,
-                            errorCode: 'unauthorized_to_create_record_key',
-                            errorMessage: 'Another user has already created this record.',
-                            errorReason: 'record_owned_by_different_user',
-                        };
-                    }
-                    console.error(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Unable to find record that was just created!`);
+                    console.error(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Studio members exist for the record, but the record is owned by a user!`);
                     return {
                         success: false,
                         errorCode: 'server_error',
@@ -265,69 +259,58 @@ export class RecordsController {
                         errorReason: 'server_error',
                     };
                 }
-                if (record.ownerId) {
-                    if (existingStudioMembers.length > 0) {
-                        console.error(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Studio members exist for the record, but the record is owned by a user!`);
-                        return {
-                            success: false,
-                            errorCode: 'server_error',
-                            errorMessage: 'A server error occurred.',
-                            errorReason: 'server_error',
-                        };
-                    }
-                    if (record.ownerId !== userId) {
-                        return {
-                            success: false,
-                            errorCode: 'unauthorized_to_create_record_key',
-                            errorMessage: 'Another user has already created this record.',
-                            errorReason: 'record_owned_by_different_user',
-                        };
-                    }
-                }
-                else if (record.studioId) {
-                    let existingStudioMembers = yield this._store.listStudioAssignments(record.studioId, {
-                        userId: userId,
-                        role: 'admin',
-                    });
-                    if (existingStudioMembers.length <= 0) {
-                        return {
-                            success: false,
-                            errorCode: 'unauthorized_to_create_record_key',
-                            errorMessage: 'You are not authorized to create a record key for this record.',
-                            errorReason: 'record_owned_by_different_user',
-                        };
-                    }
+                if (record.ownerId !== userId) {
+                    return {
+                        success: false,
+                        errorCode: 'unauthorized_to_create_record_key',
+                        errorMessage: 'Another user has already created this record.',
+                        errorReason: 'record_owned_by_different_user',
+                    };
                 }
-                console.log(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Creating record key.`);
-                const passwordBytes = randomBytes(16);
-                const password = fromByteArray(passwordBytes); // convert to human-readable string
-                const salt = record.secretSalt;
-                const passwordHash = this.hashHighEntropyPasswordWithSalt(password, salt);
-                yield this._store.addRecordKey({
-                    recordName: name,
-                    secretHash: passwordHash,
-                    policy: policy !== null && policy !== void 0 ? policy : DEFAULT_RECORD_KEY_POLICY,
-                    creatorId: (_a = record.ownerId) !== null && _a !== void 0 ? _a : userId,
-                });
-                return {
-                    success: true,
-                    recordKey: formatV2RecordKey(name, password, policy),
-                    recordName: name,
-                };
             }
-            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('[RecordsController] [createPublicRecordKey] An error occurred while creating a public record key:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                    errorReason: 'server_error',
-                };
+            else if (record.studioId) {
+                let existingStudioMembers = await this._store.listStudioAssignments(record.studioId, {
+                    userId: userId,
+                    role: 'admin',
+                });
+                if (existingStudioMembers.length <= 0) {
+                    return {
+                        success: false,
+                        errorCode: 'unauthorized_to_create_record_key',
+                        errorMessage: 'You are not authorized to create a record key for this record.',
+                        errorReason: 'record_owned_by_different_user',
+                    };
+                }
             }
-        });
+            console.log(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Creating record key.`);
+            const passwordBytes = randomBytes(16);
+            const password = fromByteArray(passwordBytes); // convert to human-readable string
+            const salt = record.secretSalt;
+            const passwordHash = this.hashHighEntropyPasswordWithSalt(password, salt);
+            await this._store.addRecordKey({
+                recordName: name,
+                secretHash: passwordHash,
+                policy: policy !== null && policy !== void 0 ? policy : DEFAULT_RECORD_KEY_POLICY,
+                creatorId: (_a = record.ownerId) !== null && _a !== void 0 ? _a : userId,
+            });
+            return {
+                success: true,
+                recordKey: formatV2RecordKey(name, password, policy),
+                recordName: name,
+            };
+        }
+        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('[RecordsController] [createPublicRecordKey] An error occurred while creating a public record key:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+                errorReason: 'server_error',
+            };
+        }
     }
     hashHighEntropyPasswordWithSalt(sessionSecret, sessionId) {
         return hashHighEntropyPasswordWithSalt(sessionSecret, sessionId);
@@ -337,381 +320,371 @@ export class RecordsController {
      * @param key The key that should be validated.
      * @returns
      */
-    validatePublicRecordKey(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const parseResult = parseRecordKey(key);
-                if (!parseResult) {
-                    return {
-                        success: false,
-                        errorCode: 'invalid_record_key',
-                        errorMessage: 'Invalid record key.',
-                    };
-                }
-                const [name, password, policy] = parseResult;
-                const record = yield this._store.getRecordByName(name);
-                if (!record) {
-                    return {
-                        success: false,
-                        errorCode: 'record_not_found',
-                        errorMessage: 'Record not found.',
-                    };
-                }
-                // Check v2 hashes first because they are much quicker to check
-                const hashV2 = hashHighEntropyPasswordWithSalt(password, record.secretSalt);
-                let valid = false;
-                let resultPolicy = DEFAULT_RECORD_KEY_POLICY;
-                let creatorId = null;
-                if (record.secretHashes.some((h) => h === hashV2)) {
-                    valid = true;
-                    creatorId = record.ownerId;
+    async validatePublicRecordKey(key) {
+        try {
+            const parseResult = parseRecordKey(key);
+            if (!parseResult) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_record_key',
+                    errorMessage: 'Invalid record key.',
+                };
+            }
+            const [name, password, policy] = parseResult;
+            const record = await this._store.getRecordByName(name);
+            if (!record) {
+                return {
+                    success: false,
+                    errorCode: 'record_not_found',
+                    errorMessage: 'Record not found.',
+                };
+            }
+            // Check v2 hashes first because they are much quicker to check
+            const hashV2 = hashHighEntropyPasswordWithSalt(password, record.secretSalt);
+            let valid = false;
+            let resultPolicy = DEFAULT_RECORD_KEY_POLICY;
+            let creatorId = null;
+            if (record.secretHashes.some((h) => h === hashV2)) {
+                valid = true;
+                creatorId = record.ownerId;
+            }
+            else {
+                const key = await this._store.getRecordKeyByRecordAndHash(name, hashV2);
+                if (key) {
+                    if (name === record.ownerId &&
+                        key.creatorId !== record.ownerId) {
+                        // The record is a user record (because the name is the same as the owner ID)
+                        // but this key was created when the record was owned by someone else.
+                        // Normally, this shouldn't happen, but it is possible if the record was created before v3.2.0 or if the record was created before the user was created.
+                        // This check is a failsafe to ensure that user records are always owned by the user, and not by someone else.
+                        valid = false;
+                    }
+                    else {
+                        resultPolicy = key.policy;
+                        creatorId = key.creatorId;
+                        valid = true;
+                    }
                 }
                 else {
-                    const key = yield this._store.getRecordKeyByRecordAndHash(name, hashV2);
-                    if (key) {
-                        if (name === record.ownerId &&
-                            key.creatorId !== record.ownerId) {
-                            // The record is a user record (because the name is the same as the owner ID)
-                            // but this key was created when the record was owned by someone else.
-                            // Normally, this shouldn't happen, but it is possible if the record was created before v3.2.0 or if the record was created before the user was created.
-                            // This check is a failsafe to ensure that user records are always owned by the user, and not by someone else.
-                            valid = false;
-                        }
-                        else {
-                            resultPolicy = key.policy;
-                            creatorId = key.creatorId;
-                            valid = true;
-                        }
+                    // Check v1 hashes
+                    const hash = hashLowEntropyPasswordWithSalt(password, record.secretSalt);
+                    if (record.secretHashes.some((h) => h === hash)) {
+                        valid = true;
                     }
                     else {
-                        // Check v1 hashes
-                        const hash = hashLowEntropyPasswordWithSalt(password, record.secretSalt);
-                        if (record.secretHashes.some((h) => h === hash)) {
-                            valid = true;
-                        }
-                        else {
-                            const key = yield this._store.getRecordKeyByRecordAndHash(name, hash);
-                            if (key) {
-                                if (name === record.ownerId &&
-                                    key.creatorId !== record.ownerId) {
-                                    // The record is a user record (because the name is the same as the owner ID)
-                                    // but this key was created when the record was owned by someone else.
-                                    // Normally, this shouldn't happen, but it is possible if the record was created before v3.2.0 or if the record was created before the user was created.
-                                    // This check is a failsafe to ensure that user records are always owned by the user, and not by someone else.
-                                    valid = false;
-                                }
-                                else {
-                                    resultPolicy = key.policy;
-                                    creatorId = key.creatorId;
-                                    valid = true;
-                                }
+                        const key = await this._store.getRecordKeyByRecordAndHash(name, hash);
+                        if (key) {
+                            if (name === record.ownerId &&
+                                key.creatorId !== record.ownerId) {
+                                // The record is a user record (because the name is the same as the owner ID)
+                                // but this key was created when the record was owned by someone else.
+                                // Normally, this shouldn't happen, but it is possible if the record was created before v3.2.0 or if the record was created before the user was created.
+                                // This check is a failsafe to ensure that user records are always owned by the user, and not by someone else.
+                                valid = false;
+                            }
+                            else {
+                                resultPolicy = key.policy;
+                                creatorId = key.creatorId;
+                                valid = true;
                             }
                         }
                     }
                 }
-                if (resultPolicy !== policy) {
-                    return {
-                        success: false,
-                        errorCode: 'invalid_record_key',
-                        errorMessage: 'Invalid record key.',
-                    };
-                }
-                if (valid) {
-                    return {
-                        success: true,
-                        recordName: name,
-                        policy: policy,
-                        ownerId: record.ownerId,
-                        keyCreatorId: creatorId !== null && creatorId !== void 0 ? creatorId : record.ownerId,
-                    };
-                }
-                else {
-                    return {
-                        success: false,
-                        errorCode: 'invalid_record_key',
-                        errorMessage: 'Invalid record key.',
-                    };
-                }
             }
-            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('[RecordsController] [validatePublicRecordKey] An error occurred while creating a public record key:', err);
+            if (resultPolicy !== policy) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'invalid_record_key',
+                    errorMessage: 'Invalid record key.',
+                };
+            }
+            if (valid) {
+                return {
+                    success: true,
+                    recordName: name,
+                    policy: policy,
+                    ownerId: record.ownerId,
+                    keyCreatorId: creatorId !== null && creatorId !== void 0 ? creatorId : record.ownerId,
                 };
             }
-        });
+            else {
+                return {
+                    success: false,
+                    errorCode: 'invalid_record_key',
+                    errorMessage: 'Invalid record key.',
+                };
+            }
+        }
+        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('[RecordsController] [validatePublicRecordKey] An error occurred while creating a public record key:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Validates the given record name. Returns information about the record if it exists.
      * @param name The name of the record.
      * @param userId The ID of the user that is validating the record.
      */
-    validateRecordName(name, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const record = yield this._store.getRecordByName(name);
-                if (!record) {
-                    if (userId && name === userId) {
-                        const allowed = yield this._doesSubscriptionAllowToCreateRecord({
-                            ownerId: userId,
-                        });
-                        if (allowed.success === false) {
-                            return allowed;
-                        }
-                        console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}] Creating record for user.`);
-                        yield this._store.addRecord({
-                            name,
-                            ownerId: userId,
-                            studioId: null,
-                            secretHashes: [],
-                            secretSalt: this._createSalt(),
-                        });
-                        return {
-                            success: true,
-                            recordName: name,
-                            ownerId: userId,
-                            studioId: null,
-                        };
-                    }
-                    let studioMembers = yield this._store.listStudioAssignments(name);
-                    if (studioMembers.length > 0) {
-                        const allowed = yield this._doesSubscriptionAllowToCreateRecord({
-                            studioId: name,
-                        });
-                        if (allowed.success === false) {
-                            return allowed;
-                        }
-                        console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}, studioId: ${name}] Creating record for studio.`);
-                        yield this._store.addRecord({
-                            name,
-                            ownerId: null,
-                            studioId: name,
-                            secretHashes: [],
-                            secretSalt: this._createSalt(),
-                        });
-                        return {
-                            success: true,
-                            recordName: name,
-                            ownerId: null,
-                            studioId: name,
-                            studioMembers,
-                        };
-                    }
-                    return {
-                        success: false,
-                        errorCode: 'record_not_found',
-                        errorMessage: 'Record not found.',
-                    };
-                }
-                else if (userId &&
-                    record.name === userId &&
-                    record.ownerId !== userId) {
-                    const allowed = yield this._doesSubscriptionAllowToCreateRecord({
+    async validateRecordName(name, userId) {
+        try {
+            const record = await this._store.getRecordByName(name);
+            if (!record) {
+                if (userId && name === userId) {
+                    const allowed = await this._doesSubscriptionAllowToCreateRecord({
                         ownerId: userId,
                     });
                     if (allowed.success === false) {
                         return allowed;
                     }
-                    // The user is not currently the owner of their own record.
-                    // This is an issue that needs to be fixed because users should always own the record that has the same name as their ID.
-                    console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}] Fixing record owner to match actual owner.`);
-                    record.ownerId = userId;
-                    // Clear the hashes and re-create the salt so that access to the record is revoked for any record key that was created before.
-                    record.secretHashes = [];
-                    record.secretSalt = this._createSalt();
-                    yield this._store.updateRecord(Object.assign({}, record));
+                    console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}] Creating record for user.`);
+                    await this._store.addRecord({
+                        name,
+                        ownerId: userId,
+                        studioId: null,
+                        secretHashes: [],
+                        secretSalt: this._createSalt(),
+                    });
+                    return {
+                        success: true,
+                        recordName: name,
+                        ownerId: userId,
+                        studioId: null,
+                    };
                 }
-                let existingStudioMembers = yield this._store.listStudioAssignments(name);
-                if (existingStudioMembers.length > 0 &&
-                    record.studioId !== name &&
-                    record.ownerId !== null) {
-                    const allowed = yield this._doesSubscriptionAllowToCreateRecord({
+                let studioMembers = await this._store.listStudioAssignments(name);
+                if (studioMembers.length > 0) {
+                    const allowed = await this._doesSubscriptionAllowToCreateRecord({
                         studioId: name,
                     });
                     if (allowed.success === false) {
                         return allowed;
                     }
-                    console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}, studioId: ${name}] Fixing record studio to match actual studio.`);
-                    record.ownerId = null;
-                    record.studioId = name;
-                    record.secretHashes = [];
-                    record.secretSalt = this._createSalt();
-                    yield this._store.updateRecord(Object.assign({}, record));
-                }
-                let studioMembers = undefined;
-                if (existingStudioMembers.length > 0) {
-                    studioMembers = existingStudioMembers;
-                }
-                else if (record.studioId) {
-                    studioMembers = yield this._store.listStudioAssignments(record.studioId);
+                    console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}, studioId: ${name}] Creating record for studio.`);
+                    await this._store.addRecord({
+                        name,
+                        ownerId: null,
+                        studioId: name,
+                        secretHashes: [],
+                        secretSalt: this._createSalt(),
+                    });
+                    return {
+                        success: true,
+                        recordName: name,
+                        ownerId: null,
+                        studioId: name,
+                        studioMembers,
+                    };
                 }
-                return {
-                    success: true,
-                    recordName: name,
-                    ownerId: record.ownerId,
-                    studioId: record.studioId,
-                    studioMembers,
-                };
-            }
-            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('[RecordsController] [validateRecordName] An error occurred while creating a validating a record name:', err);
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'record_not_found',
+                    errorMessage: 'Record not found.',
                 };
             }
-        });
-    }
-    _doesSubscriptionAllowToCreateRecord(filter) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const { features, metrics } = yield this._getSubscriptionFeatures(filter);
-            if (!((_a = features.records) === null || _a === void 0 ? void 0 : _a.allowed)) {
-                return {
-                    success: false,
-                    errorCode: 'not_authorized',
-                    errorMessage: 'Records are not allowed for this subscription.',
-                };
+            else if (userId &&
+                record.name === userId &&
+                record.ownerId !== userId) {
+                const allowed = await this._doesSubscriptionAllowToCreateRecord({
+                    ownerId: userId,
+                });
+                if (allowed.success === false) {
+                    return allowed;
+                }
+                // The user is not currently the owner of their own record.
+                // This is an issue that needs to be fixed because users should always own the record that has the same name as their ID.
+                console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}] Fixing record owner to match actual owner.`);
+                record.ownerId = userId;
+                // Clear the hashes and re-create the salt so that access to the record is revoked for any record key that was created before.
+                record.secretHashes = [];
+                record.secretSalt = this._createSalt();
+                await this._store.updateRecord({
+                    ...record,
+                });
             }
-            else if (((_b = features.records) === null || _b === void 0 ? void 0 : _b.maxRecords) >= 0) {
-                if (features.records.maxRecords <= metrics.totalRecords + 1) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'This subscription has hit its record limit.',
-                    };
+            let existingStudioMembers = await this._store.listStudioAssignments(name);
+            if (existingStudioMembers.length > 0 &&
+                record.studioId !== name &&
+                record.ownerId !== null) {
+                const allowed = await this._doesSubscriptionAllowToCreateRecord({
+                    studioId: name,
+                });
+                if (allowed.success === false) {
+                    return allowed;
                 }
+                console.log(`[RecordsController] [validateRecordName recordName: ${name}, userId: ${userId}, studioId: ${name}] Fixing record studio to match actual studio.`);
+                record.ownerId = null;
+                record.studioId = name;
+                record.secretHashes = [];
+                record.secretSalt = this._createSalt();
+                await this._store.updateRecord({
+                    ...record,
+                });
+            }
+            let studioMembers = undefined;
+            if (existingStudioMembers.length > 0) {
+                studioMembers = existingStudioMembers;
+            }
+            else if (record.studioId) {
+                studioMembers = await this._store.listStudioAssignments(record.studioId);
             }
             return {
                 success: true,
+                recordName: name,
+                ownerId: record.ownerId,
+                studioId: record.studioId,
+                studioMembers,
+            };
+        }
+        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('[RecordsController] [validateRecordName] An error occurred while creating a validating a record name:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
             };
-        });
+        }
     }
-    _getSubscriptionFeatures(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const metrics = yield this._metrics.getSubscriptionRecordMetrics(filter);
-            const config = yield this._config.getSubscriptionConfiguration();
+    async _doesSubscriptionAllowToCreateRecord(filter) {
+        var _a, _b;
+        const { features, metrics } = await this._getSubscriptionFeatures(filter);
+        if (!((_a = features.records) === null || _a === void 0 ? void 0 : _a.allowed)) {
             return {
-                metrics,
-                config,
-                features: getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType),
+                success: false,
+                errorCode: 'not_authorized',
+                errorMessage: 'Records are not allowed for this subscription.',
             };
-        });
+        }
+        else if (((_b = features.records) === null || _b === void 0 ? void 0 : _b.maxRecords) >= 0) {
+            if (features.records.maxRecords <= metrics.totalRecords + 1) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'This subscription has hit its record limit.',
+                };
+            }
+        }
+        return {
+            success: true,
+        };
+    }
+    async _getSubscriptionFeatures(filter) {
+        const metrics = await this._metrics.getSubscriptionRecordMetrics(filter);
+        const config = await this._config.getSubscriptionConfiguration();
+        return {
+            metrics,
+            config,
+            features: getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType),
+        };
     }
     /**
      * Gets the list of records that the user with the given ID has access to.
      * @param userId The ID of the user.
      */
-    listRecords(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._store.listRecordsByOwnerId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                const records = yield this._store.listRecordsByOwnerId(userId);
-                return {
-                    success: true,
-                    records: records,
-                };
-            }
-            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('[RecordsController] [listRecords] Error listing records: ', err);
+    async listRecords(userId) {
+        try {
+            if (!this._store.listRecordsByOwnerId) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
                 };
             }
-        });
+            const records = await this._store.listRecordsByOwnerId(userId);
+            return {
+                success: true,
+                records: records,
+            };
+        }
+        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('[RecordsController] [listRecords] Error listing records: ', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Gets the list of records in the given studio that the user with the given ID has access to.
      * @param studioId The ID of the studio.
      * @param userId The ID of the user that is currently logged in.
      */
-    listStudioRecords(studioId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._store.listRecordsByStudioIdAndUserId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'This operation is not supported.',
-                    };
-                }
-                const user = yield this._auth.findUser(userId);
-                if (isSuperUserRole(user === null || user === void 0 ? void 0 : user.role)) {
-                    const records = yield this._store.listRecordsByStudioId(studioId);
-                    return {
-                        success: true,
-                        records,
-                    };
-                }
-                const records = yield this._store.listRecordsByStudioIdAndUserId(studioId, userId);
+    async listStudioRecords(studioId, userId) {
+        try {
+            if (!this._store.listRecordsByStudioIdAndUserId) {
                 return {
-                    success: true,
-                    records: records,
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'This operation is not supported.',
                 };
             }
-            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('[RecordsController] [listStudioRecords] Error listing records: ', err);
+            const user = await this._auth.findUser(userId);
+            if (isSuperUserRole(user === null || user === void 0 ? void 0 : user.role)) {
+                const records = await this._store.listRecordsByStudioId(studioId);
                 return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    success: true,
+                    records,
                 };
             }
-        });
+            const records = await this._store.listRecordsByStudioIdAndUserId(studioId, userId);
+            return {
+                success: true,
+                records: records,
+            };
+        }
+        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('[RecordsController] [listStudioRecords] Error listing records: ', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to create a new studio. That is, an entity that can be used to group records.
      * @param studioName The name of the studio.
      * @param userId The ID of the user that is creating the studio.
      */
-    createStudio(studioName, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const studioId = uuid();
-                yield this._store.createStudioForUser({
-                    id: studioId,
-                    displayName: studioName,
-                }, userId);
-                return {
-                    success: true,
-                    studioId: studioId,
-                };
-            }
-            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('[RecordsController] [createStudio] An error occurred while creating a studio:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
+    async createStudio(studioName, userId) {
+        try {
+            const studioId = uuid();
+            await this._store.createStudioForUser({
+                id: studioId,
+                displayName: studioName,
+            }, userId);
+            return {
+                success: true,
+                studioId: studioId,
+            };
+        }
+        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('[RecordsController] [createStudio] An error occurred while creating a studio:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to create a new studio in the given comId. That is, an entity that can be used to group records.
@@ -719,403 +692,376 @@ export class RecordsController {
      * @param userId The ID of the user that is creating the studio.
      * @param comId The comId of the studio that this studio should belong to.
      */
-    createStudioInComId(studioName, userId, comId) {
+    async createStudioInComId(studioName, userId, comId) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const studioId = uuid();
-                const existingStudio = yield this._store.getStudioByComId(comId);
-                if (!existingStudio) {
-                    return {
-                        success: false,
-                        errorCode: 'comId_not_found',
-                        errorMessage: 'The given comId was not found.',
-                    };
-                }
-                const config = yield this._config.getSubscriptionConfiguration();
-                const features = getComIdFeatures(config, existingStudio.subscriptionStatus, existingStudio.subscriptionId);
-                if (!features.allowed) {
-                    return {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'comId features are not allowed for this comId. Make sure you have an active subscription that provides comId features.',
-                    };
-                }
-                if (typeof features.maxStudios === 'number') {
-                    const count = yield this._store.countStudiosInComId(comId);
-                    if (count >= features.maxStudios) {
-                        return {
-                            success: false,
-                            errorCode: 'subscription_limit_reached',
-                            errorMessage: 'The maximum number of studios allowed for your comId subscription has been reached.',
-                        };
-                    }
-                }
-                const comIdConfig = (_a = existingStudio.comIdConfig) !== null && _a !== void 0 ? _a : {
-                    allowedStudioCreators: 'only-members',
-                };
-                if (comIdConfig.allowedStudioCreators === 'only-members') {
-                    const assignments = yield this._store.listStudioAssignments(existingStudio.id, {
-                        userId: userId,
-                    });
-                    if (assignments.length <= 0) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'You are not authorized to create a studio in this comId.',
-                        };
-                    }
-                }
-                yield this._store.createStudioForUser({
-                    id: studioId,
-                    displayName: studioName,
-                    ownerStudioComId: comId,
-                }, userId);
+        try {
+            const studioId = uuid();
+            const existingStudio = await this._store.getStudioByComId(comId);
+            if (!existingStudio) {
                 return {
-                    success: true,
-                    studioId: studioId,
+                    success: false,
+                    errorCode: 'comId_not_found',
+                    errorMessage: 'The given comId was not found.',
                 };
             }
-            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('[RecordsController] [createStudio] An error occurred while creating a studio in a comId:', err);
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getComIdFeatures(config, existingStudio.subscriptionStatus, existingStudio.subscriptionId);
+            if (!features.allowed) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_authorized',
+                    errorMessage: 'comId features are not allowed for this comId. Make sure you have an active subscription that provides comId features.',
                 };
             }
-        });
-    }
-    /**
-     * Attempts to update the given studio.
-     */
-    updateStudio(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const _a = request.studio, { id, loomConfig, humeConfig } = _a, updates = __rest(_a, ["id", "loomConfig", "humeConfig"]);
-                const existingStudio = yield this._store.getStudioById(request.studio.id);
-                if (!existingStudio) {
+            if (typeof features.maxStudios === 'number') {
+                const count = await this._store.countStudiosInComId(comId);
+                if (count >= features.maxStudios) {
                     return {
                         success: false,
-                        errorCode: 'studio_not_found',
-                        errorMessage: 'The given studio was not found.',
+                        errorCode: 'subscription_limit_reached',
+                        errorMessage: 'The maximum number of studios allowed for your comId subscription has been reached.',
                     };
                 }
-                const assignments = yield this._store.listStudioAssignments(existingStudio.id, {
-                    userId: request.userId,
-                    role: 'admin',
+            }
+            const comIdConfig = (_a = existingStudio.comIdConfig) !== null && _a !== void 0 ? _a : {
+                allowedStudioCreators: 'only-members',
+            };
+            if (comIdConfig.allowedStudioCreators === 'only-members') {
+                const assignments = await this._store.listStudioAssignments(existingStudio.id, {
+                    userId: userId,
                 });
                 if (assignments.length <= 0) {
                     return {
                         success: false,
                         errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to update this studio.',
+                        errorMessage: 'You are not authorized to create a studio in this comId.',
                     };
                 }
-                const final = Object.assign(Object.assign({}, existingStudio), updates);
-                yield this._store.updateStudio(final);
-                if (loomConfig) {
-                    yield this._store.updateStudioLoomConfig(final.id, loomConfig);
-                }
-                if (humeConfig) {
-                    yield this._store.updateStudioHumeConfig(final.id, humeConfig);
-                }
+            }
+            await this._store.createStudioForUser({
+                id: studioId,
+                displayName: studioName,
+                ownerStudioComId: comId,
+            }, userId);
+            return {
+                success: true,
+                studioId: studioId,
+            };
+        }
+        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('[RecordsController] [createStudio] An error occurred while creating a studio in a comId:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    /**
+     * Attempts to update the given studio.
+     */
+    async updateStudio(request) {
+        try {
+            const { id, loomConfig, humeConfig, ...updates } = request.studio;
+            const existingStudio = await this._store.getStudioById(request.studio.id);
+            if (!existingStudio) {
                 return {
-                    success: true,
+                    success: false,
+                    errorCode: 'studio_not_found',
+                    errorMessage: 'The given studio was not found.',
                 };
             }
-            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('[RecordsController] [updateStudio] An error occurred while updating a studio:', err);
+            const assignments = await this._store.listStudioAssignments(existingStudio.id, {
+                userId: request.userId,
+                role: 'admin',
+            });
+            if (assignments.length <= 0) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to update this studio.',
                 };
             }
-        });
+            const final = {
+                ...existingStudio,
+                ...updates,
+            };
+            await this._store.updateStudio(final);
+            if (loomConfig) {
+                await this._store.updateStudioLoomConfig(final.id, loomConfig);
+            }
+            if (humeConfig) {
+                await this._store.updateStudioHumeConfig(final.id, humeConfig);
+            }
+            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('[RecordsController] [updateStudio] An error occurred while updating a studio:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to get information about the given studio.
      * @param studioId The ID of the studio.
      * @param userId The ID of the user that is making this request.
      */
-    getStudio(studioId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const studio = yield this._store.getStudioById(studioId);
-                if (!studio) {
-                    return {
-                        success: false,
-                        errorCode: 'studio_not_found',
-                        errorMessage: 'The given studio was not found.',
-                    };
-                }
-                const assignments = yield this._store.listStudioAssignments(studio.id, {
-                    userId: userId,
-                });
-                if (assignments.length <= 0) {
-                    return {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this studio.',
-                    };
-                }
-                let features = {
-                    allowed: false,
-                };
-                let loomFeatures = {
-                    allowed: false,
-                };
-                let humeFeatures = {
-                    allowed: false,
-                };
-                let loomConfig = undefined;
-                let humeConfig = undefined;
-                if (studio.subscriptionId &&
-                    isActiveSubscription(studio.subscriptionStatus)) {
-                    const config = yield this._config.getSubscriptionConfiguration();
-                    features = getComIdFeatures(config, studio.subscriptionStatus, studio.subscriptionId);
-                    loomFeatures = getLoomFeatures(config, studio.subscriptionStatus, studio.subscriptionId);
-                    if (loomFeatures.allowed) {
-                        loomConfig = yield this._store.getStudioLoomConfig(studio.id);
-                    }
-                    humeFeatures = getHumeAiFeatures(config, studio.subscriptionStatus, studio.subscriptionId, 'studio');
-                    if (humeFeatures.allowed) {
-                        humeConfig = yield this._store.getStudioHumeConfig(studio.id);
-                    }
-                }
+    async getStudio(studioId, userId) {
+        try {
+            const studio = await this._store.getStudioById(studioId);
+            if (!studio) {
                 return {
-                    success: true,
-                    studio: {
-                        id: studio.id,
-                        displayName: studio.displayName,
-                        logoUrl: studio.logoUrl,
-                        comId: studio.comId,
-                        ownerStudioComId: studio.ownerStudioComId,
-                        comIdConfig: studio.comIdConfig,
-                        playerConfig: studio.playerConfig,
-                        loomConfig: loomConfig
-                            ? {
-                                appId: loomConfig.appId,
-                            }
-                            : undefined,
-                        humeConfig: humeConfig
-                            ? {
-                                apiKey: humeConfig.apiKey,
-                            }
-                            : undefined,
-                        comIdFeatures: features,
-                        loomFeatures,
-                        humeFeatures,
-                    },
+                    success: false,
+                    errorCode: 'studio_not_found',
+                    errorMessage: 'The given studio was not found.',
                 };
             }
-            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('[RecordsController] [getStudio] An error occurred while getting a studio:', err);
+            const assignments = await this._store.listStudioAssignments(studio.id, {
+                userId: userId,
+            });
+            if (assignments.length <= 0) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this studio.',
                 };
             }
-        });
+            let features = {
+                allowed: false,
+            };
+            let loomFeatures = {
+                allowed: false,
+            };
+            let humeFeatures = {
+                allowed: false,
+            };
+            let loomConfig = undefined;
+            let humeConfig = undefined;
+            if (studio.subscriptionId &&
+                isActiveSubscription(studio.subscriptionStatus)) {
+                const config = await this._config.getSubscriptionConfiguration();
+                features = getComIdFeatures(config, studio.subscriptionStatus, studio.subscriptionId);
+                loomFeatures = getLoomFeatures(config, studio.subscriptionStatus, studio.subscriptionId);
+                if (loomFeatures.allowed) {
+                    loomConfig = await this._store.getStudioLoomConfig(studio.id);
+                }
+                humeFeatures = getHumeAiFeatures(config, studio.subscriptionStatus, studio.subscriptionId, 'studio');
+                if (humeFeatures.allowed) {
+                    humeConfig = await this._store.getStudioHumeConfig(studio.id);
+                }
+            }
+            return {
+                success: true,
+                studio: {
+                    id: studio.id,
+                    displayName: studio.displayName,
+                    logoUrl: studio.logoUrl,
+                    comId: studio.comId,
+                    ownerStudioComId: studio.ownerStudioComId,
+                    comIdConfig: studio.comIdConfig,
+                    playerConfig: studio.playerConfig,
+                    loomConfig: loomConfig
+                        ? {
+                            appId: loomConfig.appId,
+                        }
+                        : undefined,
+                    humeConfig: humeConfig
+                        ? {
+                            apiKey: humeConfig.apiKey,
+                        }
+                        : undefined,
+                    comIdFeatures: features,
+                    loomFeatures,
+                    humeFeatures,
+                },
+            };
+        }
+        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('[RecordsController] [getStudio] An error occurred while getting a studio:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Attempts to get the player config for the given comId.
      * @param comId The comId.
      */
-    getPlayerConfig(comId) {
+    async getPlayerConfig(comId) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const studio = yield this._store.getStudioByComId(comId);
-                if (!studio) {
-                    return {
-                        success: false,
-                        errorCode: 'comId_not_found',
-                        errorMessage: 'The given comId was not found.',
-                    };
-                }
-                return {
-                    success: true,
-                    comId: studio.comId,
-                    displayName: studio.displayName,
-                    logoUrl: (_a = studio.logoUrl) !== null && _a !== void 0 ? _a : null,
-                    playerConfig: (_b = studio.playerConfig) !== null && _b !== void 0 ? _b : null,
-                };
-            }
-            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('[RecordsController] [getPlayerConfig] An error occurred while getting the player config:', err);
+        try {
+            const studio = await this._store.getStudioByComId(comId);
+            if (!studio) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'comId_not_found',
+                    errorMessage: 'The given comId was not found.',
                 };
             }
-        });
+            return {
+                success: true,
+                comId: studio.comId,
+                displayName: studio.displayName,
+                logoUrl: (_a = studio.logoUrl) !== null && _a !== void 0 ? _a : null,
+                playerConfig: (_b = studio.playerConfig) !== null && _b !== void 0 ? _b : null,
+            };
+        }
+        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('[RecordsController] [getPlayerConfig] An error occurred while getting the player config:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Gets the list of studios that the user with the given ID has access to.
      * @param userId The ID of the user.
      */
-    listStudios(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const studios = yield this._store.listStudiosForUser(userId);
-                const config = yield this._config.getSubscriptionConfiguration();
-                return {
-                    success: true,
-                    studios: studios.map((s) => {
-                        return {
-                            studioId: s.studioId,
-                            displayName: s.displayName,
-                            role: s.role,
-                            isPrimaryContact: s.isPrimaryContact,
-                            subscriptionTier: getSubscriptionTier(config, s.subscriptionStatus, s.subscriptionId),
-                            ownerStudioComId: s.ownerStudioComId,
-                            comId: s.comId,
-                        };
-                    }),
-                };
-            }
-            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('[RecordsController] [listStudios] An error occurred while listing studios:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
+    async listStudios(userId) {
+        try {
+            const studios = await this._store.listStudiosForUser(userId);
+            const config = await this._config.getSubscriptionConfiguration();
+            return {
+                success: true,
+                studios: studios.map((s) => {
+                    return {
+                        studioId: s.studioId,
+                        displayName: s.displayName,
+                        role: s.role,
+                        isPrimaryContact: s.isPrimaryContact,
+                        subscriptionTier: getSubscriptionTier(config, s.subscriptionStatus, s.subscriptionId),
+                        ownerStudioComId: s.ownerStudioComId,
+                        comId: s.comId,
+                    };
+                }),
+            };
+        }
+        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('[RecordsController] [listStudios] An error occurred while listing studios:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Gets the list of studios that the user with the given ID has access to and that are owned by the given comId.
      * @param userId The ID of the user.
      * @param comId The comId.
      */
-    listStudiosByComId(userId, comId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const studios = yield this._store.listStudiosForUserAndComId(userId, comId);
-                const config = yield this._config.getSubscriptionConfiguration();
-                return {
-                    success: true,
-                    studios: studios.map((s) => {
-                        return {
-                            studioId: s.studioId,
-                            displayName: s.displayName,
-                            role: s.role,
-                            isPrimaryContact: s.isPrimaryContact,
-                            subscriptionTier: getSubscriptionTier(config, s.subscriptionStatus, s.subscriptionId),
-                            ownerStudioComId: s.ownerStudioComId,
-                            comId: s.comId,
-                        };
-                    }),
-                };
-            }
-            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('[RecordsController] [listStudios] An error occurred while listing studios:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
-            }
-        });
+    async listStudiosByComId(userId, comId) {
+        try {
+            const studios = await this._store.listStudiosForUserAndComId(userId, comId);
+            const config = await this._config.getSubscriptionConfiguration();
+            return {
+                success: true,
+                studios: studios.map((s) => {
+                    return {
+                        studioId: s.studioId,
+                        displayName: s.displayName,
+                        role: s.role,
+                        isPrimaryContact: s.isPrimaryContact,
+                        subscriptionTier: getSubscriptionTier(config, s.subscriptionStatus, s.subscriptionId),
+                        ownerStudioComId: s.ownerStudioComId,
+                        comId: s.comId,
+                    };
+                }),
+            };
+        }
+        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('[RecordsController] [listStudios] An error occurred while listing studios:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Gets the list of members in a studio.
      * @param studioId The ID of the studio.
      * @param userId The ID of the user that is currently logged in.
      */
-    listStudioMembers(studioId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const members = yield this._store.listStudioAssignments(studioId);
-                const userAssignment = members.find((m) => m.userId === userId);
-                let role;
-                if (!userAssignment) {
-                    const user = yield this._auth.findUser(userId);
-                    if (!isSuperUserRole(user === null || user === void 0 ? void 0 : user.role)) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'You are not authorized to access this studio.',
-                        };
-                    }
-                    else {
-                        role = 'admin';
-                    }
+    async listStudioMembers(studioId, userId) {
+        try {
+            const members = await this._store.listStudioAssignments(studioId);
+            const userAssignment = members.find((m) => m.userId === userId);
+            let role;
+            if (!userAssignment) {
+                const user = await this._auth.findUser(userId);
+                if (!isSuperUserRole(user === null || user === void 0 ? void 0 : user.role)) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'You are not authorized to access this studio.',
+                    };
                 }
                 else {
-                    role = userAssignment.role;
+                    role = 'admin';
                 }
-                const resultMembers = yield Promise.all(members.map((m) => __awaiter(this, void 0, void 0, function* () {
-                    if (this._privo && m.user.privoServiceId) {
-                        const result = yield this._privo.getUserInfo(m.user.privoServiceId);
-                        return {
-                            studioId: m.studioId,
-                            userId: m.userId,
-                            isPrimaryContact: m.isPrimaryContact,
-                            role: m.role,
-                            user: {
-                                id: m.user.id,
-                                name: result.givenName,
-                                displayName: result.displayName,
-                            },
-                        };
-                    }
-                    else {
-                        return {
-                            studioId: m.studioId,
-                            userId: m.userId,
-                            isPrimaryContact: m.isPrimaryContact,
-                            role: m.role,
-                            user: {
-                                id: m.user.id,
-                                name: m.user.name,
-                                email: m.user.email,
-                                phoneNumber: m.user.phoneNumber,
-                            },
-                        };
-                    }
-                })));
-                if (role === 'admin') {
+            }
+            else {
+                role = userAssignment.role;
+            }
+            const resultMembers = await Promise.all(members.map(async (m) => {
+                if (this._privo && m.user.privoServiceId) {
+                    const result = await this._privo.getUserInfo(m.user.privoServiceId);
                     return {
-                        success: true,
-                        members: resultMembers.map((m) => ({
-                            studioId: m.studioId,
-                            userId: m.userId,
-                            isPrimaryContact: m.isPrimaryContact,
-                            role: m.role,
-                            user: {
-                                id: m.user.id,
-                                name: m.user.name,
-                                email: m.user.email,
-                                phoneNumber: m.user.phoneNumber,
-                                displayName: m.user.displayName,
-                            },
-                        })),
+                        studioId: m.studioId,
+                        userId: m.userId,
+                        isPrimaryContact: m.isPrimaryContact,
+                        role: m.role,
+                        user: {
+                            id: m.user.id,
+                            name: result.givenName,
+                            displayName: result.displayName,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        studioId: m.studioId,
+                        userId: m.userId,
+                        isPrimaryContact: m.isPrimaryContact,
+                        role: m.role,
+                        user: {
+                            id: m.user.id,
+                            name: m.user.name,
+                            email: m.user.email,
+                            phoneNumber: m.user.phoneNumber,
+                        },
                     };
                 }
+            }));
+            if (role === 'admin') {
                 return {
                     success: true,
                     members: resultMembers.map((m) => ({
@@ -1126,238 +1072,248 @@ export class RecordsController {
                         user: {
                             id: m.user.id,
                             name: m.user.name,
+                            email: m.user.email,
+                            phoneNumber: m.user.phoneNumber,
                             displayName: m.user.displayName,
                         },
                     })),
                 };
             }
-            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('[RecordsController] [listStudioMembers] An error occurred while listing studio members:', err);
+            return {
+                success: true,
+                members: resultMembers.map((m) => ({
+                    studioId: m.studioId,
+                    userId: m.userId,
+                    isPrimaryContact: m.isPrimaryContact,
+                    role: m.role,
+                    user: {
+                        id: m.user.id,
+                        name: m.user.name,
+                        displayName: m.user.displayName,
+                    },
+                })),
+            };
+        }
+        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('[RecordsController] [listStudioMembers] An error occurred while listing studio members:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async addStudioMember(request) {
+        var _a, _b, _c, _d;
+        try {
+            if (!request.userId) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'You must be logged in to add a studio member.',
                 };
             }
-        });
-    }
-    addStudioMember(request) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!request.userId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'You must be logged in to add a studio member.',
-                    };
+            const list = await this._store.listStudioAssignments(request.studioId, {
+                userId: request.userId,
+                role: 'admin',
+            });
+            if (list.length <= 0) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this operation.',
+                };
+            }
+            let addedUserId = null;
+            if (request.addedUserId) {
+                addedUserId = request.addedUserId;
+            }
+            else if (request.addedEmail || request.addedPhoneNumber) {
+                const addedUser = await this._auth.findUserByAddress((_a = request.addedEmail) !== null && _a !== void 0 ? _a : request.addedPhoneNumber, request.addedEmail ? 'email' : 'phone');
+                if (addedUser) {
+                    addedUserId = addedUser.id;
                 }
-                const list = yield this._store.listStudioAssignments(request.studioId, {
-                    userId: request.userId,
-                    role: 'admin',
+            }
+            if (!addedUserId &&
+                this._privo &&
+                (request.addedEmail ||
+                    request.addedPhoneNumber ||
+                    request.addedDisplayName)) {
+                const privoServiceId = await this._privo.lookupServiceId({
+                    displayName: (_b = request.addedDisplayName) !== null && _b !== void 0 ? _b : undefined,
+                    email: (_c = request.addedEmail) !== null && _c !== void 0 ? _c : undefined,
+                    phoneNumber: (_d = request.addedPhoneNumber) !== null && _d !== void 0 ? _d : undefined,
                 });
-                if (list.length <= 0) {
+                if (privoServiceId) {
+                    const user = await this._auth.findUserByPrivoServiceId(privoServiceId);
+                    if (user) {
+                        addedUserId = user.id;
+                    }
+                }
+            }
+            if (!addedUserId) {
+                if (this._privo &&
+                    !request.addedEmail &&
+                    !request.addedPhoneNumber &&
+                    !request.addedUserId &&
+                    !request.addedDisplayName) {
                     return {
                         success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to perform this operation.',
+                        errorCode: 'unacceptable_request',
+                        errorMessage: 'You must provide a display name, email, phone number, or user ID to add a studio member.',
                     };
                 }
-                let addedUserId = null;
-                if (request.addedUserId) {
-                    addedUserId = request.addedUserId;
-                }
-                else if (request.addedEmail || request.addedPhoneNumber) {
-                    const addedUser = yield this._auth.findUserByAddress((_a = request.addedEmail) !== null && _a !== void 0 ? _a : request.addedPhoneNumber, request.addedEmail ? 'email' : 'phone');
-                    if (addedUser) {
-                        addedUserId = addedUser.id;
-                    }
-                }
-                if (!addedUserId &&
-                    this._privo &&
-                    (request.addedEmail ||
-                        request.addedPhoneNumber ||
-                        request.addedDisplayName)) {
-                    const privoServiceId = yield this._privo.lookupServiceId({
-                        displayName: (_b = request.addedDisplayName) !== null && _b !== void 0 ? _b : undefined,
-                        email: (_c = request.addedEmail) !== null && _c !== void 0 ? _c : undefined,
-                        phoneNumber: (_d = request.addedPhoneNumber) !== null && _d !== void 0 ? _d : undefined,
-                    });
-                    if (privoServiceId) {
-                        const user = yield this._auth.findUserByPrivoServiceId(privoServiceId);
-                        if (user) {
-                            addedUserId = user.id;
-                        }
-                    }
-                }
-                if (!addedUserId) {
-                    if (this._privo &&
-                        !request.addedEmail &&
-                        !request.addedPhoneNumber &&
-                        !request.addedUserId &&
-                        !request.addedDisplayName) {
-                        return {
-                            success: false,
-                            errorCode: 'unacceptable_request',
-                            errorMessage: 'You must provide a display name, email, phone number, or user ID to add a studio member.',
-                        };
-                    }
-                    else if (!this._privo &&
-                        !request.addedEmail &&
-                        !request.addedPhoneNumber &&
-                        !request.addedUserId) {
-                        return {
-                            success: false,
-                            errorCode: 'unacceptable_request',
-                            errorMessage: 'You must provide an email, phone number, or user ID to add a studio member.',
-                        };
-                    }
+                else if (!this._privo &&
+                    !request.addedEmail &&
+                    !request.addedPhoneNumber &&
+                    !request.addedUserId) {
                     return {
                         success: false,
-                        errorCode: 'user_not_found',
-                        errorMessage: 'The user was not able to be found.',
+                        errorCode: 'unacceptable_request',
+                        errorMessage: 'You must provide an email, phone number, or user ID to add a studio member.',
                     };
                 }
-                yield this._store.addStudioAssignment({
-                    studioId: request.studioId,
-                    userId: addedUserId,
-                    isPrimaryContact: false,
-                    role: request.role,
-                });
                 return {
-                    success: true,
+                    success: false,
+                    errorCode: 'user_not_found',
+                    errorMessage: 'The user was not able to be found.',
                 };
             }
-            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('[RecordsController] [addStudioMember] An error occurred while adding a studio member:', err);
+            await this._store.addStudioAssignment({
+                studioId: request.studioId,
+                userId: addedUserId,
+                isPrimaryContact: false,
+                role: request.role,
+            });
+            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('[RecordsController] [addStudioMember] An error occurred while adding a studio member:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async removeStudioMember(request) {
+        try {
+            if (!request.userId) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'You must be logged in to remove a studio member.',
                 };
             }
-        });
-    }
-    removeStudioMember(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!request.userId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_logged_in',
-                        errorMessage: 'You must be logged in to remove a studio member.',
-                    };
-                }
-                if (request.userId === request.removedUserId) {
-                    return {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to perform this operation.',
-                    };
-                }
-                const list = yield this._store.listStudioAssignments(request.studioId, {
-                    userId: request.userId,
-                    role: 'admin',
-                });
-                if (list.length <= 0) {
-                    return {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to perform this operation.',
-                    };
-                }
-                yield this._store.removeStudioAssignment(request.studioId, request.removedUserId);
+            if (request.userId === request.removedUserId) {
                 return {
-                    success: true,
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this operation.',
                 };
             }
-            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('[RecordsController] [removeStudioMember] An error occurred while removing a studio member:', err);
+            const list = await this._store.listStudioAssignments(request.studioId, {
+                userId: request.userId,
+                role: 'admin',
+            });
+            if (list.length <= 0) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this operation.',
                 };
             }
-        });
+            await this._store.removeStudioAssignment(request.studioId, request.removedUserId);
+            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('[RecordsController] [removeStudioMember] An error occurred while removing a studio member:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
-    requestComId(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const existingStudio = yield this._store.getStudioById(request.studioId);
-                if (!existingStudio) {
-                    return {
-                        success: false,
-                        errorCode: 'studio_not_found',
-                        errorMessage: 'The given studio was not found.',
-                    };
-                }
-                const assignments = yield this._store.listStudioAssignments(request.studioId, {
-                    role: 'admin',
-                    userId: request.userId,
-                });
-                if (assignments.length <= 0) {
-                    return {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to perform this operation.',
-                    };
-                }
-                const existingComIdStudio = yield this._store.getStudioByComId(request.requestedComId);
-                if (existingComIdStudio) {
-                    return {
-                        success: false,
-                        errorCode: 'comId_already_taken',
-                        errorMessage: 'The given comID is already taken.',
-                    };
-                }
-                const id = uuid();
-                const now = Date.now();
-                const comIdRequest = {
-                    id,
-                    userId: request.userId,
-                    studioId: request.studioId,
-                    requestingIpAddress: request.ipAddress,
-                    requestedComId: request.requestedComId,
-                    createdAtMs: now,
-                    updatedAtMs: now,
+    async requestComId(request) {
+        try {
+            const existingStudio = await this._store.getStudioById(request.studioId);
+            if (!existingStudio) {
+                return {
+                    success: false,
+                    errorCode: 'studio_not_found',
+                    errorMessage: 'The given studio was not found.',
                 };
-                yield this._store.saveComIdRequest(comIdRequest);
-                if (this._messenger) {
-                    yield this._messenger.sendRecordNotification({
-                        timeMs: now,
-                        resource: 'studio_com_id_request',
-                        action: 'created',
-                        recordName: null,
-                        resourceId: comIdRequest.studioId,
-                        request: comIdRequest,
-                    });
-                }
+            }
+            const assignments = await this._store.listStudioAssignments(request.studioId, {
+                role: 'admin',
+                userId: request.userId,
+            });
+            if (assignments.length <= 0) {
                 return {
-                    success: true,
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this operation.',
                 };
             }
-            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('[RecordsController] [requestComId] An error occurred while requesting a comId:', err);
+            const existingComIdStudio = await this._store.getStudioByComId(request.requestedComId);
+            if (existingComIdStudio) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'comId_already_taken',
+                    errorMessage: 'The given comID is already taken.',
                 };
             }
-        });
+            const id = uuid();
+            const now = Date.now();
+            const comIdRequest = {
+                id,
+                userId: request.userId,
+                studioId: request.studioId,
+                requestingIpAddress: request.ipAddress,
+                requestedComId: request.requestedComId,
+                createdAtMs: now,
+                updatedAtMs: now,
+            };
+            await this._store.saveComIdRequest(comIdRequest);
+            if (this._messenger) {
+                await this._messenger.sendRecordNotification({
+                    timeMs: now,
+                    resource: 'studio_com_id_request',
+                    action: 'created',
+                    recordName: null,
+                    resourceId: comIdRequest.studioId,
+                    request: comIdRequest,
+                });
+            }
+            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('[RecordsController] [requestComId] An error occurred while requesting a comId:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     _createSalt() {
         return fromByteArray(randomBytes(16));
@@ -1420,116 +1376,4 @@ __decorate([
 __decorate([
     traced(TRACE_NAME)
 ], RecordsController.prototype, "_createSalt", null);
-/**
- * The default policy for keys that do not have a specified record key.
- */
-export const DEFAULT_RECORD_KEY_POLICY = 'subjectfull';
-/**
- * Formats the given record name and record secret into a record key.
- * @param recordName The name of the record.
- * @param recordSecret The secret that is used to access the record.
- */
-export function formatV1RecordKey(recordName, recordSecret) {
-    return `vRK1.${toBase64String(recordName)}.${toBase64String(recordSecret)}`;
-}
-/**
- * Formats the given record name and record secret into a record key.
- * @param recordName The name of the record.
- * @param recordSecret The secret that is used to access the record.
- * @param keyPolicy The policy that the key uses.
- */
-export function formatV2RecordKey(recordName, recordSecret, keyPolicy) {
-    return `vRK2.${toBase64String(recordName)}.${toBase64String(recordSecret)}.${keyPolicy !== null && keyPolicy !== void 0 ? keyPolicy : DEFAULT_RECORD_KEY_POLICY}`;
-}
-/**
- * Parses the given record key into a name and password pair.
- * Returns null if the key cannot be parsed.
- * @param key The key to parse.
- */
-export function parseRecordKey(key) {
-    var _a;
-    return (_a = parseV2RecordKey(key)) !== null && _a !== void 0 ? _a : parseV1RecordKey(key);
-}
-/**
- * Parses a version 2 record key into a name, password, and policy trio.
- * Returns null if the key cannot be parsed or if it is not a V2 key.
- * @param key The key to parse.
- */
-export function parseV2RecordKey(key) {
-    if (!key) {
-        return null;
-    }
-    if (!key.startsWith('vRK2.')) {
-        return null;
-    }
-    const withoutVersion = key.slice('vRK2.'.length);
-    let periodAfterName = withoutVersion.indexOf('.');
-    if (periodAfterName < 0) {
-        return null;
-    }
-    const nameBase64 = withoutVersion.slice(0, periodAfterName);
-    const passwordPlusPolicy = withoutVersion.slice(periodAfterName + 1);
-    if (nameBase64.length <= 0 || passwordPlusPolicy.length <= 0) {
-        return null;
-    }
-    const periodAfterPassword = passwordPlusPolicy.indexOf('.');
-    if (periodAfterPassword < 0) {
-        return null;
-    }
-    const passwordBase64 = passwordPlusPolicy.slice(0, periodAfterPassword);
-    const policy = passwordPlusPolicy.slice(periodAfterPassword + 1);
-    if (passwordBase64.length <= 0 || policy.length <= 0) {
-        return null;
-    }
-    if (policy !== 'subjectfull' && policy !== 'subjectless') {
-        return null;
-    }
-    try {
-        const name = fromBase64String(nameBase64);
-        const password = fromBase64String(passwordBase64);
-        return [name, password, policy];
-    }
-    catch (err) {
-        return null;
-    }
-}
-/**
- * Parses a version 1 record key into a name and password pair.
- * Returns null if the key cannot be parsed or if it is not a V1 key.
- * @param key The key to parse.
- */
-export function parseV1RecordKey(key) {
-    if (!key) {
-        return null;
-    }
-    if (!key.startsWith('vRK1.')) {
-        return null;
-    }
-    const withoutVersion = key.slice('vRK1.'.length);
-    let nextPeriod = withoutVersion.indexOf('.');
-    if (nextPeriod < 0) {
-        return null;
-    }
-    const nameBase64 = withoutVersion.slice(0, nextPeriod);
-    const passwordBase64 = withoutVersion.slice(nextPeriod + 1);
-    if (nameBase64.length <= 0 || passwordBase64.length <= 0) {
-        return null;
-    }
-    try {
-        const name = fromBase64String(nameBase64);
-        const password = fromBase64String(passwordBase64);
-        return [name, password, DEFAULT_RECORD_KEY_POLICY];
-    }
-    catch (err) {
-        return null;
-    }
-}
-/**
- * Determines if the given value is a record key.
- * @param key The value to check.
- * @returns
- */
-export function isRecordKey(key) {
-    return typeof key === 'string' && parseRecordKey(key) !== null;
-}
 //# sourceMappingURL=RecordsController.js.map