@arken/seer-protocol 0.1.1 → 0.1.2

package/core/core.types.ts

@@ -0,0 +1,340 @@
+// core.types.ts
+
+import { z } from 'zod';
+import { HydratedDocument } from 'mongoose';
+import * as schema from './core.schema';
+import { Document, Model } from '../../util/mongo';
+
+// Export types from other modules if necessary
+export type * from './core.router';
+export type * from './core.service';
+export type { RouterContext } from '../../types';
+
+export type MerkleTree = z.infer<typeof schema.MerkleTree>;
+export type MerkleTreeDocument = MerkleTree & Document;
+
+export type MerkleNode = z.infer<typeof schema.MerkleNode>;
+export type MerkleNodeDocument = MerkleNode & Document;
+
+// Define all core types from schemas
+export type Account = z.infer<typeof schema.Account>;
+export type AccountDocument = Account & Document;
+
+export type Achievement = z.infer<typeof schema.Achievement>;
+export type AchievementDocument = Achievement & Document;
+
+export type Act = z.infer<typeof schema.Act>;
+export type ActDocument = Act & Document;
+
+export type Agent = z.infer<typeof schema.Agent>;
+export type AgentDocument = Agent & Document;
+
+export type Application = z.infer<typeof schema.Application>;
+export type ApplicationDocument = Application & Document;
+
+export type Badge = z.infer<typeof schema.Badge>;
+export type BadgeDocument = Badge & Document;
+
+export type BattlePass = z.infer<typeof schema.BattlePass>;
+export type BattlePassDocument = BattlePass & Document;
+
+export type Biome = z.infer<typeof schema.Biome>;
+export type BiomeDocument = Biome & Document;
+
+export type BiomeFeature = z.infer<typeof schema.BiomeFeature>;
+export type BiomeFeatureDocument = BiomeFeature & Document;
+
+export type Bounty = z.infer<typeof schema.Bounty>;
+export type BountyDocument = Bounty & Document;
+
+export type Counter = z.infer<typeof schema.Counter>;
+export type CounterDocument = Counter & Document;
+
+export type Collection = z.infer<typeof schema.Collection>;
+export type CollectionDocument = Collection & Document;
+
+export type Comment = z.infer<typeof schema.Comment>;
+export type CommentDocument = Comment & Document;
+
+export type Community = z.infer<typeof schema.Community>;
+export type CommunityDocument = Community & Document;
+
+export type Company = z.infer<typeof schema.Company>;
+export type CompanyDocument = Company & Document;
+
+export type Conversation = z.infer<typeof schema.Conversation>;
+export type ConversationDocument = Conversation & Document;
+
+export type ConversationMessage = z.infer<typeof schema.ConversationMessage>;
+export type ConversationMessageDocument = ConversationMessage & Document;
+
+export type Data = z.infer<typeof schema.Data>;
+export type DataDocument = Data & Document;
+
+export type Meta = z.infer<typeof schema.Meta>;
+export type MetaDocument = Meta & Document;
+
+export type Discussion = z.infer<typeof schema.Discussion>;
+export type DiscussionDocument = Discussion & Document;
+
+export type Energy = z.infer<typeof schema.Energy>;
+export type EnergyDocument = Energy & Document;
+
+export type Event = z.infer<typeof schema.Event>;
+export type EventDocument = Event & Document;
+
+export type File = z.infer<typeof schema.File>;
+export type FileDocument = File & Document;
+
+export type Galaxy = z.infer<typeof schema.Galaxy>;
+export type GalaxyDocument = Galaxy & Document;
+
+export type Guide = z.infer<typeof schema.Guide>;
+export type GuideDocument = Guide & Document;
+
+export type Idea = z.infer<typeof schema.Idea>;
+export type IdeaDocument = Idea & Document;
+
+export type Leaderboard = z.infer<typeof schema.Leaderboard>;
+export type LeaderboardDocument = Leaderboard & Document;
+
+export type Log = z.infer<typeof schema.Log>;
+export type LogDocument = Log & Document;
+
+export type Lore = z.infer<typeof schema.Lore>;
+export type LoreDocument = Lore & Document;
+
+export type Market = z.infer<typeof schema.Market>;
+export type MarketDocument = Market & Document;
+
+export type Memory = z.infer<typeof schema.Memory>;
+export type MemoryDocument = Memory & Document;
+
+export type Message = z.infer<typeof schema.Message>;
+export type MessageDocument = Message & Document;
+
+export type Metaverse = z.infer<typeof schema.Metaverse>;
+export type MetaverseDocument = Metaverse & Document;
+
+export type NewsArticle = z.infer<typeof schema.NewsArticle>;
+export type NewsArticleDocument = NewsArticle & Document;
+
+export type Npc = z.infer<typeof schema.Npc>;
+export type NpcDocument = Npc & Document;
+
+export type Offer = z.infer<typeof schema.Offer>;
+export type OfferDocument = Offer & Document;
+
+export type Omniverse = z.infer<typeof schema.Omniverse>;
+export type OmniverseDocument = Omniverse & Document;
+
+export type Order = z.infer<typeof schema.Order>;
+export type OrderDocument = Order & Document;
+
+export type Party = z.infer<typeof schema.Party>;
+export type PartyDocument = Party & Document;
+
+export type Payment = z.infer<typeof schema.Payment>;
+export type PaymentDocument = HydratedDocument<Payment>;
+
+export type Permission = z.infer<typeof schema.Permission>;
+export type PermissionDocument = Permission & Document;
+
+export type Person = z.infer<typeof schema.Person>;
+export type PersonDocument = Person & Document;
+
+export type Planet = z.infer<typeof schema.Planet>;
+export type PlanetDocument = Planet & Document;
+
+export type Poll = z.infer<typeof schema.Poll>;
+export type PollDocument = Poll & Document;
+
+export type Project = z.infer<typeof schema.Project>;
+export type ProjectDocument = Project & Document;
+
+export type Proposal = z.infer<typeof schema.Proposal>;
+export type ProposalDocument = Proposal & Document;
+
+export type Quest = z.infer<typeof schema.Quest>;
+export type QuestDocument = Quest & Document;
+
+export type Question = z.infer<typeof schema.Question>;
+export type QuestionDocument = Question & Document;
+
+export type Rating = z.infer<typeof schema.Rating>;
+export type RatingDocument = Rating & Document;
+
+export type Realm = z.infer<typeof schema.Realm>;
+export type RealmDocument = Realm & Document;
+
+export type RealmEvent = z.infer<typeof schema.RealmEvent>;
+export type RealmEventDocument = RealmEvent & Document;
+
+export type RealmShard = z.infer<typeof schema.RealmShard>;
+export type RealmShardDocument = RealmShard & Document;
+
+export type RealmTrait = z.infer<typeof schema.RealmTrait>;
+export type RealmTraitDocument = RealmTrait & Document;
+
+export type Revision = z.infer<typeof schema.Revision>;
+export type RevisionDocument = Revision & Document;
+
+export type Referral = z.infer<typeof schema.Referral>;
+export type ReferralDocument = Referral & Document;
+
+export type Review = z.infer<typeof schema.Review>;
+export type ReviewDocument = Review & Document;
+
+export type Role = z.infer<typeof schema.Role>;
+export type RoleDocument = Role & Document;
+
+export type Season = z.infer<typeof schema.Season>;
+export type SeasonDocument = Season & Document;
+
+export type Session = z.infer<typeof schema.Session>;
+export type SessionDocument = Session & Document;
+
+export type SolarSystem = z.infer<typeof schema.SolarSystem>;
+export type SolarSystemDocument = SolarSystem & Document;
+
+export type Star = z.infer<typeof schema.Star>;
+export type StarDocument = Star & Document;
+
+export type Stat = z.infer<typeof schema.Stat>;
+export type StatDocument = Stat & Document;
+
+export type Stash = z.infer<typeof schema.Stash>;
+export type StashDocument = Stash & Document;
+
+export type Stock = z.infer<typeof schema.Stock>;
+export type StockDocument = Stock & Document;
+
+export type Suggestion = z.infer<typeof schema.Suggestion>;
+export type SuggestionDocument = Suggestion & Document;
+
+export type Tag = z.infer<typeof schema.Tag>;
+export type TagDocument = Tag & Document;
+
+export type Team = z.infer<typeof schema.Team>;
+export type TeamDocument = Team & Document;
+
+export type Tournament = z.infer<typeof schema.Tournament>;
+export type TournamentDocument = Tournament & Document;
+
+export type Trade = z.infer<typeof schema.Trade>;
+export type TradeDocument = Trade & Document;
+
+export type Universe = z.infer<typeof schema.Universe>;
+export type UniverseDocument = Universe & Document;
+
+export type Validator = z.infer<typeof schema.Validator>;
+export type ValidatorDocument = Validator & Document;
+
+export type Vote = z.infer<typeof schema.Vote>;
+export type VoteDocument = Vote & Document;
+
+export type WorldEvent = z.infer<typeof schema.WorldEvent>;
+export type WorldEventDocument = WorldEvent & Document;
+
+export type WorldRecord = z.infer<typeof schema.WorldRecord>;
+export type WorldRecordDocument = WorldRecord & Document;
+
+export type Node = z.infer<typeof schema.Node>;
+export type NodeDocument = Node & Document;
+
+export type Prefab = z.infer<typeof schema.Prefab>;
+export type PrefabDocument = Prefab & Document;
+
+export type Object = z.infer<typeof schema.Object>;
+export type ObjectDocument = Object & Document;
+
+export type ObjectInteraction = z.infer<typeof schema.ObjectInteraction>;
+export type ObjectInteractionDocument = ObjectInteraction & Document;
+
+export type SeerEvent = z.infer<typeof schema.SeerEvent>;
+export type SeerEventDocument = SeerEvent & Document;
+
+export type SeerPayload = z.infer<typeof schema.SeerPayload>;
+export type SeerPayloadDocument = SeerPayload & Document;
+
+// Define model mappings
+export type Mappings = {
+  Account: Model<AccountDocument>;
+  Achievement: Model<AchievementDocument>;
+  Act: Model<ActDocument>;
+  Agent: Model<AgentDocument>;
+  Application: Model<ApplicationDocument>;
+  Badge: Model<BadgeDocument>;
+  BattlePass: Model<BattlePassDocument>;
+  Biome: Model<BiomeDocument>;
+  BiomeFeature: Model<BiomeFeatureDocument>;
+  Bounty: Model<BountyDocument>;
+  Counter: Model<CounterDocument>;
+  Collection: Model<CollectionDocument>;
+  Comment: Model<CommentDocument>;
+  Community: Model<CommunityDocument>;
+  Company: Model<CompanyDocument>;
+  Conversation: Model<ConversationDocument>;
+  ConversationMessage: Model<ConversationMessageDocument>;
+  Data: Model<DataDocument>;
+  Discussion: Model<DiscussionDocument>;
+  Energy: Model<EnergyDocument>;
+  Event: Model<EventDocument>;
+  File: Model<FileDocument>;
+  Galaxy: Model<GalaxyDocument>;
+  Guide: Model<GuideDocument>;
+  Idea: Model<IdeaDocument>;
+  Leaderboard: Model<LeaderboardDocument>;
+  Log: Model<LogDocument>;
+  Lore: Model<LoreDocument>;
+  Market: Model<MarketDocument>;
+  Memory: Model<MemoryDocument>;
+  Message: Model<MessageDocument>;
+  Metaverse: Model<MetaverseDocument>;
+  NewsArticle: Model<NewsArticleDocument>;
+  Npc: Model<NpcDocument>;
+  Object: Model<ObjectDocument>;
+  ObjectInteraction: Model<ObjectInteractionDocument>;
+  Offer: Model<OfferDocument>;
+  Omniverse: Model<OmniverseDocument>;
+  Order: Model<OrderDocument>;
+  Payment: Model<PaymentDocument>;
+  Party: Model<PartyDocument>;
+  Permission: Model<PermissionDocument>;
+  Person: Model<PersonDocument>;
+  Planet: Model<PlanetDocument>;
+  Poll: Model<PollDocument>;
+  Prefab: Model<PrefabDocument>;
+  Project: Model<ProjectDocument>;
+  Proposal: Model<ProposalDocument>;
+  Quest: Model<QuestDocument>;
+  Question: Model<QuestionDocument>;
+  Rating: Model<RatingDocument>;
+  Realm: Model<RealmDocument>;
+  RealmEvent: Model<RealmEventDocument>;
+  RealmShard: Model<RealmShardDocument>;
+  Revision: Model<RevisionDocument>;
+  Referral: Model<ReferralDocument>;
+  Review: Model<ReviewDocument>;
+  Role: Model<RoleDocument>;
+  Season: Model<SeasonDocument>;
+  SeerEvent: Model<SeerEventDocument>;
+  SeerPayload: Model<SeerPayloadDocument>;
+  Session: Model<SessionDocument>;
+  SolarSystem: Model<SolarSystemDocument>;
+  Star: Model<StarDocument>;
+  Stat: Model<StatDocument>;
+  Stash: Model<StashDocument>;
+  Stock: Model<StockDocument>;
+  Suggestion: Model<SuggestionDocument>;
+  Tag: Model<TagDocument>;
+  Team: Model<TeamDocument>;
+  Tournament: Model<TournamentDocument>;
+  Trade: Model<TradeDocument>;
+  Universe: Model<UniverseDocument>;
+  Validator: Model<ValidatorDocument>;
+  Vote: Model<VoteDocument>;
+  WorldEvent: Model<WorldEventDocument>;
+  WorldRecord: Model<WorldRecordDocument>;
+  Node: Model<NodeDocument>; // Added Node model mapping
+};

