1// Tiptap Editor Configuration with Extensions
2const editor = useEditor({
3  extensions: [
4    StarterKit,
5    Collaboration.configure({
6      document: yjsProvider.getYDoc(),
7    }),
8    CollaborationCursor.configure({
9      provider: yjsProvider.getWebSocketProvider(),
10      user: {
11        name: userName,
12        color: userColor,
13      },
14    }),
15    CommentExtension,
16    PageBreakExtension,
17    Table.configure({
18      resizable: true,
19      handleWidth: 16,
20    }),
21    ImageUpload.configure({
22      uploadFn: uploadToSupabase,
23    }),
24  ],
25  content: document.content,
26  onUpdate: ({ editor }) => {
27    handleDocumentUpdate(editor.getJSON());
28  },
29});

1// Yjs Provider Configuration
2class YjsProvider {
3  private doc: Y.Doc;
4  private provider: WebsocketProvider;
5
6  constructor(documentId: string, userId: string) {
7    this.doc = new Y.Doc();
8    this.provider = new WebsocketProvider(
9      'ws://localhost:3002',
10      documentId,
11      this.doc,
12      {
13        connect: true,
14        params: { userId },
15        WebSocketPolyfill: WebSocket,
16      }
17    );
18
19    // Awareness for user presence
20    this.provider.awareness.setLocalStateField('user', {
21      name: userName,
22      color: userColor,
23      cursor: null,
24    });
25  }
26
27  getYDoc() {
28    return this.doc;
29  }
30
31  getWebSocketProvider() {
32    return this.provider;
33  }
34}

1// Document Service with Role-Based Access
2export class DocumentService extends BaseService {
3  async shareDocument(
4    documentId: string,
5    ownerId: string,
6    collaborators: CollaboratorInput[]
7  ) {
8    // Verify ownership
9    const document = await this.verifyOwnership(documentId, ownerId);
10
11    // Create collaboration records
12    const collaborationPromises = collaborators.map(async (collaborator) => {
13      const user = await prisma.user.findUnique({
14        where: { email: collaborator.email },
15      });
16
17      if (!user) {
18        throw new NotFoundError('User not found');
19      }
20
21      return prisma.collaboration.create({
22        data: {
23          documentId,
24          userId: user.id,
25          role: collaborator.role,
26        },
27      });
28    });
29
30    return Promise.all(collaborationPromises);
31  }
32
33  async getAccessibleDocuments(userId: string) {
34    return prisma.document.findMany({
35      where: {
36        OR: [
37          { ownerId: userId },
38          { collaborations: { some: { userId } } },
39          { isPublic: true },
40        ],
41      },
42      include: {
43        owner: { select: { name: true, avatar: true } },
44        collaborations: {
45          include: { user: { select: { name: true, avatar: true } } },
46        },
47        _count: { select: { versions: true } },
48      },
49      orderBy: { updatedAt: 'desc' },
50    });
51  }
52}

1// Performance Monitoring & Caching
2class PerformanceMonitor {
3  private cache = new Map<string, CacheEntry>();
4
5  static async measureAsync<T>(
6    operation: string,
7    fn: () => Promise<T>
8  ): Promise<T> {
9    const startTime = Date.now();
10    try {
11      const result = await fn();
12      const duration = Date.now() - startTime;
13      console.log(`✅ ${operation} completed in ${duration}ms`);
14      return result;
15    } catch (error) {
16      const duration = Date.now() - startTime;
17      console.error(`❌ ${operation} failed after ${duration}ms:`, error);
18      throw error;
19    }
20  }
21
22  async getCachedData<T>(
23    key: string,
24    fetcher: () => Promise<T>,
25    ttl: number = 300000 // 5 minutes
26  ): Promise<T> {
27    const cached = this.cache.get(key);
28    if (cached && Date.now() - cached.timestamp < ttl) {
29      return cached.data;
30    }
31
32    const data = await fetcher();
33    this.cache.set(key, { data, timestamp: Date.now() });
34    return data;
35  }
36}
37
38// Usage in API routes
39export async function GET(request: NextRequest) {
40  return PerformanceMonitor.measureAsync(
41    'fetchDocuments',
42    async () => {
43      const data = await performanceMonitor.getCachedData(
44        `documents:${userId}`,
45        () => documentService.getAccessibleDocuments(userId),
46        30000 // 30 second cache
47      );
48      return NextResponse.json(data);
49    }
50  );
51}