@arken/node 1.5.1 → 1.5.2

package/modules/skill/skill.service.ts

@@ -1,390 +0,0 @@
-import type { RouterContext } from '../../types';
-import type { Router, RouterInput, RouterOutput } from './skill.types';
-import { getFilter } from '../../util/api';
-import type {
-  Skill,
-  SkillMod,
-  SkillClassification,
-  SkillCondition,
-  SkillStatusEffect,
-  SkillTree,
-  SkillTreeNode,
-} from './skill.types';
-
-export class Service {
-  // Skill Methods
-  async getSkill(input: RouterInput['getSkill'], ctx: RouterContext): Promise<RouterOutput['getSkill']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkill', input.query);
-
-    const filter = getFilter(input.query);
-    const skill = await ctx.app.model.Skill.findOne(filter).lean().exec();
-    if (!skill) throw new Error('Skill not found');
-
-    return skill as Skill;
-  }
-
-  async createSkill(input: RouterInput['createSkill'], ctx: RouterContext): Promise<RouterOutput['createSkill']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkill', input.data);
-
-    const skill = await ctx.app.model.Skill.create(input.data);
-    return skill as Skill;
-  }
-
-  async updateSkill(input: RouterInput['updateSkill'], ctx: RouterContext): Promise<RouterOutput['updateSkill']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkill', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkill = await ctx.app.model.Skill.findOneAndUpdate(filter, input.data, { new: true }).lean().exec();
-    if (!updatedSkill) throw new Error('Skill update failed');
-
-    return updatedSkill as Skill;
-  }
-
-  async deleteSkill(input: RouterInput['deleteSkill'], ctx: RouterContext): Promise<RouterOutput['deleteSkill']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkill', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkill = await ctx.app.model.Skill.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkill) throw new Error('Skill delete failed');
-
-    return deletedSkill as Skill;
-  }
-
-  // SkillMod Methods
-  async getSkillMod(input: RouterInput['getSkillMod'], ctx: RouterContext): Promise<RouterOutput['getSkillMod']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkillMod', input.query);
-
-    const filter = getFilter(input.query);
-    const skillMod = await ctx.app.model.SkillMod.findOne(filter).lean().exec();
-    if (!skillMod) throw new Error('SkillMod not found');
-
-    return skillMod as SkillMod;
-  }
-
-  async createSkillMod(
-    input: RouterInput['createSkillMod'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSkillMod']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkillMod', input.data);
-
-    const skillMod = await ctx.app.model.SkillMod.create(input.data);
-    return skillMod as SkillMod;
-  }
-
-  async updateSkillMod(
-    input: RouterInput['updateSkillMod'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSkillMod']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkillMod', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkillMod = await ctx.app.model.SkillMod.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedSkillMod) throw new Error('SkillMod update failed');
-
-    return updatedSkillMod as SkillMod;
-  }
-
-  async deleteSkillMod(
-    input: RouterInput['deleteSkillMod'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteSkillMod']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkillMod', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkillMod = await ctx.app.model.SkillMod.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkillMod) throw new Error('SkillMod delete failed');
-
-    return deletedSkillMod as SkillMod;
-  }
-
-  // SkillClassification Methods
-  async getSkillClassification(
-    input: RouterInput['getSkillClassification'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getSkillClassification']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkillClassification', input.query);
-
-    const filter = getFilter(input.query);
-    const skillClassification = await ctx.app.model.SkillClassification.findOne(filter).lean().exec();
-    if (!skillClassification) throw new Error('SkillClassification not found');
-
-    return skillClassification as SkillClassification;
-  }
-
-  async createSkillClassification(
-    input: RouterInput['createSkillClassification'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSkillClassification']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkillClassification', input.data);
-
-    const skillClassification = await ctx.app.model.SkillClassification.create(input.data);
-    return skillClassification as SkillClassification;
-  }
-
-  async updateSkillClassification(
-    input: RouterInput['updateSkillClassification'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSkillClassification']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkillClassification', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkillClassification = await ctx.app.model.SkillClassification.findOneAndUpdate(filter, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedSkillClassification) throw new Error('SkillClassification update failed');
-
-    return updatedSkillClassification as SkillClassification;
-  }
-
-  async deleteSkillClassification(
-    input: RouterInput['deleteSkillClassification'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteSkillClassification']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkillClassification', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkillClassification = await ctx.app.model.SkillClassification.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkillClassification) throw new Error('SkillClassification delete failed');
-
-    return deletedSkillClassification as SkillClassification;
-  }
-
-  // SkillCondition Methods
-  async getSkillCondition(
-    input: RouterInput['getSkillCondition'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getSkillCondition']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkillCondition', input.query);
-
-    const filter = getFilter(input.query);
-    const skillCondition = await ctx.app.model.SkillCondition.findOne(filter).lean().exec();
-    if (!skillCondition) throw new Error('SkillCondition not found');
-
-    return skillCondition as SkillCondition;
-  }
-
-  async createSkillCondition(
-    input: RouterInput['createSkillCondition'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSkillCondition']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkillCondition', input.data);
-
-    const skillCondition = await ctx.app.model.SkillCondition.create(input.data);
-    return skillCondition as SkillCondition;
-  }
-
-  async updateSkillCondition(
-    input: RouterInput['updateSkillCondition'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSkillCondition']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkillCondition', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkillCondition = await ctx.app.model.SkillCondition.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedSkillCondition) throw new Error('SkillCondition update failed');
-
-    return updatedSkillCondition as SkillCondition;
-  }
-
-  async deleteSkillCondition(
-    input: RouterInput['deleteSkillCondition'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteSkillCondition']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkillCondition', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkillCondition = await ctx.app.model.SkillCondition.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkillCondition) throw new Error('SkillCondition delete failed');
-
-    return deletedSkillCondition as SkillCondition;
-  }
-
-  // SkillStatusEffect Methods
-  async getSkillStatusEffect(
-    input: RouterInput['getSkillStatusEffect'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getSkillStatusEffect']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkillStatusEffect', input.query);
-
-    const filter = getFilter(input.query);
-    const skillStatusEffect = await ctx.app.model.SkillStatusEffect.findOne(filter).lean().exec();
-    if (!skillStatusEffect) throw new Error('SkillStatusEffect not found');
-
-    return skillStatusEffect as SkillStatusEffect;
-  }
-
-  async createSkillStatusEffect(
-    input: RouterInput['createSkillStatusEffect'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSkillStatusEffect']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkillStatusEffect', input.data);
-
-    const skillStatusEffect = await ctx.app.model.SkillStatusEffect.create(input.data);
-    return skillStatusEffect as SkillStatusEffect;
-  }
-
-  async updateSkillStatusEffect(
-    input: RouterInput['updateSkillStatusEffect'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSkillStatusEffect']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkillStatusEffect', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkillStatusEffect = await ctx.app.model.SkillStatusEffect.findOneAndUpdate(filter, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedSkillStatusEffect) throw new Error('SkillStatusEffect update failed');
-
-    return updatedSkillStatusEffect as SkillStatusEffect;
-  }
-
-  async deleteSkillStatusEffect(
-    input: RouterInput['deleteSkillStatusEffect'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteSkillStatusEffect']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkillStatusEffect', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkillStatusEffect = await ctx.app.model.SkillStatusEffect.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkillStatusEffect) throw new Error('SkillStatusEffect delete failed');
-
-    return deletedSkillStatusEffect as SkillStatusEffect;
-  }
-
-  // SkillTree Methods
-  async getSkillTree(input: RouterInput['getSkillTree'], ctx: RouterContext): Promise<RouterOutput['getSkillTree']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkillTree', input.query);
-
-    const filter = getFilter(input.query);
-    const skillTree = await ctx.app.model.SkillTree.findOne(filter).lean().exec();
-    if (!skillTree) throw new Error('SkillTree not found');
-
-    return skillTree as SkillTree;
-  }
-
-  async createSkillTree(
-    input: RouterInput['createSkillTree'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSkillTree']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkillTree', input.data);
-
-    const skillTree = await ctx.app.model.SkillTree.create(input.data);
-    return skillTree as SkillTree;
-  }
-
-  async updateSkillTree(
-    input: RouterInput['updateSkillTree'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSkillTree']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkillTree', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkillTree = await ctx.app.model.SkillTree.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedSkillTree) throw new Error('SkillTree update failed');
-
-    return updatedSkillTree as SkillTree;
-  }
-
-  async deleteSkillTree(
-    input: RouterInput['deleteSkillTree'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteSkillTree']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkillTree', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkillTree = await ctx.app.model.SkillTree.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkillTree) throw new Error('SkillTree delete failed');
-
-    return deletedSkillTree as SkillTree;
-  }
-
-  // SkillTreeNode Methods
-  async getSkillTreeNode(
-    input: RouterInput['getSkillTreeNode'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getSkillTreeNode']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.getSkillTreeNode', input.query);
-
-    const filter = getFilter(input.query);
-    const skillTreeNode = await ctx.app.model.SkillTreeNode.findOne(filter).lean().exec();
-    if (!skillTreeNode) throw new Error('SkillTreeNode not found');
-
-    return skillTreeNode as SkillTreeNode;
-  }
-
-  async createSkillTreeNode(
-    input: RouterInput['createSkillTreeNode'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSkillTreeNode']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.createSkillTreeNode', input.data);
-
-    const skillTreeNode = await ctx.app.model.SkillTreeNode.create(input.data);
-    return skillTreeNode as SkillTreeNode;
-  }
-
-  async updateSkillTreeNode(
-    input: RouterInput['updateSkillTreeNode'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSkillTreeNode']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.updateSkillTreeNode', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedSkillTreeNode = await ctx.app.model.SkillTreeNode.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedSkillTreeNode) throw new Error('SkillTreeNode update failed');
-
-    return updatedSkillTreeNode as SkillTreeNode;
-  }
-
-  async deleteSkillTreeNode(
-    input: RouterInput['deleteSkillTreeNode'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteSkillTreeNode']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Skill.Service.deleteSkillTreeNode', input.query);
-
-    const filter = getFilter(input.query);
-    const deletedSkillTreeNode = await ctx.app.model.SkillTreeNode.findOneAndDelete(filter).lean().exec();
-    if (!deletedSkillTreeNode) throw new Error('SkillTreeNode delete failed');
-
-    return deletedSkillTreeNode as SkillTreeNode;
-  }
-}

package/modules/skill/skill.types.ts

@@ -1,33 +0,0 @@
-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/modules/video/index.ts

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

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

package/modules/video/video.router.ts

@@ -1,143 +0,0 @@
-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/modules/video/video.schema.ts

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