@arken/seer-protocol 0.1.1 → 0.1.3

package/tsconfig.json

@@ -1,25 +1,33 @@
 {
   "compilerOptions": {
-    "module": "CommonJS",
-    "preserveSymlinks": true,
     "esModuleInterop": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM"],
+    "noImplicitAny": false,
+    "outDir": "build",
+    "preserveSymlinks": false,
+    "preserveConstEnums": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
+    "removeComments": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": false,
+    "checkJs": true,
+    "sourceMap": true,
+    "target": "ES2020",
+    "moduleResolution": "Node",
     "resolveJsonModule": true,
     "allowSyntheticDefaultImports": true,
-    "noImplicitAny": false,
-    "sourceMap": true,
-    "strictNullChecks": false,
-    "outDir": "./dist",
-    "baseUrl": ".",
-    "types": ["node", "jest"],
-    "paths": {
-      "~/*": ["./src/*"]
-    },
-    "target": "ESNext",
-    "lib": ["ESNext"],
-    "moduleResolution": "Node"
+    "types": ["jest", "node"],
+    "paths": {},
+    "allowJs": true,
+    "declaration": true,
+    "isolatedModules": true,
+    "noFallthroughCasesInSwitch": true,
+    "noEmit": false,
+    "composite": true
   },
-  "include": ["./src/**/*"],
-  "exclude": []
-}
+  "include": ["./area/**/*","./asset/**/*", "./chain/**/*","./chain/**/*","./character/**/*","./chat/**/*","./collection/**/*","./core/**/*","./evolution/**/*", "./game/**/*","./infinite/**/*","./interface/**/*","./isles/**/*","./item/**/*","./job/**/*","./market/**/*","./oasis/**/*","./product/**/*","./profile/**/*","./raffle/**/*","./skill/**/*","./trek/**/*","./video/**/*","./index.ts","./router.ts","./schema.ts","./types.ts"],
+  "exclude": ["node_modules", "build"]
+}

package/types.ts

@@ -1,29 +1,61 @@
-import * as Arken from '@arken/node';
-import { Router, RouterInput, RouterOutput } from './router';
-import * as Evolution from './modules/evolution';
-import * as Infinite from './modules/infinite';
-import * as Oasis from './modules/oasis';
-import * as Trek from './modules/trek';
-import type * as Types from './types';
-
-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 {
+
+// 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';
+
+// Exports
+export * as Area from './area';
+export * as Asset from './asset';
+export * as Chain from './chain';
+export * as Character from './character';
+export * as Chat from './chat';
+export * as Collection from './collection';
+export * as Core from './core';
+export * as Game from './game';
+export * as Interface from './interface';
+export * as Item from './item';
+export * as Job from './job';
+export * as Market from './market';
+export * as Product from './product';
+export * as Profile from './profile';
+export * as Raffle from './raffle';
+export * as Skill from './skill';
+export * as Video from './video';
+export * as Evolution from './evolution';
+export * as Infinite from './infinite';
+export * as Oasis from './oasis';
+export * as Trek from './trek';
+
+export class Application<ServiceType> {
   router: Router;
-  service: ApplicationServiceType = {};
+  service: ServiceType;
   model: ApplicationModelType = {};
-  realms: Arken.Core.Types.Realm[] = [];
+  realms: Core.Types.Realm[] = [];
 
   server: any;
   http: any;
@@ -81,8 +113,10 @@ export type ApplicationType = typeof Application;
 // };
 
 export type RouterContext = {
-  app: Application;
-} & Arken.RouterContext;
+  app: Application<any>;
+  client?: RouterClient;
+  profile?: Profile.Types.Profile;
+};
 
 export interface Client {
   id: string;
@@ -104,3 +138,117 @@ export interface Client {
 export interface ServiceContext {
   client: Client;
 }
+
+
+import { createRouter } from './router';
+
+export type * as Schema from './schema';
+
+export type Router = ReturnType<typeof createRouter>;
+
+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 &
+    Evolution.Types.Mappings & 
+    Infinite.Types.Mappings
+>;
+
+export type RouterClient = {
+  socket: any;
+  roles: string[];
+  permissions: any;
+  profile?: Profile.Types.Profile;
+  emit: any;
+};
+
+
+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,4 @@
+export * as Types from './video.types';
+export * as Models from './video.models';
+export * as Schemas from './video.schema';
+export * from './video.router';

package/video/video.models.ts

@@ -0,0 +1,25 @@
+import * as mongo from '@arken/node/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', {});

package/video/video.router.ts

@@ -0,0 +1,143 @@
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Video, VideoParticipant, VideoDialogue, VideoTranscript, VideoScene } from './video.schema';
+import { Query } from '../schema'; // Assuming the Query schema is located in '../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({
+    // Video endpoints
+    getVideo: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideo as any)(input, ctx)),
+
+    createVideo: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: Video.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideo as any)(input, ctx)),
+
+    updateVideo: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: Video.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideo as any)(input, ctx)),
+
+    deleteVideo: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideo as any)(input, ctx)),
+
+    // Video Participant endpoints
+    getVideoParticipant: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoParticipant as any)(input, ctx)),
+
+    createVideoParticipant: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoParticipant.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoParticipant as any)(input, ctx)),
+
+    updateVideoParticipant: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoParticipant.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoParticipant as any)(input, ctx)),
+
+    deleteVideoParticipant: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoParticipant as any)(input, ctx)),
+
+    // Video Dialogue endpoints
+    getVideoDialogue: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoDialogue as any)(input, ctx)),
+
+    createVideoDialogue: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoDialogue.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoDialogue as any)(input, ctx)),
+
+    updateVideoDialogue: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoDialogue.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoDialogue as any)(input, ctx)),
+
+    deleteVideoDialogue: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoDialogue as any)(input, ctx)),
+
+    // Video Transcript endpoints
+    getVideoTranscript: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoTranscript as any)(input, ctx)),
+
+    createVideoTranscript: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoTranscript.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoTranscript as any)(input, ctx)),
+
+    updateVideoTranscript: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoTranscript.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoTranscript as any)(input, ctx)),
+
+    deleteVideoTranscript: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoTranscript as any)(input, ctx)),
+
+    // Video Scene endpoints
+    getVideoScene: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Video.getVideoScene as any)(input, ctx)),
+
+    createVideoScene: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: VideoScene.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.createVideoScene as any)(input, ctx)),
+
+    updateVideoScene: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: VideoScene.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.updateVideoScene as any)(input, ctx)),
+
+    deleteVideoScene: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Video.deleteVideoScene as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/video/video.schema.ts

