@arken/seer-protocol 0.1.1 → 0.1.3

package/profile/profile.router.ts

@@ -0,0 +1,72 @@
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Profile } from './profile.schema';
+import { Query, getQueryInput, getQueryOutput, inferRouterOutputs } 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({
+    setProfileMode: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(z.string())
+      .mutation(({ input, ctx }) => (ctx.app.service.Profile.setProfileMode as any)(input, ctx)),
+
+    // Profile endpoints
+    me: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      // .output(Profile.partial())
+      .query(({ input, ctx }) => (ctx.app.service.Profile.me as any)(input, ctx)),
+
+    // Profile endpoints
+    getProfile: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Profile))
+      // .output(Profile.partial())
+      .query(({ input, ctx }) => (ctx.app.service.Profile.getProfile as any)(input, ctx)),
+
+    getProfiles: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Profile))
+      .output(z.array(Profile))
+      .query(({ input, ctx }) => (ctx.app.service.Profile.getProfiles as any)(input, ctx)),
+
+    createProfile: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Profile))
+      .output(Profile.partial())
+      .mutation(({ input, ctx }) => (ctx.app.service.Profile.createProfile as any)(input, ctx)),
+
+    updateProfile: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Profile))
+      .output(Profile.partial())
+      .mutation(({ input, ctx }) => (ctx.app.service.Profile.updateProfile as any)(input, ctx)),
+
+    getProfileStats: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Profile.getProfileStats as any)(input, ctx)),
+
+    updateProfileSettings: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, settings: Profile.shape.settings }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Profile.updateProfileSettings as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/profile/profile.schema.ts

