@arken/node 1.5.1 → 1.5.2

package/modules/item/item.schema.ts

@@ -1,120 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const ItemAttribute = Entity.merge(
-  z.object({
-    // Define fields for ItemAttribute here if needed
-  })
-);
-
-export const ItemMaterial = Entity.merge(
-  z.object({
-    // Define fields for ItemMaterial here if needed
-  })
-);
-
-export const ItemSet = Entity.merge(
-  z.object({
-    // Define fields for ItemSet here if needed
-  })
-);
-
-export const ItemSlot = Entity.merge(
-  z.object({
-    // Define fields for ItemSlot here if needed
-  })
-);
-
-export const ItemRarity = Entity.merge(
-  z.object({
-    // Define fields for ItemRarity here if needed
-  })
-);
-
-export const ItemRank = Entity.merge(
-  z.object({
-    value: z.number(),
-    // Define fields for ItemRank here if needed
-  })
-);
-
-export const ItemType = Entity.merge(
-  z.object({
-    // Define fields for ItemType here if needed
-  })
-);
-
-export const ItemSubType = Entity.merge(
-  z.object({
-    // Define fields for ItemSubType here if needed
-  })
-);
-
-export const ItemSpecificType = Entity.merge(
-  z.object({
-    // Define fields for ItemSpecificType here if needed
-  })
-);
-
-export const ItemAffix = Entity.merge(
-  z.object({
-    isPrefix: z.boolean().default(false),
-    isSuffix: z.boolean().default(false),
-    isTitle: z.boolean().default(false),
-    weight: z.number().min(0).default(1),
-    typeIds: z.array(ObjectId).optional(),
-    rarityIds: z.array(ObjectId).optional(),
-  })
-);
-
-export const ItemRecipe = Entity.merge(
-  z.object({
-    // Define fields for ItemRecipe here if needed
-  })
-);
-
-export const ItemSkin = Entity.merge(
-  z.object({
-    // Define fields for ItemSkin here if needed
-  })
-);
-
-export const ItemTransmute = Entity.merge(
-  z.object({
-    token: z.string().max(500).min(1),
-    assetId: ObjectId,
-    itemId: ObjectId,
-    chainId: ObjectId.optional(),
-  })
-);
-
-export const Item = Entity.merge(
-  z.object({
-    characterId: ObjectId.optional(),
-    assetId: ObjectId.optional(),
-    chainId: ObjectId.optional(),
-    materialId: ItemMaterial.optional(),
-    skinId: ItemSkin.optional(),
-    recipeId: ItemRecipe.optional(),
-    typeId: ItemType.optional(),
-    subTypeId: ItemSubType.optional(),
-    specificTypeId: ItemSpecificType.optional(),
-    rankId: ItemRank.optional(),
-    rankValue: z.number(),
-    rarityId: ItemRarity.optional(),
-    slotIds: z.array(ItemSlot.optional()),
-    setId: ItemSet.optional(),
-    attributes: z.array(ItemAttribute).optional(),
-    token: z.string().max(500).min(1).optional(),
-    quantity: z.number().int().nonnegative().default(1),
-    x: z.number().int().nonnegative().optional(),
-    y: z.number().int().nonnegative().optional(),
-    distribution: z
-      .enum(['Unknown', 'Found', 'Fundraiser', 'Claimed', 'Crafted', 'Airdrop', 'Reward', 'Farmed', 'Migration'])
-      .default('Unknown'),
-    // properties: z.record(z.any()).optional(),
-    // type: z.string().default('bag'), // stash, bag, equipment, etc.
-    items: z.array(z.lazy(() => Item)).default([]),
-    capacity: z.number().int().nonnegative().default(60),
-    points: z.number().int().nonnegative().default(0),
-  })
-);

package/modules/item/item.service.ts

