@arken/seer-protocol 0.1.0 → 0.1.2

package/character/index.ts

@@ -0,0 +1,5 @@
+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/chat/chat.models.ts

@@ -0,0 +1,43 @@
+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/chat/chat.router.ts

@@ -0,0 +1,67 @@
+// 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/chat/chat.schema.ts

@@ -0,0 +1,36 @@
+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/chat/chat.types.ts

@@ -0,0 +1,20 @@
+// 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/chat/index.ts

@@ -0,0 +1,5 @@
+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/collection/collection.models.ts

@@ -0,0 +1,76 @@
+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/collection/collection.router.ts

@@ -0,0 +1,91 @@
+// 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/collection/collection.schema.ts

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

package/collection/collection.types.ts

@@ -0,0 +1,36 @@
+// module/collection.types.ts
+
+import { z } from 'zod';
+import * as schema from './collection.schema';
+import { Document, Model } from '../../util/mongo';
+import exp from 'constants';
+
+export type * from './collection.router';
+export type * from './collection.service';
+export type { RouterContext } from '../../types';
+
+export type CollectibleCollection = z.infer<typeof schema.CollectibleCollection>;
+export type CollectibleCardBox = z.infer<typeof schema.CollectibleCardBox>;
+export type CollectibleCardPack = z.infer<typeof schema.CollectibleCardPack>;
+export type CollectibleCard = z.infer<typeof schema.CollectibleCard>;
+export type Card = z.infer<typeof schema.Card>;
+export type Set = z.infer<typeof schema.Set>;
+export type Series = z.infer<typeof schema.Series>;
+
+export type CollectibleCollectionDocument = CollectibleCollection & Document;
+export type CollectibleCardBoxDocument = CollectibleCardBox & Document;
+export type CollectibleCardPackDocument = CollectibleCardPack & Document;
+export type CollectibleCardDocument = CollectibleCard & Document;
+export type CardDocument = Card & Document;
+export type SetDocument = Set & Document;
+export type SeriesDocument = Series & Document;
+
+export type Mappings = {
+  CollectibleCollection: Model<CollectibleCollectionDocument>;
+  CollectibleCardBox: Model<CollectibleCardBoxDocument>;
+  CollectibleCardPack: Model<CollectibleCardPackDocument>;
+  CollectibleCard: Model<CollectibleCardDocument>;
+  Card: Model<CardDocument>;
+  Set: Model<SetDocument>;
+  Series: Model<SeriesDocument>;
+};

package/collection/index.ts

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