@casual-simulation/aux-records 3.2.3 → 3.2.4-alpha.5940763320

package/RecordsController.js

@@ -11,13 +11,162 @@ import { toBase64String, fromBase64String } from './Utils';
 import { hashHighEntropyPasswordWithSalt, hashPasswordWithSalt, } from '@casual-simulation/crypto';
 import { randomBytes } from 'tweetnacl';
 import { fromByteArray } from 'base64-js';
+import { v4 as uuid } from 'uuid';
+import { getSubscriptionFeatures } from './SubscriptionConfiguration';
 /**
  * Defines a class that manages records and their keys.
  */
 export class RecordsController {
-    constructor(store, auth) {
-        this._store = store;
-        this._auth = auth;
+    constructor(config) {
+        this._store = config.store;
+        this._auth = config.auth;
+        this._metrics = config.metrics;
+        this._config = config.config;
+    }
+    /**
+     * 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({
+                        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,
+                    });
+                }
+                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({
+                        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,
+                    });
+                }
+                return {
+                    success: true,
+                };
+            }
+            catch (err) {
+                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.
@@ -27,6 +176,7 @@ export class RecordsController {
      * @returns
      */
     createPublicRecordKey(name, policy, userId) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (!userId) {
@@ -37,7 +187,6 @@ export class RecordsController {
                         errorReason: 'not_logged_in',
                     };
                 }
-                const record = yield this._store.getRecordByName(name);
                 if (!!policy &&
                     policy !== 'subjectfull' &&
                     policy !== 'subjectless') {
@@ -48,8 +197,32 @@ export class RecordsController {
                         errorReason: 'invalid_policy',
                     };
                 }
-                if (record) {
-                    if (record.ownerId !== userId && name !== userId) {
+                let existingStudioMembers = yield this._store.listStudioAssignments(name);
+                let createResult;
+                // recordName matches studioId
+                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',
@@ -57,76 +230,70 @@ export class RecordsController {
                             errorReason: 'record_owned_by_different_user',
                         };
                     }
-                    console.log(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Creating record key.`);
-                    if (name === userId) {
-                        // 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] [action: recordKey.create 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));
-                    }
-                    const passwordBytes = randomBytes(16);
-                    const password = fromByteArray(passwordBytes); // convert to human-readable string
-                    const salt = record.secretSalt;
-                    const passwordHash = hashHighEntropyPasswordWithSalt(password, salt);
-                    yield this._store.addRecordKey({
-                        recordName: name,
-                        secretHash: passwordHash,
-                        policy: policy !== null && policy !== void 0 ? policy : DEFAULT_RECORD_KEY_POLICY,
-                        creatorId: record.ownerId,
-                    });
+                    console.error(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Unable to find record that was just created!`);
                     return {
-                        success: true,
-                        recordKey: formatV2RecordKey(name, password, policy),
-                        recordName: name,
+                        success: false,
+                        errorCode: 'server_error',
+                        errorMessage: 'A server error occurred.',
+                        errorReason: 'server_error',
                     };
                 }
-                else {
-                    if (name !== userId) {
-                        const user = yield this._auth.findUser(name);
-                        if (user) {
-                            // User exists for record. They should own the record and all record keys for it.
-                            return {
-                                success: false,
-                                errorCode: 'unauthorized_to_create_record_key',
-                                errorMessage: 'Another user has already created this record.',
-                                errorReason: 'record_owned_by_different_user',
-                            };
-                        }
+                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',
+                        };
                     }
-                    console.log(`[RecordsController] [action: recordKey.create recordName: ${name}, userId: ${userId}] Creating record.`);
-                    const passwordBytes = randomBytes(16);
-                    const password = fromByteArray(passwordBytes); // convert to human-readable string
-                    const salt = this._createSalt();
-                    const passwordHash = hashHighEntropyPasswordWithSalt(password, salt);
-                    yield this._store.addRecord({
-                        name,
-                        ownerId: userId,
-                        secretHashes: [],
-                        secretSalt: salt,
-                    });
-                    yield this._store.addRecordKey({
-                        recordName: name,
-                        secretHash: passwordHash,
-                        policy: policy !== null && policy !== void 0 ? policy : DEFAULT_RECORD_KEY_POLICY,
-                        creatorId: userId,
+                    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',
                     });
-                    return {
-                        success: true,
-                        recordKey: formatV2RecordKey(name, password, policy),
-                        recordName: name,
-                    };
+                    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 = 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) {
-                console.error(err);
+                console.error('[RecordsController] [createPublicRecordKey] An error occurred while creating a public record key:', err);
                 return {
                     success: false,
                     errorCode: 'server_error',
-                    errorMessage: err.toString(),
+                    errorMessage: 'A server error occurred.',
                     errorReason: 'server_error',
                 };
             }
@@ -234,11 +401,11 @@ export class RecordsController {
                 }
             }
             catch (err) {
-                console.error(err);
+                console.error('[RecordsController] [validatePublicRecordKey] An error occurred while creating a public record key:', err);
                 return {
                     success: false,
                     errorCode: 'server_error',
-                    errorMessage: err.toString(),
+                    errorMessage: 'A server error occurred.',
                 };
             }
         });