@@ -1,167 +0,0 @@
-import type {
-  Item,
-  ItemAttribute,
-  ItemMaterial,
-  ItemSet,
-  ItemSlot,
-  ItemRarity,
-  ItemType,
-  ItemSubType,
-  ItemSpecificType,
-  ItemAffix,
-  ItemRecipe,
-  ItemSkin,
-  ItemTransmute,
-  RouterContext,
-  Router,
-  RouterInput,
-  RouterOutput,
-} from './item.types';
-import { getFilter } from '../../util/api';
-import { ARXError } from '../../util/rpc';
-
-export class Service {
-  async getItem(input: RouterInput['getItem'], ctx: RouterContext): Promise<RouterOutput['getItem']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.getItem', input);
-
-    const filter = getFilter(input);
-    const item = await ctx.app.model.Item.findById(filter.id).lean().exec();
-    if (!item) throw new Error('Item not found');
-
-    return item as Item;
-  }
-
-  async getItems(input: RouterInput['getItems'], ctx: RouterContext): Promise<RouterOutput['getItems']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    const filter = getFilter(input);
-
-    // Optional ordering so $first picks the right representative per token
-    const sortStage = {
-      $sort: {
-        updatedDate: -1, // or createdDate, or anything that establishes “latest”
-        _id: -1, // tiebreaker for stable results
-      },
-    };
-
-    const pipeline: any[] = [
-      { $match: filter },
-      sortStage,
-      { $group: { _id: '$token', doc: { $first: '$$ROOT' } } },
-      { $replaceRoot: { newRoot: '$doc' } },
-      { $skip: input.skip || 0 },
-      { $limit: input.limit || 10 },
-    ];
-
-    const items = await ctx.app.model.Item.aggregate(pipeline).exec();
-    return items as Item[];
-  }
-
-  async createItem(input: RouterInput['createItem'], ctx: RouterContext): Promise<RouterOutput['createItem']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.createItem', input);
-
-    const item = await ctx.app.model.Item.create(input);
-    return item as Item;
-  }
-
-  async updateItem(input: RouterInput['updateItem'], ctx: RouterContext): Promise<RouterOutput['updateItem']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.updateItem', input);
-
-    const filter = getFilter(input);
-    const updatedItem = await ctx.app.model.Item.findByIdAndUpdate(filter.id, input.data, { new: true }).lean().exec();
-    if (!updatedItem) throw new Error('Item update failed');
-
-    return updatedItem as Item;
-  }
-
-  async getItemAttribute(
-    input: RouterInput['getItemAttribute'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getItemAttribute']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.getItemAttribute', input);
-
-    const filter = getFilter(input);
-    const itemAttribute = await ctx.app.model.ItemAttribute.findById(filter.id).lean().exec();
-    if (!itemAttribute) throw new Error('ItemAttribute not found');
-
-    return itemAttribute as ItemAttribute;
-  }
-
-  async createItemAttribute(
-    input: RouterInput['createItemAttribute'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createItemAttribute']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.createItemAttribute', input);
-
-    const filter = getFilter(input);
-    const itemAttribute = await ctx.app.model.ItemAttribute.create(filter);
-    return itemAttribute as ItemAttribute;
-  }
-
-  async updateItemAttribute(
-    input: RouterInput['updateItemAttribute'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateItemAttribute']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.updateItemAttribute', input);
-
-    const filter = getFilter(input);
-    const updatedItemAttribute = await ctx.app.model.ItemAttribute.findByIdAndUpdate(filter.id, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedItemAttribute) throw new Error('ItemAttribute update failed');
-
-    return updatedItemAttribute as ItemAttribute;
-  }
-
-  // Add similar methods for other entities like ItemMaterial, ItemSet, ItemSlot, ItemRarity, etc.
-
-  async getItemTransmute(
-    input: RouterInput['getItemTransmute'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getItemTransmute']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.getItemTransmute', input);
-
-    const filter = getFilter(input);
-    const itemTransmute = await ctx.app.model.ItemTransmute.findById(filter.id).lean().exec();
-    if (!itemTransmute) throw new Error('ItemTransmute not found');
-
-    return itemTransmute as ItemTransmute;
-  }
-
-  async createItemTransmute(
-    input: RouterInput['createItemTransmute'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createItemTransmute']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.createItemTransmute', input);
-
-    const itemTransmute = await ctx.app.model.ItemTransmute.create(input.data);
-    return itemTransmute as ItemTransmute;
-  }
-
-  async updateItemTransmute(
-    input: RouterInput['updateItemTransmute'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateItemTransmute']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Item.Service.updateItemTransmute', input);
-
-    const filter = getFilter(input);
-    const updatedItemTransmute = await ctx.app.model.ItemTransmute.findByIdAndUpdate(filter.id, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedItemTransmute) throw new Error('ItemTransmute update failed');
-
-    return updatedItemTransmute as ItemTransmute;
-  }
-}

