@arken/node 1.5.1 → 1.5.2

package/modules/product/product.models.ts

@@ -1,166 +0,0 @@
-import * as mongo from '../../util/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/modules/product/product.router.ts

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

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

@@ -1,160 +0,0 @@
-import type {
-  Product,
-  ProductDLC,
-  ProductBundle,
-  ProductReview,
-  RouterContext,
-  Router,
-  RouterInput,
-  RouterOutput,
-} from './product.types';
-
-export class Service {
-  async getProduct(input: RouterInput['getProduct'], ctx: RouterContext): Promise<RouterOutput['getProduct']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.getProduct', input.productId);
-
-    const product = await ctx.app.model.Product.findById(input.productId).lean().exec();
-    if (!product) throw new Error('Product not found');
-
-    return product as Product;
-  }
-
-  async createProduct(input: RouterInput['createProduct'], ctx: RouterContext): Promise<RouterOutput['createProduct']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.createProduct', input);
-
-    const product = await ctx.app.model.Product.create(input);
-    return product as Product;
-  }
-
-  async updateProduct(input: RouterInput['updateProduct'], ctx: RouterContext): Promise<RouterOutput['updateProduct']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.updateProduct', input.productId, input.data);
-
-    const updatedProduct = await ctx.app.model.Product.findByIdAndUpdate(input.productId, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedProduct) throw new Error('Product update failed');
-
-    return updatedProduct as Product;
-  }
-
-  async getProductDLC(input: RouterInput['getProductDLC'], ctx: RouterContext): Promise<RouterOutput['getProductDLC']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.getProductDLC', input.dlcId);
-
-    const productDLC = await ctx.app.model.ProductDLC.findById(input.dlcId).lean().exec();
-    if (!productDLC) throw new Error('ProductDLC not found');
-
-    return productDLC as ProductDLC;
-  }
-
-  async createProductDLC(
-    input: RouterInput['createProductDLC'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createProductDLC']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.createProductDLC', input);
-
-    const productDLC = await ctx.app.model.ProductDLC.create(input);
-    return productDLC as ProductDLC;
-  }
-
-  async updateProductDLC(
-    input: RouterInput['updateProductDLC'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateProductDLC']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.updateProductDLC', input.dlcId, input.data);
-
-    const updatedProductDLC = await ctx.app.model.ProductDLC.findByIdAndUpdate(input.dlcId, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedProductDLC) throw new Error('ProductDLC update failed');
-
-    return updatedProductDLC as ProductDLC;
-  }
-
-  async getProductBundle(
-    input: RouterInput['getProductBundle'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getProductBundle']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.getProductBundle', input.bundleId);
-
-    const productBundle = await ctx.app.model.ProductBundle.findById(input.bundleId).lean().exec();
-    if (!productBundle) throw new Error('ProductBundle not found');
-
-    return productBundle as ProductBundle;
-  }
-
-  async createProductBundle(
-    input: RouterInput['createProductBundle'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createProductBundle']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.createProductBundle', input);
-
-    const productBundle = await ctx.app.model.ProductBundle.create(input);
-    return productBundle as ProductBundle;
-  }
-
-  async updateProductBundle(
-    input: RouterInput['updateProductBundle'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateProductBundle']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.updateProductBundle', input.bundleId, input.data);
-
-    const updatedProductBundle = await ctx.app.model.ProductBundle.findByIdAndUpdate(input.bundleId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedProductBundle) throw new Error('ProductBundle update failed');
-
-    return updatedProductBundle as ProductBundle;
-  }
-
-  async getProductReview(
-    input: RouterInput['getProductReview'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getProductReview']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.getProductReview', input.reviewId);
-
-    const productReview = await ctx.app.model.ProductReview.findById(input.reviewId).lean().exec();
-    if (!productReview) throw new Error('ProductReview not found');
-
-    return productReview as ProductReview;
-  }
-
-  async createProductReview(
-    input: RouterInput['createProductReview'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createProductReview']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.createProductReview', input);
-
-    const productReview = await ctx.app.model.ProductReview.create(input);
-    return productReview as ProductReview;
-  }
-
-  async updateProductReview(
-    input: RouterInput['updateProductReview'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateProductReview']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Product.Service.updateProductReview', input.reviewId, input.data);
-
-    const updatedProductReview = await ctx.app.model.ProductReview.findByIdAndUpdate(input.reviewId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedProductReview) throw new Error('ProductReview update failed');
-
-    return updatedProductReview as ProductReview;
-  }
-}

package/modules/product/product.types.ts

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

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