package/core/index.ts

@@ -0,0 +1,5 @@
+export * as Types from './core.types';
+export * as Models from './core.models';
+export * as Schemas from './core.schema';
+export * from './core.router';
+export * from './core.service';

package/evolution/evolution.models.ts

@@ -1,3 +1,3 @@
-import * as mongo from '@arken/mongo';
+import * as mongo from '@arken/node/mongo';
 
 const { addTagVirtuals, addApplicationVirtual } = mongo;

package/evolution/evolution.router.ts

@@ -1,8 +1,8 @@
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
 import * as Arken from '@arken/node';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/schema';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
 import { RouterContext } from '../../types';
 
 export const z = zod;
@@ -1406,20 +1406,20 @@ export type RouterOutput = inferRouterOutputs<Router>;
 //     }
 //   });
 
-// import type * as Arken from '@arken/types';
-// import { isDebug, log } from '@arken/util';
+// import type * as Arken from '@arken/node/types';
+// import { isDebug, log } from '@arken/node/util';
 // import * as dotenv from 'dotenv';
-// import { catchExceptions, subProcesses } from '@arken/process';
+// import { catchExceptions, subProcesses } from '@arken/node/process';
 // import fetch from 'node-fetch';
 
 // import path from 'path';
 // import jetpack, { find } from 'fs-jetpack';
 // import beautify from 'json-beautify';
