@arken/node 1.5.1 → 1.5.2

package/modules/profile/profile.models.ts

@@ -1,214 +0,0 @@
-// profile.models.ts
-//
-import * as mongo from '../../util/mongo';
-import type * as Types from './profile.types';
-
-const { addTagVirtuals, addApplicationVirtual } = mongo;
-
-const RankingStatSchema = new mongo.Schema(
-  {
-    total: { type: Number, required: true },
-    position: { type: Number, required: true },
-  },
-  { _id: false }
-);
-
-const RankingSchema = new mongo.Schema(
-  {
-    orbs: { type: RankingStatSchema, required: true },
-    wins: { type: RankingStatSchema, required: true },
-    kills: { type: RankingStatSchema, required: true },
-    deaths: { type: RankingStatSchema, required: true },
-    points: { type: RankingStatSchema, required: true },
-    rounds: { type: RankingStatSchema, required: true },
-    evolves: { type: RankingStatSchema, required: true },
-    rewards: { type: RankingStatSchema, required: true },
-    powerups: { type: RankingStatSchema, required: true },
-    revenges: { type: RankingStatSchema, required: true },
-    winRatio: { type: RankingStatSchema, required: true },
-    timeSpent: { type: RankingStatSchema, required: true },
-    averageLatency: { type: RankingStatSchema, required: true },
-    killDeathRatio: { type: RankingStatSchema, required: true },
-    roundPointRatio: { type: RankingStatSchema, required: true },
-  },
-  { _id: false }
-);
-
-const ServerDataSchema = new mongo.Schema(
-  {
-    orbs: { type: Number },
-    wins: { type: Number },
-    kills: { type: Number },
-    deaths: { type: Number },
-    points: { type: Number },
-    rounds: { type: Number },
-    evolves: { type: Number },
-    ranking: { type: RankingSchema },
-    rewards: { type: Number },
-    earnings: { type: Number },
-    powerups: { type: Number },
-    revenges: { type: Number },
-    winRatio: { type: Number },
-    timeSpent: { type: Number },
-    winStreak: { type: Number },
-    averageLatency: { type: Number, default: null },
-    killDeathRatio: { type: Number },
-    roundPointRatio: { type: Number },
-  },
-  { _id: false }
-);
-
-const EvolutionSchema = new mongo.Schema(
-  {
-    hashes: [{ type: String }],
-    overall: {
-      orbs: { type: Number },
-      wins: { type: Number },
-      kills: { type: Number },
-      deaths: { type: Number },
-      points: { type: Number },
-      rounds: { type: Number },
-      evolves: { type: Number },
-      ranking: { type: RankingSchema },
-      rewards: { type: Number },
-      earnings: { type: Number },
-      powerups: { type: Number },
-      revenges: { type: Number },
-      winRatio: { type: Number },
-      timeSpent: { type: Number },
-      winStreak: { type: Number },
-      averageLatency: { type: Number },
-      killDeathRatio: { type: Number },
-      roundPointRatio: { type: Number },
-    },
-    servers: { type: Map, of: ServerDataSchema },
-    lastUpdated: { type: Number },
-  },
-  { _id: false }
-);
-
-// StatsSchema
-const StatsSchema = new mongo.Schema(
-  {
-    gamesOwned: { type: Number, default: 0 },
-    playedMinutes: { type: Number, default: 0 },
-    leveledUpCount: { type: Number, default: 0 },
-    xpEarnedCount: { type: Number, default: 0 },
-    craftedItemCount: { type: Number, default: 0 },
-    equippedItemCount: { type: Number, default: 0 },
-    transferredInCount: { type: Number, default: 0 },
-    transferredOutCount: { type: Number, default: 0 },
-    marketTradeSoldCount: { type: Number, default: 0 },
-    marketTradeListedCount: { type: Number, default: 0 },
-    evolution: { type: EvolutionSchema },
-  },
-  { _id: false }
-);
-
-const SettingsSchema = new mongo.Schema(
-  {
-    warp: { type: mongo.Schema.Types.Mixed, default: {} },
-    designer: { type: mongo.Schema.Types.Mixed, default: {} },
-    privacy: {
-      type: String,
-      enum: ['public', 'private', 'friends-only'],
-      default: 'public',
-    },
-    notifications: { type: Boolean, default: true },
-  },
-  { _id: false }
-);
-
-// const CharacterSubSchema = new mongo.Schema(
-//   {
-//     characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character', required: true, autopopulate: true },
-//     meta: { type: mongo.Schema.Types.Mixed, default: {} },
-//   },
-//   { _id: false }
-// );
-
-// CharacterSubSchema.virtual('character', {
-//   ref: 'Character', // The model to use
-//   localField: 'characterId', // Find in `Character` where `_id` matches `characterId`
-//   foreignField: '_id',
-//   justOne: true, // Since `characterId` is a single reference
-// });
-
-export const Profile = mongo.createModel<Types.ProfileDocument>(
-  'Profile',
-  {
-    accountId: { type: mongo.Schema.Types.ObjectId, ref: 'Account', required: true },
-    points: { type: Number, default: 0 },
-    // coins: { type: Number, default: 0 },
-    telegramUserId: { type: Number },
-    interactions: { type: Number, default: 0 },
-    activityRating: { type: Number, default: 0 },
-    address: { type: String, maxlength: 100 },
-    avatar: { type: String, maxlength: 100 },
-    roleId: { type: mongo.Schema.Types.ObjectId, ref: 'Role' },
-    privateKey: { type: String, maxlength: 300 },
-    signature: { type: String, maxlength: 200 },
-    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
-    teamId: { type: mongo.Schema.Types.ObjectId, ref: 'Team' },
-    characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character' },
-    partyId: { type: mongo.Schema.Types.ObjectId, ref: 'Party' },
-    isBanned: { type: Boolean },
-    banExpireDate: { type: Date },
-    banReason: { type: String },
-    bio: { type: String },
-    banner: { type: String },
-    mode: { type: String, default: 'gamer' },
-    friends: [
-      {
-        profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
-        meta: { type: mongo.Schema.Types.Mixed, default: {} },
-      },
-    ],
-    badges: [
-      {
-        badgeId: { type: mongo.Schema.Types.ObjectId, ref: 'Badge', required: true },
-        meta: { type: mongo.Schema.Types.Mixed, default: {} },
-      },
-    ],
-    settings: SettingsSchema,
-    stats: StatsSchema,
-    achievements: [
-      {
-        achievementId: { type: mongo.Schema.Types.ObjectId, ref: 'Achievement', required: true },
-        meta: { type: mongo.Schema.Types.Mixed, default: {} },
-        current: { type: Number, default: 0 },
-      },
-    ],
-  },
-  {
-    virtuals: [
-      ...addTagVirtuals('Profile'),
-      ...addApplicationVirtual(),
-      {
-        name: 'character',
-      },
-      {
-        name: 'characters',
-        ref: 'Character',
-        localField: '_id',
-        foreignField: 'ownerId',
-      },
-      {
-        name: 'chain',
-      },
-      {
-        name: 'role',
-      },
-      {
-        name: 'account',
-      },
-      {
-        name: 'team',
-      },
-    ],
-    indexes: [
-      { applicationId: 1, telegramUserId: 1, unique: true },
-      { applicationId: 1, accountId: 1, name: 1, unique: true },
-    ],
-  }
-);

