react-embed-docs 0.4.0 → 0.5.0

package/dist/client/components/DocumentEdit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DocumentEdit.d.ts","sourceRoot":"","sources":["../../../src/client/components/DocumentEdit.tsx"],"names":[],"mappings":"AAIA,OAAO,8BAA8B,CAAA;AAgBrC,UAAU,iBAAiB;CAAG;AAwU9B,wBAAgB,YAAY,CAAC,EAAE,EAAE,iBAAiB,2CA2RjD"}
+{"version":3,"file":"DocumentEdit.d.ts","sourceRoot":"","sources":["../../../src/client/components/DocumentEdit.tsx"],"names":[],"mappings":"AAIA,OAAO,8BAA8B,CAAA;AAgBrC,UAAU,iBAAiB;CAAG;AAwU9B,wBAAgB,YAAY,CAAC,EAAE,EAAE,iBAAiB,2CAmYjD"}

package/dist/client/components/DocumentEdit.js

@@ -4,7 +4,7 @@ import { BlockNoteView } from '@blocknote/mantine';
 import '@blocknote/mantine/style.css';
 import { useCreateBlockNote } from '@blocknote/react';
 import { Eye, ImageIcon, Loader2, Save, X } from 'lucide-react';
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { useCreateDocumentMutation, useDocumentQuery, useUpdateDocumentMutation, } from '../hooks/useDocsQuery.js';
 import { useFileUpload } from '../hooks/useFileUpload.js';
 import { useTranslation } from '../hooks/useTranslation.js';
