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

package/MemoryStore.js

@@ -0,0 +1,1381 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sortBy } from 'lodash';
+import { v4 as uuid } from 'uuid';
+import { getExpireTime, } from './PolicyStore';
+import { DEFAULT_ANY_RESOURCE_POLICY_DOCUMENT, DEFAULT_PUBLIC_READ_POLICY_DOCUMENT, PUBLIC_READ_MARKER, } from './PolicyPermissions';
+import { DateTime } from 'luxon';
+export class MemoryStore {
+    get users() {
+        return this._users;
+    }
+    get loginRequests() {
+        return this._loginRequests;
+    }
+    get sessions() {
+        return this._sessions;
+    }
+    get emailRules() {
+        return this._emailRules;
+    }
+    get smsRules() {
+        return this._smsRules;
+    }
+    get recordKeys() {
+        return this._recordKeys;
+    }
+    get dataBuckets() {
+        return this._dataBuckets;
+    }
+    get eventBuckets() {
+        return this._eventBuckets;
+    }
+    get files() {
+        return this._files;
+    }
+    get subscriptionConfiguration() {
+        return this._subscriptionConfiguration;
+    }
+    set subscriptionConfiguration(value) {
+        this._subscriptionConfiguration = value;
+    }
+    constructor(config) {
+        this._users = [];
+        this._loginRequests = [];
+        this._sessions = [];
+        this._subscriptions = [];
+        this._periods = [];
+        this._invoices = [];
+        this._records = [];
+        this._recordKeys = [];
+        this._studios = [];
+        this._studioAssignments = [];
+        this._aiChatMetrics = [];
+        this._aiImageMetrics = [];
+        this._aiSkyboxMetrics = [];
+        this._dataBuckets = new Map();
+        this._eventBuckets = new Map();
+        this._files = new Map();
+        this._fileUploadUrl = 'http://localhost:9191';
+        this._emailRules = [];
+        this._smsRules = [];
+        this._subscriptionConfiguration = config.subscriptions;
+        this.policies = {};
+        this.roles = {};
+        this.roleAssignments = {};
+    }
+    getSubscriptionConfiguration() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._subscriptionConfiguration;
+        });
+    }
+    getRecordByName(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = this._records.find((r) => r.name === name);
+            return record;
+        });
+    }
+    updateRecord(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingRecordIndex = this._records.findIndex((r) => r.name === record.name);
+            if (existingRecordIndex >= 0) {
+                this._records[existingRecordIndex] = record;
+            }
+        });
+    }
+    addRecord(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingRecordIndex = this._records.findIndex((r) => r.name === record.name);
+            if (existingRecordIndex < 0) {
+                this._records.push(record);
+            }
+        });
+    }
+    addRecordKey(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingKeyIndex = this._recordKeys.findIndex((k) => k.recordName === key.recordName &&
+                k.secretHash === key.secretHash);
+            if (existingKeyIndex < 0) {
+                this._recordKeys.push(key);
+            }
+        });
+    }
+    getRecordKeyByRecordAndHash(recordName, hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this._recordKeys.find((k) => k.recordName === recordName && k.secretHash == hash);
+            return key;
+        });
+    }
+    listRecordsByOwnerId(ownerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return sortBy(this._records
+                .filter((r) => r.ownerId === ownerId)
+                .map((r) => ({
+                name: r.name,
+                ownerId: r.ownerId,
+                studioId: r.studioId,
+            })), (r) => r.name);
+        });
+    }
+    listRecordsByStudioId(studioId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return sortBy(this._records
+                .filter((r) => r.studioId === studioId)
+                .map((r) => ({
+                name: r.name,
+                ownerId: r.ownerId,
+                studioId: r.studioId,
+            })), (r) => r.name);
+        });
+    }
+    listRecordsByStudioIdAndUserId(studioId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return sortBy(this._records
+                .filter((s) => {
+                if (s.studioId !== studioId) {
+                    return false;
+                }
+                const isAssigned = this._studioAssignments.some((a) => a.studioId === studioId && a.userId === userId);
+                return isAssigned;
+            })
+                .map((r) => ({
+                name: r.name,
+                ownerId: r.ownerId,
+                studioId: r.studioId,
+            })), (r) => r.name);
+        });
+    }
+    addStudio(studio) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingStudioIndex = this._studios.findIndex((r) => r.id === studio.id);
+            if (existingStudioIndex < 0) {
+                this._studios.push(studio);
+            }
+        });
+    }
+    createStudioForUser(studio, adminId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addStudio(studio);
+            const assignment = {
+                studioId: studio.id,
+                userId: adminId,
+                isPrimaryContact: true,
+                role: 'admin',
+            };
+            yield this.addStudioAssignment(assignment);
+            return {
+                studio,
+                assignment,
+            };
+        });
+    }
+    updateStudio(studio) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingStudioIndex = this._studios.findIndex((r) => r.id === studio.id);
+            if (existingStudioIndex >= 0) {
+                this._studios[existingStudioIndex] = studio;
+            }
+        });
+    }
+    getStudioById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._studios.find((s) => s.id === id);
+        });
+    }
+    getStudioByStripeCustomerId(customerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._studios.find((s) => s.stripeCustomerId === customerId);
+        });
+    }
+    listStudiosForUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assignments = yield this.listUserAssignments(userId);
+            const studios = yield Promise.all(assignments.map((a) => __awaiter(this, void 0, void 0, function* () {
+                const s = yield this.getStudioById(a.studioId);
+                return Object.assign(Object.assign({}, s), a);
+            })));
+            return studios.map((s) => ({
+                studioId: s.id,
+                displayName: s.displayName,
+                role: s.role,
+                isPrimaryContact: s.isPrimaryContact,
+            }));
+        });
+    }
+    addStudioAssignment(assignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingAssignmentIndex = this._studioAssignments.findIndex((r) => r.studioId === assignment.studioId &&
+                r.userId === assignment.userId);
+            if (existingAssignmentIndex < 0) {
+                this._studioAssignments.push(assignment);
+            }
+        });
+    }
+    removeStudioAssignment(studioId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._studioAssignments = this._studioAssignments.filter((s) => s.studioId !== studioId || s.userId !== userId);
+        });
+    }
+    updateStudioAssignment(assignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingAssignmentIndex = this._studioAssignments.findIndex((r) => r.studioId === assignment.studioId &&
+                r.userId === assignment.userId);
+            if (existingAssignmentIndex >= 0) {
+                this._studioAssignments[existingAssignmentIndex] = assignment;
+            }
+        });
+    }
+    listStudioAssignments(studioId, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assignments = this._studioAssignments.filter((s) => {
+                const matchesRole = !(filters === null || filters === void 0 ? void 0 : filters.role) || s.role === filters.role;
+                const matchesPrimaryContact = !(filters === null || filters === void 0 ? void 0 : filters.isPrimaryContact) ||
+                    s.isPrimaryContact === filters.isPrimaryContact;
+                const matchesUserId = !(filters === null || filters === void 0 ? void 0 : filters.userId) || s.userId === filters.userId;
+                return (s.studioId === studioId &&
+                    matchesRole &&
+                    matchesPrimaryContact &&
+                    matchesUserId);
+            });
+            let results = [];
+            for (let s of assignments) {
+                const user = yield this.findUser(s.userId);
+                if (!user) {
+                    continue;
+                }
+                results.push({
+                    studioId: s.studioId,
+                    userId: s.userId,
+                    isPrimaryContact: s.isPrimaryContact,
+                    role: s.role,
+                    user: {
+                        id: user.id,
+                        name: user.name,
+                        email: user.email,
+                        phoneNumber: user.phoneNumber,
+                    },
+                });
+            }
+            return results;
+        });
+    }
+    listUserAssignments(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assignments = this._studioAssignments.filter((s) => s.userId === userId);
+            return assignments.map((s) => {
+                const studio = this._studios.find((studio) => studio.id === s.studioId);
+                return {
+                    displayName: studio.displayName,
+                    studioId: s.studioId,
+                    userId: s.userId,
+                    isPrimaryContact: s.isPrimaryContact,
+                    role: s.role,
+                };
+            });
+        });
+    }
+    countRecords(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let count = 0;
+            for (let record of this._records) {
+                if (filter.studioId && record.studioId === filter.studioId) {
+                    count++;
+                }
+                else if (filter.ownerId && record.ownerId === filter.ownerId) {
+                    count++;
+                }
+                else {
+                    count++;
+                }
+            }
+            return count;
+        });
+    }
+    saveUser(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let index = this._findUserIndex(user.id);
+            if (index >= 0) {
+                this._users[index] = user;
+            }
+            else {
+                this._users.push(user);
+            }
+        });
+    }
+    saveNewUser(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let index = this._users.findIndex((u) => (!!user.email && u.email === user.email) ||
+                (!!user.phoneNumber && u.phoneNumber === user.phoneNumber));
+            if (index >= 0) {
+                return {
+                    success: false,
+                    errorCode: 'user_already_exists',
+                    errorMessage: 'The user already exists.',
+                };
+            }
+            else {
+                this._users.push(user);
+            }
+            return {
+                success: true,
+            };
+        });
+    }
+    findUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = this._users.find((u) => u.id === userId);
+            return user;
+        });
+    }
+    setRevokeAllSessionsTimeForUser(userId, allSessionRevokeTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.findUser(userId);
+            if (user) {
+                yield this.saveUser(Object.assign(Object.assign({}, user), { allSessionRevokeTimeMs: allSessionRevokeTimeMs }));
+            }
+        });
+    }
+    findUserByAddress(address, addressType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = this._users.find((u) => addressType === 'email'
+                ? u.email === address
+                : u.phoneNumber === address);
+            return user;
+        });
+    }
+    findUserByStripeCustomerId(customerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = this._users.find((u) => u.stripeCustomerId === customerId);
+            return user;
+        });
+    }
+    findLoginRequest(userId, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._loginRequests.find((lr) => lr.userId === userId && lr.requestId === requestId);
+        });
+    }
+    findSession(userId, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._sessions.find((s) => s.userId === userId && s.sessionId === sessionId);
+        });
+    }
+    saveLoginRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._loginRequests.findIndex((lr) => lr.userId === request.userId &&
+                lr.requestId === request.requestId);
+            if (index >= 0) {
+                this._loginRequests[index] = request;
+            }
+            else {
+                this._loginRequests.push(request);
+            }
+            return request;
+        });
+    }
+    setCurrentLoginRequest(userId, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userIndex = this._users.findIndex((u) => u.id === userId);
+            if (userIndex >= 0) {
+                const user = this._users[userIndex];
+                this._users[userIndex] = Object.assign(Object.assign({}, user), { currentLoginRequestId: requestId });
+            }
+        });
+    }
+    markLoginRequestComplete(userId, requestId, completedTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._loginRequests.findIndex((lr) => lr.userId === userId && lr.requestId === requestId);
+            if (index >= 0) {
+                this._loginRequests[index].completedTimeMs = completedTimeMs;
+            }
+            else {
+                throw new Error('Request not found.');
+            }
+        });
+    }
+    incrementLoginRequestAttemptCount(userId, requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = this._loginRequests.find((lr) => lr.userId === userId && lr.requestId === requestId);
+            if (request) {
+                request.attemptCount += 1;
+            }
+        });
+    }
+    saveSession(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._sessions.findIndex((s) => s.userId === session.userId && s.sessionId === session.sessionId);
+            if (index >= 0) {
+                this._sessions[index] = session;
+            }
+            else {
+                this._sessions.push(session);
+            }
+        });
+    }
+    replaceSession(session, newSession, revokeTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.saveSession(Object.assign(Object.assign({}, session), { revokeTimeMs: revokeTimeMs, nextSessionId: newSession.sessionId }));
+            this.saveSession(Object.assign(Object.assign({}, newSession), { previousSessionId: session.sessionId }));
+        });
+    }
+    listSessions(userId, expireTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let orderedSessions = sortBy(this._sessions.filter((s) => s.userId === userId), (s) => -s.expireTimeMs);
+            if (expireTimeMs) {
+                orderedSessions = orderedSessions.filter((s) => s.expireTimeMs < expireTimeMs);
+            }
+            return {
+                success: true,
+                sessions: orderedSessions.slice(0, 10),
+            };
+        });
+    }
+    listEmailRules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._emailRules.slice();
+        });
+    }
+    listSmsRules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._smsRules.slice();
+        });
+    }
+    saveSubscription(subscription) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._subscriptions.findIndex((s) => s.id === subscription.id);
+            if (index >= 0) {
+                this._subscriptions[index] = subscription;
+            }
+            else {
+                this._subscriptions.push(subscription);
+            }
+        });
+    }
+    getSubscriptionById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._subscriptions.find((s) => s.id === id);
+        });
+    }
+    getSubscriptionByStripeSubscriptionId(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._subscriptions.find((s) => s.stripeSubscriptionId === id);
+        });
+    }
+    saveSubscriptionPeriod(period) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._periods.findIndex((p) => p.id === period.id);
+            if (index >= 0) {
+                this._periods[index] = period;
+            }
+            else {
+                this._periods.push(period);
+            }
+        });
+    }
+    getSubscriptionPeriodById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._periods.find((p) => p.id === id);
+        });
+    }
+    listSubscriptionPeriodsBySubscriptionId(subscriptionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._periods.filter((p) => p.subscriptionId === subscriptionId);
+        });
+    }
+    saveInvoice(invoice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._invoices.findIndex((i) => i.id === invoice.id);
+            if (index >= 0) {
+                this._invoices[index] = invoice;
+            }
+            else {
+                this._invoices.push(invoice);
+            }
+        });
+    }
+    getInvoiceById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._invoices.find((i) => i.id === id);
+        });
+    }
+    updateSubscriptionInfo(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (request.userId) {
+                const user = yield this.findUser(request.userId);
+                let subscription = yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
+                if (subscription) {
+                    yield this.saveSubscription(Object.assign(Object.assign({}, subscription), { stripeCustomerId: request.stripeCustomerId, stripeSubscriptionId: request.stripeSubscriptionId, subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, currentPeriodEndMs: request.currentPeriodEndMs, currentPeriodStartMs: request.currentPeriodStartMs }));
+                }
+                else {
+                    subscription = {
+                        id: uuid(),
+                        userId: user.id,
+                        studioId: null,
+                        stripeCustomerId: request.stripeCustomerId,
+                        stripeSubscriptionId: request.stripeSubscriptionId,
+                        subscriptionId: request.subscriptionId,
+                        subscriptionStatus: request.subscriptionStatus,
+                        currentPeriodEndMs: request.currentPeriodEndMs,
+                        currentPeriodStartMs: request.currentPeriodStartMs,
+                    };
+                    yield this.saveSubscription(subscription);
+                }
+                yield this.saveUser(Object.assign(Object.assign({}, user), { subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, stripeCustomerId: request.stripeCustomerId, subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs, subscriptionInfoId: subscription.id }));
+            }
+            else if (request.studioId) {
+                const studio = yield this.getStudioById(request.studioId);
+                let subscription = yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
+                if (subscription) {
+                    yield this.saveSubscription(Object.assign(Object.assign({}, subscription), { stripeCustomerId: request.stripeCustomerId, stripeSubscriptionId: request.stripeSubscriptionId, subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, currentPeriodEndMs: request.currentPeriodEndMs, currentPeriodStartMs: request.currentPeriodStartMs }));
+                }
+                else {
+                    subscription = {
+                        id: uuid(),
+                        userId: null,
+                        studioId: studio.id,
+                        stripeCustomerId: request.stripeCustomerId,
+                        stripeSubscriptionId: request.stripeSubscriptionId,
+                        subscriptionId: request.subscriptionId,
+                        subscriptionStatus: request.subscriptionStatus,
+                        currentPeriodEndMs: request.currentPeriodEndMs,
+                        currentPeriodStartMs: request.currentPeriodStartMs,
+                    };
+                    yield this.saveSubscription(subscription);
+                }
+                yield this.updateStudio(Object.assign(Object.assign({}, studio), { subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, stripeCustomerId: request.stripeCustomerId, subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs, subscriptionInfoId: subscription.id }));
+            }
+        });
+    }
+    updateSubscriptionPeriod(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (request.userId) {
+                let user = yield this.findUser(request.userId);
+                let subscription = yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
+                if (!subscription) {
+                    subscription = {
+                        id: uuid(),
+                        userId: user.id,
+                        studioId: null,
+                        stripeCustomerId: request.stripeCustomerId,
+                        stripeSubscriptionId: request.stripeSubscriptionId,
+                        subscriptionId: request.subscriptionId,
+                        subscriptionStatus: request.subscriptionStatus,
+                        currentPeriodEndMs: request.currentPeriodEndMs,
+                        currentPeriodStartMs: request.currentPeriodStartMs,
+                    };
+                    user.stripeCustomerId = request.stripeCustomerId;
+                    user.subscriptionStatus = request.subscriptionStatus;
+                    user.subscriptionId = request.subscriptionId;
+                    user.subscriptionInfoId = subscription.id;
+                    yield this.saveSubscription(subscription);
+                }
+                yield this.saveUser(Object.assign(Object.assign({}, user), { subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs }));
+                const periodId = uuid();
+                const invoiceId = uuid();
+                yield this.saveInvoice(Object.assign({ id: invoiceId, periodId: periodId, subscriptionId: subscription.id }, request.invoice));
+                yield this.saveSubscriptionPeriod({
+                    id: periodId,
+                    invoiceId: invoiceId,
+                    subscriptionId: subscription.id,
+                    periodEndMs: request.currentPeriodEndMs,
+                    periodStartMs: request.currentPeriodStartMs,
+                });
+            }
+            else if (request.studioId) {
+                let studio = yield this.getStudioById(request.studioId);
+                let subscription = yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
+                if (!subscription) {
+                    subscription = {
+                        id: uuid(),
+                        userId: null,
+                        studioId: studio.id,
+                        stripeCustomerId: request.stripeCustomerId,
+                        stripeSubscriptionId: request.stripeSubscriptionId,
+                        subscriptionId: request.subscriptionId,
+                        subscriptionStatus: request.subscriptionStatus,
+                        currentPeriodEndMs: request.currentPeriodEndMs,
+                        currentPeriodStartMs: request.currentPeriodStartMs,
+                    };
+                    studio.stripeCustomerId = request.stripeCustomerId;
+                    studio.subscriptionStatus = request.subscriptionStatus;
+                    studio.subscriptionId = request.subscriptionId;
+                    studio.subscriptionInfoId = subscription.id;
+                    yield this.saveSubscription(subscription);
+                }
+                yield this.updateStudio(Object.assign(Object.assign({}, studio), { subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs }));
+                const periodId = uuid();
+                const invoiceId = uuid();
+                yield this.saveInvoice(Object.assign({ id: invoiceId, periodId: periodId, subscriptionId: subscription.id }, request.invoice));
+                yield this.saveSubscriptionPeriod({
+                    id: periodId,
+                    invoiceId: invoiceId,
+                    subscriptionId: subscription.id,
+                    periodEndMs: request.currentPeriodEndMs,
+                    periodStartMs: request.currentPeriodStartMs,
+                });
+            }
+        });
+    }
+    _findUserIndex(id) {
+        return this._users.findIndex((u) => u.id === id);
+    }
+    setData(recordName, address, data, publisherId, subjectId, updatePolicy, deletePolicy, markers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record = this._getDataRecord(recordName);
+            record.set(address, {
+                data: data,
+                publisherId: publisherId,
+                subjectId: subjectId,
+                updatePolicy,
+                deletePolicy,
+                markers,
+            });
+            return {
+                success: true,
+            };
+        });
+    }
+    getData(recordName, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record = this._getDataRecord(recordName);
+            let data = record.get(address);
+            if (!data) {
+                return {
+                    success: false,
+                    errorCode: 'data_not_found',
+                    errorMessage: 'The data was not found.',
+                };
+            }
+            return {
+                success: true,
+                data: data.data,
+                publisherId: data.publisherId,
+                subjectId: data.subjectId,
+                updatePolicy: data.updatePolicy,
+                deletePolicy: data.deletePolicy,
+                markers: data.markers,
+            };
+        });
+    }
+    eraseData(recordName, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record = this._getDataRecord(recordName);
+            let deleted = record.delete(address);
+            if (!deleted) {
+                return {
+                    success: false,
+                    errorCode: 'data_not_found',
+                    errorMessage: 'The data was not found.',
+                };
+            }
+            return {
+                success: true,
+            };
+        });
+    }
+    listData(recordName, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record = this._getDataRecord(recordName);
+            let items = [];
+            const count = record.size;
+            for (let [key, item] of record.entries()) {
+                if (!address || key > address) {
+                    items.push({
+                        address: key,
+                        data: item.data,
+                        markers: item.markers,
+                    });
+                }
+            }
+            return {
+                success: true,
+                items,
+                totalCount: count,
+            };
+        });
+    }
+    _getDataRecord(recordName) {
+        let record = this._dataBuckets.get(recordName);
+        if (!record) {
+            record = new Map();
+            this._dataBuckets.set(recordName, record);
+        }
+        return record;
+    }
+    presignFileUpload(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                success: true,
+                uploadHeaders: Object.assign(Object.assign({}, request.headers), { 'record-name': request.recordName, 'content-type': request.fileMimeType }),
+                uploadMethod: 'POST',
+                uploadUrl: `${this._fileUploadUrl}/${request.recordName}/${request.fileName}`,
+            };
+        });
+    }
+    presignFileRead(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                success: true,
+                requestHeaders: Object.assign(Object.assign({}, request.headers), { 'record-name': request.recordName }),
+                requestMethod: 'GET',
+                requestUrl: `${this._fileUploadUrl}/${request.recordName}/${request.fileName}`,
+            };
+        });
+    }
+    getFileNameFromUrl(fileUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (fileUrl.startsWith(this._fileUploadUrl)) {
+                let recordNameAndFileName = fileUrl.slice(this._fileUploadUrl.length + 1);
+                let nextSlash = recordNameAndFileName.indexOf('/');
+                if (nextSlash < 0) {
+                    return {
+                        success: false,
+                        errorCode: 'unacceptable_url',
+                        errorMessage: 'The URL does not match an expected format.',
+                    };
+                }
+                let recordName = recordNameAndFileName.slice(0, nextSlash);
+                let fileName = recordNameAndFileName.slice(nextSlash + 1);
+                if (recordName && fileName) {
+                    return {
+                        success: true,
+                        recordName,
+                        fileName,
+                    };
+                }
+                return {
+                    success: false,
+                    errorCode: 'unacceptable_url',
+                    errorMessage: 'The URL does not match an expected format.',
+                };
+            }
+            return {
+                success: false,
+                errorCode: 'unacceptable_url',
+                errorMessage: 'The URL does not match an expected format.',
+            };
+        });
+    }
+    getFileRecord(recordName, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let file = this._files.get(fileName);
+            if (file) {
+                return {
+                    success: true,
+                    fileName: file.fileName,
+                    recordName: file.recordName,
+                    publisherId: file.publisherId,
+                    subjectId: file.subjectId,
+                    sizeInBytes: file.sizeInBytes,
+                    uploaded: file.uploaded,
+                    description: file.description,
+                    url: `${this._fileUploadUrl}/${file.recordName}/${file.fileName}`,
+                    markers: file.markers,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    errorCode: 'file_not_found',
+                    errorMessage: 'The file was not found in the store.',
+                };
+            }
+        });
+    }
+    listUploadedFiles(recordName, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let files = sortBy([...this._files.values()].filter((f) => f.recordName === recordName && f.uploaded), (f) => f.fileName);
+            const count = files.length;
+            if (fileName) {
+                files = files.filter((f) => f.fileName > fileName);
+            }
+            return {
+                success: true,
+                files: files.slice(0, 10).map((f) => ({
+                    fileName: f.fileName,
+                    uploaded: f.uploaded,
+                    markers: f.markers,
+                    description: f.description,
+                    sizeInBytes: f.sizeInBytes,
+                    url: `${this._fileUploadUrl}/${f.recordName}/${f.fileName}`,
+                })),
+                totalCount: count,
+            };
+        });
+    }
+    addFileRecord(recordName, fileName, publisherId, subjectId, sizeInBytes, description, markers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._files.has(fileName)) {
+                return {
+                    success: false,
+                    errorCode: 'file_already_exists',
+                    errorMessage: 'The file already exists in the store.',
+                };
+            }
+            let file = {
+                fileName: fileName,
+                recordName: recordName,
+                publisherId,
+                subjectId,
+                sizeInBytes,
+                description,
+                markers,
+                uploaded: false,
+            };
+            this._files.set(fileName, file);
+            return {
+                success: true,
+            };
+        });
+    }
+    updateFileRecord(recordName, fileName, markers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._files.has(fileName)) {
+                return {
+                    success: false,
+                    errorCode: 'file_not_found',
+                    errorMessage: 'The file was not found in the store.',
+                };
+            }
+            let file = this._files.get(fileName);
+            this._files.set(fileName, Object.assign(Object.assign({}, file), { markers: markers.slice() }));
+            return {
+                success: true,
+            };
+        });
+    }
+    setFileRecordAsUploaded(recordName, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let file = this._files.get(fileName);
+            if (!file) {
+                return {
+                    success: false,
+                    errorCode: 'file_not_found',
+                    errorMessage: 'The file was not found in the store.',
+                };
+            }
+            file.uploaded = true;
+            return {
+                success: true,
+            };
+        });
+    }
+    eraseFileRecord(recordName, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deleted = this._files.delete(fileName);
+            if (!deleted) {
+                return {
+                    success: false,
+                    errorCode: 'file_not_found',
+                    errorMessage: 'The file was not found in the store.',
+                };
+            }
+            return {
+                success: true,
+            };
+        });
+    }
+    getAllowedUploadHeaders() {
+        return ['record-name', 'content-type'];
+    }
+    addEventCount(recordName, eventName, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = this._getEventRecord(recordName);
+            if (record.has(eventName)) {
+                let data = record.get(eventName);
+                data.count += count;
+            }
+            else {
+                record.set(eventName, {
+                    count: count,
+                });
+            }
+            return {
+                success: true,
+            };
+        });
+    }
+    getEventCount(recordName, eventName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = this._getEventRecord(recordName);
+            const e = record.has(eventName)
+                ? record.get(eventName)
+                : {
+                    count: 0,
+                };
+            return {
+                success: true,
+                count: e.count,
+                markers: e.markers,
+            };
+        });
+    }
+    updateEvent(recordName, eventName, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = this._getEventRecord(recordName);
+            const e = record.has(eventName)
+                ? record.get(eventName)
+                : {
+                    count: 0,
+                };
+            record.set(eventName, Object.assign(Object.assign({}, e), updates));
+            return {
+                success: true,
+            };
+        });
+    }
+    listEvents(recordName, eventName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = this._getEventRecord(recordName);
+            const totalCount = record.size;
+            let events = sortBy([...record.entries()], ([name, data]) => name);
+            if (eventName) {
+                events = events.filter(([name, data]) => name > eventName);
+            }
+            return {
+                success: true,
+                events: events.slice(0, 10).map(([name, data]) => ({
+                    eventName: name,
+                    count: data.count,
+                    markers: data.markers,
+                })),
+                totalCount,
+            };
+        });
+    }
+    _getEventRecord(recordName) {
+        let record = this._eventBuckets.get(recordName);
+        if (!record) {
+            record = new Map();
+            this._eventBuckets.set(recordName, record);
+        }
+        return record;
+    }
+    listUserPolicies(recordName, startingMarker) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const recordPolicies = (_a = this.policies[recordName]) !== null && _a !== void 0 ? _a : {};
+            const keys = sortBy(Object.keys(recordPolicies));
+            let results = [];
+            let start = !startingMarker;
+            for (let key of keys) {
+                if (start) {
+                    results.push({
+                        marker: key,
+                        document: recordPolicies[key].document,
+                        markers: recordPolicies[key].markers,
+                    });
+                }
+                else if (key === startingMarker || key > startingMarker) {
+                    start = true;
+                }
+            }
+            return {
+                success: true,
+                policies: results,
+                totalCount: results.length,
+            };
+        });
+    }
+    getUserPolicy(recordName, marker) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const policy = (_a = this.policies[recordName]) === null || _a === void 0 ? void 0 : _a[marker];
+            if (!policy) {
+                return {
+                    success: false,
+                    errorCode: 'policy_not_found',
+                    errorMessage: 'The policy was not found.',
+                };
+            }
+            return {
+                success: true,
+                document: policy.document,
+                markers: policy.markers,
+            };
+        });
+    }
+    updateUserPolicy(recordName, marker, policy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.policies[recordName]) {
+                this.policies[recordName] = {};
+            }
+            this.policies[recordName][marker] = {
+                document: policy.document,
+                markers: policy.markers,
+            };
+            return {
+                success: true,
+            };
+        });
+    }
+    listPoliciesForMarker(recordName, marker) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const policies = [DEFAULT_ANY_RESOURCE_POLICY_DOCUMENT];
+            if (marker === PUBLIC_READ_MARKER) {
+                policies.push(DEFAULT_PUBLIC_READ_POLICY_DOCUMENT);
+            }
+            const policy = (_a = this.policies[recordName]) === null || _a === void 0 ? void 0 : _a[marker];
+            if (policy) {
+                policies.push(policy.document);
+            }
+            return policies;
+        });
+    }
+    listRolesForUser(recordName, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._getRolesForEntity(recordName, userId);
+        });
+    }
+    listRolesForInst(recordName, inst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._getRolesForEntity(recordName, inst);
+        });
+    }
+    listAssignmentsForRole(recordName, role) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record = this.roles[recordName];
+            let assignedRoles = this.roleAssignments[recordName];
+            let assignments = [];
+            for (let id in record) {
+                if (record[id].has(role)) {
+                    assignments.push({
+                        type: 'user',
+                        userId: id,
+                        role: {
+                            role,
+                            expireTimeMs: null,
+                        },
+                    });
+                }
+            }
+            for (let id in assignedRoles) {
+                let roles = assignedRoles[id];
+                let assignment = roles.find((r) => r.role === role);
+                if (assignment) {
+                    assignments.push({
+                        type: 'user',
+                        userId: id,
+                        role: assignment,
+                    });
+                }
+            }
+            return {
+                assignments,
+                totalCount: assignments.length,
+            };
+        });
+    }
+    listAssignments(recordName, startingRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let record = this.roles[recordName];
+            let assignedRoles = this.roleAssignments[recordName];
+            let totalCount = 0;
+            let assignments = [];
+            for (let id in record) {
+                const roles = record[id];
+                for (let role of roles) {
+                    assignments.push({
+                        type: 'user',
+                        userId: id,
+                        role: {
+                            role,
+                            expireTimeMs: null,
+                        },
+                    });
+                    totalCount += 1;
+                }
+            }
+            for (let id in assignedRoles) {
+                let roles = assignedRoles[id];
+                for (let role of roles) {
+                    assignments.push({
+                        type: 'user',
+                        userId: id,
+                        role,
+                    });
+                    totalCount += 1;
+                }
+            }
+            assignments = sortBy(assignments, (a) => a.role.role, (a) => { var _a; return (_a = a.userId) !== null && _a !== void 0 ? _a : a.inst; });
+            if (startingRole) {
+                assignments = assignments.filter((a) => a.role.role > startingRole);
+            }
+            return {
+                assignments: assignments.slice(0, 10),
+                totalCount: totalCount,
+            };
+        });
+    }
+    assignSubjectRole(recordName, subjectId, type, role) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.roleAssignments[recordName]) {
+                this.roleAssignments[recordName] = {};
+            }
+            const roles = (_a = this.roleAssignments[recordName][subjectId]) !== null && _a !== void 0 ? _a : [];
+            const filtered = roles.filter((r) => r.role !== role.role ||
+                getExpireTime(r.expireTimeMs) <= role.expireTimeMs);
+            this.roleAssignments[recordName][subjectId] = [
+                ...filtered,
+                {
+                    role: role.role,
+                    expireTimeMs: role.expireTimeMs === Infinity ? null : role.expireTimeMs,
+                },
+            ];
+            return {
+                success: true,
+            };
+        });
+    }
+    revokeSubjectRole(recordName, subjectId, type, role) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.roleAssignments[recordName]) {
+                this.roleAssignments[recordName] = {};
+            }
+            const roles = (_a = this.roleAssignments[recordName][subjectId]) !== null && _a !== void 0 ? _a : [];
+            const filtered = roles.filter((r) => r.role !== role);
+            this.roleAssignments[recordName][subjectId] = filtered;
+            return {
+                success: true,
+            };
+        });
+    }
+    updateUserRoles(recordName, userId, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.roleAssignments[recordName]) {
+                this.roleAssignments[recordName] = {};
+            }
+            const assignments = update.roles
+                .filter((r) => getExpireTime(r.expireTimeMs) > Date.now())
+                .map((r) => (Object.assign(Object.assign({}, r), { expireTimeMs: r.expireTimeMs === Infinity ? null : r.expireTimeMs })));
+            this.roleAssignments[recordName][userId] = assignments;
+            return {
+                success: true,
+            };
+        });
+    }
+    updateInstRoles(recordName, inst, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.roleAssignments[recordName]) {
+                this.roleAssignments[recordName] = {};
+            }
+            const assignments = update.roles
+                .filter((r) => getExpireTime(r.expireTimeMs) > Date.now())
+                .map((r) => (Object.assign(Object.assign({}, r), { expireTimeMs: r.expireTimeMs === Infinity ? null : r.expireTimeMs })));
+            this.roleAssignments[recordName][inst] = assignments;
+            return {
+                success: true,
+            };
+        });
+    }
+    _getRolesForEntity(recordName, id) {
+        var _a, _b, _c, _d;
+        const roles = (_b = (_a = this.roles[recordName]) === null || _a === void 0 ? void 0 : _a[id]) !== null && _b !== void 0 ? _b : new Set();
+        const assignments = (_d = (_c = this.roleAssignments[recordName]) === null || _c === void 0 ? void 0 : _c[id]) !== null && _d !== void 0 ? _d : [];
+        return [
+            ...[...roles].map((r) => ({
+                role: r,
+                expireTimeMs: null,
+            })),
+            ...assignments.filter((a) => getExpireTime(a.expireTimeMs) > Date.now()),
+        ];
+    }
+    getSubscriptionDataMetricsByRecordName(recordName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this._getSubscriptionInfo(recordName);
+            const records = yield this._listRecordsForSubscription(recordName);
+            let totalItems = 0;
+            for (let record of records) {
+                let bucket = this._dataBuckets.get(record.name);
+                if (!bucket) {
+                    continue;
+                }
+                totalItems += bucket.size;
+            }
+            return Object.assign(Object.assign({}, info), { totalItems });
+        });
+    }
+    getSubscriptionFileMetricsByRecordName(recordName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this._getSubscriptionInfo(recordName);
+            const records = yield this._listRecordsForSubscription(recordName);
+            let totalFiles = 0;
+            let totalBytesStored = 0;
+            let totalBytesReserved = 0;
+            for (let record of records) {
+                let files = [...this.files.values()].filter((f) => f.recordName === record.name);
+                for (let file of files) {
+                    totalFiles++;
+                    totalBytesReserved += file.sizeInBytes;
+                    if (file.uploaded) {
+                        totalBytesStored += file.sizeInBytes;
+                    }
+                }
+            }
+            return Object.assign(Object.assign({}, info), { totalFiles, totalFileBytesReserved: totalBytesReserved });
+        });
+    }
+    getSubscriptionEventMetricsByRecordName(recordName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this._getSubscriptionInfo(recordName);
+            const records = yield this._listRecordsForSubscription(recordName);
+            let totalEventNames = 0;
+            for (let record of records) {
+                let bucket = this._eventBuckets.get(record.name);
+                if (!bucket) {
+                    continue;
+                }
+                totalEventNames += bucket.size;
+            }
+            return Object.assign(Object.assign({}, info), { totalEventNames });
+        });
+    }
+    getSubscriptionRecordMetrics(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metrics = yield this._getSubscriptionMetrics(filter);
+            const totalRecords = yield this.countRecords(filter);
+            return Object.assign(Object.assign({}, metrics), { totalRecords });
+        });
+    }
+    getSubscriptionAiChatMetrics(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this._getSubscriptionMetrics(filter);
+            const metrics = filter.ownerId
+                ? this._aiChatMetrics.filter((m) => m.userId === filter.ownerId &&
+                    (!info.currentPeriodStartMs ||
+                        (m.createdAtMs >= info.currentPeriodStartMs &&
+                            m.createdAtMs < info.currentPeriodEndMs)))
+                : this._aiChatMetrics.filter((m) => m.studioId === filter.studioId &&
+                    (!info.currentPeriodStartMs ||
+                        (m.createdAtMs >= info.currentPeriodStartMs &&
+                            m.createdAtMs < info.currentPeriodEndMs)));
+            let totalTokens = 0;
+            for (let m of metrics) {
+                totalTokens += m.tokens;
+            }
+            return Object.assign(Object.assign({}, info), { totalTokensInCurrentPeriod: totalTokens });
+        });
+    }
+    recordChatMetrics(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._aiChatMetrics.push(metrics);
+        });
+    }
+    getSubscriptionAiImageMetrics(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this._getSubscriptionMetrics(filter);
+            const metrics = filter.ownerId
+                ? this._aiImageMetrics.filter((m) => m.userId === filter.ownerId &&
+                    (!info.currentPeriodStartMs ||
+                        (m.createdAtMs >= info.currentPeriodStartMs &&
+                            m.createdAtMs < info.currentPeriodEndMs)))
+                : this._aiImageMetrics.filter((m) => m.studioId === filter.studioId &&
+                    (!info.currentPeriodStartMs ||
+                        (m.createdAtMs >= info.currentPeriodStartMs &&
+                            m.createdAtMs < info.currentPeriodEndMs)));
+            let totalPixels = 0;
+            for (let m of metrics) {
+                totalPixels += m.squarePixels;
+            }
+            return Object.assign(Object.assign({}, info), { totalSquarePixelsInCurrentPeriod: totalPixels });
+        });
+    }
+    recordImageMetrics(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._aiImageMetrics.push(metrics);
+        });
+    }
+    getSubscriptionAiSkyboxMetrics(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this._getSubscriptionMetrics(filter);
+            const metrics = filter.ownerId
+                ? this._aiSkyboxMetrics.filter((m) => m.userId === filter.ownerId &&
+                    (!info.currentPeriodStartMs ||
+                        (m.createdAtMs >= info.currentPeriodStartMs &&
+                            m.createdAtMs < info.currentPeriodEndMs)))
+                : this._aiSkyboxMetrics.filter((m) => m.studioId === filter.studioId &&
+                    (!info.currentPeriodStartMs ||
+                        (m.createdAtMs >= info.currentPeriodStartMs &&
+                            m.createdAtMs < info.currentPeriodEndMs)));
+            let totalSkyboxes = 0;
+            for (let m of metrics) {
+                totalSkyboxes += m.skyboxes;
+            }
+            return Object.assign(Object.assign({}, info), { totalSkyboxesInCurrentPeriod: totalSkyboxes });
+        });
+    }
+    recordSkyboxMetrics(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._aiSkyboxMetrics.push(metrics);
+        });
+    }
+    _getSubscriptionInfo(recordName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.getRecordByName(recordName);
+            const metrics = yield this._getSubscriptionMetrics(record);
+            return Object.assign(Object.assign({}, metrics), { recordName: record.name });
+        });
+    }
+    _getSubscriptionMetrics(filter) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield this.getSubscriptionConfiguration();
+            let currentPeriodStart = null;
+            let currentPeriodEnd = null;
+            if ((_a = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _a === void 0 ? void 0 : _a.defaultPeriodLength) {
+                const now = DateTime.utc();
+                const periodStart = now.minus(config.defaultFeatures.defaultPeriodLength);
+                currentPeriodStart = periodStart.toMillis();
+                currentPeriodEnd = now.toMillis();
+            }
+            let metrics = {
+                ownerId: filter.ownerId,
+                studioId: filter.studioId,
+                subscriptionId: null,
+                subscriptionStatus: null,
+                currentPeriodStartMs: currentPeriodStart,
+                currentPeriodEndMs: currentPeriodEnd,
+            };
+            if (filter.ownerId) {
+                const user = yield this.findUser(filter.ownerId);
+                if (user) {
+                    metrics.subscriptionStatus = user.subscriptionStatus;
+                    metrics.subscriptionId = user.subscriptionId;
+                    metrics.currentPeriodEndMs = user.subscriptionPeriodEndMs;
+                    metrics.currentPeriodStartMs = user.subscriptionPeriodStartMs;
+                }
+            }
+            else if (filter.studioId) {
+                const studio = yield this.getStudioById(filter.studioId);
+                if (studio) {
+                    metrics.subscriptionId = studio.subscriptionId;
+                    metrics.subscriptionStatus = studio.subscriptionStatus;
+                    metrics.currentPeriodEndMs = studio.subscriptionPeriodEndMs;
+                    metrics.currentPeriodStartMs = studio.subscriptionPeriodStartMs;
+                }
+            }
+            return metrics;
+        });
+    }
+    _listRecordsForSubscription(recordName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.getRecordByName(recordName);
+            if (record.ownerId) {
+                return this.listRecordsByOwnerId(record.ownerId);
+            }
+            else {
+                return this.listRecordsByStudioId(record.studioId);
+            }
+        });
+    }
+}
+//# sourceMappingURL=MemoryStore.js.map