package/modules/profile/profile.router.ts

@@ -1,72 +0,0 @@
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/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/modules/profile/profile.schema.ts

@@ -1,156 +0,0 @@
-// 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/modules/profile/profile.service.ts

@@ -1,149 +0,0 @@
-import type { Profile, RouterContext, RouterInput, RouterOutput } from './profile.types';
-import { ARXError } from '../../util/rpc';
-import { getFilter } from '../../util/api';
-import { deepMerge } from '../../util/object';
-
-export class Service {
-  async setProfileMode(
-    input: RouterInput['setProfileMode'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['setProfileMode']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.setProfileMode', input);
-
-    ctx.client.profile.mode = input;
-
-    // @ts-ignore
-    await ctx.client.profile.save();
-  }
-
-  async me(input: RouterInput['me'], ctx: RouterContext): Promise<RouterOutput['me']> {
-    return {
-      id: ctx.client.profile.id,
-      address: ctx.client.profile.address,
-      name: ctx.client.profile.name,
-      points: ctx.client.profile.points,
-      status: ctx.client.profile.status,
-      isBanned: ctx.client.profile.isBanned,
-      banExpireDate: ctx.client.profile.banExpireDate,
-      banReason: ctx.client.profile.banReason,
-      mode: ctx.client.profile.mode,
-      settings: ctx.client.profile.settings,
-      roles: ctx.client.roles,
-      permissions: ctx.client.permissions,
-      data: ctx.client.profile.data,
-      meta: {
-        rewards: ctx.client.profile.meta.rewards,
-        evolution: {
-          settings: {
-            zoom: ctx.client.profile.meta?.evolution?.settings?.zoom || 0.7,
-            opacity: ctx.client.profile.meta?.evolution?.settings?.opacity || 1,
-          },
-        },
-      },
-    };
-  }
-
-  async getProfile(input: RouterInput['getProfile'], ctx: RouterContext): Promise<RouterOutput['getProfile']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.getProfile', input);
-
-    const filter = getFilter(input);
-    const profile = await ctx.app.model.Profile.findOne(filter).lean().exec();
-    if (!profile) throw new ARXError('NOT_FOUND');
-
-    // @ts-ignore
-    if (profile?.meta?.market?.trades) delete profile?.meta?.market?.trades;
-
-    return profile as Profile;
-  }
-
-  async getProfiles(input: RouterInput['getProfiles'], ctx: RouterContext): Promise<RouterOutput['getProfiles']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.getProfiles', input);
-
-    const filter = getFilter(input);
-    // const profiles = await ctx.app.model.Profile.find(filter).populate('character', 'characters').exec();
-
-    const profiles = await ctx.app.model.Profile.aggregate([
-      { $limit: input.limit || 10 },
-      {
-        $lookup: {
-          from: 'Character',
-          localField: 'characterId',
-          foreignField: '_id',
-          as: 'character',
-        },
-      },
-      { $unwind: '$character' },
-      {
-        $lookup: {
-          from: 'Character',
-          localField: '_id',
-          foreignField: 'profileId',
-          as: 'characters',
-        },
-      },
-      { $unwind: '$characters' },
-    ]);
-
-    return profiles as Profile[];
-  }
-
-  async createProfile(input: RouterInput['createProfile'], ctx: RouterContext): Promise<RouterOutput['createProfile']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.createProfile', input.data);
-
-    const profile = await ctx.app.model.Profile.create(input.data);
-    return profile as Profile;
-  }
-
-  async updateProfile(input: RouterInput['updateProfile'], ctx: RouterContext): Promise<RouterOutput['updateProfile']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.updateProfile', input, input.data);
-
-    const filter = getFilter(input);
-    const updatedProfile = await ctx.app.model.Profile.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedProfile) throw new ARXError('INTERNAL_SERVER_ERROR');
-
-    // @ts-ignore
-    return updatedProfile as Profile;
-  }
-
-  async getProfileStats(
-    input: RouterInput['getProfileStats'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getProfileStats']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.getProfileStats', input);
-
-    const filter = getFilter(input);
-    const profile: Profile = await ctx.app.model.Profile.findOne(filter).lean().exec();
-    if (!profile) throw new ARXError('NOT_FOUND');
-
-    return profile.stats;
-  }
-
-  async updateProfileSettings(
-    input: RouterInput['updateProfileSettings'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateProfileSettings']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Profile.Service.updateProfileSettings', input, input.settings);
-
-    const filter = getFilter(input);
-    // @ts-ignore
-    const updatedProfile: Profile = await ctx.app.model.Profile.findOneAndUpdate(
-      filter,
-      { settings: deepMerge(ctx.client.profile.settings, input.settings) },
-      { new: true }
-    )
-      .lean()
-      .exec();
-    if (!updatedProfile) throw new ARXError('INTERNAL_SERVER_ERROR');
-
-    return updatedProfile.settings;
-  }
-}

package/modules/profile/profile.types.ts

@@ -1,22 +0,0 @@
-// profile.types.ts
-//
-import { z } from 'zod';
-import * as schema from './profile.schema';
-import { Document, Model } from '../../util/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 * from './profile.service';
-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/modules/raffle/index.ts

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

package/modules/raffle/raffle.models.ts

@@ -1,44 +0,0 @@
-import * as mongo from '../../util/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' },
-});