@arken/node 1.5.1 → 1.5.2

package/modules/character/character.types.ts

@@ -1,64 +0,0 @@
-import { z } from 'zod';
-import * as schema from './character.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './character.router';
-export type * from './character.service';
-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>;
-};

package/modules/character/index.ts

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

package/modules/chat/chat.models.ts

@@ -1,43 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './chat.types';
-
-// ChatGroup
-export const ChatGroup = mongo.createModel<Types.ChatGroupDocument>('ChatGroup', {
-  name: { type: String, required: true, maxlength: 100 },
-  type: { type: String, required: true, enum: ['group', 'private'] },
-  members: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
-  externalId: { type: String },
-  externalPlatform: { type: String, enum: ['Telegram', 'Discord'] },
-});
-
-// ChatMessage
-export const ChatMessage = mongo.createModel<Types.ChatMessageDocument>(
-  'ChatMessage',
-  {
-    groupId: { type: mongo.Schema.Types.ObjectId, ref: 'ChatGroup', required: true },
-    profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
-    content: { type: String },
-    mediaUrl: { type: String },
-    replyToId: { type: mongo.Schema.Types.ObjectId, ref: 'ChatMessage' },
-    reactions: [
-      {
-        profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
-        reaction: { type: String },
-      },
-    ],
-    externalId: { type: String },
-    externalPlatform: { type: String, enum: ['Telegram', 'Discord'] },
-    isSpam: { type: Boolean, default: false },
-    tags: { type: mongo.Schema.Types.Mixed }, // Correctly define as array of Mixed
-    summary: { type: String },
-    entities: { type: mongo.Schema.Types.Mixed }, // Correctly define as array of Mixed
-    type: {
-      type: String,
-      default: 'text',
-      enum: ['text', 'image', 'video', 'audio', 'file', 'system'],
-    },
-  },
-  {
-    indexes: [{ groupId: 1, createdDate: 1 }, { profileId: 1 }, { status: 1 }, { replyToId: 1 }, { type: 1 }],
-  }
-);

package/modules/chat/chat.router.ts

@@ -1,67 +0,0 @@
-// module/chat.router.ts
-
-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 { ChatGroup, ChatMessage } from './chat.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({
-    getChatGroup: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ chatGroupId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Chat.getChatGroup as any)(input, ctx)),
-
-    getChatGroups: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ chatGroupId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Chat.getChatGroup as any)(input, ctx)),
-
-    createChatGroup: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(ChatGroup)
-      .mutation(({ input, ctx }) => (ctx.app.service.Chat.createChatGroup as any)(input, ctx)),
-
-    updateChatGroup: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ chatGroupId: z.string(), data: ChatGroup.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chat.updateChatGroup as any)(input, ctx)),
-
-    getChatMessage: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ chatMessageId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Chat.getChatMessage as any)(input, ctx)),
-
-    getChatMessages: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ chatMessageId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Chat.getChatMessage as any)(input, ctx)),
-
-    createChatMessage: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(ChatMessage)
-      .mutation(({ input, ctx }) => (ctx.app.service.Chat.createChatMessage as any)(input, ctx)),
-
-    updateChatMessage: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ chatMessageId: z.string(), data: ChatMessage.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chat.updateChatMessage as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/chat/chat.schema.ts

@@ -1,36 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const ChatGroup = Entity.merge(
-  z.object({
-    name: z.string().max(100).min(1),
-    type: z.enum(['group', 'private']),
-    members: z.array(ObjectId),
-    externalId: z.string().optional(),
-    externalPlatform: z.enum(['Telegram', 'Discord']).optional(),
-  })
-);
-
-export const ChatMessage = Entity.merge(
-  z.object({
-    groupId: ObjectId,
-    profileId: ObjectId,
-    content: z.string().optional(),
-    mediaUrl: z.string().optional(),
-    replyToId: ObjectId.optional(),
-    reactions: z
-      .array(
-        z.object({
-          profileId: ObjectId,
-          reaction: z.string(),
-        })
-      )
-      .optional(),
-    externalId: z.string().optional(),
-    externalPlatform: z.enum(['Telegram', 'Discord']).optional(),
-    isSpam: z.boolean().default(false),
-    tags: z.array(z.unknown()).default([]),
-    summary: z.string().optional(),
-    entities: z.array(z.unknown()).default([]),
-    type: z.enum(['text', 'image', 'video', 'audio', 'file', 'system']).default('text'),
-  })
-);