@@ -346,17 +346,94 @@ export function DocumentEdit({}) {
     const [isSlugManuallyEdited, setIsSlugManuallyEdited] = useState(false);
     const [emoji, setEmoji] = useState(undefined);
     const [cover, setCover] = useState(null);
+    const [previousCover, setPreviousCover] = useState(null);
     const [isSaving, setIsSaving] = useState(false);
     const [hasLoaded, setHasLoaded] = useState(false);
-    // File upload hook
+    // Track image URLs for cleanup when deleted
+    const [previousImageUrls, setPreviousImageUrls] = useState(new Set());
+    // Helper to extract image URLs from blocks
+    const extractImageUrls = useCallback((blocks) => {
+        const urls = [];
+        for (const block of blocks) {
+            if (block.type === 'image' && block.props?.url) {
+                urls.push(block.props.url);
+            }
+            // Check nested content
+            if (block.children && block.children.length > 0) {
+                urls.push(...extractImageUrls(block.children));
+            }
+        }
+        return urls;
+    }, []);
+    // File upload hook for cover
     const { isUploading: isUploadingCover, uploadFile: uploadCover } = useFileUpload({
         maxSize: 5 * 1024 * 1024, // 5MB
         acceptedTypes: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
     });
-    // Initialize editor
+    // File upload hook for editor images
+    const { uploadFile: uploadEditorFile } = useFileUpload({
+        maxSize: 5 * 1024 * 1024, // 5MB
+        acceptedTypes: ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml'],
+    });
+    // Upload file handler for BlockNote editor
+    const handleUploadFile = useCallback(async (file) => {
+        const result = await uploadEditorFile(file);
+        return result.url;
+    }, [uploadEditorFile]);
+    // Initialize editor with file upload support
     const editor = useCreateBlockNote({
         initialContent: getDefaultContent(),
+        uploadFile: handleUploadFile,
     });
+    // Helper to extract file ID from URL
+    const extractFileIdFromUrl = useCallback((url) => {
+        // URL format: /api/docs/files/{id}
+        const match = url.match(/\/api\/docs\/files\/([a-zA-Z0-9_-]+)/);
+        return match?.[1] ?? null;
+    }, []);
+    // Soft delete file from server
+    const softDeleteFile = useCallback(async (fileId) => {
+        try {
+            const res = await fetch(`/api/docs/files/${fileId}`, {
+                method: 'DELETE',
+            });
+            if (!res.ok) {
+                console.error(`Failed to soft delete file ${fileId}:`, res.statusText);
+            }
+        }
+        catch (error) {
+            console.error(`Error soft deleting file ${fileId}:`, error);
+        }
+    }, []);
+    // Monitor editor changes and soft delete removed images
+    useEffect(() => {
+        if (!editor)
+            return;
+        const unsubscribe = editor.onChange(() => {
+            const currentBlocks = editor.document;
+            const currentImageUrls = new Set(extractImageUrls(currentBlocks));
+            // Find images that were in previous but not in current
+            for (const url of previousImageUrls) {
+                if (!currentImageUrls.has(url)) {
+                    const fileId = extractFileIdFromUrl(url);
+                    if (fileId) {
+                        softDeleteFile(fileId);
+                    }
+                }
+            }
+            setPreviousImageUrls(currentImageUrls);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [editor, extractImageUrls, extractFileIdFromUrl, softDeleteFile, previousImageUrls]);
+    // Initialize previousImageUrls when document loads
+    useEffect(() => {
+        if (editor && hasLoaded && existingDoc) {
+            const urls = new Set(extractImageUrls(editor.document));
+            setPreviousImageUrls(urls);
+        }
+    }, [editor, hasLoaded, existingDoc, extractImageUrls]);
     // Load existing document data when available
     useEffect(() => {
         if (existingDoc && !hasLoaded) {
@@ -364,8 +441,10 @@ export function DocumentEdit({}) {
             setSlug(existingDoc.slug);
             if (existingDoc.emoji)
                 setEmoji(existingDoc.emoji);
-            if (existingDoc.cover)
+            if (existingDoc.cover) {
                 setCover(existingDoc.cover);
+                setPreviousCover(existingDoc.cover);
+            }
             if (editor && existingDoc.content) {
                 try {
                     const content = typeof existingDoc.content === 'string'
@@ -405,6 +484,13 @@ export function DocumentEdit({}) {
         try {
             const content = editor.document;
             const finalSlug = slug.trim() || generateSlug(title);
+            // Check if cover was removed and soft delete the old file
+            if (previousCover && !cover) {
+                const fileId = extractFileIdFromUrl(previousCover);
+                if (fileId) {
+                    await softDeleteFile(fileId);
+                }
+            }
             if (!existingDoc) {
                 // Create new document (with parentId if it's a child document)
                 const newDoc = await createMutation.mutateAsync({
@@ -431,6 +517,8 @@ export function DocumentEdit({}) {
                     },
                 });
             }
+            // Update previousCover after successful save
+            setPreviousCover(cover);
         }
         catch (error) {
             console.error('Failed to save document:', error);

package/dist/server/FilesService.d.ts

@@ -17,25 +17,50 @@ export declare class FilesService {
      */
     upload(data: InsertFileUpload): Promise<File>;
     /**
-     * Get a file by its ID
+     * Get a file by its ID (excludes soft-deleted files)
      * @param id - The file ID
      * @returns The file record or undefined if not found
      */
     getById(id: string): Promise<File | undefined>;
     /**
-     * Delete a file by its ID
+     * Soft delete a file by its ID (sets deletedAt timestamp)
      * @param id - The file ID to delete
      * @throws Error if deletion fails
      */
     delete(id: string): Promise<void>;
     /**
-     * List all files with optional pagination
-     * @param options - Pagination options
+     * Hard delete a file by its ID (permanent deletion)
+     * @param id - The file ID to delete
+     * @throws Error if deletion fails
+     */
+    hardDelete(id: string): Promise<void>;
+    /**
+     * Restore a soft-deleted file
+     * @param id - The file ID to restore
+     * @throws Error if restoration fails
+     */
+    restore(id: string): Promise<void>;
+    /**
+     * List all non-deleted files with optional pagination
+     * @param options - Pagination options and includeDeleted flag
      * @returns Array of files and total count
      */
     list(options?: {
         limit?: number;
         offset?: number;
+        includeDeleted?: boolean;
+    }): Promise<{
+        files: File[];
+        total: number;
+    }>;
+    /**
+     * List soft-deleted files (for cleanup purposes)
+     * @param options - Pagination options
+     * @returns Array of deleted files and total count
+     */
+    listDeleted(options?: {
+        limit?: number;
+        offset?: number;
     }): Promise<{
         files: File[];
         total: number;

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

@@ -1 +1 @@
-{"version":3,"file":"FilesService.d.ts","sourceRoot":"","sources":["../../src/server/FilesService.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EAEL,KAAK,IAAI,EACV,MAAM,aAAa,CAAA;AAEpB;;;;GAIG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEnC;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBnD;;;;OAIG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAQpD;;;;OAIG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvC;;;;OAIG;IACG,IAAI,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAkBzG"}
+{"version":3,"file":"FilesService.d.ts","sourceRoot":"","sources":["../../src/server/FilesService.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EAEL,KAAK,IAAI,EACV,MAAM,aAAa,CAAA;AAEpB;;;;GAIG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEnC;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBnD;;;;OAIG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAapD;;;;OAIG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC;;;;OAIG;IACG,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3C;;;;OAIG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxC;;;;OAIG;IACG,IAAI,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAwBlI;;;;OAIG;IACG,WAAW,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAoBhH"}

package/dist/server/FilesService.js

@@ -1,4 +1,4 @@
-import { eq, sql } from 'drizzle-orm';
+import { eq, isNull, sql } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 import { filesTable } from './schema.js';
 /**
@@ -32,7 +32,7 @@ export class FilesService {
         return result;
     }
     /**
-     * Get a file by its ID
+     * Get a file by its ID (excludes soft-deleted files)
      * @param id - The file ID
      * @returns The file record or undefined if not found
      */
@@ -40,14 +40,33 @@ export class FilesService {
         const file = await this.db.query.filesTable.findFirst({
             where: eq(filesTable.id, id),
         });
+        // Return undefined if file is soft-deleted
+        if (file?.deletedAt) {
+            return undefined;
+        }
         return file;
     }
     /**
-     * Delete a file by its ID
+     * Soft delete a file by its ID (sets deletedAt timestamp)
      * @param id - The file ID to delete
      * @throws Error if deletion fails
      */
     async delete(id) {
+        const [result] = await this.db
+            .update(filesTable)
+            .set({ deletedAt: new Date() })
+            .where(eq(filesTable.id, id))
+            .returning();
+        if (!result) {
+            throw new Error('File not found');
+        }
+    }
+    /**
+     * Hard delete a file by its ID (permanent deletion)
+     * @param id - The file ID to delete
+     * @throws Error if deletion fails
+     */
+    async hardDelete(id) {
         const [result] = await this.db
             .delete(filesTable)
             .where(eq(filesTable.id, id))
@@ -57,21 +76,61 @@ export class FilesService {
         }
     }
     /**
-     * List all files with optional pagination
-     * @param options - Pagination options
+     * Restore a soft-deleted file
+     * @param id - The file ID to restore
+     * @throws Error if restoration fails
+     */
+    async restore(id) {
+        const [result] = await this.db
+            .update(filesTable)
+            .set({ deletedAt: null })
+            .where(eq(filesTable.id, id))
+            .returning();
+        if (!result) {
+            throw new Error('File not found');
+        }
+    }
+    /**
+     * List all non-deleted files with optional pagination
+     * @param options - Pagination options and includeDeleted flag
      * @returns Array of files and total count
      */
     async list(options = {}) {
-        const { limit = 50, offset = 0 } = options;
+        const { limit = 50, offset = 0, includeDeleted = false } = options;
+        // Build where condition based on includeDeleted flag
+        const whereCondition = includeDeleted ? undefined : isNull(filesTable.deletedAt);
         const files = await this.db.query.filesTable.findMany({
+            where: whereCondition,
             limit,
             offset,
             orderBy: (files, { desc }) => [desc(files.createdAt)],
         });
-        // Get total count
+        // Get total count (filtered by deleted status)
+        const totalResult = await this.db
+            .select({ count: sql `count(*)::int` })
+            .from(filesTable)
+            .where(whereCondition ?? sql `TRUE`);
+        const total = Number(totalResult[0]?.count ?? 0);
+        return { files, total };
+    }
+    /**
+     * List soft-deleted files (for cleanup purposes)
+     * @param options - Pagination options
+     * @returns Array of deleted files and total count
+     */
+    async listDeleted(options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const files = await this.db.query.filesTable.findMany({
+            where: sql `${filesTable.deletedAt} IS NOT NULL`,
+            limit,
+            offset,
+            orderBy: (files, { desc }) => [desc(files.deletedAt)],
+        });
+        // Get total count of deleted files
         const totalResult = await this.db
             .select({ count: sql `count(*)::int` })
-            .from(filesTable);
+            .from(filesTable)
+            .where(sql `${filesTable.deletedAt} IS NOT NULL`);
         const total = Number(totalResult[0]?.count ?? 0);
         return { files, total };
     }

package/dist/server/schema.d.ts

@@ -307,6 +307,18 @@ export declare const filesTable: import("drizzle-orm/pg-core").PgTableWithColumn
             enumValues: undefined;
             baseColumn: never;
         }, {}, {}>;
+        deletedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deletedAt";
+            tableName: "files";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/server/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,eAAe,gDAAmB,CAAA;AAE/C;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CxB,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;EAM3B,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpB,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB/B,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAA;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AACzD,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;AAEpD,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,YAAY,CAAA;AACvD,MAAM,MAAM,IAAI,GAAG,OAAO,UAAU,CAAC,YAAY,CAAA;AAEjD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC7E,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAEvE,MAAM,MAAM,sBAAsB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC9E,MAAM,MAAM,gBAAgB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/server/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,eAAe,gDAAmB,CAAA;AAE/C;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CxB,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;EAM3B,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpB,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB/B,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAA;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AACzD,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;AAEpD,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,YAAY,CAAA;AACvD,MAAM,MAAM,IAAI,GAAG,OAAO,UAAU,CAAC,YAAY,CAAA;AAEjD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC7E,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAEvE,MAAM,MAAM,sBAAsB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC9E,MAAM,MAAM,gBAAgB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA"}

package/dist/server/schema.js

@@ -75,11 +75,14 @@ export const filesTable = docsTableSchema.table('files', {
     createdAt: timestamp('createdAt')
         .default(sql `NOW()`)
         .notNull(),
+    deletedAt: timestamp('deletedAt'), // Soft delete for files
 }, (table) => ({
     // Index for file lookups
     filenameIdx: index('filename_idx').on(table.filename),
     // Index for mime type filtering
     mimeTypeIdx: index('mime_type_idx').on(table.mimeType),
+    // Index for soft delete queries
+    filesDeletedAtIdx: index('files_deleted_at_idx').on(table.deletedAt),
 }));
 /**
  * Document versions table

package/drizzle/migrations/0001_omniscient_fallen_one.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "docs"."files" ADD COLUMN "deletedAt" timestamp;--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "files_deleted_at_idx" ON "docs"."files" USING btree ("deletedAt");

package/drizzle/migrations/meta/0001_snapshot.json

@@ -0,0 +1,595 @@
+{
+  "id": "cd711252-7226-4bb5-a58d-0867586c7463",
+  "prevId": "31106a8d-1ede-402b-9721-ead67be66c4d",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "docs.document_presence": {
+      "name": "document_presence",
+      "schema": "docs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "document_id": {
+          "name": "document_id",
+          "type": "varchar(21)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_name": {
+          "name": "user_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_color": {
+          "name": "user_color",
+          "type": "varchar(7)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cursor_position": {
+          "name": "cursor_position",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "selection": {
+          "name": "selection",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "NOW()"
+        }
+      },
+      "indexes": {
+        "presence_idx": {
+          "name": "presence_idx",
+          "columns": [
+            {
+              "expression": "document_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "last_seen_idx": {
+          "name": "last_seen_idx",
+          "columns": [
+            {
+              "expression": "last_seen_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "document_presence_document_id_documents_id_fk": {
+          "name": "document_presence_document_id_documents_id_fk",
+          "tableFrom": "document_presence",
+          "tableTo": "documents",
+          "schemaTo": "docs",
+          "columnsFrom": [
+            "document_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "docs.document_versions": {
+      "name": "document_versions",
+      "schema": "docs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "document_id": {
+          "name": "document_id",
+          "type": "varchar(21)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version_number": {
+          "name": "version_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "change_description": {
+          "name": "change_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "emoji": {
+          "name": "emoji",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cover": {
+          "name": "cover",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ydoc_state": {
+          "name": "ydoc_state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by_name": {
+          "name": "created_by_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "NOW()"
+        }
+      },
+      "indexes": {
+        "document_version_idx": {
+          "name": "document_version_idx",
+          "columns": [
+            {
+              "expression": "document_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "version_number",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "version_created_at_idx": {
+          "name": "version_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "document_versions_document_id_documents_id_fk": {
+          "name": "document_versions_document_id_documents_id_fk",
+          "tableFrom": "document_versions",
+          "tableTo": "documents",
+          "schemaTo": "docs",
+          "columnsFrom": [
+            "document_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "docs.documents": {
+      "name": "documents",
+      "schema": "docs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(21)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'"
+        },
+        "search_index": {
+          "name": "search_index",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "emoji": {
+          "name": "emoji",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cover": {
+          "name": "cover",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isPublished": {
+          "name": "isPublished",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "parentId": {
+          "name": "parentId",
+          "type": "varchar(21)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "order": {
+          "name": "order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "authorId": {
+          "name": "authorId",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ydoc_state": {
+          "name": "ydoc_state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_modified_by": {
+          "name": "last_modified_by",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_modified_at": {
+          "name": "last_modified_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "NOW()"
+        },
+        "updatedAt": {
+          "name": "updatedAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "NOW()"
+        },
+        "deletedAt": {
+          "name": "deletedAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "content_search_idx": {
+          "name": "content_search_idx",
+          "columns": [
+            {
+              "expression": "content",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "title_search_idx": {
+          "name": "title_search_idx",
+          "columns": [
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "search_index_idx": {
+          "name": "search_index_idx",
+          "columns": [
+            {
+              "expression": "search_index",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "deleted_at_idx": {
+          "name": "deleted_at_idx",
+          "columns": [
+            {
+              "expression": "deletedAt",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "parent_id_idx": {
+          "name": "parent_id_idx",
+          "columns": [
+            {
+              "expression": "parentId",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "order_idx": {
+          "name": "order_idx",
+          "columns": [
+            {
+              "expression": "order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "documents_parentId_documents_id_fk": {
+          "name": "documents_parentId_documents_id_fk",
+          "tableFrom": "documents",
+          "tableTo": "documents",
+          "schemaTo": "docs",
+          "columnsFrom": [
+            "parentId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "documents_slug_unique": {
+          "name": "documents_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      }
+    },
+    "docs.files": {
+      "name": "files",
+      "schema": "docs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(21)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "filename": {
+          "name": "filename",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mimeType": {
+          "name": "mimeType",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "NOW()"
+        },
+        "deletedAt": {
+          "name": "deletedAt",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "filename_idx": {
+          "name": "filename_idx",
+          "columns": [
+            {
+              "expression": "filename",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "mime_type_idx": {
+          "name": "mime_type_idx",
+          "columns": [
+            {
+              "expression": "mimeType",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "files_deleted_at_idx": {
+          "name": "files_deleted_at_idx",
+          "columns": [
+            {
+              "expression": "deletedAt",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    }
+  },
+  "enums": {},
+  "schemas": {
+    "docs": "docs"
+  },
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle/migrations/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1770028583768,
       "tag": "0000_gray_monster_badoon",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1770609760944,
+      "tag": "0001_omniscient_fallen_one",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-embed-docs",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Full-stack documentation system with BlockNote editor, hierarchical structure, and file uploads",
   "type": "module",
   "main": "./dist/server/index.js",