@goscribe/server 1.0.11 → 1.1.0

package/dist/services/flashcard.service.d.ts

@@ -0,0 +1,183 @@
+import type { PrismaClient } from '@prisma/client';
+import type { CreateFlashcardInput } from '../types/index.js';
+export declare class FlashcardService {
+    private db;
+    constructor(db: PrismaClient);
+    jsonToFlashcards(json: string): Promise<any>;
+    /**
+     * List all flashcard sets for a workspace
+     */
+    listFlashcardSets(workspaceId: string, userId: string): Promise<({
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            tags: string[];
+        }[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        imageObjectKey: string | null;
+        createdById: string | null;
+    })[]>;
+    /**
+     * Get a single flashcard set
+     */
+    getFlashcardSet(setId: string, userId: string): Promise<{
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            tags: string[];
+        }[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        imageObjectKey: string | null;
+        createdById: string | null;
+    }>;
+    /**
+     * Create a new flashcard set
+     */
+    createFlashcardSet(data: {
+        workspaceId: string;
+        title: string;
+        userId: string;
+        flashcards?: CreateFlashcardInput[];
+    }): Promise<{
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            tags: string[];
+        }[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        imageObjectKey: string | null;
+        createdById: string | null;
+    }>;
+    /**
+     * Update a flashcard set
+     */
+    updateFlashcardSet(data: {
+        id: string;
+        title?: string;
+        userId: string;
+        flashcards?: (CreateFlashcardInput & {
+            id?: string;
+        })[];
+    }): Promise<{
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            tags: string[];
+        }[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        imageObjectKey: string | null;
+        createdById: string | null;
+    }>;
+    /**
+     * Delete a flashcard set
+     */
+    deleteFlashcardSet(setId: string, userId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Add a flashcard to a set
+     */
+    addFlashcard(data: {
+        setId: string;
+        userId: string;
+        flashcard: CreateFlashcardInput;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        artifactId: string;
+        order: number;
+        front: string;
+        back: string;
+        tags: string[];
+    }>;
+    /**
+     * Update a flashcard
+     */
+    updateFlashcard(data: {
+        flashcardId: string;
+        userId: string;
+        updates: Partial<CreateFlashcardInput>;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        artifactId: string;
+        order: number;
+        front: string;
+        back: string;
+        tags: string[];
+    }>;
+    /**
+     * Delete a flashcard
+     */
+    deleteFlashcard(flashcardId: string, userId: string): Promise<{
+        success: boolean;
+    }>;
+}
+/**
+ * Factory function to create flashcard service
+ */
+export declare function createFlashcardService(db: PrismaClient): FlashcardService;

package/dist/services/flashcard.service.js

@@ -0,0 +1,224 @@
+import { NotFoundError } from '../lib/errors.js';
+export class FlashcardService {
+    constructor(db) {
+        this.db = db;
+    }
+    async jsonToFlashcards(json) {
+        const flashcards = JSON.parse(json);
+        return flashcards.map((card) => ({
+            front: card.front,
+            back: card.back,
+        }));
+    }
+    /**
+     * List all flashcard sets for a workspace
+     */
+    async listFlashcardSets(workspaceId, userId) {
+        return this.db.artifact.findMany({
+            where: {
+                workspaceId,
+                type: 'FLASHCARD_SET',
+                workspace: { ownerId: userId },
+            },
+            include: {
+                flashcards: {
+                    orderBy: { order: 'asc' },
+                },
+            },
+            orderBy: { updatedAt: 'desc' },
+        });
+    }
+    /**
+     * Get a single flashcard set
+     */
+    async getFlashcardSet(setId, userId) {
+        const flashcardSet = await this.db.artifact.findFirst({
+            where: {
+                id: setId,
+                type: 'FLASHCARD_SET',
+                workspace: { ownerId: userId },
+            },
+            include: {
+                flashcards: {
+                    orderBy: { order: 'asc' },
+                },
+            },
+        });
+        if (!flashcardSet) {
+            throw new NotFoundError('Flashcard set');
+        }
+        return flashcardSet;
+    }
+    /**
+     * Create a new flashcard set
+     */
+    async createFlashcardSet(data) {
+        // Verify workspace ownership
+        const workspace = await this.db.workspace.findFirst({
+            where: {
+                id: data.workspaceId,
+                ownerId: data.userId,
+            },
+        });
+        if (!workspace) {
+            throw new NotFoundError('Workspace');
+        }
+        const { flashcards, ...setData } = data;
+        return this.db.artifact.create({
+            data: {
+                workspaceId: data.workspaceId,
+                type: 'FLASHCARD_SET',
+                title: data.title,
+                createdById: data.userId,
+                flashcards: flashcards
+                    ? {
+                        create: flashcards.map((card, index) => ({
+                            ...card,
+                            order: card.order ?? index,
+                        })),
+                    }
+                    : undefined,
+            },
+            include: {
+                flashcards: {
+                    orderBy: { order: 'asc' },
+                },
+            },
+        });
+    }
+    /**
+     * Update a flashcard set
+     */
+    async updateFlashcardSet(data) {
+        const { id, flashcards, userId, ...updateData } = data;
+        // Verify ownership
+        const existingSet = await this.db.artifact.findFirst({
+            where: {
+                id,
+                type: 'FLASHCARD_SET',
+                workspace: { ownerId: userId },
+            },
+        });
+        if (!existingSet) {
+            throw new NotFoundError('Flashcard set');
+        }
+        // Handle flashcards update if provided
+        if (flashcards) {
+            // Delete existing flashcards
+            await this.db.flashcard.deleteMany({
+                where: { artifactId: id },
+            });
+            // Create new flashcards
+            await this.db.flashcard.createMany({
+                data: flashcards.map((card, index) => ({
+                    artifactId: id,
+                    front: card.front,
+                    back: card.back,
+                    tags: card.tags || [],
+                    order: card.order ?? index,
+                })),
+            });
+        }
+        return this.db.artifact.update({
+            where: { id },
+            data: updateData,
+            include: {
+                flashcards: {
+                    orderBy: { order: 'asc' },
+                },
+            },
+        });
+    }
+    /**
+     * Delete a flashcard set
+     */
+    async deleteFlashcardSet(setId, userId) {
+        const deleted = await this.db.artifact.deleteMany({
+            where: {
+                id: setId,
+                type: 'FLASHCARD_SET',
+                workspace: { ownerId: userId },
+            },
+        });
+        if (deleted.count === 0) {
+            throw new NotFoundError('Flashcard set');
+        }
+        return { success: true };
+    }
+    /**
+     * Add a flashcard to a set
+     */
+    async addFlashcard(data) {
+        // Verify ownership
+        const set = await this.db.artifact.findFirst({
+            where: {
+                id: data.setId,
+                type: 'FLASHCARD_SET',
+                workspace: { ownerId: data.userId },
+            },
+        });
+        if (!set) {
+            throw new NotFoundError('Flashcard set');
+        }
+        // Get the next order number
+        const maxOrder = await this.db.flashcard.aggregate({
+            where: { artifactId: data.setId },
+            _max: { order: true },
+        });
+        return this.db.flashcard.create({
+            data: {
+                artifactId: data.setId,
+                front: data.flashcard.front,
+                back: data.flashcard.back,
+                tags: data.flashcard.tags || [],
+                order: data.flashcard.order ?? (maxOrder._max.order ?? 0) + 1,
+            },
+        });
+    }
+    /**
+     * Update a flashcard
+     */
+    async updateFlashcard(data) {
+        // Verify ownership
+        const flashcard = await this.db.flashcard.findFirst({
+            where: {
+                id: data.flashcardId,
+                artifact: {
+                    type: 'FLASHCARD_SET',
+                    workspace: { ownerId: data.userId },
+                },
+            },
+        });
+        if (!flashcard) {
+            throw new NotFoundError('Flashcard');
+        }
+        return this.db.flashcard.update({
+            where: { id: data.flashcardId },
+            data: data.updates,
+        });
+    }
+    /**
+     * Delete a flashcard
+     */
+    async deleteFlashcard(flashcardId, userId) {
+        const flashcard = await this.db.flashcard.findFirst({
+            where: {
+                id: flashcardId,
+                artifact: { workspace: { ownerId: userId } },
+            },
+        });
+        if (!flashcard) {
+            throw new NotFoundError('Flashcard');
+        }
+        await this.db.flashcard.delete({
+            where: { id: flashcardId },
+        });
+        return { success: true };
+    }
+}
+/**
+ * Factory function to create flashcard service
+ */
+export function createFlashcardService(db) {
+    return new FlashcardService(db);
+}

package/dist/services/podcast-segment-reorder.js

@@ -0,0 +1,107 @@
+"use strict";
+// import type { PrismaClient } from '@prisma/client';
+// import { NotFoundError } from '../lib/errors.js';
+// export interface ReorderSegmentData {
+//   id: string;
+//   newOrder: number;
+// }
+// export class PodcastSegmentReorderService {
+//   constructor(private db: PrismaClient) {}
+//   /**
+//    * Reorder podcast segments and recalculate start times
+//    */
+//   async reorderSegments(data: {
+//     episodeId: string;
+//     userId: string;
+//     newOrder: ReorderSegmentData[];
+//   }) {
+//     const { episodeId, userId, newOrder } = data;
+//     // Verify ownership
+//     const episode = await this.db.artifact.findFirst({
+//       where: {
+//         id: episodeId,
+//         type: 'PODCAST_EPISODE',
+//         workspace: { ownerId: userId },
+//       },
+//       include: {
+//         podcastSegments: {
+//           orderBy: { order: 'asc' },
+//         },
+//       },
+//     });
+//     if (!episode) {
+//       throw new NotFoundError('Podcast episode');
+//     }
+//     // Validate all segment IDs exist
+//     const segmentIds = episode.podcastSegments.map((s) => s.id);
+//     const invalidIds = newOrder.filter((item) => !segmentIds.includes(item.id));
+//     if (invalidIds.length > 0) {
+//       throw new Error(`Invalid segment IDs: ${invalidIds.map((i) => i.id).join(', ')}`);
+//     }
+//     // Validate order values are sequential
+//     const orderValues = newOrder.map((item) => item.newOrder).sort((a, b) => a - b);
+//     const expectedOrder = Array.from({ length: newOrder.length }, (_, i) => i + 1);
+//     if (JSON.stringify(orderValues) !== JSON.stringify(expectedOrder)) {
+//       throw new Error('Order values must be sequential starting from 1');
+//     }
+//     return this.db.$transaction(async (tx) => {
+//       // Update each segment's order
+//       for (const item of newOrder) {
+//         await tx.podcastSegment.update({
+//           where: { id: item.id },
+//           data: { order: item.newOrder },
+//         });
+//       }
+//       // Get all segments in new order
+//       const reorderedSegments = await tx.podcastSegment.findMany({
+//         where: { artifactId: episodeId },
+//         orderBy: { order: 'asc' },
+//       });
+//       // Recalculate start times
+//       let currentTime = 0;
+//       for (const segment of reorderedSegments) {
+//         await tx.podcastSegment.update({
+//           where: { id: segment.id },
+//           data: { startTime: currentTime },
+//         });
+//         currentTime += segment.duration;
+//       }
+//       // Update total duration in latest version
+//       const latestVersion = await tx.artifactVersion.findFirst({
+//         where: { artifactId: episodeId },
+//         orderBy: { version: 'desc' },
+//       });
+//       if (latestVersion) {
+//         const metadata = latestVersion.data as any;
+//         if (metadata) {
+//           metadata.totalDuration = currentTime;
+//           // Create new version with updated metadata
+//           await tx.artifactVersion.create({
+//             data: {
+//               artifactId: episodeId,
+//               version: latestVersion.version + 1,
+//               content: latestVersion.content,
+//               data: metadata,
+//               createdById: userId,
+//             },
+//           });
+//         }
+//       }
+//       // Update artifact timestamp
+//       await tx.artifact.update({
+//         where: { id: episodeId },
+//         data: { updatedAt: new Date() },
+//       });
+//       return {
+//         totalDuration: currentTime,
+//         segmentsReordered: reorderedSegments.length,
+//       };
+//     });
+//   }
+// }
+// /**
+//  * Factory function
+//  */
+// export function createPodcastSegmentReorderService(db: PrismaClient) {
+//   return new PodcastSegmentReorderService(db);
+// }