@arken/node 1.5.1 → 1.5.2

package/modules/chain/chain.service.ts

@@ -1,167 +0,0 @@
-import type {
-  Chain,
-  ChainContract,
-  ChainToken,
-  ChainTransaction,
-  Router,
-  RouterInput,
-  RouterOutput,
-  RouterContext,
-} from './chain.types';
-import { ARXError } from '../../util/rpc';
-import { getFilter } from '../../util/api';
-
-export class Service {
-  async getChain(input: RouterInput['getChain'], ctx: RouterContext): Promise<RouterOutput['getChain']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChain', input);
-
-    const chain = await ctx.app.model.Chain.findOne(getFilter(input)).lean().exec();
-    if (!chain) throw new Error('Chain not found');
-
-    return chain as Chain;
-  }
-
-  async getChainContract(
-    input: RouterInput['getChainContract'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getChainContract']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChainContract', input);
-
-    const chainContract = await ctx.app.model.ChainContract.findOne(getFilter(input)).lean().exec();
-    if (!chainContract) throw new Error('ChainContract not found');
-
-    return chainContract as ChainContract;
-  }
-
-  async getChainToken(input: RouterInput['getChainToken'], ctx: RouterContext): Promise<RouterOutput['getChainToken']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChainToken', input);
-
-    const chainToken = await ctx.app.model.ChainToken.findOne(getFilter(input)).lean().exec();
-    if (!chainToken) throw new Error('ChainToken not found');
-
-    return chainToken as ChainToken;
-  }
-
-  async getChainTransaction(
-    input: RouterInput['getChainTransaction'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getChainTransaction']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChainTransaction', input);
-
-    const chainTransaction = await ctx.app.model.ChainTransaction.findOne(getFilter(input)).lean().exec();
-    if (!chainTransaction) throw new Error('ChainTransaction not found');
-
-    return chainTransaction as ChainTransaction;
-  }
-
-  async createChain(input: RouterInput['createChain'], ctx: RouterContext): Promise<RouterOutput['createChain']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChain', input);
-
-    const chain = await ctx.app.model.Chain.create(input);
-
-    return chain as Chain;
-  }
-
-  async createChainContract(
-    input: RouterInput['createChainContract'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChainContract']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChainContract', input);
-
-    const chainContract = await ctx.app.model.ChainContract.create(input);
-
-    return chainContract as ChainContract;
-  }
-
-  async createChainToken(
-    input: RouterInput['createChainToken'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChainToken']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChainToken', input);
-
-    const chainToken = await ctx.app.model.ChainToken.create(input);
-
-    return chainToken as ChainToken;
-  }
-
-  async createChainTransaction(
-    input: RouterInput['createChainTransaction'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChainTransaction']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChainTransaction', input);
-
-    const chainTransaction = await ctx.app.model.ChainToken.create(input);
-
-    return chainTransaction as ChainTransaction;
-  }
-
-  async updateChain(input: RouterInput['updateChain'], ctx: RouterContext): Promise<RouterOutput['updateChain']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChain', input);
-
-    const updatedChain = await ctx.app.model.Game.findByIdAndUpdate(input.where.id.equals, { new: true }).lean().exec();
-    if (!updatedChain) throw new Error('Chain update failed');
-
-    return updatedChain as Chain;
-  }
-
-  async updateChainContract(
-    input: RouterInput['updateChainContract'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChainContract']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChainContract', input);
-
-    const updatedChainContract = await ctx.app.model.ChainContract.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-
-    if (!updatedChainContract) throw new Error('ChainContract update failed');
-
-    return updatedChainContract as ChainContract;
-  }
-
-  async updateChainToken(
-    input: RouterInput['updateChainToken'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChainToken']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChainToken', input);
-
-    const updatedChainToken = await ctx.app.model.ChainToken.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-
-    if (!updatedChainToken) throw new Error('ChainToken update failed');
-
-    return updatedChainToken as ChainToken;
-  }
-
-  async updateChainTransaction(
-    input: RouterInput['updateChainTransaction'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChainTransaction']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChainTransaction', input);
-
-    const updatedChainTransaction = await ctx.app.model.ChainTransaction.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-
-    if (!updatedChainTransaction) throw new Error('ChainTransaction update failed');
-
-    return updatedChainTransaction as ChainTransaction;
-  }
-}

