@arken/node 1.5.0 → 1.5.2

package/modules/raffle/raffle.router.ts

@@ -1,90 +0,0 @@
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import { Raffle, RaffleRequirement, RaffleReward, RaffleEntry } from './raffle.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({
-    // Raffle endpoints
-    getRaffle: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffle as any)(input, ctx)),
-
-    createRaffle: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(Raffle)
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffle as any)(input, ctx)),
-
-    updateRaffle: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleId: z.string(), data: Raffle.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffle as any)(input, ctx)),
-
-    getRaffleRequirement: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleRequirementId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleRequirement as any)(input, ctx)),
-
-    createRaffleRequirement: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(RaffleRequirement)
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleRequirement as any)(input, ctx)),
-
-    updateRaffleRequirement: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleRequirementId: z.string(), data: RaffleRequirement.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleRequirement as any)(input, ctx)),
-
-    getRaffleReward: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleRewardId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleReward as any)(input, ctx)),
-
-    createRaffleReward: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(RaffleReward)
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleReward as any)(input, ctx)),
-
-    updateRaffleReward: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleRewardId: z.string(), data: RaffleReward.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleReward as any)(input, ctx)),
-
-    getRaffleEntry: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleEntryId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleEntry as any)(input, ctx)),
-
-    createRaffleEntry: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(RaffleEntry)
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleEntry as any)(input, ctx)),
-
-    updateRaffleEntry: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ raffleEntryId: z.string(), data: RaffleEntry.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleEntry as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/raffle/raffle.schema.ts

@@ -1,32 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const Raffle = Entity.merge(
-  z.object({
-    content: z.string().min(1),
-    rewards: z.array(ObjectId).optional(), // List of reward IDs
-  })
-);
-
-export const RaffleRequirement = Entity.merge(
-  z.object({
-    amount: z.number().min(1),
-    raffleRewardId: ObjectId.optional(), // Reference to the associated RaffleReward
-  })
-);
-
-export const RaffleReward = Entity.merge(
-  z.object({
-    raffleId: ObjectId.optional(), // Reference to the associated Raffle
-    winnerId: ObjectId.optional(), // Reference to the winning Profile
-    requirements: z.array(ObjectId).optional(), // List of associated RaffleRequirement IDs
-    entries: z.array(ObjectId).optional(), // List of associated RaffleEntry IDs
-  })
-);
-
-export const RaffleEntry = Entity.merge(
-  z.object({
-    amount: z.number().min(1),
-    raffleRewardId: ObjectId.optional(), // Reference to the associated RaffleReward
-    raffleId: ObjectId.optional(), // Reference to the associated Raffle
-  })
-);

package/modules/raffle/raffle.service.ts