package/modules/chat/chat.service.ts

@@ -1,128 +0,0 @@
-// module/chat.service.ts
-
-import { getFilter } from '../../util/api';
-import type { RouterContext, RouterInput, RouterOutput, ChatGroupDocument, ChatMessageDocument } from './chat.types';
-
-export class Service {
-  constructor() {}
-
-  // ChatGroup Methods
-  async getChatGroup(input: RouterInput['getChatGroup'], ctx: RouterContext): Promise<RouterOutput['getChatGroup']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.getChatGroup', input);
-
-    const filter = getFilter(input);
-    const chatGroup = await ctx.app.model.ChatGroup.findOne(filter).lean().exec();
-    if (!chatGroup) throw new Error('ChatGroup not found');
-
-    // @ts-ignore
-    return chatGroup as ChatGroupDocument;
-  }
-
-  async getChatGroups(input: RouterInput['getChatGroups'], ctx: RouterContext): Promise<RouterOutput['getChatGroups']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.getChatGroups', input);
-
-    const filter = getFilter(input);
-    const chatGroups = await ctx.app.model.ChatGroup.find(filter).lean().exec();
-    if (!chatGroups) throw new Error('ChatGroups not found');
-
-    // @ts-ignore
-    return chatGroups as ChatGroupDocument[];
-  }
-
-  async createChatGroup(
-    input: RouterInput['createChatGroup'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChatGroup']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.createChatGroup', input);
-
-    const newChatGroup = await ctx.app.model.ChatGroup.create(input.data);
-
-    // @ts-ignore
-    return newChatGroup as ChatGroupDocument;
-  }
-
-  async updateChatGroup(
-    input: RouterInput['updateChatGroup'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChatGroup']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.updateChatGroup', input);
-
-    const filter = getFilter(input);
-    await ctx.app.model.ChatGroup.updateOne(filter, input.data, {
-      runValidators: true,
-    }).exec();
-
-    const updatedChatGroup = await ctx.app.model.ChatGroup.findOne(filter).lean().exec();
-    if (!updatedChatGroup) throw new Error('ChatGroup update failed');
-
-    // @ts-ignore
-    return updatedChatGroup as ChatGroupDocument;
-  }
-
-  // ChatMessage Methods
-  async getChatMessage(
-    input: RouterInput['getChatMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getChatMessage']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.getChatMessage', input);
-
-    const filter = getFilter(input);
-    const chatMessage = await ctx.app.model.ChatMessage.findOne(filter).lean().exec();
-    if (!chatMessage) throw new Error('ChatMessage not found');
-
-    // @ts-ignore
-    return chatMessage as ChatMessageDocument;
-  }
-
-  async getChatMessages(
-    input: RouterInput['getChatMessages'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getChatMessages']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.getChatMessages', input);
-
-    const filter = getFilter(input);
-    const chatMessages = await ctx.app.model.ChatMessage.find(filter).lean().exec();
-    if (!chatMessages) throw new Error('ChatMessages not found');
-
-    // @ts-ignore
-    return chatMessages as ChatMessageDocument[];
-  }
-
-  async createChatMessage(
-    input: RouterInput['createChatMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChatMessage']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.createChatMessage', input);
-
-    const newChatMessage = await ctx.app.model.ChatMessage.create(input.data);
-
-    // @ts-ignore
-    return newChatMessage as ChatMessageDocument;
-  }
-
-  async updateChatMessage(
-    input: RouterInput['updateChatMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChatMessage']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Chat.Service.updateChatMessage', input);
-
-    const filter = getFilter(input);
-    await ctx.app.model.ChatMessage.updateOne(filter, input.data, {
-      runValidators: true,
-    }).exec();
-
-    const updatedChatMessage = await ctx.app.model.ChatMessage.findOne(filter).lean().exec();
-    if (!updatedChatMessage) throw new Error('ChatMessage update failed');
-
-    // @ts-ignore
-    return updatedChatMessage as ChatMessageDocument;
-  }
-}

package/modules/chat/chat.types.ts