package/modules/chain/chain.types.ts

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import * as schema from './chain.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './chain.router';
-export type * from './chain.service';
-export type { RouterContext } from '../../types';
-
-export type Chain = z.infer<typeof schema.Chain>;
-export type ChainContract = z.infer<typeof schema.ChainContract>;
-export type ChainToken = z.infer<typeof schema.ChainToken>;
-export type ChainTransaction = z.infer<typeof schema.ChainTransaction>;
-
-export type ChainDocument = Chain & Document;
-export type ChainContractDocument = ChainContract & Document;
-export type ChainTokenDocument = ChainToken & Document;
-export type ChainTransactionDocument = ChainTransaction & Document;
-
-export type Mappings = {
-  Chain: Model<ChainDocument>;
-  ChainContract: Model<ChainContractDocument>;
-  ChainToken: Model<ChainTokenDocument>;
-  ChainTransaction: Model<ChainTransactionDocument>;
-};

package/modules/chain/index.ts

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

package/modules/character/character.models.ts

@@ -1,174 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './character.types';
-
-const { addTagVirtuals, addApplicationVirtual } = mongo;
-
-// CharacterEquipment Schema
-const CharacterEquipment = new mongo.Schema(
-  {
-    items: [
-      {
-        itemId: { type: mongo.Schema.Types.ObjectId, ref: 'Item', required: true },
-        slotId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSlot', required: true }, // e.g., 'head', 'chest', etc.
-      },
-    ],
-  },
-  {
-    _id: false,
-    toJSON: { virtuals: true }, // Ensure virtuals are included in JSON responses
-    toObject: { virtuals: true }, // Ensure virtuals are included in object responses
-  } // Prevents Mongoose from creating an _id field for subdocuments
-);
-
-// Add virtual for `item`
-CharacterEquipment.virtual('item', {
-  ref: 'Item',
-  localField: 'items.itemId',
-  foreignField: '_id',
-  justOne: true, // Assuming an `itemId` corresponds to one `Item`
-});
-
-// Add virtual for `slot`
-CharacterEquipment.virtual('slot', {
-  ref: 'ItemSlot',
-  localField: 'items.slotId',
-  foreignField: '_id',
-  justOne: true, // Assuming a `slotId` corresponds to one `ItemSlot`
-});
-
-// CharacterInventory Schema
-const CharacterInventory = new mongo.Schema(
-  {
-    items: [
-      {
-        itemId: { type: mongo.Schema.Types.ObjectId, ref: 'Item', required: true },
-        x: { type: Number },
-        y: { type: Number },
-      },
-    ],
-  },
-  { _id: false }
-);
-
-// Add virtual for `item`
-CharacterEquipment.virtual('item', {
-  ref: 'Item',
-  localField: 'items.itemId',
-  foreignField: '_id',
-  justOne: true, // Assuming an `itemId` corresponds to one `Item`
-});
-
-export const Character = mongo.createModel<Types.CharacterDocument>(
-  'Character',
-  {
-    // teamId: { type: mongo.Schema.Types.ObjectId, ref: 'Team', required: false, autopopulate: true },
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating', required: false },
-    classId: { type: mongo.Schema.Types.ObjectId, ref: 'CharacterClass', required: false },
-    raceId: { type: mongo.Schema.Types.ObjectId, ref: 'CharacterRace', required: false },
-    factionId: { type: mongo.Schema.Types.ObjectId, ref: 'CharacterFaction', required: false },
-    genderId: { type: mongo.Schema.Types.ObjectId, ref: 'CharacterGender', required: false },
-    guildId: { type: mongo.Schema.Types.ObjectId, ref: 'CharacterGuild', required: false },
-    isPrimary: { type: Boolean, required: false, default: false },
-    isBoss: { type: Boolean, required: false, default: false },
-    token: { type: String, required: false, trim: true },
-    points: { type: Number, default: 0, required: true },
-    equipmentIndex: { type: Number, default: 0 },
-    equipment: [{ type: CharacterEquipment, default: [] }],
-    inventoryIndex: { type: Number, default: 0 },
-    inventory: [{ type: CharacterInventory, default: [] }],
-    energyIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Energy', required: false }],
-    areaIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Area', required: false }],
-    typeIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'CharacterType', required: false }],
-    itemMaterialIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemMaterial', required: false }],
-    // level: { type: Number, required: true },
-    // experience: { type: Number, required: true },
-    // gold: { type: Number, default: 0 },
-  },
-  {
-    extend: 'EntityFields',
-    cache: { enabled: true, ttlMs: 5 * 60 * 1000 },
-    indexes: [{ points: 1 }, { token: 1 }],
-    virtuals: [
-      ...addTagVirtuals('Character'),
-      ...addApplicationVirtual(),
-      // {
-      //   name: 'team',
-      // },
-      {
-        name: 'energies',
-        ref: 'Energy',
-        localField: 'energyIds',
-        foreignField: '_id',
-      },
-      {
-        name: 'areas',
-        ref: 'Area',
-        localField: 'areaIds',
-        foreignField: '_id',
-      },
-      {
-        name: 'types',
-        ref: 'CharacterType',
-        localField: 'typeIds',
-        foreignField: '_id',
-      },
-      {
-        name: 'itemMaterials',
-        ref: 'ItemMaterial',
-        localField: 'itemMaterialIds',
-        foreignField: '_id',
-      },
-      {
-        name: 'profile',
-      },
-      {
-        name: 'rating',
-      },
-      {
-        name: 'class',
-      },
-      {
-        name: 'race',
-      },
-      {
-        name: 'faction',
-      },
-      {
-        name: 'gender',
-      },
-      // { name: 'types', ref: 'CharacterType', localField: '_id', foreignField: 'characterId' },
-      // {
-      //   name: 'inventory'
-      //   ref: 'ItemSlot',
-      //   localField: 'items.slotId',
-      //   foreignField: '_id',
-      //   justOne: true, // Assuming a `slotId` corresponds to one `ItemSlot`
-      // },
-      // {
-      //   name: 'quests'
-      // },
-    ],
-  }
-);
-
-export const CharacterAbility = mongo.createModel<Types.CharacterAbilityDocument>('CharacterAbility', {});
-
-export const CharacterAttribute = mongo.createModel<Types.CharacterAttributeDocument>('CharacterAttribute', {});
-
-export const CharacterType = mongo.createModel<Types.CharacterTypeDocument>('CharacterType', {});
-
-export const CharacterClass = mongo.createModel<Types.CharacterClassDocument>('CharacterClass', {});
-
-export const CharacterFaction = mongo.createModel<Types.CharacterFactionDocument>('CharacterFaction', {});
-
-export const CharacterRace = mongo.createModel<Types.CharacterRaceDocument>('CharacterRace', {});
-
-export const CharacterGender = mongo.createModel<Types.CharacterGenderDocument>('CharacterGender', {});
-
-export const CharacterPersonality = mongo.createModel<Types.CharacterPersonalityDocument>('CharacterPersonality', {});
-
-export const CharacterTitle = mongo.createModel<Types.CharacterTitleDocument>('CharacterTitle', {});
-
-export const CharacterGuild = mongo.createModel<Types.CharacterGuildDocument>('CharacterGuild', {});
-
-export const CharacterNameChoice = mongo.createModel<Types.CharacterNameChoiceDocument>('CharacterNameChoice', {});

