@arken/node 1.5.1 → 1.5.3

package/build/modules/core/core.service.js

@@ -1,2515 +0,0 @@
-import { ARXError } from '../../util/rpc';
-import { getFilter } from '../../util/api';
-import { log } from '../../util';
-import { deepMerge } from '../../util/object';
-import { isValidRequest } from '../../util/web3';
-import { claimMailMessage } from './mail/applyPatchesOrMail';
-import { mailClaimablePatchesBatch } from './mail/mailClaimablePatchesBatch';
-export class Service {
-    async claimConversationMessage(input, ctx) {
-        if (!ctx.client?.profile)
-            throw new Error('Unauthorized');
-        const profileId = ctx.client.profile.id;
-        const messageId = String(input.messageId);
-        const characterId = input?.characterId ? String(input.characterId) : null;
-        const Conversation = ctx.app.model.Conversation;
-        const ConversationMessage = ctx.app.model.ConversationMessage;
-        const Profile = ctx.app.model.Profile;
-        const msg = await ctx.app.model.ConversationMessage.findById(messageId).lean().exec();
-        if (!msg)
-            throw new Error('Message not found');
-        const convo = await Conversation.findOne({
-            _id: msg.conversationId,
-            $or: [{ profileId }, { 'participants.profileId': profileId }],
-        })
-            .lean()
-            .exec();
-        if (!convo)
-            throw new Error('Not authorized for this message');
-        const profile = await Profile.findById(profileId).populate('characters').exec();
-        if (!profile)
-            throw new Error('Profile not found');
-        let character = null;
-        const chars = profile.characters || [];
-        if (characterId) {
-            character = chars.find((c) => String(c._id) === characterId) ?? null;
-        }
-        else {
-            character = chars?.[0] ?? null;
-        }
-        await claimMailMessage({
-            ctx,
-            profile,
-            character: character ?? undefined,
-            messageId,
-        });
-        return { ok: true, messageId };
-    }
-    async distributeSantaChristmasTicket(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        if (!ctx.client?.roles?.includes('admin'))
-            throw new Error('Not authorized');
-        const year = 2025;
-        const dedupeKey = input?.dedupeKey || `broadcast:santa-christmas-ticket:${year}`;
-        const patches = [
-            {
-                entityType: 'profile.meta',
-                entityId: 'broadcast',
-                claimable: true,
-                ops: [{ op: 'inc', key: `rewards.tokens.christmas${year}`, value: 1 }],
-            },
-        ];
-        const result = await mailClaimablePatchesBatch({
-            ctx,
-            streamAllProfiles: true,
-            kind: 'mail',
-            conversationKey: 'system',
-            source: 'core.broadcastSantaChristmasTicket',
-            title: `Holiday Gift 🎁`,
-            body: `You received a Santa Christmas Ticket (${year}). Claim it to add it to your account.`,
-            dedupeKey,
-            claimablePatches: patches,
-            payloadUi: {
-                rewards: [{ type: 'token', id: `christmas${year}`, quantity: 1 }],
-            },
-            batchSize: input?.batchSize ?? 1000,
-        });
-        return {
-            ok: true,
-            year,
-            dedupeKey,
-            ...result,
-        };
-    }
-    async getConversationMessages(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        if (!ctx.client?.profile)
-            throw new Error('Unauthorized');
-        const profileId = String(ctx.client.profile.id);
-        const baseFilter = getFilter(input);
-        const limit = Math.min(200, Number(input.limit ?? 50));
-        const skip = Math.max(0, Number(input.skip ?? 0));
-        const cursor = input.cursor ? String(input.cursor) : null;
-        const Conversation = ctx.app.model.Conversation;
-        const ConversationMessage = ctx.app.model.ConversationMessage;
-        const requestedConversationId = baseFilter?.conversationId;
-        if (requestedConversationId && typeof requestedConversationId !== 'object') {
-            const convo = await Conversation.findOne({
-                _id: requestedConversationId,
-                $or: [{ profileId }, { 'participants.profileId': profileId }],
-            })
-                .select({ _id: 1 })
-                .lean()
-                .exec();
-            if (!convo)
-                throw new Error('Not authorized for this conversation');
-            const msgFilter = {
-                ...baseFilter,
-                conversationId: requestedConversationId,
-            };
-            if (cursor)
-                msgFilter._id = { $lt: cursor };
-            const items = await ctx.app.model.ConversationMessage.findJSON(msgFilter, null, {
-                sort: { _id: -1 },
-                skip,
-                limit,
-            });
-            const total = await ctx.app.model.ConversationMessage.countDocumentsFiltered(msgFilter);
-            return {
-                items,
-                total,
-                nextCursor: items.length ? String(items[items.length - 1]._id) : null,
-            };
-        }
-        const convos = await Conversation.find({
-            $or: [{ profileId }, { 'participants.profileId': profileId }],
-        })
-            .select({ _id: 1 })
-            .lean()
-            .exec();
-        const convoIds = convos.map((c) => c._id);
-        if (!convoIds.length)
-            return { items: [], total: 0, nextCursor: null };
-        const msgFilter = {
-            ...baseFilter,
-            conversationId: { $in: convoIds },
-        };
-        if (requestedConversationId && typeof requestedConversationId === 'object' && requestedConversationId.$in) {
-            const wanted = (requestedConversationId.$in || []).map((x) => String(x));
-            const allowed = convoIds.map((x) => String(x));
-            const intersection = wanted.filter((id) => allowed.includes(id));
-            msgFilter.conversationId = { $in: intersection };
-            if (!intersection.length)
-                return { items: [], total: 0, nextCursor: null };
-        }
-        if (cursor)
-            msgFilter._id = { $lt: cursor };
-        const items = await ctx.app.model.ConversationMessage.findJSON(msgFilter, null, {
-            sort: { _id: -1 },
-            skip,
-            limit,
-        });
-        const total = await ctx.app.model.ConversationMessage.countDocumentsFiltered(msgFilter);
-        return {
-            items,
-            total,
-            nextCursor: items.length ? String(items[items.length - 1].id) : null,
-        };
-    }
-    async setConversationMessageStar(input, ctx) {
-        if (!ctx.client?.profile)
-            throw new Error('Unauthorized');
-        const profileId = String(ctx.client.profile.id);
-        const messageId = String(input.messageId);
-        const isStarred = !!input.isStarred;
-        const Conversation = ctx.app.model.Conversation;
-        const ConversationMessage = ctx.app.model.ConversationMessage;
-        const msg = await ConversationMessage.findById(messageId).lean().exec();
-        if (!msg)
-            throw new Error('Message not found');
-        const convo = await Conversation.findOne({
-            _id: msg.conversationId,
-            $or: [{ profileId }, { 'participants.profileId': profileId }],
-        })
-            .select({ _id: 1 })
-            .lean()
-            .exec();
-        if (!convo)
-            throw new Error('Not authorized for this message');
-        await ConversationMessage.updateOne({ _id: messageId }, { $set: { isStarred } }).exec();
-        return { ok: true, messageId, isStarred };
-    }
-    async distributeSantaChristmasTicketToProfile(input, ctx) {
-        if (!input?.profileId)
-            throw new ARXError('NO_INPUT');
-        if (!ctx.client?.roles?.includes('admin'))
-            throw new Error('Not authorized');
-        const year = 2025;
-        const dedupeKey = input?.dedupeKey || `broadcast:santa-christmas-ticket:${year}`;
-        const patches = [
-            {
-                entityType: 'profile.meta',
-                entityId: 'broadcast',
-                claimable: true,
-                ops: [{ op: 'inc', key: `rewards.tokens.christmas${year}`, value: 1 }],
-            },
-        ];
-        const result = await mailClaimablePatchesBatch({
-            ctx,
-            profileIds: [input.profileId],
-            kind: 'mail',
-            conversationKey: 'system',
-            source: 'core.broadcastSantaChristmasTicket',
-            title: `Holiday Gift 🎁`,
-            body: `You received a Santa Christmas Ticket (${year}). Claim it to add it to your account.`,
-            dedupeKey,
-            claimablePatches: patches,
-            payloadUi: {
-                rewards: [{ type: 'token', id: `christmas${year}`, quantity: 1 }],
-            },
-            batchSize: 1,
-        });
-        return {
-            ok: true,
-            year,
-            dedupeKey,
-            profileId: input.profileId,
-            ...result,
-        };
-    }
-    async readAndClaimLatestMail(input, ctx) {
-        if (!input?.conversationId)
-            throw new ARXError('NO_INPUT');
-        if (!ctx.client?.profile)
-            throw new Error('Unauthorized');
-        const profileId = String(ctx.client.profile.id);
-        const conversationId = String(input.conversationId);
-        const limit = Math.max(1, Math.min(200, Number(input.limit ?? 50)));
-        const characterId = input?.characterId ? String(input.characterId) : null;
-        const Conversation = ctx.app.model.Conversation;
-        const ConversationMessage = ctx.app.model.ConversationMessage;
-        const Profile = ctx.app.model.Profile;
-        const convo = await Conversation.findOne({
-            _id: conversationId,
-            $or: [{ profileId }, { 'participants.profileId': profileId }],
-        })
-            .lean()
-            .exec();
-        if (!convo)
-            throw new Error('Not authorized');
-        const msgs = await ConversationMessage.find({
-            conversationId,
-            status: { $ne: 'Archived' },
-        })
-            .sort({ _id: -1 })
-            .limit(limit)
-            .lean()
-            .exec();
-        const now = new Date();
-        await Conversation.updateOne({ _id: conversationId }, {
-            $set: {
-                'participants.$[p].lastReadDate': now,
-                'participants.$[p].unreadCount': 0,
-            },
-        }, {
-            arrayFilters: [
-                {
-                    'p.profileId': ctx.app.db?.mongoose?.Types?.ObjectId?.isValid?.(profileId)
-                        ? ctx.app.db.mongoose.Types.ObjectId(profileId)
-                        : profileId,
-                },
-            ],
-        })
-            .exec()
-            .catch(async () => {
-            await Conversation.updateOne({ _id: conversationId, 'participants.profileId': profileId }, { $set: { 'participants.$.lastReadDate': now, 'participants.$.unreadCount': 0 } }).exec();
-        });
-        const profile = await Profile.findById(profileId).populate('characters').exec();
-        if (!profile)
-            throw new Error('Profile not found');
-        let character = null;
-        const chars = profile.characters || [];
-        if (characterId)
-            character = chars.find((c) => String(c._id) === characterId) ?? null;
-        else
-            character = chars?.[0] ?? null;
-        let claimedCount = 0;
-        for (const m of msgs) {
-            const claimable = !!m?.claim?.isClaimable && !m?.claim?.claimedDate;
-            if (!claimable)
-                continue;
-            try {
-                await claimMailMessage({
-                    ctx,
-                    profile,
-                    character: character ?? undefined,
-                    messageId: String(m._id),
-                });
-                claimedCount += 1;
-            }
-            catch {
-            }
-        }
-        return { ok: true, conversationId, readCount: msgs.length, claimedCount };
-    }
-    async archiveReadConversations(input, ctx) {
-        if (!input?.conversationId)
-            throw new ARXError('NO_INPUT');
-        if (!ctx.client?.profile)
-            throw new Error('Unauthorized');
-        const profileId = String(ctx.client.profile.id);
-        const conversationId = String(input.conversationId);
-        const Conversation = ctx.app.model.Conversation;
-        const ConversationMessage = ctx.app.model.ConversationMessage;
-        const convo = await Conversation.findOne({
-            _id: conversationId,
-            $or: [{ profileId }, { 'participants.profileId': profileId }],
-        })
-            .lean()
-            .exec();
-        if (!convo)
-            throw new Error('Not authorized');
-        const participant = Array.isArray(convo.participants)
-            ? convo.participants.find((p) => String(p.profileId) === profileId)
-            : null;
-        const lastReadDate = participant?.lastReadDate ? new Date(participant.lastReadDate) : new Date(0);
-        const res = await ConversationMessage.updateMany({
-            conversationId,
-            status: { $ne: 'Archived' },
-            isStarred: { $ne: true },
-            createdDate: { $lte: lastReadDate },
-        }, { $set: { status: 'Archived' } }).exec();
-        const archivedCount = Number(res?.modifiedCount ?? res?.nModified ?? 0);
-        return { ok: true, conversationId, archivedCount };
-    }
-    async markConversationRead(input, ctx) {
-        if (!ctx.client?.profile)
-            throw new Error('Unauthorized');
-        const profileId = String(ctx.client.profile.id);
-        const Conversation = ctx.app.model.Conversation;
-        const ConversationMessage = ctx.app.model.ConversationMessage;
-        const messageIds = Array.isArray(input?.messageIds)
-            ? input.messageIds.map((x) => String(x)).filter(Boolean)
-            : [];
-        const conversationId = input?.conversationId ? String(input.conversationId) : null;
-        const limit = Math.min(200, Number(input?.limit ?? 50));
-        let targetIds = messageIds;
-        if (!targetIds.length) {
-            if (!conversationId) {
-                return { ok: true, updatedCount: 0 };
-            }
-            const convo = await Conversation.findOne({
-                _id: conversationId,
-                $or: [{ profileId }, { 'participants.profileId': profileId }],
-            })
-                .lean()
-                .exec();
-            if (!convo)
-                throw new Error('Not authorized for this conversation');
-            const docs = await ConversationMessage.find({ conversationId })
-                .sort({ _id: -1 })
-                .limit(limit)
-                .select({ _id: 1 })
-                .lean()
-                .exec();
-            targetIds = docs.map((d) => String(d._id));
-            if (!targetIds.length)
-                return { ok: true, updatedCount: 0 };
-        }
-        else {
-            const msgs = await ConversationMessage.find({ _id: { $in: targetIds } })
-                .select({ _id: 1, conversationId: 1 })
-                .lean()
-                .exec();
-            if (!msgs.length)
-                return { ok: true, updatedCount: 0 };
-            const convoIds = Array.from(new Set(msgs.map((m) => String(m.conversationId))));
-            const allowed = await Conversation.find({
-                _id: { $in: convoIds },
-                $or: [{ profileId }, { 'participants.profileId': profileId }],
-            })
-                .select({ _id: 1 })
-                .lean()
-                .exec();
-            const allowedSet = new Set(allowed.map((c) => String(c._id)));
-            targetIds = msgs.filter((m) => allowedSet.has(String(m.conversationId))).map((m) => String(m._id));
-            if (!targetIds.length)
-                throw new Error('Not authorized for these messages');
-        }
-        const res = await ConversationMessage.updateMany({ _id: { $in: targetIds } }, {
-            $set: {
-                status: 'Read',
-                readDate: new Date(),
-            },
-        }).exec();
-        const updatedCount = Number(res?.modifiedCount ?? res?.nModified ?? 0);
-        return { ok: true, updatedCount, messageIds: targetIds };
-    }
-    async getConversations(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        const filter = getFilter(input);
-        const limit = input.limit ?? 50;
-        const skip = input.skip ?? 0;
-        const [items, total] = await Promise.all([
-            ctx.app.model.Conversation.findJSON(filter, null, { skip, limit }),
-            ctx.app.model.Conversation.find(filter).countDocuments().exec(),
-        ]);
-        return { items, total };
-    }
-    async getConversation(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getConversation', input);
-        const AUTO_CREATE_KEYS = new Set(['system', 'battles', 'reports', 'guild']);
-        function titleCase(s) {
-            if (!s)
-                return s;
-            return s.charAt(0).toUpperCase() + s.slice(1);
-        }
-        function defaultsForKey(key) {
-            if (key === 'system') {
-                return {
-                    name: 'System',
-                    category: 'system',
-                    kind: 'mail',
-                    isLocked: true,
-                    allowUserSend: false,
-                    importance: 0,
-                };
-            }
-            return {
-                name: titleCase(key),
-                category: key,
-                kind: 'mail',
-                isLocked: false,
-                allowUserSend: false,
-                importance: 0,
-            };
-        }
-        if (!ctx.client?.profile?.id)
-            throw new Error('Unauthorized');
-        input.where = input.where || {};
-        input.where.profileId = { equals: ctx.client.profile.id };
-        const where = input.where || {};
-        const requestedKey = typeof where?.key === 'string' ? where.key : typeof where?.key?.equals === 'string' ? where.key.equals : null;
-        let conversation = await ctx.app.model.Conversation.findOneJSON(getFilter(input));
-        if (conversation)
-            return conversation;
-        if (!requestedKey || !AUTO_CREATE_KEYS.has(requestedKey)) {
-            throw new Error('Conversation not found');
-        }
-        const profileId = String(ctx.client.profile.id);
-        const createDoc = {
-            key: requestedKey,
-            profileId,
-            ...defaultsForKey(requestedKey),
-            participants: [
-                {
-                    profileId,
-                    role: 'user',
-                    lastReadAt: new Date(0),
-                    unreadCount: 0,
-                    isMuted: false,
-                    isPinned: false,
-                    isArchived: false,
-                    isDeleted: false,
-                },
-            ],
-            messages: [],
-            messageCount: 0,
-            lastMessageDate: null,
-            lastMessagePreview: '',
-            meta: {},
-            data: {},
-            status: 'Active',
-        };
-        try {
-            await ctx.app.model.Conversation.create(createDoc);
-        }
-        catch (err) {
-            log('getConversation auto-create race/err', err?.message || err);
-        }
-        conversation = await ctx.app.model.Conversation.findOneJSON(getFilter(input));
-        if (!conversation)
-            throw new Error('Conversation not found');
-        return conversation;
-    }
-    async createConversation(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createConversation', input);
-        const conversation = await ctx.app.model.Conversation.create(input.data);
-        return conversation;
-    }
-    async updateConversation(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        const filters = getFilter(input);
-        if (!filters._id)
-            throw new ARXError('BAD_REQUEST');
-        log('Core.Service.updateConversation', input);
-        const updatedConversation = await ctx.app.model.Conversation.findByIdAndUpdate(filters._id, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedConversation)
-            throw new Error('Conversation update failed');
-        return updatedConversation;
-    }
-    async getConversationMessage(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getConversationMessage', input);
-        const conversationMessage = await ctx.app.model.ConversationMessage.findOneJSON(getFilter(input));
-        if (!conversationMessage)
-            throw new Error('ConversationMessage not found');
-        return conversationMessage;
-    }
-    async createConversationMessage(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createConversationMessage', input);
-        const conversationMessage = await ctx.app.model.ConversationMessage.create(input.data);
-        return conversationMessage;
-    }
-    async updateConversationMessage(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateConversationMessage', input);
-        const updatedConversationMessage = await ctx.app.model.ConversationMessage.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedConversationMessage)
-            throw new Error('ConversationMessage update failed');
-        return updatedConversationMessage;
-    }
-    async updateSettings(input, ctx) {
-        if (!ctx.client.profile)
-            return;
-        const validKeys = ['warp', 'designer'];
-        const incoming = input;
-        for (const key of Object.keys(incoming)) {
-            if (!validKeys.includes(key))
-                continue;
-            const prev = ctx.client.profile.settings[key] || {};
-            ctx.client.profile.settings[key] = deepMerge(prev, incoming[key]);
-        }
-        ctx.client.profile.markModified('settings');
-        await ctx.client.profile.save();
-        return ctx.client.profile.settings;
-    }
-    async ask(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.ask', input);
-        const { conversationId, messages } = input.data;
-        if (!conversationId) {
-            throw new Error('NO_CONVERSATION_ID');
-        }
-        if (!Array.isArray(messages) || messages.length === 0) {
-            throw new Error('NO_MESSAGES');
-        }
-        const lastMessage = messages[messages.length - 1];
-        if (!lastMessage?.content) {
-            throw new Error('NO_MESSAGE_CONTENT');
-        }
-        const userRole = lastMessage.role || 'user';
-        await ctx.app.model.ConversationMessage.create({
-            conversationId,
-            role: userRole,
-            content: lastMessage.content,
-        });
-        const assistantReply = {
-            content: 'Request success.',
-            role: 'assistant',
-        };
-        await ctx.app.model.ConversationMessage.create({
-            conversationId,
-            role: assistantReply.role,
-            content: assistantReply.content,
-        });
-        return assistantReply;
-    }
-    async authorize(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.authorize', input);
-        const isValid = await isValidRequest(ctx.app.web3.bsc, {
-            signature: {
-                address: input.address,
-                hash: input.token,
-                data: input.data || 'evolution',
-            },
-        });
-        if (!isValid)
-            throw new Error(`Invalid signature: ${input.address} ${input.token}`);
-        ctx.client.profile = await ctx.app.model.Profile.findOne({
-            address: input.address,
-        });
-        if (!ctx.client.profile)
-            throw new Error('Profile not found: ' + input.address);
-        const roles = ['guest'];
-        if (input.address.toLowerCase() === '0xDfA8f768d82D719DC68E12B199090bDc3691fFc7'.toLowerCase() ||
-            input.address.toLowerCase() === '0x81F8C054667046171C0EAdC73063Da557a828d6f'.toLowerCase() ||
-            input.address.toLowerCase() === '0x954246b18fee13712C48E5a7Da5b78D88e8891d5'.toLowerCase()) {
-            roles.push('mod');
-            roles.push('admin');
-        }
-        roles.push('user');
-        ctx.client.roles = roles;
-        const permissions = {
-            'character.create': roles.includes('mod'),
-            'character.view': roles.includes('mod'),
-            'character.remove': roles.includes('mod'),
-            'character.update': roles.includes('mod'),
-            'rewards.distribute': roles.includes('admin'),
-            'character.data.write': roles.includes('mod'),
-            'character.inventory.write': roles.includes('mod'),
-            'profile.meta.write': roles.includes('mod'),
-            'character.data.write:evolution.quest.*': roles.includes('mod'),
-        };
-        ctx.client.permissions = permissions;
-        return {
-            token: input.token,
-        };
-    }
-    async syncGetPayloadsSince(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.syncGetPayloadsSince', input);
-        const sinceDate = new Date(input.since);
-        const payloads = await ctx.app.model.SeerPayload.find({
-            createdDate: { $gt: sinceDate },
-        })
-            .lean()
-            .exec();
-        return { payloads };
-    }
-    async getAccount(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getAccount', input);
-        const account = await ctx.app.model.Account.findOne(getFilter(input)).exec();
-        if (!account)
-            throw new Error('Account not found');
-        return account;
-    }
-    async getAccounts(ctx) {
-        log('Core.Service.getAccounts');
-        const accounts = await ctx.app.model.Account.find().exec();
-        return accounts;
-    }
-    async createAccount(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createAccount', input);
-        const account = await ctx.app.model.Account.create(input);
-        return account;
-    }
-    async updateAccount(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateAccount', input);
-        const updatedAccount = await ctx.app.model.Account.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedAccount)
-            throw new Error('Account update failed');
-        return updatedAccount;
-    }
-    async getAchievement(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getAchievement', input);
-        const achievement = await ctx.app.model.Achievement.findOne(getFilter(input)).exec();
-        if (!achievement)
-            throw new Error('Achievement not found');
-        return achievement;
-    }
-    async getAchievements(ctx) {
-        log('Core.Service.getAchievements');
-        const achievements = await ctx.app.model.Achievement.find().exec();
-        return achievements;
-    }
-    async createAchievement(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createAchievement', input);
-        const achievement = await ctx.app.model.Achievement.create(input);
-        return achievement;
-    }
-    async updateAchievement(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateAchievement', input);
-        const updatedAchievement = await ctx.app.model.Achievement.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedAchievement)
-            throw new Error('Achievement update failed');
-        return updatedAchievement;
-    }
-    async info(input, ctx) {
-        return { version: '1.1.1' };
-    }
-    async stats(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.stats');
-        const stats = await ctx.app.model.Stat.find().sort({ number: -1 }).limit(1).exec();
-        return stats.map((stat) => stat.toObject());
-    }
-    async getAct(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getAct', input);
-        const act = await ctx.app.model.Act.findOne(getFilter(input)).exec();
-        if (!act)
-            throw new Error('Act not found');
-        return act;
-    }
-    async getActs(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        const filter = getFilter(input);
-        const limit = input.limit ?? 50;
-        const skip = input.skip ?? 0;
-        const [items, total] = await Promise.all([
-            ctx.app.model.Act.find(filter).skip(skip).limit(limit).lean().exec(),
-            ctx.app.model.Act.find(filter).countDocuments().exec(),
-        ]);
-        return { items, total };
-    }
-    async createAct(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createAct', input);
-        const act = await ctx.app.model.Act.create(input);
-        return act;
-    }
-    async updateAct(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateAct', input);
-        const updatedAct = await ctx.app.model.Act.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedAct)
-            throw new Error('Act update failed');
-        return updatedAct;
-    }
-    async getAgent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getAgent', input);
-        const agent = await ctx.app.model.Agent.findOne(getFilter(input)).exec();
-        if (!agent)
-            throw new Error('Agent not found');
-        return agent;
-    }
-    async createAgent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createAgent', input);
-        const agent = await ctx.app.model.Agent.create(input);
-        return agent;
-    }
-    async updateAgent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateAgent', input);
-        const updatedAgent = await ctx.app.model.Agent.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedAgent)
-            throw new Error('Agent update failed');
-        return updatedAgent;
-    }
-    async getApplication(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getApplication', input);
-        const application = await ctx.app.model.Application.findOne(getFilter(input)).exec();
-        if (!application)
-            throw new Error('Application not found');
-        return application;
-    }
-    async createApplication(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createApplication', input);
-        const application = await ctx.app.model.Application.create(input);
-        return application;
-    }
-    async updateApplication(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateApplication', input);
-        const updatedApplication = await ctx.app.model.Application.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedApplication)
-            throw new Error('Application update failed');
-        return updatedApplication;
-    }
-    async getBadge(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getBadge', input);
-        const badge = await ctx.app.model.Badge.findOne(getFilter(input)).exec();
-        if (!badge)
-            throw new Error('Badge not found');
-        return badge;
-    }
-    async createBadge(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createBadge', input);
-        const badge = await ctx.app.model.Badge.create(input);
-        return badge;
-    }
-    async updateBadge(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateBadge', input);
-        const updatedBadge = await ctx.app.model.Badge.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedBadge)
-            throw new Error('Badge update failed');
-        return updatedBadge;
-    }
-    async getBattlePass(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getBattlePass', input);
-        const battlePass = await ctx.app.model.BattlePass.findOne(getFilter(input)).exec();
-        if (!battlePass)
-            throw new Error('BattlePass not found');
-        return battlePass;
-    }
-    async createBattlePass(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createBattlePass', input);
-        const battlePass = await ctx.app.model.BattlePass.create(input);
-        return battlePass;
-    }
-    async updateBattlePass(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateBattlePass', input);
-        const updatedBattlePass = await ctx.app.model.BattlePass.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedBattlePass)
-            throw new Error('BattlePass update failed');
-        return updatedBattlePass;
-    }
-    async getBiome(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getBiome', input);
-        const biome = await ctx.app.model.Biome.findOne(getFilter(input)).exec();
-        if (!biome)
-            throw new Error('Biome not found');
-        return biome;
-    }
-    async createBiome(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createBiome', input);
-        const biome = await ctx.app.model.Biome.create(input);
-        return biome;
-    }
-    async updateBiome(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateBiome', input);
-        const updatedBiome = await ctx.app.model.Biome.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedBiome)
-            throw new Error('Biome update failed');
-        return updatedBiome;
-    }
-    async getBiomeFeature(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getBiomeFeature', input);
-        const biomeFeature = await ctx.app.model.BiomeFeature.findOne(getFilter(input)).exec();
-        if (!biomeFeature)
-            throw new Error('BiomeFeature not found');
-        return biomeFeature;
-    }
-    async createBiomeFeature(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createBiomeFeature', input);
-        const biomeFeature = await ctx.app.model.BiomeFeature.create(input);
-        return biomeFeature;
-    }
-    async updateBiomeFeature(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateBiomeFeature', input);
-        const updatedBiomeFeature = await ctx.app.model.BiomeFeature.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedBiomeFeature)
-            throw new Error('BiomeFeature update failed');
-        return updatedBiomeFeature;
-    }
-    async getCollection(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getCollection', input);
-        const collection = await ctx.app.model.Collection.findOne(getFilter(input)).exec();
-        if (!collection)
-            throw new Error('Collection not found');
-        return collection;
-    }
-    async createCollection(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createCollection', input);
-        const collection = await ctx.app.model.Collection.create(input);
-        return collection;
-    }
-    async updateCollection(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateCollection', input);
-        const updatedCollection = await ctx.app.model.Collection.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedCollection)
-            throw new Error('Collection update failed');
-        return updatedCollection;
-    }
-    async getComment(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getComment', input);
-        const comment = await ctx.app.model.Comment.findOne(getFilter(input)).exec();
-        if (!comment)
-            throw new Error('Comment not found');
-        return comment;
-    }
-    async createComment(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createComment', input);
-        const comment = await ctx.app.model.Comment.create(input);
-        return comment;
-    }
-    async updateComment(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateComment', input);
-        const updatedComment = await ctx.app.model.Comment.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedComment)
-            throw new Error('Comment update failed');
-        return updatedComment;
-    }
-    async getCommunity(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getCommunity', input);
-        const community = await ctx.app.model.Community.findOne(getFilter(input)).exec();
-        if (!community)
-            throw new Error('Community not found');
-        return community;
-    }
-    async createCommunity(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createCommunity', input);
-        const community = await ctx.app.model.Community.create(input);
-        return community;
-    }
-    async updateCommunity(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateCommunity', input);
-        const updatedCommunity = await ctx.app.model.Community.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedCommunity)
-            throw new Error('Community update failed');
-        return updatedCommunity;
-    }
-    async getCompany(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getCompany', input);
-        const company = await ctx.app.model.Company.findOne(getFilter(input)).exec();
-        if (!company)
-            throw new Error('Company not found');
-        return company;
-    }
-    async createCompany(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createCompany', input);
-        const company = await ctx.app.model.Company.create(input);
-        return company;
-    }
-    async updateCompany(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateCompany', input.where.id.equals, input.data);
-        const updatedCompany = await ctx.app.model.Company.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedCompany)
-            throw new Error('Company update failed');
-        return updatedCompany;
-    }
-    async getData(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getData', input.where.id.equals);
-        const data = await ctx.app.model.Data.findOne(getFilter(input)).exec();
-        if (!data)
-            throw new Error('Data not found');
-        return data;
-    }
-    async createData(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createData', input);
-        const data = await ctx.app.model.Data.create(input);
-        return data;
-    }
-    async updateData(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateData', input.where.id.equals, input.data);
-        const updatedData = await ctx.app.model.Data.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedData)
-            throw new Error('Data update failed');
-        return updatedData;
-    }
-    async getDiscussion(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getDiscussion', input.where.id.equals);
-        const discussion = await ctx.app.model.Discussion.findOne(getFilter(input)).exec();
-        if (!discussion)
-            throw new Error('Discussion not found');
-        return discussion;
-    }
-    async createDiscussion(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createDiscussion', input);
-        const discussion = await ctx.app.model.Discussion.create(input);
-        return discussion;
-    }
-    async updateDiscussion(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateDiscussion', input);
-        const updatedDiscussion = await ctx.app.model.Discussion.findByIdAndUpdate(input.where.id.equals, input.data, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedDiscussion)
-            throw new Error('Discussion update failed');
-        return updatedDiscussion;
-    }
-    async getEnergy(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getEnergy', input);
-        const energy = await ctx.app.model.Energy.findOne(getFilter(input)).exec();
-        if (!energy)
-            throw new Error('Energy not found');
-        return energy;
-    }
-    async getEnergies(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getEnergies', input);
-        const filter = getFilter(input);
-        const limit = input.limit ?? 50;
-        const skip = input.skip ?? 0;
-        const [items, total] = await Promise.all([
-            ctx.app.model.Energy.find(filter).skip(skip).limit(limit).lean().exec(),
-            ctx.app.model.Energy.find(filter).countDocuments().exec(),
-        ]);
-        return { items, total };
-    }
-    async createEnergy(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createEnergy', input);
-        const energy = await ctx.app.model.Energy.create(input);
-        return energy;
-    }
-    async updateEnergy(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateEnergy', input);
-        const updatedEnergy = await ctx.app.model.Energy.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedEnergy)
-            throw new Error('Energy update failed');
-        return updatedEnergy;
-    }
-    async getEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getEvent', input);
-        const event = await ctx.app.model.Event.findOne(getFilter(input)).exec();
-        if (!event)
-            throw new Error('Event not found');
-        return event;
-    }
-    async createEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createEvent', input);
-        const event = await ctx.app.model.Event.create(input);
-        return event;
-    }
-    async updateEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateEvent', input);
-        const updatedEvent = await ctx.app.model.Event.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedEvent)
-            throw new Error('Event update failed');
-        return updatedEvent;
-    }
-    async getFile(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getFile', input);
-        const file = await ctx.app.model.File.findOne(getFilter(input)).exec();
-        if (!file)
-            throw new Error('File not found');
-        return file;
-    }
-    async createFile(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createFile', input);
-        const file = await ctx.app.model.File.create(input);
-        return file;
-    }
-    async updateFile(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateFile', input);
-        const updatedFile = await ctx.app.model.File.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-            .lean()
-            .exec();
-        if (!updatedFile)
-            throw new Error('File update failed');
-        return updatedFile;
-    }
-    async getGalaxy(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getGalaxy', input);
-        const galaxy = await ctx.app.model.Galaxy.findOne(getFilter(input)).exec();
-        if (!galaxy)
-            throw new Error('Galaxy not found');
-        return galaxy;
-    }
-    async createGalaxy(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createGalaxy', input);
-        const galaxy = await ctx.app.model.Galaxy.create(input);
-        return galaxy;
-    }
-    async updateGalaxy(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateGalaxy', input);
-        const updatedGalaxy = await ctx.app.model.Galaxy.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedGalaxy)
-            throw new Error('Galaxy update failed');
-        return updatedGalaxy;
-    }
-    async getGuide(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getGuide', input);
-        const guide = await ctx.app.model.Guide.findOne(getFilter(input)).exec();
-        if (!guide)
-            throw new Error('Guide not found');
-        return guide;
-    }
-    async createGuide(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createGuide', input);
-        const guide = await ctx.app.model.Guide.create(input);
-        return guide;
-    }
-    async updateGuide(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateGuide', input);
-        const updatedGuide = await ctx.app.model.Guide.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedGuide)
-            throw new Error('Guide update failed');
-        return updatedGuide;
-    }
-    async getIdea(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getIdea', input);
-        const idea = await ctx.app.model.Idea.findOne(getFilter(input)).exec();
-        if (!idea)
-            throw new Error('Idea not found');
-        return idea;
-    }
-    async createIdea(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createIdea', input);
-        const idea = await ctx.app.model.Idea.create(input);
-        return idea;
-    }
-    async updateIdea(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateIdea', input);
-        const updatedIdea = await ctx.app.model.Idea.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedIdea)
-            throw new Error('Idea update failed');
-        return updatedIdea;
-    }
-    async getLeaderboard(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getLeaderboard', input);
-        const leaderboard = await ctx.app.model.Leaderboard.findOne(getFilter(input)).exec();
-        if (!leaderboard)
-            throw new Error('Leaderboard not found');
-        return leaderboard;
-    }
-    async createLeaderboard(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createLeaderboard', input);
-        const leaderboard = await ctx.app.model.Leaderboard.create(input);
-        return leaderboard;
-    }
-    async updateLeaderboard(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateLeaderboard', input);
-        const updatedLeaderboard = await ctx.app.model.Leaderboard.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedLeaderboard)
-            throw new Error('Leaderboard update failed');
-        return updatedLeaderboard;
-    }
-    async getLog(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getLog', input);
-        const item = await ctx.app.model.Log.findOne(getFilter(input)).exec();
-        if (!item)
-            throw new Error('Log not found');
-        return item;
-    }
-    async createLog(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createLog', input);
-        const item = await ctx.app.model.Log.create(input);
-        return item;
-    }
-    async updateLog(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateLog', input);
-        const item = await ctx.app.model.Log.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!item)
-            throw new Error('Log update failed');
-        return item;
-    }
-    async getLore(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getLore', input);
-        const lore = await ctx.app.model.Lore.findOne(getFilter(input)).exec();
-        if (!lore)
-            throw new Error('Lore not found');
-        return lore;
-    }
-    async createLore(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createLore', input);
-        const lore = await ctx.app.model.Lore.create(input);
-        return lore;
-    }
-    async updateLore(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateLore', input);
-        const updatedLore = await ctx.app.model.Lore.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedLore)
-            throw new Error('Lore update failed');
-        return updatedLore;
-    }
-    async getMemory(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getMemory', input);
-        const memory = await ctx.app.model.Memory.findOne(getFilter(input)).exec();
-        if (!memory)
-            throw new Error('Memory not found');
-        return memory;
-    }
-    async createMemory(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createMemory', input);
-        const memory = await ctx.app.model.Memory.create(input);
-        return memory;
-    }
-    async updateMemory(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateMemory', input);
-        const updatedMemory = await ctx.app.model.Memory.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedMemory)
-            throw new Error('Memory update failed');
-        return updatedMemory;
-    }
-    async getMessage(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getMessage', input);
-        const message = await ctx.app.model.Message.findOne(getFilter(input)).exec();
-        if (!message)
-            throw new Error('Message not found');
-        return message;
-    }
-    async createMessage(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createMessage', input);
-        const message = await ctx.app.model.Message.create(input);
-        return message;
-    }
-    async updateMessage(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateMessage', input);
-        const updatedMessage = await ctx.app.model.Message.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedMessage)
-            throw new Error('Message update failed');
-        return updatedMessage;
-    }
-    async getMetaverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getMetaverse', input);
-        const metaverse = await ctx.app.model.Metaverse.findOne(getFilter(input)).exec();
-        if (!metaverse)
-            throw new Error('Metaverse not found');
-        return metaverse;
-    }
-    async createMetaverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createMetaverse', input);
-        const metaverse = await ctx.app.model.Metaverse.create(input);
-        return metaverse;
-    }
-    async updateMetaverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateMetaverse', input);
-        const updatedMetaverse = await ctx.app.model.Metaverse.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedMetaverse)
-            throw new Error('Metaverse update failed');
-        return updatedMetaverse;
-    }
-    async getNewsArticle(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getNewsArticle', input);
-        const newsArticle = await ctx.app.model.NewsArticle.findOne(getFilter(input)).exec();
-        if (!newsArticle)
-            throw new Error('NewsArticle not found');
-        return newsArticle;
-    }
-    async createNewsArticle(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createNewsArticle', input);
-        const newsArticle = await ctx.app.model.NewsArticle.create(input);
-        return newsArticle;
-    }
-    async updateNewsArticle(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateNewsArticle', input);
-        const updatedNewsArticle = await ctx.app.model.NewsArticle.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedNewsArticle)
-            throw new Error('NewsArticle update failed');
-        return updatedNewsArticle;
-    }
-    async getNpc(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getNpc', input);
-        const npc = await ctx.app.model.Npc.findOne(getFilter(input)).exec();
-        if (!npc)
-            throw new Error('Npc not found');
-        return npc;
-    }
-    async createNpc(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createNpc', input);
-        const npc = await ctx.app.model.Npc.create(input);
-        return npc;
-    }
-    async updateNpc(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateNpc', input);
-        const updatedNpc = await ctx.app.model.Npc.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedNpc)
-            throw new Error('Npc update failed');
-        return updatedNpc;
-    }
-    async getOffer(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getOffer', input);
-        const offer = await ctx.app.model.Offer.findOne(getFilter(input)).exec();
-        if (!offer)
-            throw new Error('Offer not found');
-        return offer;
-    }
-    async createOffer(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createOffer', input);
-        const offer = await ctx.app.model.Offer.create(input);
-        return offer;
-    }
-    async updateOffer(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateOffer', input);
-        const updatedOffer = await ctx.app.model.Offer.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedOffer)
-            throw new Error('Offer update failed');
-        return updatedOffer;
-    }
-    async getOmniverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getOmniverse', input);
-        const omniverse = await ctx.app.model.Omniverse.findOne(getFilter(input)).exec();
-        if (!omniverse)
-            throw new Error('Omniverse not found');
-        return omniverse;
-    }
-    async createOmniverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createOmniverse', input);
-        const omniverse = await ctx.app.model.Omniverse.create(input);
-        return omniverse;
-    }
-    async updateOmniverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateOmniverse', input);
-        const updatedOmniverse = await ctx.app.model.Omniverse.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedOmniverse)
-            throw new Error('Omniverse update failed');
-        return updatedOmniverse;
-    }
-    async getOrder(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getOrder', input);
-        const order = await ctx.app.model.Order.findOne(getFilter(input)).exec();
-        if (!order)
-            throw new Error('Order not found');
-        return order;
-    }
-    async createOrder(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createOrder', input);
-        const order = await ctx.app.model.Order.create(input);
-        return order;
-    }
-    async updateOrder(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateOrder', input);
-        const updatedOrder = await ctx.app.model.Order.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedOrder)
-            throw new Error('Order update failed');
-        return updatedOrder;
-    }
-    async getPayment(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getPayment', input);
-        const payment = await ctx.app.model.Payment.findOne(getFilter(input)).exec();
-        if (!payment)
-            throw new Error('Payment not found');
-        return payment;
-    }
-    async createPayment(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createPayment', input);
-        const payment = await ctx.app.model.Payment.create(input);
-        return payment;
-    }
-    async updatePayment(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updatePayment', input);
-        const updatedPayment = await ctx.app.model.Payment.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedPayment)
-            throw new Error('Payment update failed');
-        return updatedPayment;
-    }
-    async getPermission(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getPermission', input);
-        const permission = await ctx.app.model.Permission.findOne(getFilter(input)).exec();
-        if (!permission)
-            throw new Error('Permission not found');
-        return permission;
-    }
-    async createPermission(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createPermission', input);
-        const permission = await ctx.app.model.Permission.create(input);
-        return permission;
-    }
-    async updatePermission(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updatePermission', input);
-        const updatedPermission = await ctx.app.model.Permission.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedPermission)
-            throw new Error('Permission update failed');
-        return updatedPermission;
-    }
-    async getPerson(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getPerson', input);
-        const person = await ctx.app.model.Person.findOne(getFilter(input)).exec();
-        if (!person)
-            throw new Error('Person not found');
-        return person;
-    }
-    async createPerson(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createPerson', input);
-        const person = await ctx.app.model.Person.create(input);
-        return person;
-    }
-    async updatePerson(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updatePerson', input);
-        const updatedPerson = await ctx.app.model.Person.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedPerson)
-            throw new Error('Person update failed');
-        return updatedPerson;
-    }
-    async getPlanet(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getPlanet', input);
-        const planet = await ctx.app.model.Planet.findOne(getFilter(input)).exec();
-        if (!planet)
-            throw new Error('Planet not found');
-        return planet;
-    }
-    async createPlanet(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createPlanet', input);
-        const planet = await ctx.app.model.Planet.create(input);
-        return planet;
-    }
-    async updatePlanet(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updatePlanet', input);
-        const updatedPlanet = await ctx.app.model.Planet.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedPlanet)
-            throw new Error('Planet update failed');
-        return updatedPlanet;
-    }
-    async getPoll(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getPoll', input);
-        const poll = await ctx.app.model.Poll.findOne(getFilter(input)).exec();
-        if (!poll)
-            throw new Error('Poll not found');
-        return poll;
-    }
-    async createPoll(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createPoll', input);
-        const poll = await ctx.app.model.Poll.create(input);
-        return poll;
-    }
-    async updatePoll(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updatePoll', input);
-        const updatedPoll = await ctx.app.model.Poll.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedPoll)
-            throw new Error('Poll update failed');
-        return updatedPoll;
-    }
-    async getProject(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getProject', input);
-        const project = await ctx.app.model.Project.findOne(getFilter(input)).exec();
-        if (!project)
-            throw new Error('Project not found');
-        return project;
-    }
-    async createProject(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createProject', input);
-        const project = await ctx.app.model.Project.create(input);
-        return project;
-    }
-    async updateProject(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateProject', input);
-        const updatedProject = await ctx.app.model.Project.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedProject)
-            throw new Error('Project update failed');
-        return updatedProject;
-    }
-    async getProposal(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getProposal', input);
-        const proposal = await ctx.app.model.Proposal.findOne(getFilter(input)).exec();
-        if (!proposal)
-            throw new Error('Proposal not found');
-        return proposal;
-    }
-    async createProposal(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createProposal', input);
-        const proposal = await ctx.app.model.Proposal.create(input);
-        return proposal;
-    }
-    async updateProposal(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateProposal', input);
-        const updatedProposal = await ctx.app.model.Proposal.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedProposal)
-            throw new Error('Proposal update failed');
-        return updatedProposal;
-    }
-    async getQuest(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getQuest', input);
-        const quest = await ctx.app.model.Quest.findOne(getFilter(input)).exec();
-        if (!quest)
-            throw new Error('Quest not found');
-        return quest;
-    }
-    async createQuest(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createQuest', input);
-        const quest = await ctx.app.model.Quest.create(input);
-        return quest;
-    }
-    async updateQuest(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateQuest', input);
-        const updatedQuest = await ctx.app.model.Quest.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedQuest)
-            throw new Error('Quest update failed');
-        return updatedQuest;
-    }
-    async getRating(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getRating', input);
-        const rating = await ctx.app.model.Rating.findOne(getFilter(input)).exec();
-        if (!rating)
-            throw new Error('Rating not found');
-        return rating;
-    }
-    async createRating(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createRating', input);
-        const rating = await ctx.app.model.Rating.create(input);
-        return rating;
-    }
-    async updateRating(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateRating', input);
-        const updatedRating = await ctx.app.model.Rating.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedRating)
-            throw new Error('Rating update failed');
-        return updatedRating;
-    }
-    async getRealm(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getRealm', input);
-        const realm = await ctx.app.model.Realm.findOne(getFilter(input)).exec();
-        if (!realm)
-            throw new Error('Realm not found');
-        return realm;
-    }
-    async getRealms(input, ctx) {
-        log('Core.Service.getRealms', input);
-        const filter = getFilter(input);
-        filter.status = 'Online';
-        let realms = await ctx.app.model.Realm.find(filter).exec();
-        console.log('getRealms', realms);
-        realms = [
-            {
-                status: 'Online',
-                clientCount: 1,
-                regionCode: 'EU',
-                endpoint: 'evolution-realm-1.arken.gg',
-                gameId: '673996aec43266df5f966da6',
-                realmShards: [
-                    {
-                        status: 'Online',
-                        clientCount: 1,
-                        endpoint: 'evolution-realm-shard-1.arken.gg',
-                    },
-                ],
-            },
-        ];
-        return realms;
-    }
-    async createRealm(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createRealm', input);
-        const realm = await ctx.app.model.Realm.create(input);
-        return realm;
-    }
-    async updateRealm(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateRealm', input);
-        const updatedRealm = await ctx.app.model.Realm.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedRealm)
-            throw new Error('Realm update failed');
-        return updatedRealm;
-    }
-    async getRealmEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getRealmEvent', input);
-        const realmEvent = await ctx.app.model.RealmEvent.findOne(getFilter(input)).exec();
-        if (!realmEvent)
-            throw new Error('RealmEvent not found');
-        return realmEvent;
-    }
-    async getRealmEvents(input, ctx) {
-        log('Core.Service.getRealmEvents', input);
-        const filter = getFilter(input);
-        filter.status = 'Online';
-        let realmEvents = await ctx.app.model.RealmEvent.find(filter).exec();
-        console.log('getRealmEvents', realmEvents);
-        return realmEvents;
-    }
-    async createRealmEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createRealmEvent', input);
-        const realmEvent = await ctx.app.model.RealmEvent.create(input);
-        return realmEvent;
-    }
-    async updateRealmEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateRealmEvent', input);
-        const updatedRealmEvent = await ctx.app.model.RealmEvent.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedRealmEvent)
-            throw new Error('RealmEvent update failed');
-        return updatedRealmEvent;
-    }
-    async getRevision(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getRevision', input);
-        const revision = await ctx.app.model.Revision.findOne(getFilter(input)).exec();
-        if (!revision)
-            throw new Error('Revision not found');
-        return revision;
-    }
-    async createRevision(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createRevision', input);
-        const revision = await ctx.app.model.Revision.create(input);
-        return revision;
-    }
-    async updateRevision(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateRevision', input);
-        const updatedRevision = await ctx.app.model.Revision.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedRevision)
-            throw new Error('Revision update failed');
-        return updatedRevision;
-    }
-    async getReferral(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getReferral', input);
-        const referral = await ctx.app.model.Referral.findOne(getFilter(input)).exec();
-        if (!referral)
-            throw new Error('Referral not found');
-        return referral;
-    }
-    async createReferral(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createReferral', input);
-        const referral = await ctx.app.model.Referral.create(input);
-        return referral;
-    }
-    async updateReferral(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateReferral', input);
-        const updatedReferral = await ctx.app.model.Referral.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedReferral)
-            throw new Error('Referral update failed');
-        return updatedReferral;
-    }
-    async getReview(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getReview', input);
-        const review = await ctx.app.model.Review.findOne(getFilter(input)).exec();
-        if (!review)
-            throw new Error('Review not found');
-        return review;
-    }
-    async createReview(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createReview', input);
-        const review = await ctx.app.model.Review.create(input);
-        return review;
-    }
-    async updateReview(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateReview', input);
-        const updatedReview = await ctx.app.model.Review.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedReview)
-            throw new Error('Review update failed');
-        return updatedReview;
-    }
-    async getRole(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getRole', input);
-        const role = await ctx.app.model.Role.findOne(getFilter(input)).exec();
-        if (!role)
-            throw new Error('Role not found');
-        return role;
-    }
-    async createRole(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createRole', input);
-        const role = await ctx.app.model.Role.create(input);
-        return role;
-    }
-    async updateRole(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateRole', input);
-        const updatedRole = await ctx.app.model.Role.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedRole)
-            throw new Error('Role update failed');
-        return updatedRole;
-    }
-    async getSeason(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getSeason', input);
-        const season = await ctx.app.model.Season.findOne(getFilter(input)).exec();
-        if (!season)
-            throw new Error('Season not found');
-        return season;
-    }
-    async createSeason(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createSeason', input);
-        const season = await ctx.app.model.Season.create(input);
-        return season;
-    }
-    async updateSeason(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateSeason', input);
-        const updatedSeason = await ctx.app.model.Season.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedSeason)
-            throw new Error('Season update failed');
-        return updatedSeason;
-    }
-    async getRealmShard(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getRealmShard', input);
-        const server = await ctx.app.model.RealmShard.findOne(getFilter(input)).exec();
-        if (!server)
-            throw new Error('RealmShard not found');
-        return server;
-    }
-    async getRealmShards(input, ctx) {
-        log('Core.Service.getRealmShards', input);
-        const filter = getFilter(input);
-        filter.status = 'Active';
-        const servers = await ctx.app.model.RealmShard.find(filter).exec();
-        return servers;
-    }
-    async createRealmShard(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createRealmShard', input);
-        const server = await ctx.app.model.RealmShard.create(input);
-        return server;
-    }
-    async updateRealmShard(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateRealmShard', input);
-        const updatedRealmShard = await ctx.app.model.RealmShard.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedRealmShard)
-            throw new Error('RealmShard update failed');
-        return updatedRealmShard;
-    }
-    async getSession(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getSession', input);
-        const session = await ctx.app.model.Session.findOne(getFilter(input)).exec();
-        if (!session)
-            throw new Error('Session not found');
-        return session;
-    }
-    async createSession(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createSession', input);
-        const session = await ctx.app.model.Session.create(input);
-        return session;
-    }
-    async updateSession(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateSession', input);
-        const updatedSession = await ctx.app.model.Session.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedSession)
-            throw new Error('Session update failed');
-        return updatedSession;
-    }
-    async getSolarSystem(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getSolarSystem', input);
-        const solarSystem = await ctx.app.model.SolarSystem.findOne(getFilter(input)).exec();
-        if (!solarSystem)
-            throw new Error('SolarSystem not found');
-        return solarSystem;
-    }
-    async createSolarSystem(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createSolarSystem', input);
-        const solarSystem = await ctx.app.model.SolarSystem.create(input);
-        return solarSystem;
-    }
-    async updateSolarSystem(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateSolarSystem', input);
-        const updatedSolarSystem = await ctx.app.model.SolarSystem.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedSolarSystem)
-            throw new Error('SolarSystem update failed');
-        return updatedSolarSystem;
-    }
-    async getStar(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getStar', input);
-        const star = await ctx.app.model.Star.findOne(getFilter(input)).exec();
-        if (!star)
-            throw new Error('Star not found');
-        return star;
-    }
-    async createStar(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createStar', input);
-        const star = await ctx.app.model.Star.create(input);
-        return star;
-    }
-    async updateStar(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateStar', input);
-        const updatedStar = await ctx.app.model.Star.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedStar)
-            throw new Error('Star update failed');
-        return updatedStar;
-    }
-    async getStash(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getStash', input);
-        const stash = await ctx.app.model.Stash.findOne(getFilter(input)).exec();
-        if (!stash)
-            throw new Error('Stash not found');
-        return stash;
-    }
-    async createStash(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createStash', input);
-        const stash = await ctx.app.model.Stash.create(input);
-        return stash;
-    }
-    async updateStash(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateStash', input);
-        const updatedStash = await ctx.app.model.Stash.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedStash)
-            throw new Error('Stash update failed');
-        return updatedStash;
-    }
-    async getStock(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getStock', input);
-        const stock = await ctx.app.model.Stock.findOne(getFilter(input)).exec();
-        if (!stock)
-            throw new Error('Stock not found');
-        return stock;
-    }
-    async createStock(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createStock', input);
-        const stock = await ctx.app.model.Stock.create(input);
-        return stock;
-    }
-    async updateStock(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateStock', input);
-        const updatedStock = await ctx.app.model.Stock.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedStock)
-            throw new Error('Stock update failed');
-        return updatedStock;
-    }
-    async getSuggestion(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getSuggestion', input);
-        const suggestion = await ctx.app.model.Suggestion.findOne(getFilter(input)).exec();
-        if (!suggestion)
-            throw new Error('Suggestion not found');
-        return suggestion;
-    }
-    async createSuggestion(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createSuggestion', input);
-        const suggestion = await ctx.app.model.Suggestion.create(input);
-        return suggestion;
-    }
-    async updateSuggestion(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateSuggestion', input);
-        const updatedSuggestion = await ctx.app.model.Suggestion.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedSuggestion)
-            throw new Error('Suggestion update failed');
-        return updatedSuggestion;
-    }
-    async getTag(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getTag', input);
-        const tag = await ctx.app.model.Tag.findOne(getFilter(input)).exec();
-        if (!tag)
-            throw new Error('Tag not found');
-        return tag;
-    }
-    async createTag(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createTag', input);
-        const tag = await ctx.app.model.Tag.create(input);
-        return tag;
-    }
-    async updateTag(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateTag', input);
-        const updatedTag = await ctx.app.model.Tag.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedTag)
-            throw new Error('Tag update failed');
-        return updatedTag;
-    }
-    async getTeam(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getTeam', input);
-        const filter = getFilter(input);
-        const team = await ctx.app.model.Team.findOne(filter).exec();
-        if (!team)
-            throw new Error('Team not found');
-        return team;
-    }
-    async getTeams(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getTeams', input);
-        const filter = getFilter(input);
-        const teams = await ctx.app.model.Team.find(filter)
-            .skip(input.skip || 0)
-            .limit(input.limit || 10)
-            .exec();
-        return teams;
-    }
-    async createTeam(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createTeam', input);
-        const team = await ctx.app.model.Team.create(input);
-        return team;
-    }
-    async updateTeam(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateTeam', input);
-        const updatedTeam = await ctx.app.model.Team.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedTeam)
-            throw new Error('Team update failed');
-        return updatedTeam;
-    }
-    async getTournament(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getTournament', input);
-        const tournament = await ctx.app.model.Tournament.findOne(getFilter(input)).exec();
-        if (!tournament)
-            throw new Error('Tournament not found');
-        return tournament;
-    }
-    async createTournament(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createTournament', input);
-        const tournament = await ctx.app.model.Tournament.create(input);
-        return tournament;
-    }
-    async updateTournament(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateTournament', input);
-        const updatedTournament = await ctx.app.model.Tournament.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedTournament)
-            throw new Error('Tournament update failed');
-        return updatedTournament;
-    }
-    async getTrade(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getTrade', input);
-        const trade = await ctx.app.model.Trade.findOne(getFilter(input)).exec();
-        if (!trade)
-            throw new Error('Trade not found');
-        return trade;
-    }
-    async getTrades(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getTrades', input);
-        const trade = await ctx.app.model.Trade.find().limit(10).exec();
-        return trade;
-    }
-    async createTrade(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createTrade', input);
-        const trade = await ctx.app.model.Trade.create(input);
-        return trade;
-    }
-    async updateTrade(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateTrade', input);
-        const updatedTrade = await ctx.app.model.Trade.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedTrade)
-            throw new Error('Trade update failed');
-        return updatedTrade;
-    }
-    async getUniverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getUniverse', input);
-        const universe = await ctx.app.model.Universe.findOne(getFilter(input)).exec();
-        if (!universe)
-            throw new Error('Universe not found');
-        return universe;
-    }
-    async createUniverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createUniverse', input);
-        const universe = await ctx.app.model.Universe.create(input);
-        return universe;
-    }
-    async updateUniverse(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateUniverse', input);
-        const updatedUniverse = await ctx.app.model.Universe.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedUniverse)
-            throw new Error('Universe update failed');
-        return updatedUniverse;
-    }
-    async getValidator(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getValidator', input);
-        const validator = await ctx.app.model.Validator.findOne(getFilter(input)).exec();
-        if (!validator)
-            throw new Error('Validator not found');
-        return validator;
-    }
-    async createValidator(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createValidator', input);
-        const validator = await ctx.app.model.Validator.create(input);
-        return validator;
-    }
-    async updateValidator(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateValidator', input);
-        const updatedValidator = await ctx.app.model.Validator.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedValidator)
-            throw new Error('Validator update failed');
-        return updatedValidator;
-    }
-    async getVote(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getVote', input);
-        const vote = await ctx.app.model.Vote.findOne(getFilter(input)).exec();
-        if (!vote)
-            throw new Error('Vote not found');
-        return vote;
-    }
-    async createVote(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createVote', input);
-        const vote = await ctx.app.model.Vote.create(input);
-        return vote;
-    }
-    async updateVote(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateVote', input);
-        const updatedVote = await ctx.app.model.Vote.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-        if (!updatedVote)
-            throw new Error('Vote update failed');
-        return updatedVote;
-    }
-    async getWorldEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getWorldEvent', input);
-        const worldEvent = await ctx.app.model.WorldEvent.findOne(getFilter(input)).exec();
-        if (!worldEvent)
-            throw new Error('WorldEvent not found');
-        return worldEvent;
-    }
-    async createWorldEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createWorldEvent', input);
-        const worldEvent = await ctx.app.model.WorldEvent.create(input);
-        return worldEvent;
-    }
-    async updateWorldEvent(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateWorldEvent', input);
-        const updatedWorldEvent = await ctx.app.model.WorldEvent.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedWorldEvent)
-            throw new Error('WorldEvent update failed');
-        return updatedWorldEvent;
-    }
-    async getWorldRecord(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getWorldRecord', input);
-        const worldRecord = await ctx.app.model.WorldRecord.findOne(getFilter(input)).exec();
-        if (!worldRecord)
-            throw new Error('WorldRecord not found');
-        return worldRecord;
-    }
-    async createWorldRecord(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createWorldRecord', input);
-        const worldRecord = await ctx.app.model.WorldRecord.create(input);
-        return worldRecord;
-    }
-    async updateWorldRecord(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateWorldRecord', input);
-        const updatedWorldRecord = await ctx.app.model.WorldRecord.findByIdAndUpdate(input.where.id.equals, {
-            new: true,
-        })
-            .lean()
-            .exec();
-        if (!updatedWorldRecord)
-            throw new Error('WorldRecord update failed');
-        return updatedWorldRecord;
-    }
-    async getBounty(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.getBounty', input);
-        const bounty = await ctx.app.model.Bounty.findOne(getFilter(input)).exec();
-        if (!bounty)
-            throw new Error('Bounty not found');
-        return bounty;
-    }
-    async createBounty(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.createBounty', input);
-        const bounty = await ctx.app.model.Bounty.create(input);
-        return bounty;
-    }
-    async updateBounty(input, ctx) {
-        if (!input)
-            throw new ARXError('NO_INPUT');
-        log('Core.Service.updateBounty', input);
-        const updatedBounty = await ctx.app.model.Bounty.findByIdAndUpdate(input.where.id.equals, { new: true })
-            .lean()
-            .exec();
-        if (!updatedBounty)
-            throw new Error('Bounty update failed');
-        return updatedBounty;
-    }
-}
-//# sourceMappingURL=core.service.js.map