react-embed-docs 0.1.0

package/dist/server/DocsService.js

@@ -0,0 +1,512 @@
+import { and, asc, count, desc, eq, getTableColumns, isNull, sql, } from 'drizzle-orm';
+import { nanoid } from 'nanoid';
+import { documentsTable } from './schema.js';
+/**
+ * DocsService
+ * Handles all CRUD operations for documents with BlockNote content
+ */
+export class DocsService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * List documents with filtering and pagination
+     * Returns documents without content field to reduce payload size
+     */
+    async list(filters = {}, options = {}) {
+        const { offset = 0, limit = 10, sortBy = 'createdAt', sortDir = 'desc', } = options;
+        const { search, parentId, isPublished } = filters;
+        const where = [isNull(documentsTable.deletedAt)];
+        if (search) {
+            // Search in both title and content using PostgreSQL JSONB operators
+            const searchPattern = `%${search}%`;
+            where.push(sql `${documentsTable.title} ILIKE ${searchPattern} OR 
+            jsonb_path_exists(${documentsTable.content}, 
+              ('$[*].content ? (@.type == "text" && @.text like_regex "' || ${search} || '" flag "i")')::jsonpath) OR
+            jsonb_path_exists(${documentsTable.content},
+              ('$[*].content[*].text ? (@ like_regex "' || ${search} || '" flag "i")')::jsonpath)`);
+        }
+        if (parentId !== undefined) {
+            if (parentId === null) {
+                where.push(isNull(documentsTable.parentId));
+            }
+            else {
+                where.push(eq(documentsTable.parentId, parentId));
+            }
+        }
+        if (isPublished !== undefined) {
+            where.push(eq(documentsTable.isPublished, isPublished));
+        }
+        const totalQuery = this.db
+            .select({ count: count() })
+            .from(documentsTable)
+            .where(and(...where));
+        const columns = getTableColumns(documentsTable);
+        const sortColumn = columns[sortBy] ?? columns.createdAt;
+        const orderByClause = sortDir === 'asc' ? asc(sortColumn) : desc(sortColumn);
+        const documents = await this.db.query.documentsTable.findMany({
+            where: and(...where),
+            orderBy: orderByClause,
+            limit,
+            offset,
+            columns: {
+                id: true,
+                title: true,
+                slug: true,
+                emoji: true,
+                cover: true,
+                isPublished: true,
+                parentId: true,
+                order: true,
+                authorId: true,
+                createdAt: true,
+                updatedAt: true,
+                deletedAt: true,
+                // Exclude: content, searchIndex
+            },
+        });
+        const totalResult = await totalQuery;
+        return {
+            documents: documents,
+            total: totalResult[0]?.count ?? 0,
+        };
+    }
+    /**
+     * Full-text search with ranking using searchIndex column
+     * More efficient than JSONB search for large datasets
+     */
+    async searchText(query, options = {}) {
+        const { limit = 20, offset = 0 } = options;
+        const searchPattern = `%${query}%`;
+        // Use ILIKE on searchIndex column and also check title separately for ranking
+        const results = await this.db.execute(sql `
+      SELECT 
+        d.*,
+        CASE 
+          WHEN d.title ILIKE ${searchPattern} THEN 2
+          WHEN d.search_index ILIKE ${searchPattern} THEN 1
+          ELSE 0
+        END as rank
+      FROM docs.documents d
+      WHERE d.deleted_at IS NULL
+        AND d.search_index ILIKE ${searchPattern}
+      ORDER BY rank DESC, d.updated_at DESC
+      LIMIT ${limit}
+      OFFSET ${offset}
+    `);
+        // Get total count
+        const countResult = await this.db.execute(sql `
+      SELECT COUNT(*) as total
+      FROM docs.documents d
+      WHERE d.deleted_at IS NULL
+        AND d.search_index ILIKE ${searchPattern}
+    `);
+        const total = Number(countResult[0]?.total ?? 0);
+        // Map results
+        const mappedResults = results.map((row) => ({
+            document: row,
+            rank: Number(row.rank),
+        }));
+        return { results: mappedResults, total };
+    }
+    /**
+     * Advanced search with highlighting
+     * Searches JSONB content directly for more precise matching
+     */
+    async search(query, options = {}) {
+        const { limit = 20, offset = 0 } = options;
+        const searchPattern = `%${query}%`;
+        // Use raw SQL for complex search with ranking
+        const results = await this.db.execute(sql `
+      SELECT 
+        d.*,
+        CASE 
+          WHEN d.title ILIKE ${searchPattern} THEN 3
+          WHEN jsonb_path_exists(d.content, ('$[*].content ? (@.type == "text" && @.text like_regex "' || ${query} || '" flag "i")')::jsonpath) THEN 2
+          WHEN jsonb_path_exists(d.content, ('$[*].content[*].text ? (@ like_regex "' || ${query} || '" flag "i")')::jsonpath) THEN 1
+          ELSE 0
+        END as rank
+      FROM docs.documents d
+      WHERE d.deleted_at IS NULL
+        AND (
+          d.title ILIKE ${searchPattern}
+          OR jsonb_path_exists(d.content, ('$[*].content ? (@.type == "text" && @.text like_regex "' || ${query} || '" flag "i")')::jsonpath)
+          OR jsonb_path_exists(d.content, ('$[*].content[*].text ? (@ like_regex "' || ${query} || '" flag "i")')::jsonpath)
+        )
+      ORDER BY rank DESC, d.updated_at DESC
+      LIMIT ${limit}
+      OFFSET ${offset}
+    `);
+        // Get total count
+        const countResult = await this.db.execute(sql `
+      SELECT COUNT(*) as total
+      FROM docs.documents d
+      WHERE d.deleted_at IS NULL
+        AND (
+          d.title ILIKE ${searchPattern}
+          OR jsonb_path_exists(d.content, ('$[*].content ? (@.type == "text" && @.text like_regex "' || ${query} || '" flag "i")')::jsonpath)
+          OR jsonb_path_exists(d.content, ('$[*].content[*].text ? (@ like_regex "' || ${query} || '" flag "i")')::jsonpath)
+        )
+    `);
+        const total = Number(countResult[0]?.total ?? 0);
+        // Map results to SearchResult format
+        const mappedResults = results.map((row) => ({
+            document: row,
+            rank: Number(row.rank),
+            highlights: this.extractHighlights(row.content, query),
+        }));
+        return { results: mappedResults, total };
+    }
+    extractFromContentItem(queryLower, item) {
+        const highlights = [];
+        if (item.text && item.text.toLowerCase().includes(queryLower)) {
+            // Extract surrounding context (50 chars before and after)
+            const text = item.text;
+            const index = text.toLowerCase().indexOf(queryLower);
+            const start = Math.max(0, index - 50);
+            const end = Math.min(text.length, index + queryLower.length + 50);
+            const context = text.substring(start, end);
+            highlights.push(context);
+            // Limit to 3 highlights
+            if (highlights.length >= 3)
+                return highlights;
+        }
+        return highlights;
+    }
+    /**
+     * Extract text highlights from BlockNote content
+     * Returns surrounding context around matched text
+     */
+    extractHighlights(content, query) {
+        const highlights = [];
+        const queryLower = query.toLowerCase();
+        if (!Array.isArray(content))
+            return highlights;
+        for (const block of content) {
+            if (block.content && Array.isArray(block.content)) {
+                for (const item of block.content) {
+                    if (Array.isArray(item)) {
+                        // Nested content arrays
+                        for (const nestedItem of item) {
+                            const results = this.extractFromContentItem(queryLower, nestedItem);
+                            if (results.length > 0) {
+                                highlights.push(...results);
+                            }
+                        }
+                        continue;
+                    }
+                    const results = this.extractFromContentItem(queryLower, item);
+                    if (results.length > 0) {
+                        highlights.push(...results);
+                    }
+                }
+            }
+            if (highlights.length >= 3)
+                break;
+        }
+        return highlights;
+    }
+    /**
+     * Extract plain text from BlockNote content
+     * Used for building search index
+     */
+    extractTextFromContent(content) {
+        const textParts = [];
+        function extractFromContentItem(item) {
+            if (item.text && typeof item.text === 'string') {
+                textParts.push(item.text);
+            }
+        }
+        function extractFromBlock(block) {
+            if (!block.content || !Array.isArray(block.content))
+                return;
+            for (const contentItem of block.content) {
+                if (Array.isArray(contentItem)) {
+                    // Nested content arrays
+                    for (const nestedItem of contentItem) {
+                        extractFromContentItem(nestedItem);
+                    }
+                }
+                else {
+                    extractFromContentItem(contentItem);
+                }
+            }
+        }
+        if (!Array.isArray(content)) {
+            return '';
+        }
+        for (const block of content) {
+            if (block && typeof block === 'object') {
+                extractFromBlock(block);
+            }
+        }
+        return textParts.join(' ');
+    }
+    /**
+     * Build search index from title and content
+     * Concatenates title and extracted text for full-text search
+     */
+    buildSearchIndex(title, content) {
+        const contentText = this.extractTextFromContent(content);
+        return `${title} ${contentText}`.trim();
+    }
+    /**
+     * Get document by ID
+     */
+    async getById(id) {
+        const document = await this.db.query.documentsTable.findFirst({
+            where: and(eq(documentsTable.id, id), isNull(documentsTable.deletedAt)),
+        });
+        return document;
+    }
+    /**
+     * Get document by slug
+     */
+    async getBySlug(slug) {
+        const document = await this.db.query.documentsTable.findFirst({
+            where: and(eq(documentsTable.slug, slug), isNull(documentsTable.deletedAt)),
+        });
+        return document;
+    }
+    /**
+     * Create new document
+     * Automatically generates search index from title and content
+     */
+    async create(data) {
+        const id = nanoid();
+        const searchIndex = this.buildSearchIndex(data.title, data.content);
+        let parentId = null;
+        if (data.parentSlugs) {
+            for (const parentSlug of data.parentSlugs) {
+                const parent = await this.getBySlug(parentSlug);
+                if (!parent) {
+                    throw new Error(`Parent document not found: ${parentSlug}`);
+                }
+                parentId = parent.id;
+            }
+        }
+        const [result] = await this.db
+            .insert(documentsTable)
+            .values({
+            ...data,
+            parentId,
+            id,
+            searchIndex,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        })
+            .returning();
+        if (!result) {
+            throw new Error('Failed to create document');
+        }
+        return result;
+    }
+    /**
+     * Update existing document
+     * Rebuilds search index if title or content changes
+     */
+    async update(id, data) {
+        // If title or content is being updated, we need to rebuild the searchIndex
+        let searchIndex;
+        if (data.title !== undefined || data.content !== undefined) {
+            // Get current document to have both values
+            const currentDoc = await this.getById(id);
+            if (!currentDoc) {
+                return undefined;
+            }
+            const title = data.title ?? currentDoc.title;
+            const content = data.content ?? currentDoc.content;
+            searchIndex = this.buildSearchIndex(title, content);
+        }
+        const [result] = await this.db
+            .update(documentsTable)
+            .set({
+            ...data,
+            ...(searchIndex !== undefined && { searchIndex }),
+            updatedAt: new Date(),
+        })
+            .where(and(eq(documentsTable.id, id), isNull(documentsTable.deletedAt)))
+            .returning();
+        return result;
+    }
+    /**
+     * Soft delete document
+     * Sets deletedAt timestamp instead of removing from database
+     */
+    async delete(id) {
+        const [result] = await this.db
+            .update(documentsTable)
+            .set({
+            deletedAt: new Date(),
+        })
+            .where(and(eq(documentsTable.id, id), isNull(documentsTable.deletedAt)))
+            .returning();
+        return result;
+    }
+    /**
+     * Get children documents by parent ID
+     * Returns documents without content field
+     */
+    async getChildren(parentId) {
+        const children = await this.db.query.documentsTable.findMany({
+            where: and(eq(documentsTable.parentId, parentId), isNull(documentsTable.deletedAt)),
+            orderBy: asc(documentsTable.order),
+            columns: {
+                id: true,
+                title: true,
+                slug: true,
+                emoji: true,
+                cover: true,
+                isPublished: true,
+                parentId: true,
+                order: true,
+                authorId: true,
+                createdAt: true,
+                updatedAt: true,
+                deletedAt: true,
+                // Exclude: content, searchIndex
+            },
+        });
+        return children;
+    }
+    /**
+     * Get all documents as flat tree structure
+     * Useful for building document tree UI
+     * Returns documents without content field
+     */
+    async getTree() {
+        const allDocs = await this.db.query.documentsTable.findMany({
+            where: isNull(documentsTable.deletedAt),
+            orderBy: [asc(documentsTable.parentId), asc(documentsTable.order)],
+            columns: {
+                id: true,
+                title: true,
+                slug: true,
+                emoji: true,
+                cover: true,
+                isPublished: true,
+                parentId: true,
+                order: true,
+                authorId: true,
+                createdAt: true,
+                updatedAt: true,
+                deletedAt: true,
+                // Exclude: content, searchIndex
+            },
+        });
+        return allDocs;
+    }
+    /**
+     * Reorder document - move to new parent and/or position
+     * Automatically reorders siblings to maintain consistent ordering
+     */
+    async reorder(id, newParentId, newOrder) {
+        // Get the current document
+        const doc = await this.getById(id);
+        if (!doc) {
+            return undefined;
+        }
+        const oldParentId = doc.parentId;
+        // Update the moved document
+        const [updated] = await this.db
+            .update(documentsTable)
+            .set({
+            parentId: newParentId,
+            order: newOrder,
+            updatedAt: new Date(),
+        })
+            .where(and(eq(documentsTable.id, id), isNull(documentsTable.deletedAt)))
+            .returning();
+        // Reorder other documents in the old parent if parent changed
+        if (oldParentId !== undefined && oldParentId !== newParentId) {
+            const siblings = await this.db.query.documentsTable.findMany({
+                where: and(oldParentId === null
+                    ? isNull(documentsTable.parentId)
+                    : eq(documentsTable.parentId, oldParentId), isNull(documentsTable.deletedAt)),
+                orderBy: asc(documentsTable.order),
+            });
+            // Reassign orders to siblings with spacing for future insertions
+            for (let i = 0; i < siblings.length; i++) {
+                const sibling = siblings[i];
+                if (sibling) {
+                    await this.db
+                        .update(documentsTable)
+                        .set({ order: i * 10 })
+                        .where(eq(documentsTable.id, sibling.id));
+                }
+            }
+        }
+        // Reorder documents in the new parent
+        const newSiblings = await this.db.query.documentsTable.findMany({
+            where: and(newParentId === null
+                ? isNull(documentsTable.parentId)
+                : eq(documentsTable.parentId, newParentId), isNull(documentsTable.deletedAt)),
+            orderBy: asc(documentsTable.order),
+        });
+        // Reassign orders to ensure proper spacing
+        for (let i = 0; i < newSiblings.length; i++) {
+            const sibling = newSiblings[i];
+            if (sibling) {
+                await this.db
+                    .update(documentsTable)
+                    .set({ order: i * 10 })
+                    .where(eq(documentsTable.id, sibling.id));
+            }
+        }
+        return updated;
+    }
+    /**
+     * Update just the order field of a document
+     */
+    async updateOrder(id, order) {
+        const [result] = await this.db
+            .update(documentsTable)
+            .set({
+            order,
+            updatedAt: new Date(),
+        })
+            .where(and(eq(documentsTable.id, id), isNull(documentsTable.deletedAt)))
+            .returning();
+        return result;
+    }
+    /**
+     * Get breadcrumb path for a document
+     * Returns array of ancestors from root to parent, plus the document itself
+     * Returns documents without content field
+     */
+    async getBreadcrumbs(id) {
+        const breadcrumbs = [];
+        const visited = new Set();
+        let currentId = id;
+        while (currentId) {
+            // Prevent infinite loops from circular references
+            if (visited.has(currentId))
+                break;
+            visited.add(currentId);
+            const doc = await this.db.query.documentsTable.findFirst({
+                where: and(eq(documentsTable.id, currentId), isNull(documentsTable.deletedAt)),
+                columns: {
+                    id: true,
+                    title: true,
+                    slug: true,
+                    emoji: true,
+                    cover: true,
+                    isPublished: true,
+                    parentId: true,
+                    order: true,
+                    authorId: true,
+                    createdAt: true,
+                    updatedAt: true,
+                    deletedAt: true,
+                    // Exclude: content, searchIndex
+                },
+            });
+            if (!doc)
+                break;
+            breadcrumbs.unshift(doc);
+            currentId = doc.parentId ?? null;
+        }
+        return breadcrumbs;
+    }
+}