package/modules/item/item.types.ts

@@ -1,74 +0,0 @@
-// module/item.types.ts
-
-import { z } from 'zod';
-import * as schema from './item.schema';
-import { Document, Model } from '../../util/mongo';
-import type { RouterContext } from '../../types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { Router } from './item.router';
-
-export type * from './item.router';
-export type * from './item.service';
-export type { RouterContext };
-
-export type Item = z.infer<typeof schema.Item>;
-export type ItemDocument = Item & Document;
-
-export type ItemAttribute = z.infer<typeof schema.ItemAttribute>;
-export type ItemAttributeDocument = ItemAttribute & Document;
-
-export type ItemMaterial = z.infer<typeof schema.ItemMaterial>;
-export type ItemMaterialDocument = ItemMaterial & Document;
-
-export type ItemSet = z.infer<typeof schema.ItemSet>;
-export type ItemSetDocument = ItemSet & Document;
-
-export type ItemSlot = z.infer<typeof schema.ItemSlot>;
-export type ItemSlotDocument = ItemSlot & Document;
-
-export type ItemRarity = z.infer<typeof schema.ItemRarity>;
-export type ItemRarityDocument = ItemRarity & Document;
-
-export type ItemRank = z.infer<typeof schema.ItemRank>;
-export type ItemRankDocument = ItemRank & Document;
-
-export type ItemType = z.infer<typeof schema.ItemType>;
-export type ItemTypeDocument = ItemType & Document;
-
-export type ItemSubType = z.infer<typeof schema.ItemSubType>;
-export type ItemSubTypeDocument = ItemSubType & Document;
-
-export type ItemSpecificType = z.infer<typeof schema.ItemSpecificType>;
-export type ItemSpecificTypeDocument = ItemSpecificType & Document;
-
-export type ItemAffix = z.infer<typeof schema.ItemAffix>;
-export type ItemAffixDocument = ItemAffix & Document;
-
-export type ItemRecipe = z.infer<typeof schema.ItemRecipe>;
-export type ItemRecipeDocument = ItemRecipe & Document;
-
-export type ItemSkin = z.infer<typeof schema.ItemSkin>;
-export type ItemSkinDocument = ItemSkin & Document;
-
-export type ItemTransmute = z.infer<typeof schema.ItemTransmute>;
-export type ItemTransmuteDocument = ItemTransmute & Document;
-
-export type Mappings = {
-  Item: Model<ItemDocument>;
-  ItemAttribute: Model<ItemAttributeDocument>;
-  ItemMaterial: Model<ItemMaterialDocument>;
-  ItemSet: Model<ItemSetDocument>;
-  ItemSlot: Model<ItemSlotDocument>;
-  ItemRarity: Model<ItemRarityDocument>;
-  ItemRank: Model<ItemRankDocument>;
-  ItemType: Model<ItemTypeDocument>;
-  ItemSubType: Model<ItemSubTypeDocument>;
-  ItemSpecificType: Model<ItemSpecificTypeDocument>;
-  ItemAffix: Model<ItemAffixDocument>;
-  ItemRecipe: Model<ItemRecipeDocument>;
-  ItemSkin: Model<ItemSkinDocument>;
-  ItemTransmute: Model<ItemTransmuteDocument>;
-};
-
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/job/index.ts

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

package/modules/job/job.models.ts

@@ -1,14 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './job.types';
-
-export const Job = mongo.createModel<Types.JobDocument>(
-  'Job',
-  {
-    mod: { type: String, required: true },
-    startDate: { type: Date },
-    expireDate: { type: Date },
-  },
-  {
-    indexes: [{ applicationId: 1, mod: 1, key: 1 }],
-  }
-);

package/modules/job/job.router.ts