@@ -1,20 +0,0 @@
-// module/chat.types.ts
-
-import { z } from 'zod';
-import * as schema from './chat.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './chat.router';
-export type * from './chat.service';
-export type { RouterContext } from '../../types';
-
-export type ChatGroup = z.infer<typeof schema.ChatGroup>;
-export type ChatGroupDocument = ChatGroup & Document;
-
-export type ChatMessage = z.infer<typeof schema.ChatMessage>;
-export type ChatMessageDocument = ChatMessage & Document;
-
-export type Mappings = {
-  ChatGroup: Model<ChatGroupDocument>;
-  ChatMessage: Model<ChatMessageDocument>;
-};

package/modules/chat/index.ts

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

package/modules/collection/collection.models.ts

@@ -1,76 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './collection.types';
-
-export const CollectibleCollection = mongo.createModel<Types.CollectibleCollectionDocument>('CollectibleCollection', {
-  hype: { type: Number, default: 0 },
-  value: { type: Number, default: 0 },
-});
-
-export const CollectibleCardBox = mongo.createModel<Types.CollectibleCardBoxDocument>('CollectibleCardBox', {
-  collectibleCollectionId: { type: mongo.Schema.Types.ObjectId, ref: 'CollectibleCollection', required: true },
-  franchise: { type: String, required: true, trim: true },
-});
-
-export const CollectibleCardPack = mongo.createModel<Types.CollectibleCardPackDocument>('CollectibleCardPack', {
-  collectibleCollectionId: { type: mongo.Schema.Types.ObjectId, ref: 'CollectibleCollection', required: true },
-  franchise: { type: String, required: true, trim: true },
-  ungraded: { type: Number, default: 0 },
-  grade10: { type: Number, default: 0 },
-  grade9: { type: Number, default: 0 },
-  grade8: { type: Number, default: 0 },
-  grade7: { type: Number, default: 0 },
-  grade6: { type: Number, default: 0 },
-  grade5: { type: Number, default: 0 },
-  grade4: { type: Number, default: 0 },
-  grade3: { type: Number, default: 0 },
-  grade2: { type: Number, default: 0 },
-  grade1: { type: Number, default: 0 },
-  additional: { type: String, trim: true },
-  code: { type: String, trim: true },
-  hype: { type: Number, default: 0 },
-  series: { type: String, trim: true },
-  category: { type: String, trim: true },
-  year: { type: Number },
-});
-
-export const CollectibleCard = mongo.createModel<Types.CollectibleCardDocument>('CollectibleCard', {
-  collectibleCollectionId: { type: mongo.Schema.Types.ObjectId, ref: 'CollectibleCollection', required: true },
-  franchise: { type: String, required: true, trim: true },
-  ungraded: { type: Number, default: 0 },
-  grade10: { type: Number, default: 0 },
-  grade9: { type: Number, default: 0 },
-  grade8: { type: Number, default: 0 },
-  grade7: { type: Number, default: 0 },
-  grade6: { type: Number, default: 0 },
-  grade5: { type: Number, default: 0 },
-  grade4: { type: Number, default: 0 },
-  grade3: { type: Number, default: 0 },
-  grade2: { type: Number, default: 0 },
-  grade1: { type: Number, default: 0 },
-  additional: { type: String, trim: true },
-  code: { type: String, trim: true },
-  hype: { type: Number, default: 0 },
-  series: { type: String, trim: true },
-  category: { type: String, trim: true },
-  year: { type: Number },
-});
-
-export const Set = mongo.createModel<Types.SetDocument>('Set', {
-  seriesId: { type: mongo.Schema.Types.ObjectId, ref: 'Series', required: true },
-  name: { type: String, required: true, trim: true },
-  language: { type: String, required: true, trim: true },
-  live: { type: Boolean, default: false },
-  releaseDate: { type: String, required: true, trim: true },
-});
-
-export const Card = mongo.createModel<Types.CardDocument>('Card', {
-  setId: { type: mongo.Schema.Types.ObjectId, ref: 'Set', required: true },
-  name: { type: String, required: true, trim: true },
-  language: { type: String, required: true, trim: true },
-  releaseDate: { type: String, required: true, trim: true },
-  cardId: { type: Number, required: true },
-});
-
-export const Series = mongo.createModel<Types.SeriesDocument>('Series', {
-  name: { type: String, required: true, trim: true },
-});

package/modules/collection/collection.router.ts

