@arken/seer-protocol 0.1.1 → 0.1.3

package/product/product.models.ts

@@ -0,0 +1,166 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './product.types';
+
+export const Product = mongo.createModel<Types.ProductDocument>(
+  'Product',
+  {
+    shortDescription: { type: String, maxlength: 300, required: false },
+    content: { type: String, required: false },
+    communityId: { type: mongo.Schema.Types.ObjectId, ref: 'Community', required: false },
+    type: { type: String, default: 'game', maxlength: 100 },
+    releaseDate: { type: Date },
+
+    // New fields from Objection.js model
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
+    score: { type: Number },
+    ownerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+    ideaId: { type: mongo.Schema.Types.ObjectId, ref: 'Idea' },
+    meta: {
+      name: String,
+      members: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
+      isProposal: Boolean,
+      price: Number,
+      oldPrice: Number,
+      images: Object,
+      video: String,
+      genre: String,
+      releaseDate: String,
+      developer: String,
+      publisher: String,
+      developerTags: [String],
+      languageSupport: [Object], // Adjust as needed
+      systemRequirements: [Object], // Adjust as needed
+      tags: [{ type: mongo.Schema.Types.ObjectId, ref: 'Tag' }],
+      type: String,
+      downloads: Number,
+      plans: [Object], // Adjust as needed
+      frequentlyTradedAssets: [{ type: mongo.Schema.Types.ObjectId, ref: 'Asset' }],
+      saleBox: Object,
+      assets: [{ type: mongo.Schema.Types.ObjectId, ref: 'Asset' }],
+      community: Object,
+      nameUrl: String,
+      steamId: Number,
+      author: String,
+    },
+  },
+  {
+    virtuals: [
+      {
+        name: 'projects',
+        ref: 'Project',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      {
+        name: 'leaderboards',
+        ref: 'Leaderboard',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      {
+        name: 'games',
+        ref: 'Game',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      {
+        name: 'productUpdates',
+        ref: 'ProductUpdate',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      // Adding missing relations as virtuals
+      {
+        name: 'owner',
+        ref: 'Profile',
+        localField: 'ownerId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'rating',
+        ref: 'Rating',
+        localField: 'ratingId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'community',
+        ref: 'Community',
+        localField: 'communityId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'idea',
+        ref: 'Idea',
+        localField: 'ideaId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'subproducts',
+        ref: 'Product',
+        localField: '_id',
+        foreignField: 'parentId',
+      },
+      {
+        name: 'servers',
+        ref: 'Server',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      // {
+      //   name: 'votes',
+      //   ref: 'Vote',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.toProductId',
+      //     to: 'nodes.fromVoteId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+      // {
+      //   name: 'files',
+      //   ref: 'File',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.fromProductId',
+      //     to: 'nodes.toFileId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+      // {
+      //   name: 'tags',
+      //   ref: 'Tag',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.fromProductId',
+      //     to: 'nodes.toTagId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+      // {
+      //   name: 'internalTags',
+      //   ref: 'Tag',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.fromProductId',
+      //     to: 'nodes.toTagId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+    ],
+  }
+);
+
+export const ProductUpdate = mongo.createModel<Types.ProductUpdateDocument>('ProductUpdate', {
+  productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product', required: true },
+  updateContent: { type: String, required: true },
+  updateDate: { type: Date, required: true },
+});

package/product/product.router.ts

@@ -0,0 +1,93 @@
+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 { Product, ProductDLC, ProductBundle, ProductReview } from './product.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({
+    // Product endpoints
+    getProduct: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ productId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProduct as any)(input, ctx)),
+
+    createProduct: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(Product)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProduct as any)(input, ctx)),
+
+    updateProduct: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ productId: z.string(), data: Product.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProduct as any)(input, ctx)),
+
+    // ProductDLC endpoints
+    getProductDLC: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ dlcId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProductDLC as any)(input, ctx)),
+
+    createProductDLC: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(ProductDLC)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProductDLC as any)(input, ctx)),
+
+    updateProductDLC: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ dlcId: z.string(), data: ProductDLC.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProductDLC as any)(input, ctx)),
+
+    // ProductBundle endpoints
+    getProductBundle: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ bundleId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProductBundle as any)(input, ctx)),
+
+    createProductBundle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(ProductBundle)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProductBundle as any)(input, ctx)),
+
+    updateProductBundle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ bundleId: z.string(), data: ProductBundle.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProductBundle as any)(input, ctx)),
+
+    // ProductReview endpoints
+    getProductReview: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ reviewId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProductReview as any)(input, ctx)),
+
+    createProductReview: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(ProductReview)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProductReview as any)(input, ctx)),
+
+    updateProductReview: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ reviewId: z.string(), data: ProductReview.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProductReview as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/product/product.schema.ts

@@ -0,0 +1,186 @@
+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,32 @@
+import { z } from 'zod';
+import * as schema from './product.schema';
+import { Document, Model } from '@arken/node/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 { 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,4 @@
+export * as Types from './profile.types';
+export * as Models from './profile.models';
+export * as Schemas from './profile.schema';
+export * from './profile.router';

package/profile/profile.models.ts

@@ -0,0 +1,214 @@
+// profile.models.ts
+//
+import * as mongo from '@arken/node/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 },
+    ],
+  }
+);