@arken/seer-protocol 0.1.0 → 0.1.2

package/skill/skill.router.ts

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

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

package/skill/skill.types.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import * as schema from './skill.schema';
+import { Document, Model } from '../../util/mongo';
+
+export type * from './skill.router';
+export type * from './skill.service';
+export type { RouterContext } from '../../types';
+
+export type Skill = z.infer<typeof schema.Skill>;
+export type SkillMod = z.infer<typeof schema.SkillMod>;
+export type SkillClassification = z.infer<typeof schema.SkillClassification>;
+export type SkillCondition = z.infer<typeof schema.SkillCondition>;
+export type SkillStatusEffect = z.infer<typeof schema.SkillStatusEffect>;
+export type SkillTree = z.infer<typeof schema.SkillTree>;
+export type SkillTreeNode = z.infer<typeof schema.SkillTreeNode>;
+
+export type SkillDocument = Skill & Document;
+export type SkillModDocument = SkillMod & Document;
+export type SkillClassificationDocument = SkillClassification & Document;
+export type SkillConditionDocument = SkillCondition & Document;
+export type SkillStatusEffectDocument = SkillStatusEffect & Document;
+export type SkillTreeDocument = SkillTree & Document;
+export type SkillTreeNodeDocument = SkillTreeNode & Document;
+
+export type Mappings = {
+  Skill: Model<SkillDocument>;
+  SkillMod: Model<SkillModDocument>;
+  SkillClassification: Model<SkillClassificationDocument>;
+  SkillCondition: Model<SkillConditionDocument>;
+  SkillStatusEffect: Model<SkillStatusEffectDocument>;
+  SkillTree: Model<SkillTreeDocument>;
+  SkillTreeNode: Model<SkillTreeNodeDocument>;
+};

package/{src/modules/trek → trek}/trek.router.ts

@@ -2,7 +2,7 @@
 
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/node/util/rpc';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
 import type { inferRouterOutputs, inferRouterInputs } from '@trpc/server';
 import type { RouterContext } from '../../types';
 

package/types.ts

