@casual-simulation/aux-records 3.2.11 → 3.2.12

package/RecordsServer.js

@@ -26,6 +26,7 @@ import { AVAILABLE_PERMISSIONS_VALIDATION } from '@casual-simulation/aux-common'
 import { AI_CHAT_MESSAGE_SCHEMA } from './AIChatInterface';
 import { WebsocketEventTypes, websocketEventSchema, websocketRequestMessageSchema, } from '@casual-simulation/aux-common/websockets/WebsocketEvents';
 import { DEFAULT_BRANCH_NAME } from '@casual-simulation/aux-common';
+import { COM_ID_CONFIG_SCHEMA, COM_ID_PLAYER_CONFIG } from './ComIdConfig';
 const NOT_LOGGED_IN_RESULT = {
     success: false,
     errorCode: 'not_logged_in',
@@ -93,7 +94,8 @@ const ADDRESS_VALIDATION = z
     invalid_type_error: 'address must be a string.',
     required_error: 'address is required.',
 })
-    .nonempty('address must not be empty.');
+    .min(1)
+    .max(512);
 /**
  * The Zod validation for event names.
  */
@@ -102,7 +104,29 @@ const EVENT_NAME_VALIDATION = z
     invalid_type_error: 'eventName must be a string.',
     required_error: 'eventName is required.',
 })
-    .nonempty('eventName must not be empty.');
+    .min(1)
+    .max(128);
+const STUDIO_ID_VALIDATION = z
+    .string({
+    invalid_type_error: 'studioId must be a string.',
+    required_error: 'studioId is required.',
+})
+    .min(1)
+    .max(128);
+const COM_ID_VALIDATION = z
+    .string({
+    invalid_type_error: 'comId must be a string.',
+    required_error: 'comId is required.',
+})
+    .min(1)
+    .max(128);
+const STUDIO_DISPLAY_NAME_VALIDATION = z
+    .string({
+    invalid_type_error: 'displayName must be a string.',
+    required_error: 'displayName is required.',
+})
+    .min(1)
+    .max(128);
 /**
  * The Zod validation for markers.
  */
@@ -112,11 +136,13 @@ const MARKERS_VALIDATION = z
     invalid_type_error: 'individual markers must be strings.',
     required_error: 'invidiaul markers must not be null or empty.',
 })
-    .nonempty('invidiaul markers must not be null or empty.'), {
+    .min(1)
+    .max(128), {
     invalid_type_error: 'markers must be an array of strings.',
     required_error: 'markers is required.',
 })
-    .nonempty('markers must not be empty.');
+    .nonempty('markers must not be empty.')
+    .max(10, 'markers must not contain more than 10 markers.');
 const NO_WHITESPACE_MESSAGE = 'The value cannot not contain spaces.';
 const NO_WHITESPACE_REGEX = /^\S*$/g;
 const NO_SPECIAL_CHARACTERS_MESSAGE = 'The value cannot not contain special characters.';
@@ -125,14 +151,31 @@ const DISPLAY_NAME_VALIDATION = z
     .string()
     .trim()
     .min(1)
+    .max(128)
     .regex(NO_WHITESPACE_REGEX, NO_WHITESPACE_MESSAGE)
     .regex(NO_SPECIAL_CHARACTERS_REGEX, NO_SPECIAL_CHARACTERS_MESSAGE);
 const NAME_VALIDATION = z
     .string()
     .trim()
     .min(1)
+    .max(128)
     .regex(NO_WHITESPACE_REGEX, NO_WHITESPACE_MESSAGE)
     .regex(NO_SPECIAL_CHARACTERS_REGEX, NO_SPECIAL_CHARACTERS_MESSAGE);
+const RECORD_NAME_VALIDATION = z
+    .string({
+    required_error: 'recordName is required.',
+    invalid_type_error: 'recordName must be a string.',
+})
+    .trim()
+    .min(1)
+    .max(128);
+const INSTANCE_VALIDATION = z.string().min(1).max(128);
+const INSTANCES_ARRAY_VALIDATION = z.array(INSTANCE_VALIDATION).min(1).max(3);
+const INSTANCES_QUERY_VALIDATION = z
+    .string()
+    .min(1)
+    .max(128 * 3)
+    .transform((value) => parseInstancesList(value));
 /**
  * Defines a class that represents a generic HTTP server suitable for Records HTTP Requests.
  */