-// import { fancyTimeFormat } from '@arken/time';
+// import { fancyTimeFormat } from '@arken/node/time';
 // import md5 from 'js-md5';
 // import { getClientSocket } from '@arken/websocket';
-// import { isValidRequest, getSignedRequest } from '@arken/web3';
-// import getUsername from '@arken/legacy/getOldUsername';
+// import { isValidRequest, getSignedRequest } from '@arken/node/web3';
+// import getUsername from '@arken/node/legacy/getOldUsername';
 // import { z } from 'zod';
 
 // export async function monitorEvolutionRealms(app) {}

package/evolution/evolution.schema.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/evolution/evolution.types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Model, Document } from '@arken/mongo';
+import { Model, Document } from '@arken/node/mongo';
 import * as schema from './evolution.schema';
 
 export type * from './evolution.router';

package/game/game.models.ts

@@ -0,0 +1,53 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './game.types';
+
+const { addTagVirtuals, addApplicationVirtual } = mongo;
+
+export const Game = mongo.createModel<Types.GameDocument>(
+  'Game',
+  {
+    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product', required: true },
+    statId: { type: mongo.Schema.Types.ObjectId, ref: 'GameStat' },
+  },
+  {
+    extend: 'EntityFields',
+    indexes: [{ applicationId: 1, name: 1, unique: true }],
+    virtuals: [
+      ...addTagVirtuals('Application'),
+      { name: 'stat' },
+      { name: 'stats', ref: 'GameStat', localField: '_id', foreignField: 'gameId' },
+      { name: 'rounds', ref: 'GameRound', localField: '_id', foreignField: 'gameId' },
+      // {
+      //   name: 'latestStat',
+      //   ref: 'GameStat',
+      //   localField: '_id',
+      //   foreignField: 'gameId',
+      //   options: { sort: { createdAt: -1 }, limit: 1 },
+      // },
+    ],
+  }
+);
+
+export const GameStat = mongo.createModel<Types.GameStatDocument>(
+  'GameStat',
+  {
+    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game', required: true },
+  },
+  {
+    extend: 'EntityFields',
+    virtuals: [...addTagVirtuals('Application'), { name: 'game' }],
+  }
+);
+
+export const GameRound = mongo.createModel<Types.GameRoundDocument>(
+  'GameRound',
+  {
+    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game', required: true },
+  },
+  {
+    extend: 'EntityFields',
+    virtuals: [...addTagVirtuals('Application'), { name: 'game' }],
+  }
+);
+
+export const Era = mongo.createModel<Types.EraDocument>('Era', {});

