@arken/seer-protocol 0.1.0 → 0.1.2

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 '../../util/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,33 @@
+import { z } from 'zod';
+import * as schema from './video.schema';
+import { Document, Model } from '../../util/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 * from './video.service';
+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>;

package/src/index.ts

@@ -1,22 +0,0 @@
-import type * as Arken from '@arken/node/types';
-import * as dotenv from 'dotenv';
-import * as Schema from '@arken/node/schema';
-import { createRouter as createRouter2 } from './router';
-import type * as Types from './types';
-
-export * as Trek from './modules/trek';
-export * as Evolution from './modules/evolution';
-export * as Infinite from './modules/infinite';
-export * as Oasis from './modules/oasis';
-
-export { Application } from './types';
-
-export type { Types };
-
-export { createRouter } from './router';
-
-export type Router = ReturnType<typeof createRouter2>;
-export type RouterInput = Schema.inferRouterInputs<Router>;
-export type RouterOutput = Schema.inferRouterOutputs<Router>;
-
-dotenv.config();