@@ -393,10 +436,22 @@ export class RecordsServer {
                 request.path === '/api/v2/ai/image') {
                 return formatResponse(request, yield this._aiGenerateImage(request), this._allowedApiOrigins);
             }
+            else if (request.method === 'GET' &&
+                request.path === '/api/v2/studios') {
+                return formatResponse(request, yield this._getStudio(request), this._allowedAccountOrigins);
+            }
             else if (request.method === 'POST' &&
                 request.path === '/api/v2/studios') {
                 return formatResponse(request, yield this._postStudio(request), this._allowedAccountOrigins);
             }
+            else if (request.method === 'PUT' &&
+                request.path === '/api/v2/studios') {
+                return formatResponse(request, yield this._updateStudio(request), this._allowedAccountOrigins);
+            }
+            else if (request.method === 'POST' &&
+                request.path === '/api/v2/studios/requestComId') {
+                return formatResponse(request, yield this._requestComId(request), this._allowedAccountOrigins);
+            }
             else if (request.method === 'GET' &&
                 request.path === '/api/v2/studios/list') {
                 return formatResponse(request, yield this._listStudios(request), this._allowedApiOrigins);
@@ -413,6 +468,10 @@ export class RecordsServer {
                 request.path === '/api/v2/studios/members') {
                 return formatResponse(request, yield this._removeStudioMember(request), this._allowedAccountOrigins);
             }
+            else if (request.method === 'GET' &&
+                request.path === '/api/v2/player/config') {
+                return formatResponse(request, yield this._getPlayerConfig(request), this._allowedApiOrigins);
+            }
             else if (request.method === 'GET' &&
                 request.path === '/api/v2/subscriptions') {
                 return formatResponse(request, yield this._getSubscriptionInfoV2(request), this._allowedAccountOrigins);
@@ -748,12 +807,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty.'),
+                recordName: RECORD_NAME_VALIDATION,
                 ownerId: z
                     .string({
                     invalid_type_error: 'ownerId must be a string.',
@@ -810,10 +864,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                recordName: z.string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                }),
+                recordName: RECORD_NAME_VALIDATION,
                 policy: z.string({
                     invalid_type_error: 'policy must be a string.',
                     required_error: 'policy is required.',
@@ -855,12 +906,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 marker: z
                     .string({
                     invalid_type_error: 'marker must be a string.',
@@ -868,7 +914,7 @@ export class RecordsServer {
                 })
                     .nonempty('marker must not be empty'),
                 permission: AVAILABLE_PERMISSIONS_VALIDATION,
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.nonempty().optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -918,12 +964,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 marker: z
                     .string({
                     invalid_type_error: 'marker must be a string.',
@@ -931,7 +972,7 @@ export class RecordsServer {
                 })
                     .nonempty('marker must not be empty'),
                 permission: AVAILABLE_PERMISSIONS_VALIDATION,
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -961,12 +1002,7 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 marker: z
                     .string({
                     invalid_type_error: 'marker must be a string.',
@@ -996,12 +1032,7 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 startingMarker: z
                     .string({
                     invalid_type_error: 'startingMarker must be a string.',
@@ -1032,26 +1063,14 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 userId: z
                     .string({
                     invalid_type_error: 'userId must be a string.',
                     required_error: 'userId is required.',
                 })
                     .nonempty('userId must not be empty'),
-                instances: z
-                    .string({
-                    invalid_type_error: 'instances must be a string.',
-                    required_error: 'instances is required.',
-                })
-                    .nonempty('instances must not be empty')
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query);
             if (parseResult.success === false) {
@@ -1075,26 +1094,14 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 inst: z
                     .string({
                     invalid_type_error: 'inst must be a string.',
                     required_error: 'inst is required.',
                 })
                     .nonempty('inst must not be empty'),
-                instances: z
-                    .string({
-                    invalid_type_error: 'instances must be a string.',
-                    required_error: 'instances is required.',
-                })
-                    .nonempty('instances must not be empty')
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query);
             if (parseResult.success === false) {
@@ -1118,12 +1125,7 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 startingRole: z
                     .string({
                     invalid_type_error: 'startingRole must be a string.',
@@ -1138,14 +1140,7 @@ export class RecordsServer {
                 })
                     .nonempty('role must not be empty')
                     .optional(),
-                instances: z
-                    .string({
-                    invalid_type_error: 'instances must be a string.',
-                    required_error: 'instances is required.',
-                })
-                    .nonempty('instances must not be empty')
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query);
             if (parseResult.success === false) {
@@ -1182,12 +1177,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 userId: z
                     .string({
                     invalid_type_error: 'userId must be a string.',
@@ -1215,7 +1205,7 @@ export class RecordsServer {
                 })
                     .positive('expireTimeMs must be positive')
                     .optional(),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -1251,12 +1241,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 userId: z
                     .string({
                     invalid_type_error: 'userId must be a string.',
@@ -1277,7 +1262,7 @@ export class RecordsServer {
                     required_error: 'role is required.',
                 })
                     .nonempty('role must not be empty'),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -1317,7 +1302,7 @@ export class RecordsServer {
             const schema = z.object({
                 model: z.string().nonempty().optional(),
                 messages: z.array(AI_CHAT_MESSAGE_SCHEMA).nonempty(),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
                 temperature: z.number().min(0).max(2).optional(),
                 topP: z.number().optional(),
                 presencePenalty: z.number().min(-2).max(2).optional(),
@@ -1356,8 +1341,8 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                prompt: z.string().nonempty(),
-                negativePrompt: z.string().nonempty().optional(),
+                prompt: z.string().nonempty().max(600),
+                negativePrompt: z.string().nonempty().max(600).optional(),
                 blockadeLabs: z
                     .object({
                     skyboxStyleId: z.number().optional(),
@@ -1365,7 +1350,7 @@ export class RecordsServer {
                     seed: z.number().optional(),
                 })
                     .optional(),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -1404,14 +1389,7 @@ export class RecordsServer {
                     required_error: 'skyboxId is required.',
                 })
                     .nonempty('skyboxId must not be empty'),
-                instances: z
-                    .string({
-                    invalid_type_error: 'instances must be a string.',
-                    required_error: 'instances is required.',
-                })
-                    .nonempty('instances must not be empty')
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query);
             if (parseResult.success === false) {
@@ -1472,7 +1450,7 @@ export class RecordsServer {
                 cfgScale: z.number().min(0).int().optional(),
                 clipGuidancePreset: z.string().nonempty().optional(),
                 stylePreset: z.string().nonempty().optional(),
-                instances: z.array(z.string().nonempty()).optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -1506,6 +1484,30 @@ export class RecordsServer {
             return returnResult(result);
         });
     }
+    _getStudio(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!validateOrigin(request, this._allowedAccountOrigins)) {
+                return returnResult(INVALID_ORIGIN_RESULT);
+            }
+            const schema = z.object({
+                studioId: STUDIO_ID_VALIDATION,
+            });
+            const parseResult = schema.safeParse(request.query);
+            if (parseResult.success === false) {
+                return returnZodError(parseResult.error);
+            }
+            const { studioId } = parseResult.data;
+            const sessionKeyValidation = yield this._validateSessionKey(request);
+            if (sessionKeyValidation.success === false) {
+                if (sessionKeyValidation.errorCode === 'no_session_key') {
+                    return returnResult(NOT_LOGGED_IN_RESULT);
+                }
+                return returnResult(sessionKeyValidation);
+            }
+            const result = yield this._records.getStudio(studioId, sessionKeyValidation.userId);
+            return returnResult(result);
+        });
+    }
     _postStudio(request) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!validateOrigin(request, this._allowedAccountOrigins)) {
@@ -1519,18 +1521,71 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                displayName: z
+                displayName: STUDIO_DISPLAY_NAME_VALIDATION,
+                ownerStudioComId: z
+                    .string({
+                    invalid_type_error: 'ownerStudioComId must be a string.',
+                    required_error: 'ownerStudioComId is required.',
+                })
+                    .nonempty('ownerStudioComId must not be empty')
+                    .nullable()
+                    .optional(),
+            });
+            const parseResult = schema.safeParse(jsonResult.value);
+            if (parseResult.success === false) {
+                return returnZodError(parseResult.error);
+            }
+            const { displayName, ownerStudioComId } = parseResult.data;
+            const sessionKeyValidation = yield this._validateSessionKey(request);
+            if (sessionKeyValidation.success === false) {
+                if (sessionKeyValidation.errorCode === 'no_session_key') {
+                    return returnResult(NOT_LOGGED_IN_RESULT);
+                }
+                return returnResult(sessionKeyValidation);
+            }
+            if (!ownerStudioComId) {
+                const result = yield this._records.createStudio(displayName, sessionKeyValidation.userId);
+                return returnResult(result);
+            }
+            else {
+                const result = yield this._records.createStudioInComId(displayName, sessionKeyValidation.userId, ownerStudioComId);
+                return returnResult(result);
+            }
+        });
+    }
+    _updateStudio(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!validateOrigin(request, this._allowedAccountOrigins)) {
+                return returnResult(INVALID_ORIGIN_RESULT);
+            }
+            if (typeof request.body !== 'string') {
+                return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
+            }
+            const jsonResult = tryParseJson(request.body);
+            if (!jsonResult.success || typeof jsonResult.value !== 'object') {
+                return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
+            }
+            const schema = z.object({
+                id: STUDIO_ID_VALIDATION,
+                displayName: STUDIO_DISPLAY_NAME_VALIDATION.optional(),
+                logoUrl: z
                     .string({
-                    invalid_type_error: 'displayName must be a string.',
-                    required_error: 'displayName is required.',
+                    invalid_type_error: 'logoUrl must be a string.',
+                    required_error: 'logoUrl is required.',
                 })
-                    .nonempty('displayName must not be empty'),
+                    .url()
+                    .min(1)
+                    .max(512)
+                    .nullable()
+                    .optional(),
+                comIdConfig: COM_ID_CONFIG_SCHEMA.optional(),
+                playerConfig: COM_ID_PLAYER_CONFIG.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
                 return returnZodError(parseResult.error);
             }
-            const { displayName } = parseResult.data;
+            const { id, displayName, logoUrl, comIdConfig, playerConfig } = parseResult.data;
             const sessionKeyValidation = yield this._validateSessionKey(request);
             if (sessionKeyValidation.success === false) {
                 if (sessionKeyValidation.errorCode === 'no_session_key') {
@@ -1538,7 +1593,53 @@ export class RecordsServer {
                 }
                 return returnResult(sessionKeyValidation);
             }
-            const result = yield this._records.createStudio(displayName, sessionKeyValidation.userId);
+            const result = yield this._records.updateStudio({
+                userId: sessionKeyValidation.userId,
+                studio: {
+                    id,
+                    displayName,
+                    logoUrl,
+                    comIdConfig,
+                    playerConfig,
+                },
+            });
+            return returnResult(result);
+        });
+    }
+    _requestComId(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!validateOrigin(request, this._allowedAccountOrigins)) {
+                return returnResult(INVALID_ORIGIN_RESULT);
+            }
+            if (typeof request.body !== 'string') {
+                return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
+            }
+            const jsonResult = tryParseJson(request.body);
+            if (!jsonResult.success || typeof jsonResult.value !== 'object') {
+                return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
+            }
+            const schema = z.object({
+                studioId: STUDIO_ID_VALIDATION,
+                comId: COM_ID_VALIDATION,
+            });
+            const parseResult = schema.safeParse(jsonResult.value);
+            if (parseResult.success === false) {
+                return returnZodError(parseResult.error);
+            }
+            const { studioId, comId } = parseResult.data;
+            const sessionKeyValidation = yield this._validateSessionKey(request);
+            if (sessionKeyValidation.success === false) {
+                if (sessionKeyValidation.errorCode === 'no_session_key') {
+                    return returnResult(NOT_LOGGED_IN_RESULT);
+                }
+                return returnResult(sessionKeyValidation);
+            }
+            const result = yield this._records.requestComId({
+                studioId,
+                userId: sessionKeyValidation.userId,
+                requestedComId: comId,
+                ipAddress: request.ipAddress,
+            });
             return returnResult(result);
         });
     }
@@ -1547,12 +1648,14 @@ export class RecordsServer {
             if (!validateOrigin(request, this._allowedApiOrigins)) {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
-            const schema = z.object({});
+            const schema = z.object({
+                comId: z.string().nonempty().optional(),
+            });
             const parseResult = schema.safeParse(request.query);
             if (parseResult.success === false) {
                 return returnZodError(parseResult.error);
             }
-            const {} = parseResult.data;
+            const { comId } = parseResult.data;
             const sessionKeyValidation = yield this._validateSessionKey(request);
             if (sessionKeyValidation.success === false) {
                 if (sessionKeyValidation.errorCode === 'no_session_key') {
@@ -1560,8 +1663,14 @@ export class RecordsServer {
                 }
                 return returnResult(sessionKeyValidation);
             }
-            const result = yield this._records.listStudios(sessionKeyValidation.userId);
-            return returnResult(result);
+            if (comId) {
+                const result = yield this._records.listStudiosByComId(sessionKeyValidation.userId, comId);
+                return returnResult(result);
+            }
+            else {
+                const result = yield this._records.listStudios(sessionKeyValidation.userId);
+                return returnResult(result);
+            }
         });
     }
     _listStudioMembers(request) {
@@ -1570,12 +1679,7 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                studioId: z
-                    .string({
-                    invalid_type_error: 'studioId must be a string.',
-                    required_error: 'studioId is required.',
-                })
-                    .nonempty('studioId must not be empty'),
+                studioId: STUDIO_ID_VALIDATION,
             });
             const parseResult = schema.safeParse(request.query);
             if (parseResult.success === false) {
@@ -1606,12 +1710,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                studioId: z
-                    .string({
-                    invalid_type_error: 'studioId must be a string.',
-                    required_error: 'studioId is required.',
-                })
-                    .nonempty('studioId must not be empty'),
+                studioId: STUDIO_ID_VALIDATION,
                 addedUserId: z
                     .string({
                     invalid_type_error: 'addedUserId must be a string.',
@@ -1671,12 +1770,7 @@ export class RecordsServer {
                 return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
             }
             const schema = z.object({
-                studioId: z
-                    .string({
-                    invalid_type_error: 'studioId must be a string.',
-                    required_error: 'studioId is required.',
-                })
-                    .nonempty('studioId must not be empty'),
+                studioId: STUDIO_ID_VALIDATION,
                 removedUserId: z
                     .string({
                     invalid_type_error: 'removedUserId must be a string.',
@@ -1705,24 +1799,29 @@ export class RecordsServer {
             return returnResult(result);
         });
     }
+    _getPlayerConfig(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!validateOrigin(request, this._allowedApiOrigins)) {
+                return returnResult(INVALID_ORIGIN_RESULT);
+            }
+            const schema = z.object({
+                comId: z.string().nonempty(),
+            });
+            const parseResult = schema.safeParse(request.query);
+            if (parseResult.success === false) {
+                return returnZodError(parseResult.error);
+            }
+            const { comId } = parseResult.data;
+            const result = yield this._records.getPlayerConfig(comId);
+            return returnResult(result);
+        });
+    }
     _listData(request) {
         return __awaiter(this, void 0, void 0, function* () {
             const schema = z.object({
-                recordName: z
-                    .string({
-                    required_error: 'recordName is required.',
-                    invalid_type_error: 'recordName must be a string.',
-                })
-                    .nonempty('recordName must not be empty'),
-                address: z.union([z.string(), z.null()]).optional(),
-                instances: z
-                    .string({
-                    invalid_type_error: 'instances must be a string.',
-                    required_error: 'instances is required.',
-                })
-                    .nonempty('instances must not be empty')
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                recordName: RECORD_NAME_VALIDATION,
+                address: ADDRESS_VALIDATION.nullable().optional(),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
             if (parseResult.success === false) {
@@ -1794,6 +1893,8 @@ export class RecordsServer {
                     invalid_type_error: 'fileSha256Hex must be a string.',
                     required_error: 'fileSha256Hex is required.',
                 })
+                    .min(1)
+                    .max(128)
                     .nonempty('fileSha256Hex must be non-empty.'),
                 fileByteLength: z
                     .number({
@@ -1802,15 +1903,20 @@ export class RecordsServer {
                 })
                     .positive('fileByteLength must be a positive integer number.')
                     .int('fileByteLength must be a positive integer number.'),
-                fileMimeType: z.string({
+                fileMimeType: z
+                    .string({
                     invalid_type_error: 'fileMimeType must be a string.',
                     required_error: 'fileMimeType is required.',
-                }),
+                })
+                    .min(1)
+                    .max(128),
                 fileDescription: z
                     .string({
                     invalid_type_error: 'fileDescription must be a string.',
                     required_error: 'fileDescription is required.',
                 })
+                    .min(1)
+                    .max(128)
                     .optional(),
                 markers: z
                     .array(z.string(), {
@@ -1819,7 +1925,7 @@ export class RecordsServer {
                 })
                     .nonempty('markers must be non-empty.')
                     .optional(),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -1905,7 +2011,7 @@ export class RecordsServer {
                     required_error: 'markers is required.',
                 })
                     .nonempty('markers must be non-empty.'),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -1928,13 +2034,7 @@ export class RecordsServer {
     _readFile(request) {
         return __awaiter(this, void 0, void 0, function* () {
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must be non-empty.')
-                    .optional(),
+                recordName: RECORD_NAME_VALIDATION.optional(),
                 fileName: z
                     .string({
                     invalid_type_error: 'fileName must be a string.',
@@ -1949,11 +2049,7 @@ export class RecordsServer {
                 })
                     .nonempty('fileUrl must be non-empty.')
                     .optional(),
-                instances: z
-                    .string()
-                    .nonempty()
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
             if (parseResult.success === false) {
@@ -2020,12 +2116,7 @@ export class RecordsServer {
     _listFiles(request) {
         return __awaiter(this, void 0, void 0, function* () {
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must be non-empty.'),
+                recordName: RECORD_NAME_VALIDATION,
                 fileName: z
                     .string({
                     invalid_type_error: 'fileName must be a string.',
@@ -2033,11 +2124,7 @@ export class RecordsServer {
                 })
                     .nonempty('fileName must be non-empty.')
                     .optional(),
-                instances: z
-                    .string()
-                    .nonempty()
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
             if (parseResult.success === false) {
@@ -2086,7 +2173,7 @@ export class RecordsServer {
                     invalid_type_error: 'fileUrl must be a string.',
                     required_error: 'fileUrl is required.',
                 }),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -2148,7 +2235,7 @@ export class RecordsServer {
                 })
                     .optional(),
                 markers: MARKERS_VALIDATION.optional(),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -2197,26 +2284,14 @@ export class RecordsServer {
     _baseGetRecordData(request, controller) {
         return __awaiter(this, void 0, void 0, function* () {
             const schema = z.object({
-                recordName: z
-                    .string({
-                    required_error: 'recordName is required.',
-                    invalid_type_error: 'recordName must be a string.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 address: z
                     .string({
                     required_error: 'address is required.',
                     invalid_type_error: 'address must be a string.',
                 })
                     .nonempty('address must not be empty'),
-                instances: z
-                    .string({
-                    invalid_type_error: 'instances must be a string.',
-                    required_error: 'instances is required.',
-                })
-                    .nonempty('instances must not be empty')
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
             if (parseResult.success === false) {
@@ -2267,7 +2342,7 @@ export class RecordsServer {
             const schema = z.object({
                 recordKey: RECORD_KEY_VALIDATION,
                 address: ADDRESS_VALIDATION,
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -2310,23 +2385,14 @@ export class RecordsServer {
                 return returnResult(INVALID_ORIGIN_RESULT);
             }
             const schema = z.object({
-                recordName: z
-                    .string({
-                    required_error: 'recordName is required.',
-                    invalid_type_error: 'recordName must be a string.',
-                })
-                    .nonempty('recordName must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
                 eventName: z
                     .string({
                     required_error: 'eventName is required.',
                     invalid_type_error: 'eventName must be a string.',
                 })
                     .nonempty('eventName must not be empty'),
-                instances: z
-                    .string()
-                    .nonempty()
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
             if (parseResult.success === false) {
@@ -2376,7 +2442,7 @@ export class RecordsServer {
                     invalid_type_error: 'count must be a number.',
                     required_error: 'count is required.',
                 }),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -2417,12 +2483,7 @@ export class RecordsServer {
     _listEvents(request) {
         return __awaiter(this, void 0, void 0, function* () {
             const schema = z.object({
-                recordName: z
-                    .string({
-                    invalid_type_error: 'recordName must be a string.',
-                    required_error: 'recordName is required.',
-                })
-                    .nonempty('recordName must be non-empty.'),
+                recordName: RECORD_NAME_VALIDATION,
                 eventName: z
                     .string({
                     invalid_type_error: 'eventName must be a string.',
@@ -2430,11 +2491,7 @@ export class RecordsServer {
                 })
                     .nonempty('eventName must be non-empty.')
                     .optional(),
-                instances: z
-                    .string()
-                    .nonempty()
-                    .optional()
-                    .transform((value) => parseInstancesList(value)),
+                instances: INSTANCES_QUERY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
             if (parseResult.success === false) {
@@ -2482,7 +2539,7 @@ export class RecordsServer {
                 eventName: EVENT_NAME_VALIDATION,
                 count: z.number().optional(),
                 markers: MARKERS_VALIDATION.optional(),
-                instances: z.array(z.string()).nonempty().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             });
             const parseResult = schema.safeParse(jsonResult.value);
             if (parseResult.success === false) {
@@ -3092,7 +3149,7 @@ export class RecordsServer {
                 return returnResult(NOT_LOGGED_IN_RESULT);
             }
             const schema = z.object({
-                recordName: z.string().nonempty().optional(),
+                recordName: RECORD_NAME_VALIDATION.optional(),
                 inst: z.string().optional(),
             });
             const parseResult = schema.safeParse(request.query || {});
@@ -3122,8 +3179,8 @@ export class RecordsServer {
                 return returnResult(NOT_LOGGED_IN_RESULT);
             }
             const schema = z.object({
-                recordKey: z.string().nonempty().optional(),
-                recordName: z.string().nonempty().optional(),
+                recordKey: RECORD_KEY_VALIDATION.optional(),
+                recordName: RECORD_NAME_VALIDATION.optional(),
                 inst: z.string().optional(),
             });
             if (typeof request.body !== 'string') {
@@ -3155,7 +3212,7 @@ export class RecordsServer {
                 return returnResult(MODERATION_NOT_SUPPORTED_RESULT);
             }
             const schema = z.object({
-                recordName: z.string().nonempty().nullable(),
+                recordName: RECORD_NAME_VALIDATION.nullable(),
                 inst: z.string().nonempty(),
                 automaticReport: z.boolean(),
                 reportReason: z.union([
@@ -3219,7 +3276,7 @@ export class RecordsServer {
                 userId = validation.userId;
             }
             const schema = z.object({
-                recordName: z.string().nonempty().nullable().optional(),
+                recordName: RECORD_NAME_VALIDATION.nullable().optional(),
                 inst: z.string().nonempty(),
                 branch: z.string().nonempty().default(DEFAULT_BRANCH_NAME),
             });