@@ -0,0 +1,46 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const Video = Entity.merge(
+  z.object({
+    youtubeId: z.string().min(1),
+    url: z.string().url(),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    duration: z.number().min(0).optional(),
+    // publishedAt: z.date().optional(),
+  })
+);
+
+export const VideoParticipant = Entity.merge(
+  z.object({
+    videoId: ObjectId, // Reference to the associated Video
+    profileId: ObjectId.optional(), // Reference to a participant profile
+    role: z.enum(['Host', 'Contributor', 'Guest']).optional(),
+  })
+);
+
+export const VideoDialogue = Entity.merge(
+  z.object({
+    videoId: ObjectId, // Reference to the associated Video
+    participantId: ObjectId, // Reference to the VideoParticipant
+    text: z.string().min(1),
+    timestamp: z.string().regex(/^\d{2}:\d{2}:\d{2}$/), // Format HH:MM:SS
+  })
+);
+
+export const VideoTranscript = Entity.merge(
+  z.object({
+    videoId: ObjectId, // Reference to the associated Video
+    transcript: z.array(VideoDialogue), // Array of dialogues
+    summary: z.string().optional(),
+  })
+);
+
+export const VideoScene = Entity.merge(
+  z.object({
+    videoId: ObjectId, // Reference to the associated Video
+    startTime: z.string().regex(/^\d{2}:\d{2}:\d{2}$/), // Format HH:MM:SS
+    endTime: z.string().regex(/^\d{2}:\d{2}:\d{2}$/), // Format HH:MM:SS
+    description: z.string().optional(),
+  })
+);

package/video/video.types.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import * as schema from './video.schema';
+import { Document, Model } from '@arken/node/mongo';
+import type { RouterContext } from '../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './video.router';
+
+export type * from './video.router';
+export type { RouterContext };
+
+export type Video = z.infer<typeof schema.Video>;
+export type VideoParticipant = z.infer<typeof schema.VideoParticipant>;
+export type VideoDialogue = z.infer<typeof schema.VideoDialogue>;
+export type VideoTranscript = z.infer<typeof schema.VideoTranscript>;
+export type VideoScene = z.infer<typeof schema.VideoScene>;
+
+export type VideoDocument = Video & Document;
+export type VideoParticipantDocument = VideoParticipant & Document;
+export type VideoDialogueDocument = VideoDialogue & Document;
+export type VideoTranscriptDocument = VideoTranscript & Document;
+export type VideoSceneDocument = VideoScene & Document;
+
+export type Mappings = {
+  Video: Model<VideoDocument>;
+  VideoParticipant: Model<VideoParticipantDocument>;
+  VideoDialogue: Model<VideoDialogueDocument>;
+  VideoTranscript: Model<VideoTranscriptDocument>;
+  VideoScene: Model<VideoSceneDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;