@@ -0,0 +1,273 @@
+
+// arken/packages/seer/protocol/types.ts
+//
+import * as Arken from '@arken/node';
+import { Router, RouterInput, RouterOutput } from './router';
+
+
+// Imports
+import * as Area from './area';
+import * as Asset from './asset';
+import * as Chain from './chain';
+import * as Character from './character';
+import * as Chat from './chat';
+import * as Collection from './collection';
+import * as Core from './core';
+import * as Game from './game';
+import * as Interface from './interface';
+import * as Item from './item';
+import * as Job from './job';
+import * as Market from './market';
+import * as Product from './product';
+import * as Profile from './profile';
+import * as Raffle from './raffle';
+import * as Skill from './skill';
+import * as Video from './video';
+import * as Evolution from './evolution';
+import * as Infinite from './infinite';
+import * as Oasis from './oasis';
+import * as Trek from './trek';
+
+export type { Router, RouterInput, RouterOutput };
+
+export type ApplicationServiceType = Partial<{
+  Trek: Trek.Service;
+  Evolution: Evolution.Service;
+  Infinite: Infinite.Service;
+  Oasis: Oasis.Service;
+}> &
+  Arken.ApplicationServiceType;
+
+export type ApplicationModelType = Partial<Evolution.Types.Mappings & Infinite.Types.Mappings> &
+  Arken.ApplicationModelType;
+
+export class Application {
+  router: Router;
+  service: ApplicationServiceType = {};
+  model: ApplicationModelType = {};
+  realms: Arken.Core.Types.Realm[] = [];
+
+  server: any;
+  http: any;
+  https: any;
+  isHttps: boolean;
+  cache: any;
+  db: any;
+  services: any;
+  applications: any;
+  application: any;
+  contracts: any;
+  contractInfo: any;
+  contractMetadata: any;
+  ethersProvider: any;
+  data: any;
+  signers: any;
+  filters: Record<string, any> = { applicationId: null };
+
+  // async getRealms(
+  //   input: Types.RouterInput['getRealms'],
+  //   ctx: Types.ServiceContext
+  // ): Promise<Types.RouterOutput['getRealms']> {
+  //   throw new Error('Not implemented');
+  // }
+
+  // async updateRealm(
+  //   input: Types.RouterInput['updateRealm'],
+  //   ctx: Types.ServiceContext
+  // ): Promise<Types.RouterOutput['updateRealm']> {
+  //   throw new Error('Not implemented');
+  // }
+}
+
+export type ApplicationType = typeof Application;
+// export type Seer =
+// export type Seer = {
+//   service: ApplicationServiceType;
+//   model: ApplicationModelType;
+//   realms: Arken.Core.Types.Realm[];
+
+//   server: any;
+//   http: any;
+//   https: any;
+//   isHttps: boolean;
+//   cache: any;
+//   db: any;
+//   services: any;
+//   applications: any;
+//   application: any;
+//   filters: Record<string, any>;
+//   contracts: any;
+//   contractInfo: any;
+//   contractMetadata: any;
+//   signers: any;
+// };
+
+export type RouterContext = {
+  app: Application;
+} & Arken.RouterContext;
+
+export interface Client {
+  id: string;
+  name: string;
+  ip: string;
+  socket: any;
+  endpoint: string;
+  ioCallbacks: any;
+  info: any;
+  lastReportedTime: number;
+  isMod: boolean;
+  isAdmin: boolean;
+  isSeer: boolean;
+  log: {
+    clientDisconnected: number;
+  };
+}
+
+export interface ServiceContext {
+  client: Client;
+}
+
+
+import { createRouter } from './router';
+
+export * as util from './util';
+
+export type * as Schema from './schema';
+
+export type Router = ReturnType<typeof createRouter>;
+
+export type ApplicationServiceType = Partial<{
+  Area: Area.Service;
+  Asset: Asset.Service;
+  Chain: Chain.Service;
+  Character: Character.Service;
+  Chat: Chat.Service;
+  Collection: Collection.Service;
+  Core: Core.Service;
+  Game: Game.Service;
+  Interface: Interface.Service;
+  Item: Item.Service;
+  Job: Job.Service;
+  Market: Market.Service;
+  Product: Product.Service;
+  Profile: Profile.Service;
+  Raffle: Raffle.Service;
+  Skill: Skill.Service;
+  Video: Video.Service;
+}>;
+
+export type ApplicationModelType = Partial<
+  Area.Types.Mappings &
+    Asset.Types.Mappings &
+    Chain.Types.Mappings &
+    Character.Types.Mappings &
+    Chat.Types.Mappings &
+    Collection.Types.Mappings &
+    Core.Types.Mappings &
+    Game.Types.Mappings &
+    Interface.Types.Mappings &
+    Item.Types.Mappings &
+    Job.Types.Mappings &
+    Market.Types.Mappings &
+    Product.Types.Mappings &
+    Profile.Types.Mappings &
+    Raffle.Types.Mappings &
+    Skill.Types.Mappings &
+    Video.Types.Mappings
+>;
+
+export interface Application {
+  model: ApplicationModelType;
+  service: ApplicationServiceType;
+  web3?: any;
+}
+
+export type RouterClient = {
+  socket: any;
+  roles: string[];
+  permissions: any;
+  profile?: Profile.Types.Profile;
+  emit: any;
+};
+
+export type RouterContext = {
+  app: Application;
+  client?: RouterClient;
+  profile?: Profile.Types.Profile;
+};
+
+export interface Signature {
+  hash?: string;
+  address?: string;
+}
+
+export type Position = {
+  x: number;
+  y: number;
+  z?: number;
+};
+
+export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+
+export type PatchOp =
+  | { op: 'set'; key: string; value: any }
+  | { op: 'unset'; key: string }
+  | { op: 'inc'; key: string; value: number }
+  | { op: 'push'; key: string; value: any }
+  | { op: 'merge'; key: string; value: Record<string, any> };
+
+export type EntityPatch = {
+  entityType: string; // allow any string
+  entityId: string;
+  baseVersion?: number;
+  ops: PatchOp[];
+  claimable?: boolean;
+};
+
+export type GameObjectDef = {
+  id: string;
+  type: string; // allow any string
+  name: string;
+  position: { x: number; y: number };
+  radius?: number; // interaction distance
+  tags?: string[];
+  meta?: Record<string, any>;
+};
+
+export type Requirement =
+  | { kind: 'exists'; key: string }
+  | { kind: 'touchedObject'; objectId: string; afterKey?: string; writeKey: string };
+
+// Generic effects (can be positive or negative)
+export type Effect =
+  | { kind: 'item.grant'; itemKey: string; quantity?: number }
+  | { kind: 'currency.grant'; key: string; amount: number } // negative amount allowed
+  | { kind: 'reputation.delta'; npcId: string; amount: number } // negative allowed
+  | { kind: 'state.patch'; patch: EntityPatch } // generic patch against any entityType
+  | { kind: 'ui.unlock'; uiKey: string } // optional, future
+  | { kind: 'emit'; eventType: string; payload?: any }; // optional, future
+
+export type QuestDef = {
+  id: string;
+  metaverseId: string;
+  name: string;
+
+  // Requirements can be checked shard-side (for anti-cheat) AND client-side (for UI state)
+  requirements: Requirement[];
+
+  // Effects are applied on completion/claim (seer-side)
+  effects: Effect[];
+
+  // keys shard will write (auditing + permissions)
+  writes?: string[];
+};
+
+type QuestCompleteOp = {
+  kind: 'quest.complete';
+  id: string;
+  ts: number;
+  questId: string;
+  metaverseId: string;
+  evidence?: Record<string, any>;
+  effects?: any[]; // can include effect refs for replay/debug
+};

package/video/index.ts

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

package/video/video.models.ts

@@ -0,0 +1,25 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './video.types';
+
+export const Video = mongo.createModel<Types.VideoDocument>('Video', {
+  youtubeId: { type: String, unique: true, required: true },
+  url: { type: String, required: true },
+});
+
+export const VideoParticipant = mongo.createModel<Types.VideoParticipantDocument>('VideoParticipant', {
+  profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
+});
+
+export const VideoDialogue = mongo.createModel<Types.VideoDialogueDocument>('VideoDialogue', {
+  participantId: { type: mongo.Schema.Types.ObjectId, ref: 'VideoParticipant', required: true },
+  text: { type: String, required: true },
+  timestamp: { type: String, required: true },
+});
+
+export const VideoTranscript = mongo.createModel<Types.VideoTranscriptDocument>('VideoTranscript', {
+  videoId: { type: mongo.Schema.Types.ObjectId, ref: 'Video', required: true },
+  // transcript: { type: [mongo.Schema.Types.Mixed], required: true },
+  summary: { type: String, optional: true },
+});
+
+export const VideoScene = mongo.createModel<Types.VideoSceneDocument>('VideoScene', {});