@@ -0,0 +1,219 @@
+// profile.schema.ts
+//
+import { z, ObjectId, Entity } from '../schema';
+import { Character } from '../character/character.schema';
+import { Achievement, Badge } from '../core/core.schema';
+
+const RankingStatSchema = z.object({
+  total: z.number(),
+  position: z.number(),
+});
+
+// Define the Ranking schema
+const RankingSchema = z.object({
+  orbs: RankingStatSchema,
+  wins: RankingStatSchema,
+  kills: RankingStatSchema,
+  deaths: RankingStatSchema,
+  points: RankingStatSchema,
+  rounds: RankingStatSchema,
+  evolves: RankingStatSchema,
+  rewards: RankingStatSchema,
+  powerups: RankingStatSchema,
+  revenges: RankingStatSchema,
+  winRatio: RankingStatSchema,
+  timeSpent: RankingStatSchema,
+  averageLatency: RankingStatSchema,
+  killDeathRatio: RankingStatSchema,
+  roundPointRatio: RankingStatSchema,
+});
+
+const ServerDataSchema = z.object({
+  orbs: z.number().optional(),
+  wins: z.number().optional(),
+  kills: z.number().optional(),
+  deaths: z.number().optional(),
+  points: z.number().optional(),
+  rounds: z.number().optional(),
+  evolves: z.number().optional(),
+  ranking: RankingSchema.optional(),
+  rewards: z.number().optional(),
+  earnings: z.number().optional(),
+  powerups: z.number().optional(),
+  revenges: z.number().optional(),
+  winRatio: z.number().optional(),
+  timeSpent: z.number().optional(),
+  winStreak: z.number().optional(),
+  averageLatency: z
+    .number()
+    .nullable()
+    .optional(),
+  killDeathRatio: z.number().optional(),
+  roundPointRatio: z.number().optional(),
+});
+
+// Profile schema for a user on a digital game platform
+export const Profile = Entity.merge(
+  z.object({
+    accountId: ObjectId.optional(), // TODO; fix?
+    partyId: ObjectId.optional(),
+    points: z.number().optional(),
+    // currency: z.number().optional(),
+    telegramUserId: z.number().optional(),
+    interactions: z.number().default(0),
+    activityRating: z.number().default(0),
+    address: z
+      .string()
+      .max(100)
+      .optional(),
+    avatar: z
+      .string()
+      .max(100)
+      .optional(),
+    roleId: ObjectId.optional(),
+    privateKey: z
+      .string()
+      .max(300)
+      .optional(),
+    signature: z
+      .string()
+      .max(200)
+      .optional(),
+    chainId: ObjectId.optional(),
+    teamId: ObjectId.optional(),
+    characterId: ObjectId.optional(),
+    isBanned: z.boolean().optional(),
+    banExpireDate: z.date().optional(),
+    banReason: z.string().optional(),
+    mode: z
+      .string()
+      .default('gamer')
+      .optional(),
+
+    bio: z.string().optional(),
+    banner: z
+      .string()
+      .url()
+      .optional(), // URL to the user's banner image
+    friends: z
+      .array(
+        z.object({
+          friend: z.lazy(() => Profile),
+          meta: z.any().optional(),
+        })
+      )
+      .optional(),
+    achievements: z
+      .array(
+        z.object({
+          achievementId: ObjectId,
+          meta: z.any().optional(),
+          current: z.number().default(0),
+        })
+      )
+      .optional(),
+    badges: z
+      .array(
+        z.object({
+          badgeId: ObjectId,
+          meta: z.any().optional(),
+        })
+      )
+      .optional(),
+    character: Character.optional(),
+    characters: z.array(ObjectId.optional()).optional(),
+    settings: z
+      .object({
+        warp: z.any().default({}),
+        designer: z.any().default({}),
+        privacy: z.enum(['public', 'private', 'friends-only']).default('public'),
+        notifications: z.boolean().default(true),
+      })
+      .optional(),
+    stats: z
+      .object({
+        gamesOwned: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        playedMinutes: z
+          .number()
+          .nonnegative()
+          .default(0), // Total playtime in hours
+        leveledUpCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        xpEarnedCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        craftedItemCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        equippedItemCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        transferredInCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        transferredOutCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        marketTradeSoldCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        marketTradeListedCount: z
+          .number()
+          .int()
+          .nonnegative()
+          .default(0),
+        evolution: z
+          .object({
+            hashes: z.array(z.string()).default([]),
+            overall: z
+              .object({
+                orbs: z.number().optional(),
+                wins: z.number().optional(),
+                kills: z.number().optional(),
+                deaths: z.number().optional(),
+                points: z.number().optional(),
+                rounds: z.number().optional(),
+                evolves: z.number().optional(),
+                ranking: RankingSchema.optional(),
+                rewards: z.number().optional(),
+                earnings: z.number().optional(),
+                powerups: z.number().optional(),
+                revenges: z.number().optional(),
+                winRatio: z.number().optional(),
+                timeSpent: z.number().optional(),
+                winStreak: z.number().optional(),
+                averageLatency: z
+                  .number()
+                  .optional()
+                  .nullable(),
+                killDeathRatio: z.number().optional(),
+                roundPointRatio: z.number().optional(),
+              })
+              .default({}),
+            servers: z.record(ServerDataSchema).optional(),
+            lastUpdated: z.number().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+  })
+);

package/profile/profile.types.ts

@@ -0,0 +1,21 @@
+// profile.types.ts
+//
+import { z } from 'zod';
+import * as schema from './profile.schema';
+import { Document, Model } from '@arken/node/mongo';
+import type { RouterContext } from '../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './profile.router';
+
+export type * from './profile.router';
+export type { RouterContext };
+
+export type Profile = z.infer<typeof schema.Profile>;
+export type ProfileDocument = Profile & Document;
+
+export type Mappings = {
+  Profile: Model<ProfileDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/raffle/index.ts

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

package/raffle/raffle.models.ts

@@ -0,0 +1,44 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './raffle.types';
+
+export const Raffle = mongo.createModel<Types.RaffleDocument>(
+  'Raffle',
+  {
+    content: { type: String, required: true },
+    rewards: [{ type: mongo.Schema.Types.ObjectId, ref: 'RaffleReward' }],
+  },
+  {
+    virtuals: [
+      {
+        name: 'raffleRequirements',
+        ref: 'RaffleRequirement',
+        localField: '_id',
+        foreignField: 'raffleId',
+      },
+      {
+        name: 'raffleEntries',
+        ref: 'RaffleEntry',
+        localField: '_id',
+        foreignField: 'raffleId',
+      },
+    ],
+  }
+);
+
+export const RaffleRequirement = mongo.createModel<Types.RaffleRequirementDocument>('RaffleRequirement', {
+  amount: { type: Number, required: true },
+  raffleRewardId: { type: mongo.Schema.Types.ObjectId, ref: 'RaffleReward' },
+});
+
+export const RaffleReward = mongo.createModel<Types.RaffleRewardDocument>('RaffleReward', {
+  raffleId: { type: mongo.Schema.Types.ObjectId, ref: 'Raffle' },
+  winnerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+  requirements: [{ type: mongo.Schema.Types.ObjectId, ref: 'RaffleRequirement' }],
+  entries: [{ type: mongo.Schema.Types.ObjectId, ref: 'RaffleEntry' }],
+});
+
+export const RaffleEntry = mongo.createModel<Types.RaffleEntryDocument>('RaffleEntry', {
+  amount: { type: Number, required: true },
+  raffleRewardId: { type: mongo.Schema.Types.ObjectId, ref: 'RaffleReward' },
+  raffleId: { type: mongo.Schema.Types.ObjectId, ref: 'Raffle' },
+});

package/raffle/raffle.router.ts

@@ -0,0 +1,90 @@
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Raffle, RaffleRequirement, RaffleReward, RaffleEntry } from './raffle.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({
+    // Raffle endpoints
+    getRaffle: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffle as any)(input, ctx)),
+
+    createRaffle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(Raffle)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffle as any)(input, ctx)),
+
+    updateRaffle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleId: z.string(), data: Raffle.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffle as any)(input, ctx)),
+
+    getRaffleRequirement: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRequirementId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleRequirement as any)(input, ctx)),
+
+    createRaffleRequirement: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(RaffleRequirement)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleRequirement as any)(input, ctx)),
+
+    updateRaffleRequirement: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRequirementId: z.string(), data: RaffleRequirement.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleRequirement as any)(input, ctx)),
+
+    getRaffleReward: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRewardId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleReward as any)(input, ctx)),
+
+    createRaffleReward: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(RaffleReward)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleReward as any)(input, ctx)),
+
+    updateRaffleReward: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRewardId: z.string(), data: RaffleReward.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleReward as any)(input, ctx)),
+
+    getRaffleEntry: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleEntryId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleEntry as any)(input, ctx)),
+
+    createRaffleEntry: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(RaffleEntry)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleEntry as any)(input, ctx)),
+
+    updateRaffleEntry: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleEntryId: z.string(), data: RaffleEntry.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleEntry as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/raffle/raffle.schema.ts