@@ -1,44 +0,0 @@
-// job.router.ts
-
-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 { Job } from './job.schema';
-import { Query } 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({
-    getJob: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Job.getJob as any)(input, ctx)),
-
-    createJob: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: Job }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Job.createJob as any)(input, ctx)),
-
-    updateJob: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: Job.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Job.updateJob as any)(input, ctx)),
-
-    updateMetrics: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.any())
-      .mutation(({ input, ctx }) => (ctx.app.service.Job.updateMetrics as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/job/job.schema.ts

@@ -1,9 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const Job = Entity.merge(
-  z.object({
-    mod: z.string(),
-    startDate: z.date().optional(),
-    expireDate: z.date().optional(),
-  })
-);

package/modules/job/job.service.ts

@@ -1,243 +0,0 @@
-// job.service.ts
-
-import type { Job, RouterContext, RouterInput, RouterOutput } from './job.types';
-import { getFilter } from '../../util/api';
-import dayjs from 'dayjs';
-
-export class Service {
-  async getJob(input: RouterInput['getJob'], ctx: RouterContext): Promise<RouterOutput['getJob']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Job.Service.getJob', input.query);
-
-    const filter = getFilter(input.query);
-    const job = await ctx.app.model.Job.findOne(filter).lean().exec();
-    if (!job) throw new Error('Job not found');
-
-    return job as Job;
-  }
-
-  async createJob(input: RouterInput['createJob'], ctx: RouterContext): Promise<RouterOutput['createJob']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Job.Service.createJob', input.data);
-
-    const job = await ctx.app.model.Job.create(input.data);
-    return job as Job;
-  }
-
-  async updateJob(input: RouterInput['updateJob'], ctx: RouterContext): Promise<RouterOutput['updateJob']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Job.Service.updateJob', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedJob = await ctx.app.model.Job.findOneAndUpdate(filter, input.data, { new: true }).lean().exec();
-    if (!updatedJob) throw new Error('Job update failed');
-
-    return updatedJob as Job;
-  }
-
-  async updateMetrics(input: RouterInput['updateMetrics'], ctx: RouterContext): Promise<RouterOutput['updateMetrics']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Job.Service.updateMetrics');
-
-    let latestRecord;
-    let latestNumber = 1;
-
-    const { Stat, Payment } = ctx.app.model;
-
-    try {
-      latestRecord = await Stat.findOne().sort({ number: -1 }).exec();
-
-      if (latestRecord) {
-        latestNumber = latestRecord.number;
-
-        const dayAgo = dayjs().subtract(1, 'day');
-
-        // Unset the latest record if it's older than one day, so a new one is created
-        if (!dayjs(latestRecord.createdDate).isAfter(dayAgo)) {
-          latestRecord = undefined;
-        }
-      }
-    } catch (e) {
-      console.log('Error getting latest stat record', e);
-    }
-
-    const totalPaymentsCount = await Payment.countDocuments().exec();
-    const pendingPayments = await Payment.where({ status: { $in: ['Processing', 'Processed', 'Finalized'] } });
-    const completedPayments = await Payment.where({ status: { $in: ['Completed'] } });
-
-    const pendingTokens: any = {};
-    const distributedTokens: any = {};
-
-    for (const payment of pendingPayments) {
-      for (const i in payment.meta.tokenKeys) {
-        const key = payment.meta.tokenKeys[i];
-        const amount = payment.meta.tokenAmounts[i];
-
-        if (!pendingTokens[key]) pendingTokens[key] = 0;
-
-        pendingTokens[key] += amount;
-      }
-    }
-
-    for (const payment of completedPayments) {
-      for (const i in payment.meta.tokenKeys) {
-        const key = payment.meta.tokenKeys[i];
-        const amount = payment.meta.tokenAmounts[i];
-
-        if (!distributedTokens[key]) distributedTokens[key] = 0;
-
-        distributedTokens[key] += amount;
-      }
-    }
-
-    const pendingPaymentsCount = pendingPayments.length;
-    const completedPaymentsCount = completedPayments.length;
-
-    // const result = await ctx.app.model.Profile.aggregate([
-    //   {
-    //     $group: {
-    //       _id: null,
-    //       totalDoge: { $sum: "$meta.rewards.tokens.doge" },
-    //       totalPepe: { $sum: "$meta.rewards.tokens.pepe" },
-    //     }
-    //   }
-    // ]);
-    const pendingRewardTokens = await ctx.app.model.Profile.aggregate([
-      {
-        // Convert meta.rewards.tokens => { k, v } pairs
-        $project: {
-          tokens: { $objectToArray: '$meta.rewards.tokens' },
-        },
-      },
-      {
-        // Unwind each { k, v } into its own document
-        $unwind: '$tokens',
-      },
-      {
-        // Group by token name (k), summing up values (v)
-        $group: {
-          _id: '$tokens.k',
-          total: { $sum: '$tokens.v' },
-        },
-      },
-      {
-        // Re-group into a single document with an array of { k, v }
-        $group: {
-          _id: null,
-          tokens: {
-            $push: {
-              k: '$_id',
-              v: '$total',
-            },
-          },
-        },
-      },
-      {
-        // Convert the array [ { k, v }, { k, v }, ... ] back into an object
-        $project: {
-          _id: 0,
-          tokens: { $arrayToObject: '$tokens' },
-        },
-      },
-    ]);
-
-    const meta: any = {
-      payments: {
-        totalCount: totalPaymentsCount,
-        pendingCount: pendingPaymentsCount,
-        completedCount: completedPaymentsCount,
-        status: {
-          Processing: await Payment.where({ status: 'Processing' }).countDocuments().exec(),
-          Processed: await Payment.where({ status: 'Processed' }).countDocuments().exec(),
-          Finalized: await Payment.where({ status: 'Finalized' }).countDocuments().exec(),
-          Completed: await Payment.where({ status: 'Completed' }).countDocuments().exec(),
-          Voided: await Payment.where({ status: 'Voided' }).countDocuments().exec(),
-        },
-        pendingTokens,
-        distributedTokens,
-      },
-      rewards: {
-        pendingRewardTokens: pendingRewardTokens?.[0]?.tokens || {},
-      },
-    };
-
-    if (latestRecord) {
-      await Stat.updateOne(
-        { _id: latestRecord.id },
-        {
-          ...latestRecord.toObject(),
-          meta,
-        }
-      ).exec();
-    } else {
-      await Stat.create({
-        number: latestNumber + 1,
-        createdDate: new Date(),
-        meta,
-      });
-    }
-
-    // if (!input) throw new Error('Input should not be void');
-    // console.log('Job.Service.updateMetrics');
-
-    // let latestRecord;
-    // let latestNumber = 1;
-
-    // const { Stat, Interface, InterfaceComponent } = ctx.app.model;
-
-    // try {
-    //   latestRecord = await Stat.findOne().sort({ number: -1 }).exec();
-
-    //   if (latestRecord) {
-    //     latestNumber = latestRecord.number;
-
-    //     const dayAgo = dayjs().subtract(1, 'day');
-
-    //     // Unset the latest record if it's older than one day, so a new one is created
-    //     if (!dayjs(latestRecord.createdDate).isAfter(dayAgo)) {
-    //       latestRecord = undefined;
-    //     }
-    //   }
-    // } catch (e) {
-    //   console.log('Error getting latest stat record', e);
-    // }
-
-    // const TotalInterfaces = await Interface.countDocuments().exec();
-    // const TotalInterfaceDrafted = await Interface.where({ status: 'Draft' }).countDocuments().exec();
-    // const TotalInterfacePublished = await Interface.where({ status: 'Published' }).countDocuments().exec();
-    // const TotalInterfacePaused = await Interface.where({ status: 'Paused' }).countDocuments().exec();
-    // const TotalInterfaceFinished = await Interface.where({ status: 'Finished' }).countDocuments().exec();
-    // const TotalInterfaceArchived = await Interface.where({ status: 'Archived' }).countDocuments().exec();
-    // const TotalInterfaceSubmissions = 1; // Example static value, replace with actual logic if needed
-    // const TotalInterfaceTemplates = await InterfaceComponent.countDocuments().exec();
-
-    // const meta = {
-    //   TotalInterfaces,
-    //   TotalInterfaceDrafted,
-    //   TotalInterfacePublished,
-    //   TotalInterfacePaused,
-    //   TotalInterfaceArchived,
-    //   TotalInterfaceFinished,
-    //   TotalInterfaceSubmissions,
-    //   TotalInterfaceTemplates,
-    // };
-
-    // if (latestRecord) {
-    //   await Stat.updateOne(
-    //     { _id: latestRecord.id },
-    //     {
-    //       ...latestRecord.toObject(),
-    //       meta,
-    //     }
-    //   ).exec();
-    // } else {
-    //   await Stat.create({
-    //     number: latestNumber + 1,
-    //     createdDate: new Date(),
-    //     meta,
-    //   });
-    // }
-
-    return { status: 1 };
-  }
-}