@arken/seer-protocol 0.1.1 → 0.1.2

package/core/core.models.ts

@@ -0,0 +1,1380 @@
+// node/modules/core/core.models.ts
+
+import * as mongo from '../../util/mongo';
+import type * as Types from './core.types';
+
+const { createModel, addTagVirtuals, addApplicationVirtual } = mongo;
+
+// MerkleTree Model
+export const MerkleTree = createModel<Types.MerkleTreeDocument>(
+  'MerkleTree',
+  {
+    root: { type: String, required: true, default: '0x' + '0'.repeat(64) },
+    depth: { type: Number, required: true, default: 16 }, // log2(#leaves)
+  },
+  {
+    // extend: 'CommonFields',
+    virtuals: [...addTagVirtuals('MerkleTree'), ...addApplicationVirtual()],
+  }
+);
+
+// MerkleNode Model
+export const MerkleNode = createModel<Types.MerkleNodeDocument>(
+  'MerkleNode',
+  {
+    treeId: { type: mongo.Schema.Types.ObjectId, ref: 'MerkleTree', required: true },
+    level: { type: Number, required: true }, // 0 = leaves
+    index: { type: Number, required: true }, // position in level
+    hash: { type: String, required: true },
+  },
+  {
+    // extend: 'CommonFields',
+    indexes: [{ treeId: 1, level: 1, index: 1 }],
+    virtuals: [...addTagVirtuals('MerkleNode'), ...addApplicationVirtual()],
+  }
+);
+
+// Omniverse Model
+export const Omniverse = createModel<Types.OmniverseDocument>(
+  'Omniverse',
+  {
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+  },
+  {
+    extend: 'CommonFields',
+    virtuals: [...addTagVirtuals('Omniverse'), ...addApplicationVirtual()],
+  }
+);
+
+// Metaverse Model
+export const Metaverse = createModel<Types.MetaverseDocument>(
+  'Metaverse',
+  {
+    omniverseId: { type: mongo.Schema.Types.ObjectId, ref: 'Omniverse', required: true },
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+  },
+  {
+    extend: 'CommonFields',
+    virtuals: [...addTagVirtuals('Metaverse'), ...addApplicationVirtual()],
+  }
+);
+
+// Application Model
+export const Application = createModel<Types.ApplicationDocument>(
+  'Application',
+  {
+    ownerId: { type: mongo.Schema.Types.ObjectId, ref: 'Account' },
+    metaverseId: { type: mongo.Schema.Types.ObjectId, ref: 'Metaverse' },
+    name: { type: String, required: true },
+    description: { type: String },
+  },
+  {
+    extend: 'CommonFields',
+    indexes: [{ metaverseId: 1, name: 1, unique: true }],
+    virtuals: [
+      ...addTagVirtuals('Application'),
+      { name: 'agents', ref: 'Agent', localField: '_id', foreignField: 'applicationId' },
+      { name: 'chain' },
+      { name: 'account' },
+      { name: 'assets' },
+      { name: 'badges' },
+      { name: 'battlePasses' },
+      { name: 'collections' },
+      { name: 'communities' },
+      { name: 'discussions' },
+      { name: 'events' },
+      { name: 'exchanges' },
+      { name: 'files' },
+      { name: 'ideas' },
+      { name: 'leaderboards' },
+      { name: 'assetLicenses' },
+      { name: 'logs' },
+      { name: 'marketPairs' },
+      { name: 'markets' },
+      { name: 'messages' },
+      { name: 'offers' },
+      { name: 'orders' },
+      { name: 'products' },
+      { name: 'projects' },
+      { name: 'ratings' },
+      { name: 'realms' },
+      { name: 'reviews' },
+      { name: 'roles' },
+      { name: 'realmShards' },
+      { name: 'suggestions' },
+      { name: 'tags' },
+      { name: 'tokens' },
+      { name: 'tradeIdeas' },
+      { name: 'trades' },
+      { name: 'buyerTrades' },
+      { name: 'transactions' },
+      { name: 'votes' },
+      { name: 'payments' },
+      { name: 'permissions' },
+      { name: 'stats' },
+      { name: 'revisions' },
+      { name: 'comments' },
+      { name: 'interfaces' },
+      { name: 'characters' },
+      { name: 'metaverses' },
+      { name: 'omniverses' },
+      { name: 'referrals' },
+      { name: 'recipientReferrals' },
+      { name: 'senderReferrals' },
+      { name: 'chains' },
+      { name: 'characterAbilities' },
+      { name: 'tournaments' },
+      { name: 'teams' },
+      { name: 'items' },
+      { name: 'skills' },
+      { name: 'itemRecipes' },
+      { name: 'itemSkins' },
+      { name: 'stashes' },
+      { name: 'biomes' },
+      { name: 'planets' },
+      { name: 'solarSystems' },
+      { name: 'universes' },
+      { name: 'stars' },
+      { name: 'areas' },
+      { name: 'acts' },
+      { name: 'characterClasses' },
+      { name: 'characterFactions' },
+      { name: 'eras' },
+      { name: 'seasons' },
+      { name: 'itemAttributes' },
+      { name: 'itemMaterials' },
+      { name: 'itemSets' },
+      { name: 'itemSlots' },
+      { name: 'itemRarities' },
+      { name: 'itemTypes' },
+      { name: 'itemSubTypes' },
+      { name: 'itemSpecificTypes' },
+      { name: 'characterGenders' },
+      { name: 'characterRaces' },
+      { name: 'characterPersonalities' },
+      { name: 'characterTitles' },
+      { name: 'lores' },
+      { name: 'energies' },
+      { name: 'guides' },
+      { name: 'achievements' },
+      { name: 'games' },
+      { name: 'npcs' },
+      { name: 'characterAttributes' },
+      { name: 'characterTypes' },
+      { name: 'areaTypes' },
+      { name: 'areaLandmarks' },
+      { name: 'biomeFeatures' },
+      { name: 'skillMods' },
+      { name: 'skillClassifications' },
+      { name: 'skillConditions' },
+      { name: 'skillStatusEffects' },
+      { name: 'skillTrees' },
+      { name: 'skillTreeNodes' },
+      { name: 'areaNameChoices' },
+      { name: 'characterNameChoices' },
+      { name: 'validators' },
+      { name: 'productUpdates' },
+      { name: 'polls' },
+      { name: 'galaxies' },
+      { name: 'quests' },
+      { name: 'raffles' },
+      { name: 'raffleEntries' },
+      { name: 'raffleRequirements' },
+      { name: 'raffleRewards' },
+      { name: 'proposals' },
+      { name: 'companies' },
+      { name: 'people' },
+    ],
+  }
+);
+
+// Account Model
+export const Account = createModel<Types.AccountDocument>(
+  'Account',
+  {
+    username: { type: String },
+    email: { type: String },
+    address: { type: String },
+    addressIndex: { type: Number },
+    telegramUserId: { type: Number },
+    activeProfileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+    sessionUserId: { type: String },
+  },
+  {
+    indexes: [
+      // { applicationId: 1, username: 1, unique: true },
+      {
+        fields: { applicationId: 1, telegramUserId: 1 },
+        options: {
+          unique: true,
+          partialFilterExpression: { telegramUserId: { $exists: true } },
+        },
+      },
+    ],
+    virtuals: [
+      {
+        name: 'profiles',
+        ref: 'Profile',
+        localField: '_id',
+        foreignField: 'accountId',
+        justOne: false,
+      },
+      ...addTagVirtuals('Account'),
+      ...addApplicationVirtual(),
+    ],
+  }
+);
+
+// Achievement Model
+export const Achievement = createModel<Types.AchievementDocument>(
+  'Achievement',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Achievement'), ...addApplicationVirtual()],
+  }
+);
+
+// Act Model
+export const Act = createModel<Types.ActDocument>(
+  'Act',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Act'), ...addApplicationVirtual()],
+  }
+);
+
+// Agent Model
+export const Agent = createModel<Types.AgentDocument>(
+  'Agent',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Agent'), ...addApplicationVirtual()],
+  }
+);
+
+// Badge Model
+export const Badge = createModel<Types.BadgeDocument>(
+  'Badge',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Badge'), ...addApplicationVirtual()],
+  }
+);
+
+// BattlePass Model
+export const BattlePass = createModel<Types.BattlePassDocument>(
+  'BattlePass',
+  {},
+  {
+    virtuals: [...addTagVirtuals('BattlePass'), ...addApplicationVirtual()],
+  }
+);
+
+// Biome Model
+export const Biome = createModel<Types.BiomeDocument>(
+  'Biome',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Biome'), ...addApplicationVirtual()],
+  }
+);
+
+// BiomeFeature Model
+export const BiomeFeature = createModel<Types.BiomeFeatureDocument>(
+  'BiomeFeature',
+  {},
+  {
+    virtuals: [...addTagVirtuals('BiomeFeature'), ...addApplicationVirtual()],
+  }
+);
+
+// Bounty Model
+export const Bounty = createModel<Types.BountyDocument>(
+  'Bounty',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Bounty'), ...addApplicationVirtual()],
+  }
+);
+
+export const Counter = createModel<Types.CounterDocument>(
+  'Counter',
+  // @ts-ignore
+  { _id: { type: String, required: true }, seq: { type: Number, default: 0 } },
+  { versionKey: false, virtuals: [...addTagVirtuals('Counter'), ...addApplicationVirtual()] }
+);
+
+// Collection Model
+export const Collection = createModel<Types.CollectionDocument>(
+  'Collection',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Collection'), ...addApplicationVirtual()],
+  }
+);
+
+// Comment Model
+export const Comment = createModel<Types.CommentDocument>(
+  'Comment',
+  {
+    body: { type: String, required: true },
+    entity: { type: mongo.Schema.Types.ObjectId },
+    entityModel: { type: String },
+    text: { type: String },
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Comment'), ...addApplicationVirtual()],
+  }
+);
+
+// Community Model
+export const Community = createModel<Types.CommunityDocument>(
+  'Community',
+  {
+    ideas: [{ type: mongo.Schema.Types.ObjectId, ref: 'Idea' }],
+    products: [{ type: mongo.Schema.Types.ObjectId, ref: 'Product' }],
+    projects: [{ type: mongo.Schema.Types.ObjectId, ref: 'Project' }],
+  },
+  {
+    virtuals: [...addTagVirtuals('Community'), ...addApplicationVirtual()],
+  }
+);
+
+// Company Model
+export const Company = createModel<Types.CompanyDocument>(
+  'Company',
+  {
+    content: { type: String },
+    people: [{ type: mongo.Schema.Types.ObjectId, ref: 'Person' }],
+  },
+  {
+    virtuals: [...addTagVirtuals('Company'), ...addApplicationVirtual()],
+  }
+);
+
+// =========================
+// Conversation (Thread)
+// =========================
+//
+// Key points:
+// - "mailboxKey" gives you a stable unique identity for system inbox threads.
+// - Participants field-level index removed; indexes centralized below.
+// - lastMessageDate naming normalized.
+// - Back-compat messages[] kept, but consider disabling pushes or capping.
+//
+export const Conversation = createModel<Types.ConversationDocument>(
+  'Conversation',
+  {
+    // Back-compat: old "owner" thread (mailbox-style threads should set this)
+    profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', index: true },
+
+    // Mail/chat type
+    kind: {
+      type: String,
+      enum: ['mail', 'dm', 'group', 'support', 'system'],
+      default: 'mail',
+      index: true,
+    },
+
+    // Participants so the same model can do mail+discord-like threads
+    participants: [
+      {
+        profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+
+        role: { type: String, enum: ['user', 'system', 'gm', 'npc'], default: 'user' },
+
+        lastReadAt: { type: Date, default: new Date(0) },
+        unreadCount: { type: Number, default: 0 },
+
+        isMuted: { type: Boolean, default: false },
+        isPinned: { type: Boolean, default: false },
+        isArchived: { type: Boolean, default: false },
+        isDeleted: { type: Boolean, default: false },
+      },
+    ],
+
+    isLocked: { type: Boolean, default: true },
+    allowUserSend: { type: Boolean, default: false },
+
+    category: { type: String, default: 'system' },
+    importance: { type: Number, default: 0 },
+
+    // ✅ keep consistent with your service code (use lastMessageDate everywhere)
+    lastMessageDate: { type: Date, default: null, index: true },
+    lastMessagePreview: { type: String, default: '' },
+    messageCount: { type: Number, default: 0 },
+
+    // Back-compat only. Don’t rely on this for reads at scale.
+    messages: [{ type: mongo.Schema.Types.ObjectId, ref: 'ConversationMessage' }],
+  },
+  {
+    indexes: [
+      // Inbox list (participant mailbox / DMs / etc.)
+      { fields: { 'participants.profileId': 1, lastMessageDate: -1 } },
+
+      // Filtered by kind (mail tab, dm tab, etc.)
+      { fields: { kind: 1, 'participants.profileId': 1, lastMessageDate: -1 } },
+
+      // Back-compat owner mailbox queries
+      { fields: { profileId: 1, kind: 1, lastMessageDate: -1 } },
+      {
+        fields: { key: 1, profileId: 1 },
+        options: {
+          unique: true,
+          partialFilterExpression: { profileId: { $type: 'objectId' } },
+        },
+      },
+      {
+        fields: { kind: 1, profileId: 1 },
+        options: {
+          unique: true,
+          partialFilterExpression: { profileId: { $type: 'objectId' } },
+        },
+      },
+
+      {
+        fields: { applicationId: 1, kind: 1, profileId: 1, key: 1 },
+        options: {
+          unique: true,
+          partialFilterExpression: { key: { $type: 'string' } },
+        },
+      },
+    ],
+    virtuals: [...addTagVirtuals('Conversation'), ...addApplicationVirtual()],
+  }
+);
+
+// =========================
+// ConversationMessage (Message)
+// =========================
+//
+// Key points:
+// - Primary paging index is (conversationId, _id:-1).
+// - Claim fields use claimedDate consistently.
+// - Dedupe is per-conversation (compound) and unique when present.
+// - Claimable listing inside a conversation has a supporting index.
+//
+export const ConversationMessage = createModel<Types.ConversationMessageDocument>(
+  'ConversationMessage',
+  {
+    conversationId: { type: mongo.Schema.Types.ObjectId, ref: 'Conversation', required: true, index: true },
+
+    role: { type: String, enum: ['user', 'assistant', 'system'], required: true },
+
+    type: {
+      type: String,
+      enum: ['text', 'notice', 'reward', 'action', 'system'],
+      default: 'text',
+      index: true,
+    },
+
+    isStarred: { type: Boolean, default: false, index: true },
+
+    content: { type: String, default: '' },
+
+    payload: { type: mongo.Schema.Types.Mixed },
+
+    replyToId: { type: mongo.Schema.Types.ObjectId, ref: 'ConversationMessage' },
+
+    claim: {
+      isClaimable: { type: Boolean, default: false, index: true },
+
+      // ✅ normalized field names (match your latest applyPatchesOrMail.ts)
+      claimedDate: { type: Date, default: null },
+      claimedByProfileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', default: null },
+
+      dedupeKey: { type: String, default: null },
+
+      attachments: { type: [mongo.Schema.Types.Mixed], default: [] },
+
+      revokedDate: { type: Date, default: null },
+      revokeReason: { type: String, default: null },
+    },
+  },
+  {
+    indexes: [
+      // ✅ Primary paging for “latest messages”
+      { fields: { conversationId: 1, _id: -1 } },
+
+      // Optional (only if you actually sort by createdDate elsewhere)
+      { fields: { conversationId: 1, createdDate: -1 } },
+
+      // Claim listing scans (admin / analytics)
+      { fields: { 'claim.isClaimable': 1, 'claim.claimedDate': 1 } },
+
+      // Claim listing inside a conversation (UI list “claimable first”)
+      { fields: { conversationId: 1, 'claim.isClaimable': 1, 'claim.claimedDate': 1, _id: -1 } },
+
+      // Fast dedupe lookup per conversation
+      { fields: { conversationId: 1, 'claim.dedupeKey': 1 } },
+
+      // ✅ Enforce dedupeKey uniqueness per conversation when present
+      {
+        fields: { conversationId: 1, 'claim.dedupeKey': 1 },
+        options: {
+          unique: true,
+          partialFilterExpression: { 'claim.dedupeKey': { $type: 'string' } },
+        },
+      },
+
+      { fields: { isStarred: 1, conversationId: 1, _id: -1 } },
+    ],
+    virtuals: [...addTagVirtuals('ConversationMessage'), ...addApplicationVirtual()],
+  }
+);
+
+// Data Model
+export const Data = createModel<Types.DataDocument>(
+  'Data',
+  {
+    mod: { type: String, required: true },
+  },
+  {
+    virtuals: [...addTagVirtuals('Data'), ...addApplicationVirtual()],
+  }
+);
+
+export const Meta = createModel<Types.DataDocument>(
+  'Meta',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Meta'), ...addApplicationVirtual()],
+  }
+);
+
+// Discussion Model
+export const Discussion = createModel<Types.DiscussionDocument>(
+  'Discussion',
+  {
+    content: { type: String },
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Discussion' },
+    rootMessageId: { type: mongo.Schema.Types.ObjectId, ref: 'Message' },
+    type: { type: String, default: 'Discussion' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Discussion'), ...addApplicationVirtual()],
+  }
+);
+
+// Energy Model
+export const Energy = createModel<Types.EnergyDocument>(
+  'Energy',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Energy'), ...addApplicationVirtual()],
+  }
+);
+
+// Event Model
+export const Event = createModel<Types.EventDocument>(
+  'Event',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Event'), ...addApplicationVirtual()],
+  }
+);
+
+// File Model
+export const File = createModel<Types.FileDocument>(
+  'File',
+  {
+    content: { type: String },
+    storageType: { type: String, max: 100 },
+    accessType: { type: String, max: 100 },
+  },
+  {
+    virtuals: [...addTagVirtuals('File'), ...addApplicationVirtual()],
+  }
+);
+
+// Galaxy Model
+export const Galaxy = createModel<Types.GalaxyDocument>(
+  'Galaxy',
+  {
+    universeId: { type: mongo.Schema.Types.ObjectId, ref: 'Universe' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Galaxy'), ...addApplicationVirtual()],
+  }
+);
+
+// Guide Model
+export const Guide = createModel<Types.GuideDocument>(
+  'Guide',
+  {
+    content: { type: String },
+    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game' },
+    attachments: [mongo.Schema.Types.Mixed],
+  },
+  {
+    virtuals: [...addTagVirtuals('Guide'), ...addApplicationVirtual()],
+  }
+);
+
+// Idea Model
+export const Idea = createModel<Types.IdeaDocument>(
+  'Idea',
+  {
+    type: { type: String, max: 100 },
+    communityId: { type: mongo.Schema.Types.ObjectId, ref: 'Community' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Idea'), ...addApplicationVirtual()],
+  }
+);
+
+// Leaderboard Model
+export const Leaderboard = createModel<Types.LeaderboardDocument>(
+  'Leaderboard',
+  {
+    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Leaderboard'), ...addApplicationVirtual()],
+  }
+);
+
+// Log Model
+export const Log = createModel<Types.LogDocument>(
+  'Log',
+  {
+    mod: { type: String, required: true },
+    messages: [mongo.Schema.Types.Mixed],
+    // tags: [mongo.Schema.Types.Mixed],
+  },
+  {
+    virtuals: [...addTagVirtuals('Log'), ...addApplicationVirtual()],
+  }
+);
+
+// Lore Model
+export const Lore = createModel<Types.LoreDocument>(
+  'Lore',
+  {
+    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Lore'), ...addApplicationVirtual()],
+  }
+);
+
+// Market Model
+export const Market = createModel<Types.MarketDocument>(
+  'Market',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Market'), ...addApplicationVirtual()],
+  }
+);
+
+// Memory Model
+export const Memory = createModel<Types.MemoryDocument>(
+  'Memory',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Memory'), ...addApplicationVirtual()],
+  }
+);
+
+// Message Model
+export const Message = createModel<Types.MessageDocument>(
+  'Message',
+  {
+    content: { type: String },
+    type: { type: String, max: 100 },
+    replyToId: { type: mongo.Schema.Types.ObjectId, ref: 'Message' },
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Message' },
+    conversationId: { type: mongo.Schema.Types.ObjectId, ref: 'Conversation' },
+    // messages: [{ type: mongo.Schema.Types.ObjectId, ref: 'Message' }],
+  },
+  {
+    virtuals: [...addTagVirtuals('Message'), ...addApplicationVirtual()],
+  }
+);
+
+// NewsArticle Model
+export const NewsArticle = createModel<Types.NewsArticleDocument>(
+  'NewsArticle',
+  {
+    href: { type: String, required: true },
+    source: { type: String, required: true },
+  },
+  {
+    virtuals: [...addTagVirtuals('NewsArticle'), ...addApplicationVirtual()],
+  }
+);
+
+// Npc Model
+export const Npc = createModel<Types.NpcDocument>(
+  'Npc',
+  {
+    characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Npc'), ...addApplicationVirtual()],
+  }
+);
+
+// Offer Model
+export const Offer = createModel<Types.OfferDocument>(
+  'Offer',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Offer'), ...addApplicationVirtual()],
+  }
+);
+
+// Order Model
+export const Order = createModel<Types.OrderDocument>(
+  'Order',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Order'), ...addApplicationVirtual()],
+  }
+);
+
+// Payment Model
+export const Payment = createModel<Types.PaymentDocument>(
+  'Payment',
+  {
+    status: {
+      type: String,
+      default: 'Submitted',
+      enum: [
+        'Archived',
+        'Processing',
+        'Failed',
+        'Submitted',
+        'Denied',
+        'Processed',
+        'Voided',
+        'Completed',
+        'Refunding',
+        'Refunded',
+        'Expired',
+      ],
+    },
+  },
+  {
+    virtuals: [{ name: 'owner' }, ...addTagVirtuals('Payment'), ...addApplicationVirtual()],
+  }
+);
+
+// Permission Model
+export const Permission = createModel<Types.PermissionDocument>(
+  'Permission',
+  {
+    roles: [{ type: mongo.Schema.Types.ObjectId, ref: 'Role' }],
+  },
+  {
+    virtuals: [...addTagVirtuals('Permission'), ...addApplicationVirtual()],
+  }
+);
+
+// Person Model
+export const Person = createModel<Types.PersonDocument>(
+  'Person',
+  {
+    content: { type: String },
+    companyId: { type: mongo.Schema.Types.ObjectId, ref: 'Company' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Person'), ...addApplicationVirtual()],
+  }
+);
+
+// Planet Model
+export const Planet = createModel<Types.PlanetDocument>(
+  'Planet',
+  {
+    solarSystemId: { type: mongo.Schema.Types.ObjectId, ref: 'SolarSystem' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Planet'), ...addApplicationVirtual()],
+  }
+);
+
+// Poll Model
+export const Poll = createModel<Types.PollDocument>(
+  'Poll',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Poll'), ...addApplicationVirtual()],
+  }
+);
+
+// Project Model
+export const Project = createModel<Types.ProjectDocument>(
+  'Project',
+  {
+    content: { type: String },
+    contractStatus: { type: String, default: 'Pending' },
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Project' },
+    realmId: { type: mongo.Schema.Types.ObjectId, ref: 'Realm' },
+    communityId: { type: mongo.Schema.Types.ObjectId, ref: 'Community' },
+    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Project'), ...addApplicationVirtual()],
+  }
+);
+
+// Proposal Model
+export const Proposal = createModel<Types.ProposalDocument>(
+  'Proposal',
+  {
+    content: { type: String },
+  },
+  {
+    virtuals: [...addTagVirtuals('Proposal'), ...addApplicationVirtual()],
+  }
+);
+
+// Quest Model
+export const Quest = createModel<Types.QuestDocument>(
+  'Quest',
+  {
+    type: { type: String, default: 'zone' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Quest'), ...addApplicationVirtual()],
+  }
+);
+
+// Question Model
+export const Question = createModel<Types.QuestionDocument>(
+  'Question',
+  {
+    topics: [mongo.Schema.Types.Mixed],
+    text: { type: String, required: true },
+    answer: { type: String, required: true },
+    popularity: { type: Number },
+  },
+  {
+    virtuals: [...addTagVirtuals('Question'), ...addApplicationVirtual()],
+  }
+);
+
+// Rating Model
+export const Rating = createModel<Types.RatingDocument>(
+  'Rating',
+  {
+    votes: [{ type: mongo.Schema.Types.ObjectId, ref: 'Vote' }],
+  },
+  {
+    virtuals: [...addTagVirtuals('Rating'), ...addApplicationVirtual()],
+  }
+);
+
+// Realm Model
+export const Realm = createModel<Types.RealmDocument>(
+  'Realm',
+  {
+    endpoint: { type: String },
+    status: { type: String },
+    clientCount: { type: Number },
+    regionCode: { type: String },
+    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game', required: true },
+  },
+  {
+    virtuals: [
+      ...addTagVirtuals('Realm'),
+      ...addApplicationVirtual(),
+      { name: 'realmShards' },
+      { name: 'realmTraits' },
+      { name: 'realmEvents' },
+    ],
+  }
+);
+
+// RealmEvent Model
+export const RealmEvent = createModel<Types.RealmEventDocument>(
+  'RealmEvent',
+  {
+    description: { type: String, required: true },
+    startDate: { type: Date, required: false },
+    endDate: { type: Date, required: false },
+  },
+  {
+    virtuals: [...addTagVirtuals('RealmEvent'), ...addApplicationVirtual()],
+  }
+);
+
+// RealmTrait Model
+export const RealmTrait = createModel<Types.RealmTraitDocument>(
+  'RealmTrait',
+  {
+    description: { type: String, required: true },
+  },
+  {
+    virtuals: [...addTagVirtuals('RealmTrait'), ...addApplicationVirtual()],
+  }
+);
+
+// Referral Model
+export const Referral = createModel<Types.ReferralDocument>(
+  'Referral',
+  {
+    recipientId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+    senderId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+  },
+  {
+    virtuals: [...addTagVirtuals('Referral'), ...addApplicationVirtual()],
+  }
+);
+
+// Review Model
+export const Review = createModel<Types.ReviewDocument>(
+  'Review',
+  {
+    value: { type: String },
+  },
+  {
+    virtuals: [...addTagVirtuals('Review'), ...addApplicationVirtual()],
+  }
+);
+
+// Role Model
+export const Role = createModel<Types.RoleDocument>(
+  'Role',
+  {
+    value: { type: String },
+    profiles: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
+    permissions: [{ type: mongo.Schema.Types.ObjectId, ref: 'Permission' }],
+  },
+  {
+    virtuals: [...addTagVirtuals('Role'), ...addApplicationVirtual()],
+  }
+);
+
+// Season Model
+export const Season = createModel<Types.SeasonDocument>(
+  'Season',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Season'), ...addApplicationVirtual()],
+  }
+);
+
+// RealmShard Model
+export const RealmShard = createModel<Types.RealmShardDocument>(
+  'RealmShard',
+  {
+    realmId: { type: mongo.Schema.Types.ObjectId, ref: 'Realm' },
+    endpoint: { type: String },
+    status: { type: String },
+    clientCount: { type: Number },
+  },
+  {
+    virtuals: [...addTagVirtuals('RealmShard'), ...addApplicationVirtual()],
+  }
+);
+
+// Session Model
+export const Session = createModel<Types.SessionDocument>(
+  'Session',
+  {
+    expired: { type: Date, required: true },
+  },
+  {
+    virtuals: [...addTagVirtuals('Session'), ...addApplicationVirtual()],
+  }
+);
+
+// SolarSystem Model
+export const SolarSystem = createModel<Types.SolarSystemDocument>(
+  'SolarSystem',
+  {
+    galaxyId: { type: mongo.Schema.Types.ObjectId, ref: 'Galaxy' },
+  },
+  {
+    virtuals: [...addTagVirtuals('SolarSystem'), ...addApplicationVirtual()],
+  }
+);
+
+// Star Model
+export const Star = createModel<Types.StarDocument>(
+  'Star',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Star'), ...addApplicationVirtual()],
+  }
+);
+
+// Stat Model
+export const Stat = createModel<Types.StatDocument>(
+  'Stat',
+  {
+    number: { type: Number, default: 0 },
+  },
+  {
+    virtuals: [...addTagVirtuals('Stat'), ...addApplicationVirtual()],
+  }
+);
+
+// Stash Model
+export const Stash = createModel<Types.StashDocument>(
+  'Stash',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Stash'), ...addApplicationVirtual()],
+  }
+);
+
+// Stock Model
+export const Stock = createModel<Types.StockDocument>(
+  'Stock',
+  {
+    rank: { type: Number, min: 0 },
+    price: { type: Number, min: 0 },
+    hourChange: { type: Number },
+    dayChange: { type: Number },
+    weekChange: { type: Number },
+    marketCap: { type: Number, min: 0 },
+    volume: { type: Number, min: 0 },
+    ticker: { type: String },
+    unusualActivity: { type: Number, min: 0 },
+  },
+  {
+    virtuals: [...addTagVirtuals('Stock'), ...addApplicationVirtual()],
+  }
+);
+
+// Suggestion Model
+export const Suggestion = createModel<Types.SuggestionDocument>(
+  'Suggestion',
+  {
+    content: { type: String },
+  },
+  {
+    virtuals: [...addTagVirtuals('Suggestion'), ...addApplicationVirtual()],
+  }
+);
+
+// Tag Model
+export const Tag = createModel<Types.TagDocument>(
+  'Tag',
+  {
+    value: { type: String },
+  },
+  {
+    virtuals: [...addApplicationVirtual()],
+  }
+);
+
+// Team Model
+export const Team = createModel<Types.TeamDocument>(
+  'Team',
+  {
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+    points: { type: Number, default: 0 },
+    memberCount: { type: Number, default: 0 },
+  },
+  {
+    virtuals: [
+      ...addTagVirtuals('Team'),
+      ...addApplicationVirtual(),
+      {
+        name: 'profiles',
+        ref: 'Profile',
+        localField: '_id',
+        foreignField: 'teamId',
+      },
+    ],
+  }
+);
+
+// Tournament Model
+export const Tournament = createModel<Types.TournamentDocument>(
+  'Tournament',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Tournament'), ...addApplicationVirtual()],
+  }
+);
+
+// Trade Model
+export const Trade = createModel<Types.TradeDocument>(
+  'Trade',
+  {
+    status: {
+      type: String,
+      default: 'Active',
+      enum: ['Paused', 'Pending', 'Active', 'Delisted', 'Sold'],
+    },
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
+    buyerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Trade' },
+    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
+    sellerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+    tokenId: { type: mongo.Schema.Types.ObjectId, ref: 'ChainToken' },
+  },
+  {
+    virtuals: [...addTagVirtuals('Trade'), ...addApplicationVirtual()],
+  }
+);
+
+// Universe Model
+export const Universe = createModel<Types.UniverseDocument>(
+  'Universe',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Universe'), ...addApplicationVirtual()],
+  }
+);
+
+// Validator Model
+export const Validator = createModel<Types.ValidatorDocument>(
+  'Validator',
+  {},
+  {
+    virtuals: [...addTagVirtuals('Validator'), ...addApplicationVirtual()],
+  }
+);
+
+// Vote Model
+export const Vote = createModel<Types.VoteDocument>(
+  'Vote',
+  {
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+  },
+  {
+    virtuals: [
+      {
+        name: 'parent',
+        ref: 'Node',
+        localField: '_id',
+        foreignField: 'from',
+        justOne: true,
+        match: { fromModel: 'Vote' },
+      },
+      {
+        name: 'owner',
+        ref: 'Profile',
+        localField: '_id',
+        foreignField: '_id',
+        justOne: true,
+      },
+      ...addTagVirtuals('Vote'),
+      ...addApplicationVirtual(),
+    ],
+  }
+);
+
+// WorldEvent Model
+export const WorldEvent = createModel<Types.WorldEventDocument>(
+  'WorldEvent',
+  {
+    text: { type: String, required: true },
+    importance: { type: Number },
+    // tags: [mongo.Schema.Types.Mixed],
+  },
+  {
+    virtuals: [...addTagVirtuals('WorldEvent'), ...addApplicationVirtual()],
+  }
+);
+
+// WorldRecord Model
+export const WorldRecord = createModel<Types.WorldRecordDocument>(
+  'WorldRecord',
+  {
+    holderId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+    score: { type: Number },
+    // tags: [mongo.Schema.Types.Mixed],
+  },
+  {
+    virtuals: [
+      {
+        name: 'holder',
+        ref: 'Profile',
+        localField: '_id',
+        foreignField: '_id',
+        justOne: true,
+      },
+      ...addTagVirtuals('WorldRecord'),
+      ...addApplicationVirtual(),
+    ],
+  }
+);
+
+// Node Model (for polymorphic relationships)
+export const Node = createModel<Types.NodeDocument>(
+  'Node',
+  {
+    relationKey: { type: String, required: true },
+    fromModel: { type: String, required: true },
+    from: { type: mongo.Schema.Types.ObjectId, required: true },
+    toModel: { type: String, required: true },
+    to: { type: mongo.Schema.Types.ObjectId, required: true },
+  },
+  {
+    indexes: [
+      { fromModel: 1, from: 1 },
+      { toModel: 1, to: 1 },
+    ],
+  }
+);
+
+export const Prefab = createModel<Types.PrefabDocument>(
+  'Prefab',
+  {
+    name: { type: String, required: true },
+    fbxPath: { type: String, required: true },
+    customizationOptions: { type: mongo.Schema.Types.Mixed }, // e.g., color, scale range, etc.
+    childPrefabs: [
+      {
+        prefabId: { type: mongo.Schema.Types.ObjectId, ref: 'Prefab' },
+        position: { type: mongo.Schema.Types.Mixed }, // Relative position within parent prefab
+        rotation: { type: mongo.Schema.Types.Mixed },
+        scale: { type: Number, default: 1.0 },
+      },
+    ],
+  },
+  {
+    extend: 'EntityFields',
+    virtuals: [...addTagVirtuals('Prefab'), ...addApplicationVirtual()],
+  }
+);
+
+export const Object = createModel<Types.ObjectDocument>(
+  'Object',
+  {
+    prefabId: { type: mongo.Schema.Types.ObjectId, ref: 'Prefab', required: true },
+    // profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+    // worldCoordinates: {
+    //   x: { type: Number, required: true },
+    //   y: { type: Number, required: true },
+    //   z: { type: Number, required: true },
+    // },
+    rotation: { type: mongo.Schema.Types.Mixed },
+    scale: { type: Number, default: 1.0 },
+    customizations: { type: mongo.Schema.Types.Mixed },
+    childInstances: [
+      {
+        prefabId: { type: mongo.Schema.Types.ObjectId, ref: 'Prefab' },
+        worldCoordinates: { type: mongo.Schema.Types.Mixed },
+        rotation: { type: mongo.Schema.Types.Mixed },
+        scale: { type: Number, default: 1.0 },
+      },
+    ],
+  },
+  {
+    extend: 'EntityFields',
+    virtuals: [...addTagVirtuals('Object'), ...addApplicationVirtual()],
+  }
+);
+
+export const ObjectInteraction = createModel<Types.ObjectInteractionDocument>(
+  'ObjectInteraction',
+  {
+    profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+    objectId: { type: mongo.Schema.Types.ObjectId, ref: 'Object', required: true },
+    interactionType: { type: String, enum: ['use', 'fight', 'open', 'talk'], required: true },
+    outcome: { type: mongo.Schema.Types.Mixed },
+    // timestamp: { type: Date, default: Date.now },
+  },
+  {
+    extend: 'EntityFields',
+    virtuals: [...addTagVirtuals('Interaction'), ...addApplicationVirtual()],
+  }
+);
+
+// Party Model
+export const Party = createModel<Types.PartyDocument>(
+  'Party',
+  {
+    targetAreaId: { type: mongo.Schema.Types.ObjectId, ref: 'Area', required: false }, // Adjust 'Area' to actual collection if known
+    limit: { type: Number, default: 6 },
+    isPublic: { type: Boolean, default: true },
+    isVisibleToEnemies: { type: Boolean, default: true },
+    isApprovalRequired: { type: Boolean, default: false },
+    isNonLeaderInviteAllowed: { type: Boolean, default: false },
+    isCombatEnabled: { type: Boolean, default: true },
+    isFriendlyFireEnabled: { type: Boolean, default: true },
+    isLocalQuestShared: { type: Boolean, default: true },
+    isGlobalQuestShared: { type: Boolean, default: true },
+    isMergeEnabled: { type: Boolean, default: false },
+    isRejoinEnabled: { type: Boolean, default: false },
+    itemDistribution: {
+      type: String,
+      enum: ['Random', 'Personal'],
+      required: true,
+    },
+    leaderId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: false }, // Adjust 'Profile' to actual collection if known
+    powerRequired: { type: Number, required: true, default: 1 },
+    levelRequired: { type: Number, required: true, default: 1 },
+    approvalMethod: {
+      type: String,
+      enum: ['Auto Accept', 'Approval Required'],
+      required: true,
+    },
+    memberIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }], // Adjust 'Profile' if necessary
+    assistantIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
+    pendingMemberIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
+    blockedMemberIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
+  },
+  {
+    virtuals: [
+      { name: 'owner' },
+      {
+        name: 'members',
+        ref: 'Profile',
+        localField: '_id',
+        foreignField: 'partyId',
+      },
+      ...addTagVirtuals('Party'),
+      ...addApplicationVirtual(),
+    ],
+  }
+);
+
+export const SeerEvent = mongo.createModel<Types.SeerEventDocument>(
+  'SeerEvent',
+  {
+    kind: { type: String, required: true }, // model name: 'Character', 'Item', etc.
+    operation: {
+      type: String,
+      enum: ['create', 'update', 'delete'],
+      required: true,
+    },
+    recordId: { type: String, required: true },
+    applicationId: { type: mongo.Schema.Types.ObjectId, ref: 'Application' },
+
+    // ✅ this is the important fix: schema *object* with `type: Mixed`
+    payload: { type: mongo.Schema.Types.Mixed, required: true },
+
+    seq: { type: Number, required: true, index: true },
+    timestamp: { type: Date, default: Date.now, index: true },
+  },
+  {
+    // extend: 'CommonFields', // or 'EntityFields' if you want applicationId/ownerId, but you already have applicationId above
+    indexes: [{ seq: 1 }, { timestamp: 1 }],
+  }
+);
+
+export const SeerPayload = mongo.createModel<Types.SeerPayloadDocument>(
+  'SeerPayload',
+  {
+    fromSeer: { type: String, required: true },
+    applicationId: { type: mongo.Schema.Types.ObjectId, ref: 'Application' },
+
+    // list of raw events we snapshot
+    // TS doesn't love `[Mixed]`, so we cast this field only
+    events: {
+      type: [mongo.Schema.Types.Mixed],
+      default: [],
+    } as any,
+
+    eventsHash: { type: String, required: true },
+    merkleRoot: { type: String, required: true },
+
+    proof: { type: mongo.Schema.Types.Mixed, required: true },
+    publicSignals: { type: [String], default: [] },
+  },
+  {
+    // extend: 'CommonFields',
+    indexes: [{ createdDate: 1 }],
+  }
+);