@@ -1,91 +0,0 @@
-// module/collection.router.ts
-
-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 { CollectibleCollection, CollectibleCardBox, CollectibleCardPack, CollectibleCard } from './collection.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({
-    getCollectibleCollection: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCollectionId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Collection.getCollectibleCollection as any)(input, ctx)),
-
-    createCollectibleCollection: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(CollectibleCollection)
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.createCollectibleCollection as any)(input, ctx)),
-
-    updateCollectibleCollection: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCollectionId: z.string(), data: CollectibleCollection.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.updateCollectibleCollection as any)(input, ctx)),
-
-    getCollectibleCardBox: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCardBoxId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Collection.getCollectibleCardBox as any)(input, ctx)),
-
-    createCollectibleCardBox: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(CollectibleCardBox)
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.createCollectibleCardBox as any)(input, ctx)),
-
-    updateCollectibleCardBox: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCardBoxId: z.string(), data: CollectibleCardBox.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.updateCollectibleCardBox as any)(input, ctx)),
-
-    getCollectibleCardPack: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCardPackId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Collection.getCollectibleCardPack as any)(input, ctx)),
-
-    createCollectibleCardPack: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(CollectibleCardPack)
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.createCollectibleCardPack as any)(input, ctx)),
-
-    updateCollectibleCardPack: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCardPackId: z.string(), data: CollectibleCardPack.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.updateCollectibleCardPack as any)(input, ctx)),
-
-    getCollectibleCard: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCardId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Collection.getCollectibleCard as any)(input, ctx)),
-
-    createCollectibleCard: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(CollectibleCard)
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.createCollectibleCard as any)(input, ctx)),
-
-    updateCollectibleCard: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ collectibleCardId: z.string(), data: CollectibleCard.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Collection.updateCollectibleCard as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/collection/collection.schema.ts

@@ -1,90 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const CollectibleCollection = Entity.merge(
-  z.object({
-    hype: z.number().optional(),
-    value: z.number().optional(),
-  })
-);
-
-export const CollectibleCardBox = Entity.merge(
-  z.object({
-    collectibleCollectionId: ObjectId,
-    franchise: z.string().min(1),
-  })
-);
-
-export const CollectibleCardPack = Entity.merge(
-  z.object({
-    collectibleCollectionId: ObjectId,
-    franchise: z.string().min(1),
-    ungraded: z.number().optional(),
-    grade10: z.number().optional(),
-    grade9: z.number().optional(),
-    grade8: z.number().optional(),
-    grade7: z.number().optional(),
-    grade6: z.number().optional(),
-    grade5: z.number().optional(),
-    grade4: z.number().optional(),
-    grade3: z.number().optional(),
-    grade2: z.number().optional(),
-    grade1: z.number().optional(),
-    additional: z.string().optional(),
-    code: z.string().optional(),
-    hype: z.number().optional(),
-    series: z.string().optional(),
-    category: z.string().optional(),
-    year: z.number().optional(),
-  })
-);
-
-export const CollectibleCard = Entity.merge(
-  z.object({
-    collectibleCollectionId: ObjectId,
-    franchise: z.string().min(1),
-    ungraded: z.number().optional(),
-    grade10: z.number().optional(),
-    grade9: z.number().optional(),
-    grade8: z.number().optional(),
-    grade7: z.number().optional(),
-    grade6: z.number().optional(),
-    grade5: z.number().optional(),
-    grade4: z.number().optional(),
-    grade3: z.number().optional(),
-    grade2: z.number().optional(),
-    grade1: z.number().optional(),
-    additional: z.string().optional(),
-    code: z.string().optional(),
-    hype: z.number().optional(),
-    series: z.string().optional(),
-    category: z.string().optional(),
-    year: z.number().optional(),
-  })
-);
-
-export const Card = Entity.merge(
-  z.object({
-    setId: ObjectId,
-    name: z.string(),
-    language: z.string(),
-    releaseDate: z.string(),
-    cardId: z.number(),
-  })
-);
-
-export const Set = Entity.merge(
-  z.object({
-    seriesId: ObjectId,
-    name: z.string(),
-    language: z.string(),
-    live: z.boolean(),
-    releaseDate: z.string(),
-    cards: z.array(Card).optional(),
-  })
-);
-
-export const Series = Entity.merge(
-  z.object({
-    name: z.string(),
-  })
-);