@@ -254,10 +421,17 @@ export class RecordsController {
                 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(),
                         });
@@ -265,6 +439,31 @@ export class RecordsController {
                             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 {
@@ -276,6 +475,12 @@ export class RecordsController {
                 else if (userId &&
                     record.name === userId &&
                     record.ownerId !== userId) {
+                    const allowed = yield 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.`);
@@ -285,24 +490,85 @@ export class RecordsController {
                     record.secretSalt = this._createSalt();
                     yield this._store.updateRecord(Object.assign({}, record));
                 }
+                let existingStudioMembers = yield this._store.listStudioAssignments(name);
+                if (existingStudioMembers.length > 0 &&
+                    record.studioId !== name &&
+                    record.ownerId !== null) {
+                    const allowed = yield 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);
+                }
                 return {
                     success: true,
                     recordName: name,
                     ownerId: record.ownerId,
+                    studioId: record.studioId,
+                    studioMembers,
                 };
             }
             catch (err) {
-                console.error(err);
+                console.error('[RecordsController] [validateRecordName] An error occurred while creating a public record key:', err);
                 return {
                     success: false,
                     errorCode: 'server_error',
-                    errorMessage: err.toString(),
+                    errorMessage: 'A server error occurred.',
                 };
             }
         });
     }
+    _doesSubscriptionAllowToCreateRecord(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { features, metrics } = yield this._getSubscriptionFeatures(filter);
+            if (!features.records.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'Records are not allowed for this subscription.',
+                };
+            }
+            else if (features.records.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,
+            };
+        });
+    }
+    _getSubscriptionFeatures(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metrics = yield this._metrics.getSubscriptionRecordMetrics(filter);
+            const config = yield this._config.getSubscriptionConfiguration();
+            return {
+                metrics,
+                config,
+                features: getSubscriptionFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.ownerId ? 'user' : 'studio'),
+            };
+        });
+    }
     /**
-     * Gets the list of records that the user with the given ID owns.
+     * Gets the list of records that the user with the given ID has access to.
      * @param userId The ID of the user.
      */
     listRecords(userId) {
@@ -331,6 +597,258 @@ export class RecordsController {
             }
         });
     }
+    /**
+     * 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 records = yield this._store.listRecordsByStudioIdAndUserId(studioId, userId);
+                return {
+                    success: true,
+                    records: records,
+                };
+            }
+            catch (err) {
+                console.log('[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) {
+                console.error('[RecordsController] [createStudio] An error occurred while creating a studio:', 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);
+                return {
+                    success: true,
+                    studios: studios.map((s) => ({
+                        studioId: s.studioId,
+                        displayName: s.displayName,
+                        role: s.role,
+                        isPrimaryContact: s.isPrimaryContact,
+                    })),
+                };
+            }
+            catch (err) {
+                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);
+                if (!userAssignment) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'You are not authorized to access this studio.',
+                    };
+                }
+                if (userAssignment.role === 'admin') {
+                    return {
+                        success: true,
+                        members: members.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,
+                            },
+                        })),
+                    };
+                }
+                return {
+                    success: true,
+                    members: members.map((m) => ({
+                        studioId: m.studioId,
+                        userId: m.userId,
+                        isPrimaryContact: m.isPrimaryContact,
+                        role: m.role,
+                        user: {
+                            id: m.user.id,
+                            name: m.user.name,
+                        },
+                    })),
+                };
+            }
+            catch (err) {
+                console.error('[RecordsController] [listStudioMembers] An error occurred while listing studio members:', err);
+                return {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'A server error occurred.',
+                };
+            }
+        });
+    }
+    addStudioMember(request) {
+        var _a;
+        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 = 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.',
+                    };
+                }
+                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) {
+                        return {
+                            success: false,
+                            errorCode: 'user_not_found',
+                            errorMessage: 'The user was not able to be found.',
+                        };
+                    }
+                    addedUserId = addedUser.id;
+                }
+                else {
+                    return {
+                        success: false,
+                        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,
+                };
+            }
+            catch (err) {
+                console.error('[RecordsController] [addStudioMember] An error occurred while adding a studio member:', err);
+                return {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'A server error occurred.',
+                };
+            }
+        });
+    }
+    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);
+                return {
+                    success: true,
+                };
+            }
+            catch (err) {
+                console.error('[RecordsController] [removeStudioMember] An error occurred while removing a studio member:', err);
+                return {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'A server error occurred.',
+                };
+            }
+        });
+    }
     _createSalt() {
         return fromByteArray(randomBytes(16));
     }