@arken/seer-protocol 0.1.1 → 0.1.3

package/character/character.models.ts

@@ -0,0 +1,174 @@
+import * as mongo from '@arken/node/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/character/character.router.ts

@@ -0,0 +1,314 @@
+// module/character.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/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>;

package/character/character.schema.ts

@@ -0,0 +1,150 @@
+// module/character.schema.ts
+
+import { z, ObjectId, Entity } from '../schema';
+import { Item } from '../item/item.schema';
+
+export const CharacterEquipment = Entity.merge(
+  z.object({
+    characterId: ObjectId,
+    leftHand: Item.optional(),
+    rightHand: Item.optional(),
+    head: Item.optional(),
+    pet: Item.optional(),
+    neck: Item.optional(),
+    legs: Item.optional(),
+    chest: Item.optional(),
+    waist: Item.optional(),
+    hands: Item.optional(),
+    wrists: Item.optional(),
+    shoulders: Item.optional(),
+    feet: Item.optional(),
+    finger1: Item.optional(),
+    finger2: Item.optional(),
+    trinket1: Item.optional(),
+    trinket2: Item.optional(),
+    trinket3: Item.optional(),
+    body: Item.optional(),
+    companion: Item.optional(),
+    mount: Item.optional(),
+  })
+);
+
+export const CharacterInventory = Entity.merge(
+  z.object({
+    characterId: ObjectId,
+    items: z.array(Item).default([]),
+  })
+);
+
+// Character schema
+export const Character = Entity.merge(
+  z.object({
+    profileId: ObjectId.optional(),
+    ratingId: ObjectId.optional(),
+    classId: ObjectId.optional(),
+    raceId: ObjectId.optional(),
+    factionId: ObjectId.optional(),
+    genderId: ObjectId.optional(),
+    guildId: ObjectId.optional(),
+    token: z
+      .string()
+      .min(1)
+      .optional(),
+    points: z.number().default(0),
+    isPrimary: z.boolean().default(false),
+    isBoss: z.boolean().default(false),
+    isPlayer: z.boolean().default(false),
+    equipmentIndex: z.number().default(0),
+    equipment: z.array(CharacterEquipment).default([]),
+    inventoryIndex: z.number().default(0),
+    inventory: z.array(CharacterInventory).default([]),
+    energyIds: z.array(ObjectId).optional(),
+    areaIds: z.array(ObjectId).optional(),
+    typeIds: z.array(ObjectId).optional(),
+    itemMaterialIds: z.array(ObjectId).optional(),
+  })
+);
+
+// CharacterAbility schema
+export const CharacterAbility = Entity.merge(
+  z.object({
+    // Define fields for CharacterAbility here if needed
+  })
+);
+
+// CharacterAttribute schema
+export const CharacterAttribute = Entity.merge(
+  z.object({
+    // Define fields for CharacterAttribute here if needed
+  })
+);
+
+// CharacterType schema
+export const CharacterType = Entity.merge(
+  z.object({
+    // Define fields for CharacterType here if needed
+  })
+);
+
+// CharacterClass schema
+export const CharacterClass = Entity.merge(
+  z.object({
+    // Define fields for CharacterClass here if needed
+  })
+);
+
+// CharacterRace schema
+export const CharacterRace = Entity.merge(
+  z.object({
+    npcs: z.array(ObjectId).optional(),
+  })
+);
+
+// CharacterGender schema
+export const CharacterGender = Entity.merge(
+  z.object({
+    // Define fields for CharacterGender here if needed
+  })
+);
+
+// CharacterPersonality schema
+export const CharacterPersonality = Entity.merge(
+  z.object({
+    // Define fields for CharacterPersonality here if needed
+  })
+);
+
+// CharacterTitle schema
+export const CharacterTitle = Entity.merge(
+  z.object({
+    // Define fields for CharacterTitle here if needed
+  })
+);
+
+// CharacterFaction schema
+export const CharacterFaction = Entity.merge(
+  z.object({
+    shortDescription: z.string(),
+    // "npcs": [],
+    // "areas": [24, 77],
+    // "activeFactionConflict": [9], // CharacterFaction list
+    // "passiveFactionConflict": [6], // CharacterFaction list
+    // "activeGuildConflict": [], // Team
+    // "areaConflict": [], // Area list
+    // "characters": [] // Character list
+  })
+);
+
+// CharacterNameChoice schema
+export const CharacterNameChoice = Entity.merge(
+  z.object({
+    // Define fields for CharacterNameChoice here if needed
+  })
+);
+
+// CharacterGuild schema
+export const CharacterGuild = Entity.merge(
+  z.object({
+    // Define fields for CharacterGuild here if needed
+  })
+);