@@ -0,0 +1,32 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const Raffle = Entity.merge(
+  z.object({
+    content: z.string().min(1),
+    rewards: z.array(ObjectId).optional(), // List of reward IDs
+  })
+);
+
+export const RaffleRequirement = Entity.merge(
+  z.object({
+    amount: z.number().min(1),
+    raffleRewardId: ObjectId.optional(), // Reference to the associated RaffleReward
+  })
+);
+
+export const RaffleReward = Entity.merge(
+  z.object({
+    raffleId: ObjectId.optional(), // Reference to the associated Raffle
+    winnerId: ObjectId.optional(), // Reference to the winning Profile
+    requirements: z.array(ObjectId).optional(), // List of associated RaffleRequirement IDs
+    entries: z.array(ObjectId).optional(), // List of associated RaffleEntry IDs
+  })
+);
+
+export const RaffleEntry = Entity.merge(
+  z.object({
+    amount: z.number().min(1),
+    raffleRewardId: ObjectId.optional(), // Reference to the associated RaffleReward
+    raffleId: ObjectId.optional(), // Reference to the associated Raffle
+  })
+);

package/raffle/raffle.types.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import * as schema from './raffle.schema';
+import { Document, Model } from '@arken/node/mongo';
+import type { RouterContext } from '../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './raffle.router';
+
+export type * from './raffle.router';
+export type { RouterContext };
+
+export type Raffle = z.infer<typeof schema.Raffle>;
+export type RaffleRequirement = z.infer<typeof schema.RaffleRequirement>;
+export type RaffleReward = z.infer<typeof schema.RaffleReward>;
+export type RaffleEntry = z.infer<typeof schema.RaffleEntry>;
+
+export type RaffleDocument = Raffle & Document;
+export type RaffleRequirementDocument = RaffleRequirement & Document;
+export type RaffleRewardDocument = RaffleReward & Document;
+export type RaffleEntryDocument = RaffleEntry & Document;
+
+export type Mappings = {
+  Raffle: Model<RaffleDocument>;
+  RaffleRequirement: Model<RaffleRequirementDocument>;
+  RaffleReward: Model<RaffleRewardDocument>;
+  RaffleEntry: Model<RaffleEntryDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/router.ts

@@ -1,34 +1,28 @@
-import util from '@arken/util';
 import { initTRPC } from '@trpc/server';
-import { observable } from '@trpc/server/observable';
-import { serialize, deserialize } from '@arken/rpc';
 import { z } from 'zod';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
-import { Query, getQueryInput, getQueryOutput, inferRouterOutputs } from '@arken/schema';
-import * as Arken from '@arken/types';
-import * as Schema from '@arken/schema';
-import * as Area from '@arken/protocol/area/area.router';
-import * as Asset from '@arken/protocol/asset/asset.router';
-import * as Character from '@arken/protocol/character/character.router';
-import * as Chain from '@arken/protocol/chain/chain.router';
-import * as Chat from '@arken/protocol/chat/chat.router';
-import * as Collection from '@arken/protocol/collection/collection.router';
-import * as Core from '@arken/protocol/core/core.router';
-import * as Game from '@arken/protocol/game/game.router';
-import * as Interface from '@arken/protocol/interface/interface.router';
-import * as Item from '@arken/protocol/item/item.router';
-import * as Job from '@arken/protocol/job/job.router';
-import * as Market from '@arken/protocol/market/market.router';
-import * as Product from '@arken/protocol/product/product.router';
-import * as Profile from '@arken/protocol/profile/profile.router';
-import * as Raffle from '@arken/protocol/raffle/raffle.router';
-import * as Skill from '@arken/protocol/skill/skill.router';
-import * as Video from '@arken/protocol/video/video.router';
-import * as Trek from './modules/trek/trek.router';
-import * as Isles from './modules/isles/isles.router';
-import * as Evolution from './modules/evolution/evolution.router';
-import * as Infinite from './modules/infinite/infinite.router';
-import * as Oasis from './modules/oasis/oasis.router';
+import * as Schema from '@arken/node/schema';
+import * as Area from './area/area.router';
+import * as Asset from './asset/asset.router';
+import * as Character from './character/character.router';
+import * as Chain from './chain/chain.router';
+import * as Chat from './chat/chat.router';
+import * as Collection from './collection/collection.router';
+import * as Core from './core/core.router';
+import * as Game from './game/game.router';
+import * as Interface from './interface/interface.router';
+import * as Item from './item/item.router';
+import * as Job from './job/job.router';
+import * as Market from './market/market.router';
+import * as Product from './product/product.router';
+import * as Profile from './profile/profile.router';
+import * as Raffle from './raffle/raffle.router';
+import * as Skill from './skill/skill.router';
+import * as Video from './video/video.router';
+import * as Trek from './trek/trek.router';
+import * as Isles from './isles/isles.router';
+import * as Evolution from './evolution/evolution.router';
+import * as Infinite from './infinite/infinite.router';
+import * as Oasis from './oasis/oasis.router';
 import type * as Types from './types';
 
 export type RouterContext = {