@@ -1,167 +0,0 @@
-import type {
-  Raffle,
-  RaffleRequirement,
-  RaffleReward,
-  RaffleEntry,
-  RouterContext,
-  Router,
-  RouterInput,
-  RouterOutput,
-} from './raffle.types';
-
-export class Service {
-  async getRaffle(input: RouterInput['getRaffle'], ctx: RouterContext): Promise<RouterOutput['getRaffle']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.getRaffle', input.raffleId);
-
-    const raffle = await ctx.app.model.Raffle.findById(input.raffleId).lean().exec();
-    if (!raffle) throw new Error('Raffle not found');
-
-    return raffle as Raffle;
-  }
-
-  async createRaffle(input: RouterInput['createRaffle'], ctx: RouterContext): Promise<RouterOutput['createRaffle']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.createRaffle', input);
-
-    const raffle = await ctx.app.model.Raffle.create(input);
-    return raffle as Raffle;
-  }
-
-  async updateRaffle(input: RouterInput['updateRaffle'], ctx: RouterContext): Promise<RouterOutput['updateRaffle']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.updateRaffle', input.raffleId, input.data);
-
-    const updatedRaffle = await ctx.app.model.Raffle.findByIdAndUpdate(input.raffleId, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedRaffle) throw new Error('Raffle update failed');
-
-    return updatedRaffle as Raffle;
-  }
-
-  async getRaffleRequirement(
-    input: RouterInput['getRaffleRequirement'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getRaffleRequirement']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.getRaffleRequirement', input.raffleRequirementId);
-
-    const raffleRequirement = await ctx.app.model.RaffleRequirement.findById(input.raffleRequirementId).lean().exec();
-    if (!raffleRequirement) throw new Error('Raffle Requirement not found');
-
-    return raffleRequirement as RaffleRequirement;
-  }
-
-  async createRaffleRequirement(
-    input: RouterInput['createRaffleRequirement'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createRaffleRequirement']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.createRaffleRequirement', input);
-
-    const raffleRequirement = await ctx.app.model.RaffleRequirement.create(input);
-    return raffleRequirement as RaffleRequirement;
-  }
-
-  async updateRaffleRequirement(
-    input: RouterInput['updateRaffleRequirement'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateRaffleRequirement']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.updateRaffleRequirement', input.raffleRequirementId, input.data);
-
-    const updatedRaffleRequirement = await ctx.app.model.RaffleRequirement.findByIdAndUpdate(
-      input.raffleRequirementId,
-      input.data,
-      { new: true }
-    )
-      .lean()
-      .exec();
-    if (!updatedRaffleRequirement) throw new Error('Raffle Requirement update failed');
-
-    return updatedRaffleRequirement as RaffleRequirement;
-  }
-
-  async getRaffleReward(
-    input: RouterInput['getRaffleReward'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getRaffleReward']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.getRaffleReward', input.raffleRewardId);
-
-    const raffleReward = await ctx.app.model.RaffleReward.findById(input.raffleRewardId).lean().exec();
-    if (!raffleReward) throw new Error('Raffle Reward not found');
-
-    return raffleReward as RaffleReward;
-  }
-
-  async createRaffleReward(
-    input: RouterInput['createRaffleReward'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createRaffleReward']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.createRaffleReward', input);
-
-    const raffleReward = await ctx.app.model.RaffleReward.create(input);
-    return raffleReward as RaffleReward;
-  }
-
-  async updateRaffleReward(
-    input: RouterInput['updateRaffleReward'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateRaffleReward']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.updateRaffleReward', input.raffleRewardId, input.data);
-
-    const updatedRaffleReward = await ctx.app.model.RaffleReward.findByIdAndUpdate(input.raffleRewardId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedRaffleReward) throw new Error('Raffle Reward update failed');
-
-    return updatedRaffleReward as RaffleReward;
-  }
-
-  async getRaffleEntry(
-    input: RouterInput['getRaffleEntry'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getRaffleEntry']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.getRaffleEntry', input.raffleEntryId);
-
-    const raffleEntry = await ctx.app.model.RaffleEntry.findById(input.raffleEntryId).lean().exec();
-    if (!raffleEntry) throw new Error('Raffle Entry not found');
-
-    return raffleEntry as RaffleEntry;
-  }
-
-  async createRaffleEntry(
-    input: RouterInput['createRaffleEntry'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createRaffleEntry']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.createRaffleEntry', input);
-
-    const raffleEntry = await ctx.app.model.RaffleEntry.create(input);
-    return raffleEntry as RaffleEntry;
-  }
-
-  async updateRaffleEntry(
-    input: RouterInput['updateRaffleEntry'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateRaffleEntry']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Raffle.Service.updateRaffleEntry', input.raffleEntryId, input.data);
-
-    const updatedRaffleEntry = await ctx.app.model.RaffleEntry.findByIdAndUpdate(input.raffleEntryId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedRaffleEntry) throw new Error('Raffle Entry update failed');
-
-    return updatedRaffleEntry as RaffleEntry;
-  }
-}

package/modules/raffle/raffle.types.ts

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import * as schema from './raffle.schema';
-import { Document, Model } from '../../util/mongo';
-import type { RouterContext } from '../../types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { Router } from './raffle.router';
-
-export type * from './raffle.router';
-export type * from './raffle.service';
-export type { RouterContext };
-
-export type Raffle = z.infer<typeof schema.Raffle>;
-export type RaffleRequirement = z.infer<typeof schema.RaffleRequirement>;
-export type RaffleReward = z.infer<typeof schema.RaffleReward>;
-export type RaffleEntry = z.infer<typeof schema.RaffleEntry>;
-
-export type RaffleDocument = Raffle & Document;
-export type RaffleRequirementDocument = RaffleRequirement & Document;
-export type RaffleRewardDocument = RaffleReward & Document;
-export type RaffleEntryDocument = RaffleEntry & Document;
-
-export type Mappings = {
-  Raffle: Model<RaffleDocument>;
-  RaffleRequirement: Model<RaffleRequirementDocument>;
-  RaffleReward: Model<RaffleRewardDocument>;
-  RaffleEntry: Model<RaffleEntryDocument>;
-};
-
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/skill/index.ts

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

package/modules/skill/skill.models.ts

@@ -1,16 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './skill.types';
-
-export const Skill = mongo.createModel<Types.SkillDocument>('Skill', {});
-
-export const SkillMod = mongo.createModel<Types.SkillModDocument>('SkillMod', {});
-
-export const SkillClassification = mongo.createModel<Types.SkillClassificationDocument>('SkillClassification', {});
-
-export const SkillCondition = mongo.createModel<Types.SkillConditionDocument>('SkillCondition', {});
-
-export const SkillStatusEffect = mongo.createModel<Types.SkillStatusEffectDocument>('SkillStatusEffect', {});
-
-export const SkillTree = mongo.createModel<Types.SkillTreeDocument>('SkillTree', {});
-
-export const SkillTreeNode = mongo.createModel<Types.SkillTreeNodeDocument>('SkillTreeNode', {});