package/character/character.types.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import * as schema from './character.schema';
+import { Document, Model } from '@arken/node/mongo';
+
+export type * from './character.router';
+export type { RouterContext } from '../types';
+
+export type Character = z.infer<typeof schema.Character>;
+export type CharacterDocument = Character & Document;
+
+export type CharacterEquipment = z.infer<typeof schema.CharacterEquipment>;
+export type CharacterEquipmentDocument = CharacterEquipment & Document;
+
+export type CharacterInventory = z.infer<typeof schema.CharacterInventory>;
+export type CharacterInventoryDocument = CharacterInventory & Document;
+
+export type CharacterAbility = z.infer<typeof schema.CharacterAbility>;
+export type CharacterAbilityDocument = CharacterAbility & Document;
+
+export type CharacterAttribute = z.infer<typeof schema.CharacterAttribute>;
+export type CharacterAttributeDocument = CharacterAttribute & Document;
+
+export type CharacterClass = z.infer<typeof schema.CharacterClass>;
+export type CharacterClassDocument = CharacterClass & Document;
+
+export type CharacterFaction = z.infer<typeof schema.CharacterFaction>;
+export type CharacterFactionDocument = CharacterFaction & Document;
+
+export type CharacterGender = z.infer<typeof schema.CharacterGender>;
+export type CharacterGenderDocument = CharacterGender & Document;
+
+export type CharacterNameChoice = z.infer<typeof schema.CharacterNameChoice>;
+export type CharacterNameChoiceDocument = CharacterNameChoice & Document;
+
+export type CharacterPersonality = z.infer<typeof schema.CharacterPersonality>;
+export type CharacterPersonalityDocument = CharacterPersonality & Document;
+
+export type CharacterRace = z.infer<typeof schema.CharacterRace>;
+export type CharacterRaceDocument = CharacterRace & Document;
+
+export type CharacterTitle = z.infer<typeof schema.CharacterTitle>;
+export type CharacterTitleDocument = CharacterTitle & Document;
+
+export type CharacterType = z.infer<typeof schema.CharacterType>;
+export type CharacterTypeDocument = CharacterType & Document;
+
+export type CharacterGuild = z.infer<typeof schema.CharacterGuild>;
+export type CharacterGuildDocument = CharacterGuild & Document;
+
+export type Mappings = {
+  Character: Model<CharacterDocument>;
+  CharacterAbility: Model<CharacterAbilityDocument>;
+  CharacterAttribute: Model<CharacterAttributeDocument>;
+  CharacterClass: Model<CharacterClassDocument>;
+  CharacterFaction: Model<CharacterFactionDocument>;
+  CharacterGender: Model<CharacterGenderDocument>;
+  CharacterNameChoice: Model<CharacterNameChoiceDocument>;
+  CharacterPersonality: Model<CharacterPersonalityDocument>;
+  CharacterRace: Model<CharacterRaceDocument>;
+  CharacterTitle: Model<CharacterTitleDocument>;
+  CharacterType: Model<CharacterTypeDocument>;
+  CharacterGuild: Model<CharacterGuildDocument>;
+};