package/dist/server/ExportService.d.ts

@@ -0,0 +1,106 @@
+import type { Document } from '../shared/types.js';
+/**
+ * Options for DOCX export
+ */
+export interface DocxExportOptions {
+    includeTitle?: boolean;
+    includeEmoji?: boolean;
+    author?: string;
+    company?: string;
+}
+/**
+ * Options for PDF export
+ */
+export interface PdfExportOptions {
+    includeTitle?: boolean;
+    includeEmoji?: boolean;
+    format?: 'A4' | 'Letter' | 'Legal';
+    margin?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+}
+/**
+ * Export result
+ */
+export interface ExportResult {
+    buffer: Buffer;
+    filename: string;
+    mimeType: string;
+}
+/**
+ * Service for exporting documents to various formats
+ */
+export declare class ExportService {
+    /**
+     * Export document to DOCX format
+     * Requires 'docx' package to be installed
+     */
+    exportToDocx(document: Document, options?: DocxExportOptions): Promise<ExportResult>;
+    /**
+     * Export document to PDF format
+     * Requires 'puppeteer' or 'playwright' package to be installed
+     */
+    exportToPdf(document: Document, options?: PdfExportOptions): Promise<ExportResult>;
+    /**
+     * Export document to HTML format
+     */
+    exportToHtml(document: Document, options?: {
+        includeTitle?: boolean;
+        includeEmoji?: boolean;
+    }): Promise<ExportResult>;
+    /**
+     * Export document to Markdown format
+     */
+    exportToMarkdown(document: Document, options?: {
+        includeTitle?: boolean;
+        includeEmoji?: boolean;
+    }): Promise<ExportResult>;
+    /**
+     * Convert a BlockNote block to DOCX Paragraph
+     */
+    private blockToDocxParagraph;
+    /**
+     * Convert BlockNote content items to TextRun array
+     */
+    private convertContentToTextRuns;
+    /**
+     * Extract plain text from content
+     */
+    private extractTextFromContent;
+    /**
+     * Generate HTML from document
+     */
+    private generateHtml;
+    /**
+     * Convert a BlockNote block to HTML
+     */
+    private blockToHtml;
+    /**
+     * Render content items to HTML
+     */
+    private renderContentToHtml;
+    /**
+     * Convert a single content item to HTML
+     */
+    private contentItemToHtml;
+    /**
+     * Convert a table block to HTML
+     */
+    private renderTableToHtml;
+    /**
+     * Convert a block to Markdown
+     */
+    private blockToMarkdown;
+    /**
+     * Escape HTML special characters
+     */
+    private escapeHtml;
+    /**
+     * Sanitize filename for filesystem
+     */
+    private sanitizeFilename;
+}
+//# sourceMappingURL=ExportService.d.ts.map

package/dist/server/ExportService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportService.d.ts","sourceRoot":"","sources":["../../src/server/ExportService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAwC,MAAM,oBAAoB,CAAA;AAExF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,MAAM,CAAC,EAAE,IAAI,GAAG,QAAQ,GAAG,OAAO,CAAA;IAClC,MAAM,CAAC,EAAE;QACP,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,IAAI,CAAC,EAAE,MAAM,CAAA;KACd,CAAA;CACF;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB;;;OAGG;IACG,YAAY,CAChB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,YAAY,CAAC;IAgExB;;;OAGG;IACG,WAAW,CACf,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,YAAY,CAAC;IA4DxB;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAO,GAC/D,OAAO,CAAC,YAAY,CAAC;IAYxB;;OAEG;IACG,gBAAgB,CACpB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAO,GAC/D,OAAO,CAAC,YAAY,CAAC;IA4BxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsF5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAyChC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,OAAO,CAAC,YAAY;IAqEpB;;OAEG;IACH,OAAO,CAAC,WAAW;IA+CnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiBzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2CvB;;OAEG;IACH,OAAO,CAAC,UAAU;IASlB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAOzB"}