package/modules/character/character.router.ts

@@ -1,314 +0,0 @@
-// module/character.router.ts
-
-import { z as zod } from 'zod';
-import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import {
-  Character,
-  CharacterAbility,
-  CharacterAttribute,
-  CharacterType,
-  CharacterClass,
-  CharacterRace,
-  CharacterGender,
-  CharacterPersonality,
-  CharacterTitle,
-  CharacterFaction,
-  CharacterNameChoice,
-} from './character.schema';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } 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({
-    getCharacterInventory: procedure
-      .use(hasRole('user', t))
-      .use(customErrorFormatter(t))
-      .input(
-        z.object({
-          characterId: z.string(),
-        })
-      )
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.getCharacterInventory as any)(input, ctx)),
-
-    setActiveCharacter: procedure
-      .use(hasRole('user', t))
-      .use(customErrorFormatter(t))
-      .input(
-        z.object({
-          characterId: z.string(),
-        })
-      )
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.setActiveCharacter as any)(input, ctx)),
-
-    exchangeCharacterItem: procedure
-      .use(hasRole('user', t))
-      .use(customErrorFormatter(t))
-      .input(
-        z.object({
-          characterId: z.string(),
-          itemId: z.string(),
-        })
-      )
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.exchangeCharacterItem as any)(input, ctx)),
-
-    getCharacterData: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterData as any)(input, ctx)),
-
-    getCharacter: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      // .output(Character)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacter as any)(input, ctx)),
-
-    getCharacters: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      // .output(z.array(Character))
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacters as any)(input, ctx)),
-
-    saveCharacters: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(z.array(Character), { partialData: false }))
-      // .output(z.array(Character.pick({ id: true })))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.saveCharacters as any)(input, ctx)),
-
-    updateCharacter: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      .output(Character.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacter as any)(input, ctx)),
-
-    getCharacterAbility: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterAbility))
-      .output(CharacterAbility)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterAbility as any)(input, ctx)),
-
-    createCharacterAbility: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterAbility))
-      .output(CharacterAbility.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterAbility as any)(input, ctx)),
-
-    updateCharacterAbility: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterAbility))
-      .output(CharacterAbility.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterAbility as any)(input, ctx)),
-
-    getCharacterAttribute: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterAttribute))
-      .output(CharacterAttribute)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterAttribute as any)(input, ctx)),
-
-    createCharacterAttribute: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterAttribute))
-      .output(CharacterAttribute.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterAttribute as any)(input, ctx)),
-
-    updateCharacterAttribute: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      .output(Character.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterAttribute as any)(input, ctx)),
-
-    getCharacterType: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterType))
-      .output(CharacterType)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterType as any)(input, ctx)),
-
-    createCharacterType: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterType))
-      .output(CharacterType.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterType as any)(input, ctx)),
-
-    updateCharacterType: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterType))
-      .output(CharacterType.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterType as any)(input, ctx)),
-
-    getCharacterClass: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterClass))
-      .output(CharacterClass)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterClass as any)(input, ctx)),
-
-    createCharacterClass: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterClass))
-      .output(CharacterClass.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterClass as any)(input, ctx)),
-
-    updateCharacterClass: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterClass))
-      .output(CharacterClass.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterClass as any)(input, ctx)),
-
-    getCharacterRace: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      .output(Character)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterRace as any)(input, ctx)),
-
-    createCharacterRace: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterRace))
-      .output(CharacterRace.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterRace as any)(input, ctx)),
-
-    updateCharacterRace: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterRace))
-      .output(CharacterRace.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterRace as any)(input, ctx)),
-
-    getCharacterGender: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterGender))
-      .output(CharacterGender)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterGender as any)(input, ctx)),
-
-    createCharacterGender: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterGender))
-      .output(CharacterGender.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterGender as any)(input, ctx)),
-
-    updateCharacterGender: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Character))
-      .output(Character.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterGender as any)(input, ctx)),
-
-    getCharacterPersonality: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterPersonality))
-      .output(CharacterPersonality)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterPersonality as any)(input, ctx)),
-
-    createCharacterPersonality: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterPersonality))
-      .output(CharacterPersonality.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterPersonality as any)(input, ctx)),
-
-    updateCharacterPersonality: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterPersonality))
-      .output(CharacterPersonality.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterPersonality as any)(input, ctx)),
-
-    getCharacterTitle: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterTitle))
-      .output(CharacterTitle)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterTitle as any)(input, ctx)),
-
-    createCharacterTitle: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterTitle))
-      .output(CharacterTitle.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterTitle as any)(input, ctx)),
-
-    updateCharacterTitle: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterTitle))
-      .output(CharacterTitle.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterTitle as any)(input, ctx)),
-
-    getCharacterFaction: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterFaction))
-      .output(CharacterFaction)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterFaction as any)(input, ctx)),
-
-    getCharacterFactions: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterFaction))
-      .output(z.array(CharacterFaction))
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterFactions as any)(input, ctx)),
-
-    createCharacterFaction: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterFaction))
-      .output(CharacterFaction.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterFaction as any)(input, ctx)),
-
-    updateCharacterFaction: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterFaction))
-      .output(CharacterFaction.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterFaction as any)(input, ctx)),
-
-    getCharacterNameChoice: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterNameChoice))
-      .output(CharacterNameChoice)
-      .query(({ input, ctx }) => (ctx.app.service.Character.getCharacterNameChoice as any)(input, ctx)),
-
-    createCharacterNameChoice: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterNameChoice))
-      .output(CharacterNameChoice.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.createCharacterNameChoice as any)(input, ctx)),
-
-    updateCharacterNameChoice: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(CharacterNameChoice))
-      .output(CharacterNameChoice.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Character.updateCharacterNameChoice as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;