@arken/node 1.5.1 → 1.5.2

package/modules/interface/interface.schema.ts

@@ -1,59 +0,0 @@
-// arken/packages/node/modules/interface/interface.schema.ts
-//
-import { z, ObjectId, Entity } from '../../schema';
-
-// Patch ops for interface composition
-const InterfacePatch = z.object({
-  op: z.enum(['merge', 'replace', 'remove', 'push', 'unshift', 'splice']).default('merge'),
-  key: z.string().min(1), // target node key (or special key like "root")
-  path: z.string().optional(), // optional deep path inside that node, ex: "props.omit"
-  value: z.unknown().optional(), // payload for merge/replace/push/etc
-});
-
-export const Interface = Entity.merge(
-  z.object({
-    ratingId: ObjectId.optional(),
-    groupId: ObjectId.optional(),
-    submissions: z.array(ObjectId).optional(),
-
-    // ✅ NEW: composition / inheritance
-    inherits: z.array(z.string()).default([]),
-
-    // ✅ NEW: variables available to formula scope + patch engine
-    variables: z.record(z.unknown()).default({}),
-
-    // ✅ NEW: patch list applied on top of inherited/base nodes
-    patches: z.array(InterfacePatch).default([]),
-
-    // existing
-    nodes: z.any(), // you can later tighten this to z.array(AnyNodeSchema)
-    version: z.number().optional(),
-    status: z.enum(['Paused', 'Pending', 'Active', 'Archived', 'Published', 'Draft']).default('Active'),
-  })
-);
-
-export const InterfaceGroup = Entity.merge(
-  z.object({
-    roles: z.array(ObjectId).optional(),
-  })
-);
-
-export const InterfaceComponent = Entity.merge(
-  z.object({
-    value: z.unknown().optional(),
-    data: z.record(z.unknown()).optional(),
-    type: z.string().optional(),
-    hasAttachment: z.boolean().optional(),
-    hasValidation: z.boolean().optional(),
-    isDisabled: z.boolean().optional(),
-    isEditable: z.boolean().optional(),
-    isRequired: z.boolean().optional(),
-  })
-);
-
-export const InterfaceSubmission = Entity.merge(
-  z.object({
-    interfaceId: ObjectId,
-    interface: ObjectId.optional(),
-  })
-);

package/modules/interface/interface.service.ts