package/modules/skill/skill.router.ts

@@ -1,201 +0,0 @@
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import {
-  Skill,
-  SkillMod,
-  SkillClassification,
-  SkillCondition,
-  SkillStatusEffect,
-  SkillTree,
-  SkillTreeNode,
-} from './skill.schema';
-import { Query } from '../../schema';
-
-export const z = zod;
-export const t = initTRPC.context<RouterContext>().create();
-export const router = t.router;
-export const procedure = t.procedure;
-
-export const createRouter = () =>
-  router({
-    // Skill Procedures
-    getSkill: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkill as any)(input, ctx)),
-
-    createSkill: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: Skill.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkill as any)(input, ctx)),
-
-    updateSkill: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: Skill.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkill as any)(input, ctx)),
-
-    deleteSkill: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkill as any)(input, ctx)),
-
-    // SkillMod Procedures
-    getSkillMod: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillMod as any)(input, ctx)),
-
-    createSkillMod: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: SkillMod.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillMod as any)(input, ctx)),
-
-    updateSkillMod: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: SkillMod.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillMod as any)(input, ctx)),
-
-    deleteSkillMod: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillMod as any)(input, ctx)),
-
-    // SkillClassification Procedures
-    getSkillClassification: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillClassification as any)(input, ctx)),
-
-    createSkillClassification: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: SkillClassification.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillClassification as any)(input, ctx)),
-
-    updateSkillClassification: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: SkillClassification.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillClassification as any)(input, ctx)),
-
-    deleteSkillClassification: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillClassification as any)(input, ctx)),
-
-    // SkillCondition Procedures
-    getSkillCondition: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillCondition as any)(input, ctx)),
-
-    createSkillCondition: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: SkillCondition.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillCondition as any)(input, ctx)),
-
-    updateSkillCondition: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: SkillCondition.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillCondition as any)(input, ctx)),
-
-    deleteSkillCondition: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillCondition as any)(input, ctx)),
-
-    // SkillStatusEffect Procedures
-    getSkillStatusEffect: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillStatusEffect as any)(input, ctx)),
-
-    createSkillStatusEffect: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: SkillStatusEffect.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillStatusEffect as any)(input, ctx)),
-
-    updateSkillStatusEffect: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: SkillStatusEffect.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillStatusEffect as any)(input, ctx)),
-
-    deleteSkillStatusEffect: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillStatusEffect as any)(input, ctx)),
-
-    // SkillTree Procedures
-    getSkillTree: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillTree as any)(input, ctx)),
-
-    createSkillTree: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: SkillTree.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillTree as any)(input, ctx)),
-
-    updateSkillTree: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: SkillTree.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillTree as any)(input, ctx)),
-
-    deleteSkillTree: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillTree as any)(input, ctx)),
-
-    // SkillTreeNode Procedures
-    getSkillTreeNode: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Skill.getSkillTreeNode as any)(input, ctx)),
-
-    createSkillTreeNode: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: SkillTreeNode.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.createSkillTreeNode as any)(input, ctx)),
-
-    updateSkillTreeNode: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: SkillTreeNode.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.updateSkillTreeNode as any)(input, ctx)),
-
-    deleteSkillTreeNode: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Skill.deleteSkillTreeNode as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/skill/skill.schema.ts

@@ -1,40 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const Skill = Entity.merge(
-  z.object({
-    name: z.string().min(1),
-    description: z.string().min(1).optional(),
-    type: z.enum(['attack', 'defense', 'utility']),
-    cooldown: z.number().min(0).optional(),
-    power: z.number().min(0).optional(),
-  })
-);
-
-export const SkillEffect = Entity.merge(
-  z.object({
-    skillId: ObjectId, // Reference to the associated Skill
-    effectType: z.enum(['damage', 'heal', 'buff', 'debuff']),
-    magnitude: z.number().min(0),
-    duration: z.number().min(0).optional(),
-  })
-);
-
-export const SkillRequirement = Entity.merge(
-  z.object({
-    skillId: ObjectId, // Reference to the associated Skill
-    levelRequired: z.number().min(1),
-    previousSkillId: ObjectId.optional(), // Reference to a prerequisite skill
-  })
-);
-
-export const SkillMod = Entity.merge(z.object({}));
-
-export const SkillClassification = Entity.merge(z.object({}));
-
-export const SkillCondition = Entity.merge(z.object({}));
-
-export const SkillStatusEffect = Entity.merge(z.object({}));
-
-export const SkillTree = Entity.merge(z.object({}));
-
-export const SkillTreeNode = Entity.merge(z.object({}));