package/game/game.router.ts

@@ -0,0 +1,110 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '../../util/rpc';
+import type { RouterContext } from '../../types';
+import { Era, Game, GameStat } from './game.schema';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '../../schema';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    getGame: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Game))
+      .output(Game)
+      .query(({ input, ctx }) => (ctx.app.service.Game.getGame as any)(input, ctx)),
+
+    getGames: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Game))
+      .output(z.array(Game))
+      .query(({ input, ctx }) => (ctx.app.service.Game.getGames as any)(input, ctx)),
+
+    createGame: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Game))
+      .output(Game.pick({ id: true }))
+      .query(({ input, ctx }) => (ctx.app.service.Game.createGame as any)(input, ctx)),
+
+    updateGame: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Game))
+      .output(Game.pick({ id: true }))
+      .query(({ input, ctx }) => (ctx.app.service.Game.updateGame as any)(input, ctx)),
+
+    getGameStat: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(GameStat))
+      .output(GameStat)
+      .query(({ input, ctx }) => (ctx.app.service.Game.getGameStat as any)(input, ctx)),
+
+    getGameStats: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(GameStat))
+      .output(z.array(GameStat))
+      .query(({ input, ctx }) => (ctx.app.service.Game.getGameStats as any)(input, ctx)),
+
+    createGameStat: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(GameStat))
+      .output(GameStat.pick({ id: true }))
+      .query(({ input, ctx }) => (ctx.app.service.Game.createGameStat as any)(input, ctx)),
+
+    updateGameStat: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(GameStat))
+      .output(GameStat.pick({ id: true }))
+      .query(({ input, ctx }) => (ctx.app.service.Game.updateGame as any)(input, ctx)),
+
+    // Era Procedures
+    getEra: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Era))
+      .output(Era)
+      .query(({ input, ctx }) => (ctx.app.service.Game.getEra as any)(input, ctx)),
+
+    getEras: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Era))
+      .output(z.array(Era))
+      .query(({ input, ctx }) => (ctx.app.service.Game.getEras as any)(input, ctx)),
+
+    createEra: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Era))
+      .output(Era.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Game.createEra as any)(input, ctx)),
+
+    updateEra: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Era))
+      .output(Era.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Game.updateEra as any)(input, ctx)),
+
+    deleteEra: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Era))
+      .output(Era.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Game.deleteEra as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/game/game.schema.ts

@@ -0,0 +1,23 @@
+import { z, ObjectId, Entity } from '../../schema';
+
+export const GameStat = Entity.merge(
+  z.object({
+    gameId: ObjectId,
+  })
+);
+
+export const Game = Entity.merge(
+  z.object({
+    productId: ObjectId,
+    statId: ObjectId.optional(),
+    stat: GameStat.nullable().optional(),
+  })
+);
+
+export const GameRound = Entity.merge(
+  z.object({
+    gameId: ObjectId,
+  })
+);
+
+export const Era = Entity.merge(z.object({}));

package/game/game.types.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { Model, Document } from '../../util/mongo';
+import * as schema from './game.schema';
+
+export type * from './game.router';
+export type * from './game.service';
+export type { RouterContext } from '../../types';
+
+// Define types based on the schema
+export type Game = z.infer<typeof schema.Game>;
+export type GameDocument = Game & Document;
+
+export type GameStat = z.infer<typeof schema.GameStat>;
+export type GameStatDocument = GameStat & Document;
+
+export type GameRound = z.infer<typeof schema.GameRound>;
+export type GameRoundDocument = GameRound & Document;
+
+export type Era = z.infer<typeof schema.Era>;
+export type EraDocument = Era & Document;
+
+// Mappings for MongoDB models
+export type Mappings = {
+  Game: Model<GameDocument>;
+  GameStat: Model<GameStatDocument>;
+  GameRound: Model<GameRoundDocument>;
+  Era: Model<EraDocument>;
+};

package/game/index.ts

@@ -0,0 +1,5 @@
+export type * as Types from './game.types';
+export * as Models from './game.models';
+export * as Schemas from './game.schema';
+export * from './game.router';
+export * from './game.service';

package/index.ts

@@ -1,9 +1,46 @@
-import type * as Arken from '@arken/types';
+import type * as Arken from '@arken/node/types';
 import * as dotenv from 'dotenv';
-import * as Schema from '@arken/schema';
+import * as Schema from '@arken/node/schema';
 import { createRouter as createRouter2 } from './router';
 import type * as Types from './types';
 
+// Imports
+import * as Area from './modules/area';
+import * as Asset from './modules/asset';
+import * as Chain from './modules/chain';
+import * as Character from './modules/character';
+import * as Chat from './modules/chat';
+import * as Collection from './modules/collection';
+import * as Core from './modules/core';
+import * as Game from './modules/game';
+import * as Interface from './modules/interface';
+import * as Item from './modules/item';
+import * as Job from './modules/job';
+import * as Market from './modules/market';
+import * as Product from './modules/product';
+import * as Profile from './modules/profile';
+import * as Raffle from './modules/raffle';
+import * as Skill from './modules/skill';
+import * as Video from './modules/video';
+
+// Exports
+export * as Area from './modules/asrea';
+export * as Asset from './modules/asset';
+export * as Chain from './modules/chain';
+export * as Character from './modules/character';
+export * as Chat from './modules/chat';
+export * as Collection from './modules/collection';
+export * as Core from './modules/core';
+export * as Game from './modules/game';
+export * as Interface from './modules/interface';
+export * as Item from './modules/item';
+export * as Job from './modules/job';
+export * as Market from './modules/market';
+export * as Product from './modules/product';
+export * as Profile from './modules/profile';
+export * as Raffle from './modules/raffle';
+export * as Skill from './modules/skill';
+export * as Video from './modules/video';
 export * as Trek from './modules/trek';
 export * as Evolution from './modules/evolution';
 export * as Infinite from './modules/infinite';

package/infinite/infinite.models.ts

@@ -1,3 +1,3 @@
-import * as mongo from '@arken/mongo';
+import * as mongo from '@arken/node/mongo';
 
 const { addTagVirtuals, addApplicationVirtual } = mongo;