@@ -1,356 +0,0 @@
-import _ from 'lodash';
-import { getFilter } from '../../util/api';
-import type {
-  RouterContext,
-  RouterInput,
-  RouterOutput,
-  Interface,
-  InterfaceDocument,
-  InterfaceGroupDocument,
-  InterfaceComponentDocument,
-} from './interface.types';
-import { log, logError } from '../../util';
-import { ARXError } from '../../util/rpc';
-
-export class Service {
-  constructor() {}
-
-  // Interface Methods
-  async getInterfaces(input: RouterInput['getInterfaces'], ctx: RouterContext): Promise<RouterOutput['getInterfaces']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getInterfaces', input);
-    const filter = getFilter(input);
-    const limit = input.limit ?? 50;
-    const skip = input.skip ?? 0;
-
-    const [items, total] = await Promise.all([
-      // If your Interface model has findJSON like Conversation:
-      ctx.app.model.Interface.findJSON(filter, null, { skip, limit }),
-      ctx.app.model.Interface.find(filter).countDocuments().exec(),
-    ]);
-
-    return { items, total };
-  }
-
-  async getInterface(input: RouterInput['getInterface'], ctx: RouterContext): Promise<RouterOutput['getInterface']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getInterface', input);
-    // If you have findOneJSON on Interface:
-    const iface = await ctx.app.model.Interface.findOneJSON(getFilter(input));
-    if (!iface) throw new Error('Interface not found');
-    return iface as Interface;
-  }
-
-  async createInterface(
-    input: RouterInput['createInterface'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createInterface']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createInterface', input);
-
-    // Same pattern as createConversation: expect { data: {...} }
-    const iface = await ctx.app.model.Interface.create(input.data);
-    return iface as Interface;
-  }
-
-  async updateInterface(
-    input: RouterInput['updateInterface'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateInterface']> {
-    if (!input) throw new ARXError('NO_INPUT');
-
-    const filters = getFilter(input);
-    if (!filters._id) throw new ARXError('BAD_REQUEST');
-
-    log('Core.Service.updateInterface', input);
-    const updatedInterface = await ctx.app.model.Interface.findByIdAndUpdate(filters._id, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-
-    if (!updatedInterface) throw new Error('Interface update failed');
-    return updatedInterface as Interface;
-  }
-
-  async deleteInterface(
-    input: RouterInput['deleteInterface'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteInterface']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.deleteInterface', input);
-    const deleted = await ctx.app.model.Interface.findByIdAndDelete(input.where.id.equals).exec();
-    if (!deleted) throw new Error('Interface not found');
-    return { id: input.where.id.equals };
-  }
-
-  // // Interface Methods
-  // async getInterface(input: RouterInput['getInterface'], ctx: RouterContext): Promise<RouterOutput['getInterface']> {
-  //   if (!input) throw new Error('Input should not be void');
-  //   console.log('Interface.Service.getInterface', input);
-
-  //   const filter = getFilter(input);
-  //   const interfac = await ctx.app.model.Interface.findOne(filter).select('-meta').exec();
-  //   if (!interfac) throw new Error('Interface not found');
-
-  //   if (!interfac.version) interfac.version = 1;
-  //   if (!interfac.meta) interfac.meta = {};
-
-  //   return interfac as InterfaceDocument;
-  // }
-
-  // async getInterfaces(input: RouterInput['getInterfaces'], ctx: RouterContext): Promise<RouterOutput['getInterfaces']> {
-  //   if (!input) throw new Error('Input should not be void');
-
-  //   const filter = getFilter(input);
-  //   console.log('Interface.Service.getInterfaces', input, filter);
-  //   const interfaces = await ctx.app.model.Interface.find(filter).select('-meta').exec();
-  //   const rolesOnUsers = ['Super User']; // await this.fetchRolesFromContext(ctx);
-
-  //   for (const interfac of interfaces) {
-  //     if (!interfac.version) interfac.version = 1;
-  //     if (!interfac.meta) interfac.meta = {};
-  //   }
-
-  //   return interfaces.filter((interfac) => {
-  //     const roles = [];
-  //     return this.hasPermission(roles, rolesOnUsers);
-  //   }) as InterfaceDocument[];
-  // }
-
-  // async createInterface(
-  //   input: RouterInput['createInterface'],
-  //   ctx: RouterContext
-  // ): Promise<RouterOutput['createInterface']> {
-  //   if (!input) throw new Error('Input should not be void');
-
-  //   const existingInterface = await ctx.app.model.Interface.findOne({ key: input.data.key }).exec();
-  //   const version = existingInterface ? existingInterface.version + 1 : 1;
-
-  //   const newInterface = await ctx.app.model.Interface.create({
-  //     ...input.data,
-  //     status: input.data.status || 'Draft',
-  //     version,
-  //     createdDate: new Date(),
-  //   });
-
-  //   await ctx.app.service.Job.updateMetrics({}, ctx);
-
-  //   return newInterface as InterfaceDocument;
-  // }
-
-  async createInterfaceDraft(
-    input: RouterInput['createInterfaceDraft'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createInterfaceDraft']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.createInterfaceDraft', input);
-
-    const existingInterface = await ctx.app.model.Interface.findOne({ key: input.data.key }).exec();
-    const version = existingInterface ? existingInterface.version + 1 : 1;
-
-    const newInterface = await ctx.app.model.Interface.create({
-      ...input.data,
-      status: input.data.status || 'Draft',
-      version,
-      createdDate: new Date(),
-    });
-
-    await ctx.app.service.Job.updateMetrics({}, ctx);
-
-    return newInterface as InterfaceDocument;
-  }
-
-  // async updateInterface(
-  //   input: RouterInput['updateInterface'],
-  //   ctx: RouterContext
-  // ): Promise<RouterOutput['updateInterface']> {
-  //   if (!input) throw new Error('Input should not be void');
-  //   console.log('Interface.Service.updateInterface', input);
-
-  //   const filter = getFilter(input);
-  //   let interfac: any = await ctx.app.model.Interface.findOne(filter).exec();
-  //   if (!interfac) throw new Error('Interface does not exist');
-
-  //   if (interfac.status === 'Published' || input.data.groupId) {
-  //     await ctx.app.model.Interface.updateMany({ key: interfac.key, status: 'Draft' }, { status: 'Archived' }).exec();
-  //     const version =
-  //       (await ctx.app.model.Interface.find({ key: interfac.key }).sort({ version: -1 }).exec())[0].version + 1;
-
-  //     interfac = (await ctx.app.model.Interface.create({
-  //       ...interfac,
-  //       ...input.data,
-  //       status: 'Draft',
-  //       version,
-  //       createdDate: new Date(),
-  //     })) as InterfaceDocument;
-  //   } else {
-  //     await ctx.app.model.Interface.updateOne(filter, input.data).exec();
-  //     interfac = await ctx.app.model.Interface.findOne(filter).exec();
-  //   }
-
-  //   await ctx.app.service.Job.updateMetrics({}, ctx);
-
-  //   return interfac as InterfaceDocument;
-  // }
-
-  // async deleteInterface(
-  //   input: RouterInput['deleteInterface'],
-  //   ctx: RouterContext
-  // ): Promise<RouterOutput['deleteInterface']> {
-  //   if (!input) throw new Error('Input should not be void');
-  //   console.log('Interface.Service.deleteInterface', input);
-
-  //   const filter = getFilter(input);
-  //   const interfac = await ctx.app.model.Interface.findOne(filter).exec();
-  //   if (!interfac) throw new Error('Interface does not exist');
-
-  //   interfac.status = 'Archived';
-  //   interfac.updatedDate = new Date();
-  //   await ctx.app.model.Interface.updateOne(filter, interfac).exec();
-
-  //   await ctx.app.service.Job.updateMetrics({}, ctx);
-
-  //   return interfac as InterfaceDocument;
-  // }
-
-  async getInterfaceGroup(
-    input: RouterInput['getInterfaceGroup'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getInterfaceGroup']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.getInterfaceGroup', input);
-
-    const filter = getFilter(input);
-    const group = await ctx.app.model.InterfaceGroup.findOne(filter).exec();
-    if (!group) throw new Error('InterfaceGroup not found');
-
-    if (!group.roles) group.roles = [];
-
-    // for (const role of group.roles) {
-    //   role.role = await ctx.app.service.Profile.findRole({
-    //     where: { id: { equals: role.role.id } },
-    //   });
-    // }
-
-    return group as InterfaceGroupDocument;
-  }
-
-  async getInterfaceGroups(
-    input: RouterInput['getInterfaceGroups'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getInterfaceGroups']> {
-    console.log('Interface.Service.getInterfaceGroups', input);
-
-    const filter = getFilter(input);
-    const groups = await ctx.app.model.InterfaceGroup.find(filter).exec();
-
-    return groups as InterfaceGroupDocument[];
-  }
-
-  async createInterfaceGroup(
-    input: RouterInput['createInterfaceGroup'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createInterfaceGroup']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.createInterfaceGroup', input);
-
-    const newGroup = await ctx.app.model.InterfaceGroup.create(input.data);
-
-    return newGroup as InterfaceGroupDocument;
-  }
-
-  async updateInterfaceGroup(
-    input: RouterInput['updateInterfaceGroup'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateInterfaceGroup']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.updateInterfaceGroup', input);
-
-    const filter = getFilter(input);
-    await ctx.app.model.InterfaceGroup.updateOne(filter, input.data, {
-      runValidators: true,
-    }).exec();
-
-    const updatedGroup = await ctx.app.model.InterfaceGroup.findOne(filter).exec();
-    if (!updatedGroup) throw new Error('InterfaceGroup update failed');
-
-    return updatedGroup as InterfaceGroupDocument;
-  }
-
-  async getInterfaceComponent(
-    input: RouterInput['getInterfaceComponent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getInterfaceComponent']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.getInterfaceComponent', input);
-
-    const filter = getFilter(input);
-    const component = await ctx.app.model.InterfaceComponent.findOne(filter).exec();
-    if (!component) throw new Error('InterfaceComponent not found');
-
-    return component as InterfaceComponentDocument;
-  }
-
-  async createInterfaceComponent(
-    input: RouterInput['createInterfaceComponent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createInterfaceComponent']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.createInterfaceComponent', input);
-
-    if (
-      await ctx.app.model.InterfaceComponent.findOne({
-        $or: [{ name: input.data.name }, { key: input.data.key }],
-      }).exec()
-    ) {
-      throw new Error('Component template already exists');
-    }
-
-    const component = await ctx.app.model.InterfaceComponent.create({
-      name: input.data.name,
-      key: input.data.key,
-      status: input.data.status,
-      meta: input.data.meta,
-    });
-
-    await ctx.app.service.Job.updateMetrics({}, ctx);
-
-    return component as InterfaceComponentDocument;
-  }
-
-  async updateInterfaceComponent(
-    input: RouterInput['updateInterfaceComponent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateInterfaceComponent']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Interface.Service.updateInterfaceComponent', input);
-
-    const filter = getFilter(input);
-    const data = Object.entries(input.data).reduce((acc, [key, value]: any) => {
-      if (value?.set) acc[key] = value.set;
-      return acc;
-    }, {} as any);
-
-    await ctx.app.model.InterfaceComponent.updateOne(filter, data, {
-      runValidators: true,
-    }).exec();
-
-    const updatedComponent = await ctx.app.model.InterfaceComponent.findOne(filter).exec();
-    if (!updatedComponent) throw new Error('InterfaceComponent update failed');
-
-    await ctx.app.service.Job.updateMetrics({}, ctx);
-
-    return updatedComponent as InterfaceComponentDocument;
-  }
-
-  // Helper Methods
-  private async fetchRolesFromContext(ctx: RouterContext): Promise<string[]> {
-    // @ts-ignore
-    return ctx.profile?.roles.filter((r) => r.status === 'Active').map((r) => r.role.name) || [];
-  }
-
-  private hasPermission(roles: string[], rolesOnUsers: string[]): boolean {
-    return rolesOnUsers.includes('Super User') || _.intersection(roles, rolesOnUsers).length > 0;
-  }
-}

package/modules/interface/interface.types.ts

@@ -1,25 +0,0 @@
-import { z, Model, Document } from '../../util/mongo';
-import * as schema from './interface.schema';
-
-export type * from './interface.router';
-export type * from './interface.service';
-export type { RouterContext } from '../../types';
-
-export type Interface = z.infer<typeof schema.Interface>;
-export type InterfaceDocument = Interface & Document;
-
-export type InterfaceGroup = z.infer<typeof schema.InterfaceGroup>;
-export type InterfaceGroupDocument = InterfaceGroup & Document;
-
-export type InterfaceComponent = z.infer<typeof schema.InterfaceComponent>;
-export type InterfaceComponentDocument = InterfaceComponent & Document;
-
-export type InterfaceSubmission = z.infer<typeof schema.InterfaceSubmission>;
-export type InterfaceSubmissionDocument = InterfaceSubmission & Document;
-
-export type Mappings = {
-  Interface: Model<InterfaceDocument>;
-  InterfaceGroup: Model<InterfaceGroupDocument>;
-  InterfaceComponent: Model<InterfaceComponentDocument>;
-  InterfaceSubmission: Model<InterfaceSubmissionDocument>;
-};

package/modules/item/index.ts

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

package/modules/item/item.models.ts

@@ -1,124 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './item.types';
-
-const { addTagVirtuals, addApplicationVirtual } = mongo;
-
-export const Item = mongo.createModel<Types.ItemDocument>(
-  'Item',
-  {
-    token: { type: String, maxlength: 500, minlength: 1, required: true },
-    characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character', required: true },
-    assetId: { type: mongo.Schema.Types.ObjectId, ref: 'Asset', required: true },
-    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: false },
-    materialId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemMaterial', required: false },
-    skinId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSkin', required: false },
-    recipeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRecipe', required: false },
-    typeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemType', required: false },
-    subTypeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSubType', required: false },
-    specificTypeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSpecificType', required: false },
-    rarityId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRarity', required: false },
-    rankId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRank', required: false },
-    rankValue: { type: Number, integer: true, min: 0, max: 100, required: false },
-    slotIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemSlot', required: false }],
-    setId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSet', required: false },
-    attributes: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemAttribute', required: false }],
-    quantity: { type: Number, integer: true, min: 0, default: 1 },
-    distribution: { type: String, default: 'Unknown' },
-    x: { type: Number, integer: true, min: 0, required: false },
-    y: { type: Number, integer: true, min: 0, required: false },
-    items: [{ type: mongo.Schema.Types.ObjectId, ref: 'Item', default: [] }],
-    capacity: { type: Number, integer: true, min: 0, default: 60 },
-    points: { type: Number, integer: true, min: 0, default: 0 },
-  },
-  {
-    extend: 'EntityFields',
-    indexes: [{ quantity: 1 }, { points: 1 }, { capacity: 1 }],
-    virtuals: [
-      ...addTagVirtuals('Item'),
-      ...addApplicationVirtual(),
-      {
-        name: 'character',
-      },
-      {
-        name: 'asset',
-      },
-      {
-        name: 'chain',
-      },
-      {
-        name: 'material',
-      },
-      {
-        name: 'skin',
-      },
-      {
-        name: 'recipe',
-      },
-      {
-        name: 'type',
-      },
-      {
-        name: 'subType',
-      },
-      {
-        name: 'specificType',
-      },
-      {
-        name: 'rarity',
-      },
-    ],
-  }
-);
-
-export const ItemAttribute = mongo.createModel<Types.ItemAttributeDocument>('ItemAttribute', {});
-
-export const ItemMaterial = mongo.createModel<Types.ItemMaterialDocument>('ItemMaterial', {});
-
-export const ItemSet = mongo.createModel<Types.ItemSetDocument>('ItemSet', {});
-
-export const ItemSlot = mongo.createModel<Types.ItemSlotDocument>('ItemSlot', {});
-
-export const ItemRarity = mongo.createModel<Types.ItemRarityDocument>('ItemRarity', {});
-
-export const ItemRank = mongo.createModel<Types.ItemRankDocument>('ItemRank', {
-  value: { type: Number },
-});
-
-export const ItemType = mongo.createModel<Types.ItemTypeDocument>('ItemType', {});
-
-export const ItemSubType = mongo.createModel<Types.ItemSubTypeDocument>('ItemSubType', {});
-
-export const ItemSpecificType = mongo.createModel<Types.ItemSpecificTypeDocument>('ItemSpecificType', {});
-
-export const ItemAffix = mongo.createModel<Types.ItemAffixDocument>('ItemAffix', {
-  isPrefix: { type: Boolean, default: false },
-  isSuffix: { type: Boolean, default: false },
-  isTitle: { type: Boolean, default: false },
-  weight: { type: Number, min: 0, default: 1 },
-  typeIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemType', required: false }],
-  rarityIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemRarity', required: false }],
-});
-
-export const ItemRecipe = mongo.createModel<Types.ItemRecipeDocument>('ItemRecipe', {});
-
-export const ItemSkin = mongo.createModel<Types.ItemSkinDocument>('ItemSkin', {});
-
-export const ItemTransmute = mongo.createModel<Types.ItemTransmuteDocument>(
-  'ItemTransmute',
-  {
-    token: { type: String, maxlength: 500, required: true },
-    assetId: { type: mongo.Schema.Types.ObjectId, ref: 'Asset', required: true },
-    itemId: { type: mongo.Schema.Types.ObjectId, ref: 'Item', required: true },
-    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
-  },
-  {
-    virtuals: [
-      {
-        name: 'item',
-      },
-      {
-        name: 'asset',
-      },
-    ],
-  }
-);

package/modules/item/item.router.ts

@@ -1,103 +0,0 @@
-import { z as zod } from 'zod';
-import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '../../schema';
-import {
-  Item,
-  ItemAttribute,
-  ItemMaterial,
-  ItemSet,
-  ItemSlot,
-  ItemRarity,
-  ItemType,
-  ItemSubType,
-  ItemSpecificType,
-  ItemAffix,
-  ItemRecipe,
-  ItemSkin,
-  ItemTransmute,
-} from './item.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({
-    getItem: procedure
-      .use(hasRole('guest', t))
-      .input(getQueryInput(Item))
-      .output(Item)
-      .query(({ input, ctx }) => (ctx.app.service.Item.getItem as any)(input, ctx)),
-
-    getItems: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Item))
-      // .output(z.array(Item))
-      .query(({ input, ctx }) => (ctx.app.service.Item.getItems as any)(input, ctx)),
-
-    createItem: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Item))
-      .output(Item.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItem as any)(input, ctx)),
-
-    updateItem: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Item))
-      .output(Item.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItem as any)(input, ctx)),
-
-    getItemAttribute: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ItemAttribute))
-      .output(ItemAttribute)
-      .query(({ input, ctx }) => (ctx.app.service.Item.getItemAttribute as any)(input, ctx)),
-
-    createItemAttribute: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ItemAttribute))
-      .output(ItemAttribute.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItemAttribute as any)(input, ctx)),
-
-    updateItemAttribute: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ItemAttribute))
-      .output(ItemAttribute.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItemAttribute as any)(input, ctx)),
-
-    // Add more procedures for other entities like ItemMaterial, ItemSet, ItemSlot, ItemRarity, etc.
-
-    getItemTransmute: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ItemTransmute))
-      .output(ItemTransmute)
-      .query(({ input, ctx }) => (ctx.app.service.Item.getItemTransmute as any)(input, ctx)),
-
-    createItemTransmute: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ItemTransmute))
-      .output(ItemTransmute.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItemTransmute as any)(input, ctx)),
-
-    updateItemTransmute: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ItemTransmute))
-      .output(ItemTransmute.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItemTransmute as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;