@arken/seer-protocol 0.1.0 → 0.1.2

package/product/product.schema.ts

@@ -0,0 +1,149 @@
+import { z, ObjectId, Entity } from '../../schema';
+
+// Extend the ProductMeta schema
+const ProductMeta = z.object({
+  name: z.string(),
+  members: z.array(ObjectId), // Array of Profile references
+  isProposal: z.boolean(),
+  price: z.number().nonnegative(),
+  oldPrice: z.number().nonnegative().optional(),
+  images: z.record(z.string(), z.any()),
+  video: z.string().url(),
+  genre: z.string(),
+  releaseDate: z.string(),
+  developer: z.string(),
+  publisher: z.string(),
+  developerTags: z.array(z.string()),
+  languageSupport: z.array(z.any()), // Replace with actual Language schema if available
+  systemRequirements: z.array(z.any()), // Replace with actual SystemRequirement schema if available
+  tags: z.array(ObjectId), // Array of Tag references
+  type: z.string(),
+  downloads: z.number().int().nonnegative(),
+  plans: z.array(z.any()), // Replace with actual ProductPlan schema if available
+  frequentlyTradedAssets: z.array(ObjectId), // Array of Asset references
+  saleBox: z.record(z.string(), z.any()),
+  assets: z.array(ObjectId), // Array of Asset references
+  community: z.record(z.string(), z.any()),
+  nameUrl: z.string(),
+  steamId: z.number().int(),
+  author: z.string(),
+});
+
+// Updated Product schema
+export const Product = Entity.merge(
+  z.object({
+    shortDescription: z.string().max(300).min(1),
+    content: z.string().min(1),
+    communityId: ObjectId,
+    type: z.string().max(100).default('game'),
+    releaseDate: z.date().optional(),
+    sku: z.string().min(1),
+    categoryId: ObjectId.optional(),
+    price: z.number().nonnegative(),
+    discountPrice: z.number().nonnegative().optional(),
+    currency: z.string().length(3),
+    images: z.array(z.string().url()).optional(),
+    videos: z.array(z.string().url()).optional(),
+    digitalContent: z
+      .array(
+        z.object({
+          url: z.string().url(),
+          size: z.number().nonnegative(),
+          drm: z.enum(['None', 'Steam', 'Epic', 'Uplay', 'Origin']).optional(),
+        })
+      )
+      .optional(),
+    dlcs: z.array(ObjectId).optional(),
+    bundles: z.array(ObjectId).optional(),
+    achievements: z
+      .array(
+        z.object({
+          name: z.string(),
+          description: z.string().optional(),
+          icon: z.string().url().optional(),
+        })
+      )
+      .optional(),
+    reviews: z
+      .array(
+        z.object({
+          userId: ObjectId,
+          rating: z.number().min(1).max(5),
+          comment: z.string().optional(),
+          createdDate: z.date().default(() => new Date()),
+        })
+      )
+      .optional(),
+    cloudSave: z.boolean().default(false),
+    ugcSupport: z.boolean().default(false),
+    wishlistCount: z.number().int().nonnegative().default(0),
+
+    // Additional fields from Objection.js model
+    parentId: ObjectId.optional(),
+    score: z.number().optional(),
+    ownerId: ObjectId.optional(),
+    ratingId: ObjectId.optional(),
+    ideaId: ObjectId.optional(),
+    meta: ProductMeta.optional(),
+  })
+);
+
+// ProductDLC schema
+export const ProductDLC = Entity.merge(
+  z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    gameId: ObjectId,
+    price: z.number().nonnegative(),
+    discountPrice: z.number().nonnegative().optional(),
+    currency: z.string().length(3),
+    digitalContent: z
+      .array(
+        z.object({
+          url: z.string().url(),
+          size: z.number().nonnegative(),
+          drm: z.enum(['None', 'Steam', 'Epic', 'Uplay', 'Origin']).optional(),
+        })
+      )
+      .optional(),
+    achievements: z
+      .array(
+        z.object({
+          name: z.string(),
+          description: z.string().optional(),
+          icon: z.string().url().optional(),
+        })
+      )
+      .optional(),
+  })
+);
+
+// ProductBundle schema
+export const ProductBundle = Entity.merge(
+  z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    products: z.array(ObjectId),
+    price: z.number().nonnegative(),
+    discountPrice: z.number().nonnegative().optional(),
+    currency: z.string().length(3),
+  })
+);
+
+// ProductReview schema
+export const ProductReview = Entity.merge(
+  z.object({
+    userId: ObjectId,
+    productId: ObjectId,
+    rating: z.number().min(1).max(5),
+    comment: z.string().optional(),
+  })
+);
+
+export const ProductUpdate = Entity.merge(
+  z.object({
+    productId: ObjectId,
+    updateContent: z.string().min(1),
+    updateDate: z.date(),
+  })
+);

package/product/product.types.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import * as schema from './product.schema';
+import { Document, Model } from '../../util/mongo';
+import type { RouterContext } from '../../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './product.router';
+
+export type * from './product.router';
+export type * from './product.service';
+export type { RouterContext };
+
+export type Product = z.infer<typeof schema.Product>;
+export type ProductUpdate = z.infer<typeof schema.ProductUpdate>;
+export type ProductDLC = z.infer<typeof schema.ProductDLC>;
+export type ProductBundle = z.infer<typeof schema.ProductBundle>;
+export type ProductReview = z.infer<typeof schema.ProductReview>;
+
+export type ProductDocument = Product & Document;
+export type ProductUpdateDocument = ProductUpdate & Document;
+export type ProductDLCDocument = ProductDLC & Document;
+export type ProductBundleDocument = ProductBundle & Document;
+export type ProductReviewDocument = ProductReview & Document;
+
+export type Mappings = {
+  Product: Model<ProductDocument>;
+  ProductUpdate: Model<ProductUpdateDocument>;
+  ProductDLC: Model<ProductDLCDocument>;
+  ProductBundle: Model<ProductBundleDocument>;
+  ProductReview: Model<ProductReviewDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/profile/index.ts

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

package/profile/profile.models.ts

@@ -0,0 +1,214 @@
+// 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/profile/profile.router.ts

@@ -0,0 +1,72 @@
+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/profile/profile.schema.ts

@@ -0,0 +1,156 @@
+// 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,22 @@
+// 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/raffle/index.ts

@@ -0,0 +1,5 @@
+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';