@arken/node 1.5.0 → 1.5.2

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>;

package/modules/character/character.schema.ts

@@ -1,147 +0,0 @@
-// 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
-  })
-);