react-embed-docs 0.1.0

package/dist/server/schema.js

@@ -0,0 +1,126 @@
+import { relations, sql } from 'drizzle-orm';
+import { boolean, foreignKey, index, integer, jsonb, pgSchema, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+/**
+ * Documents schema
+ * Uses 'docs' PostgreSQL schema for document storage
+ */
+export const docsTableSchema = pgSchema('docs');
+/**
+ * Documents table
+ * Stores documentation pages with BlockNote content
+ */
+export const documentsTable = docsTableSchema.table('documents', {
+    id: varchar('id', { length: 21 }).primaryKey(), // nanoid length is 21
+    title: varchar('title', { length: 255 }).notNull(),
+    slug: varchar('slug', { length: 255 }).unique().notNull(),
+    content: jsonb('content').notNull().default('[]').$type(), // BlockNote JSON content
+    searchIndex: text('search_index'), // Concatenated text from title + content for full-text search
+    emoji: varchar('emoji', { length: 10 }), // Emoji/icon for the document (nullable)
+    cover: varchar('cover', { length: 500 }), // Cover image URL (nullable)
+    isPublished: boolean('isPublished').default(true).notNull(),
+    parentId: varchar('parentId', { length: 21 }),
+    order: integer('order').default(0).notNull(), // For sorting documents within a parent
+    authorId: integer('authorId'), // Optional author reference (not tied to system users)
+    // Collaboration fields
+    ydocState: text('ydoc_state'), // Base64 encoded Yjs state vector
+    lastModifiedBy: varchar('last_modified_by', { length: 255 }),
+    lastModifiedAt: timestamp('last_modified_at'),
+    createdAt: timestamp('createdAt')
+        .default(sql `NOW()`)
+        .notNull(),
+    updatedAt: timestamp('updatedAt')
+        .default(sql `NOW()`)
+        .notNull(),
+    deletedAt: timestamp('deletedAt'), // Soft delete
+}, (table) => ({
+    // Self-referential foreign key for parent-child relationships
+    parentFk: foreignKey({
+        columns: [table.parentId],
+        foreignColumns: [table.id],
+    }),
+    // GIN index for JSONB content search
+    contentSearchIdx: index('content_search_idx').using('gin', table.content),
+    // Index for title search
+    titleSearchIdx: index('title_search_idx').on(table.title),
+    // Index for full-text search using searchIndex column
+    searchIndexIdx: index('search_index_idx').on(table.searchIndex),
+    // Index for soft delete queries
+    deletedAtIdx: index('deleted_at_idx').on(table.deletedAt),
+    // Index for parent queries
+    parentIdIdx: index('parent_id_idx').on(table.parentId),
+    // Index for ordering
+    orderIdx: index('order_idx').on(table.order),
+}));
+/**
+ * Document relations
+ * Supports hierarchical document structure
+ */
+export const documentRelations = relations(documentsTable, ({ one, many }) => ({
+    parent: one(documentsTable, {
+        fields: [documentsTable.parentId],
+        references: [documentsTable.id],
+    }),
+    children: many(documentsTable),
+}));
+/**
+ * Files table
+ * Stores uploaded files directly in database as base64
+ */
+export const filesTable = docsTableSchema.table('files', {
+    id: varchar('id', { length: 21 }).primaryKey(), // nanoid
+    filename: varchar('filename', { length: 255 }).notNull(),
+    mimeType: varchar('mimeType', { length: 100 }).notNull(),
+    size: integer('size').notNull(), // file size in bytes
+    content: text('content').notNull(), // base64 encoded file content
+    createdAt: timestamp('createdAt')
+        .default(sql `NOW()`)
+        .notNull(),
+}, (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),
+}));
+/**
+ * Document versions table
+ * Stores version history for documents
+ */
+export const documentVersionsTable = docsTableSchema.table('document_versions', {
+    id: uuid('id').defaultRandom().primaryKey(),
+    documentId: varchar('document_id', { length: 21 }).notNull().references(() => documentsTable.id),
+    // Version info
+    versionNumber: integer('version_number').notNull(),
+    changeDescription: text('change_description'),
+    // Snapshot
+    title: varchar('title', { length: 255 }).notNull(),
+    content: jsonb('content').notNull().$type(),
+    emoji: varchar('emoji', { length: 10 }),
+    cover: varchar('cover', { length: 500 }),
+    ydocState: text('ydoc_state'), // Base64 encoded Yjs state for collab restore
+    // Metadata
+    createdBy: varchar('created_by', { length: 255 }),
+    createdByName: varchar('created_by_name', { length: 255 }),
+    createdAt: timestamp('created_at').default(sql `NOW()`).notNull(),
+}, (table) => ({
+    // Index for document versions
+    documentVersionIdx: index('document_version_idx').on(table.documentId, table.versionNumber),
+    createdAtIdx: index('version_created_at_idx').on(table.createdAt),
+}));
+/**
+ * Document presence table
+ * Tracks active users editing documents (for real-time collaboration)
+ */
+export const documentPresenceTable = docsTableSchema.table('document_presence', {
+    id: uuid('id').defaultRandom().primaryKey(),
+    documentId: varchar('document_id', { length: 21 }).notNull().references(() => documentsTable.id),
+    userId: varchar('user_id', { length: 255 }).notNull(),
+    userName: varchar('user_name', { length: 255 }),
+    userColor: varchar('user_color', { length: 7 }), // #RRGGBB
+    cursorPosition: jsonb('cursor_position'), // { blockId, index }
+    selection: jsonb('selection'), // { anchor, head }
+    lastSeenAt: timestamp('last_seen_at').default(sql `NOW()`).notNull(),
+}, (table) => ({
+    // Index for presence lookups
+    presenceIdx: index('presence_idx').on(table.documentId, table.userId),
+    lastSeenIdx: index('last_seen_idx').on(table.lastSeenAt),
+}));

package/dist/shared/types.d.ts

@@ -0,0 +1,314 @@
+import { z } from 'zod';
+/**
+ * BlockNote content types
+ * BlockNote editor outputs an array of blocks with nested content
+ */
+export interface BlockNoteContentItem {
+    type: string;
+    text?: string;
+}
+export interface BlockNoteBlock {
+    type: string;
+    content?: BlockNoteContentItem[] | BlockNoteContentItem[][];
+}
+export type BlockNoteContent = BlockNoteBlock[];
+/**
+ * Document interfaces
+ */
+export interface Document {
+    id: string;
+    title: string;
+    slug: string;
+    content: BlockNoteContent;
+    searchIndex?: string | null;
+    emoji?: string | null;
+    cover?: string | null;
+    isPublished: boolean;
+    parentId?: string | null;
+    order: number;
+    authorId?: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt?: Date | null;
+}
+/**
+ * Document without content - used for list/tree views
+ * to reduce payload size
+ */
+export type DocumentSummary = Omit<Document, 'content' | 'searchIndex'>;
+export type DocumentMode = 'view' | 'edit' | 'create';
+export interface FlattenedItem extends DocumentSummary {
+    depth: number;
+    hasChildren: boolean;
+}
+/**
+ * Search result types
+ */
+export interface SearchResult {
+    document: Document;
+    rank: number;
+    highlights: string[];
+}
+export interface SearchTextResult {
+    document: Document;
+    rank: number;
+}
+/**
+ * File upload types
+ */
+export interface FileUpload {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    content: string;
+    createdAt: Date;
+}
+export interface InsertFileUpload {
+    filename: string;
+    mimeType: string;
+    size: number;
+    content: string;
+}
+/**
+ * List documents filters and options
+ */
+export interface ListDocumentsFilters {
+    search?: string;
+    parentId?: string | null;
+    isPublished?: boolean;
+}
+export interface ListDocumentsOptions {
+    offset?: number;
+    limit?: number;
+    sortBy?: keyof Document;
+    sortDir?: 'asc' | 'desc';
+}
+export interface ListDocumentsResult {
+    documents: DocumentSummary[];
+    total: number;
+}
+/**
+ * Zod schemas for validation
+ */
+export declare const documentSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    slug: z.ZodString;
+    content: z.ZodAny;
+    searchIndex: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    emoji: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cover: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPublished: z.ZodBoolean;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    order: z.ZodNumber;
+    authorId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    deletedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    id: string;
+    order: number;
+    title: string;
+    isPublished: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    content?: any;
+    searchIndex?: string | null | undefined;
+    emoji?: string | null | undefined;
+    cover?: string | null | undefined;
+    parentId?: string | null | undefined;
+    authorId?: number | null | undefined;
+    deletedAt?: Date | null | undefined;
+}, {
+    slug: string;
+    id: string;
+    order: number;
+    title: string;
+    isPublished: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    content?: any;
+    searchIndex?: string | null | undefined;
+    emoji?: string | null | undefined;
+    cover?: string | null | undefined;
+    parentId?: string | null | undefined;
+    authorId?: number | null | undefined;
+    deletedAt?: Date | null | undefined;
+}>;
+export declare const createDocumentSchema: z.ZodObject<{
+    title: z.ZodString;
+    slug: z.ZodString;
+    content: z.ZodDefault<z.ZodOptional<z.ZodAny>>;
+    emoji: z.ZodOptional<z.ZodString>;
+    cover: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    isPublished: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    parentSlugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    authorId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    title: string;
+    isPublished: boolean;
+    content?: any;
+    emoji?: string | undefined;
+    cover?: string | null | undefined;
+    authorId?: number | undefined;
+    parentSlugs?: string[] | undefined;
+}, {
+    slug: string;
+    title: string;
+    content?: any;
+    emoji?: string | undefined;
+    cover?: string | null | undefined;
+    isPublished?: boolean | undefined;
+    authorId?: number | undefined;
+    parentSlugs?: string[] | undefined;
+}>;
+export type CreateDocument = z.infer<typeof createDocumentSchema>;
+export declare const updateDocumentSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodAny>>>;
+    emoji: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    cover: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    isPublished: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+    parentSlugs: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    authorId: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    slug?: string | undefined;
+    title?: string | undefined;
+    content?: any;
+    emoji?: string | undefined;
+    cover?: string | null | undefined;
+    isPublished?: boolean | undefined;
+    authorId?: number | undefined;
+    parentSlugs?: string[] | undefined;
+}, {
+    slug?: string | undefined;
+    title?: string | undefined;
+    content?: any;
+    emoji?: string | undefined;
+    cover?: string | null | undefined;
+    isPublished?: boolean | undefined;
+    authorId?: number | undefined;
+    parentSlugs?: string[] | undefined;
+}>;
+export type UpdateDocument = z.infer<typeof updateDocumentSchema>;
+export declare const documentListSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<Omit<{
+        id: z.ZodString;
+        title: z.ZodString;
+        slug: z.ZodString;
+        content: z.ZodAny;
+        searchIndex: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        emoji: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        cover: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isPublished: z.ZodBoolean;
+        parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        order: z.ZodNumber;
+        authorId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        deletedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    }, "content">, "strip", z.ZodTypeAny, {
+        slug: string;
+        id: string;
+        order: number;
+        title: string;
+        isPublished: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        searchIndex?: string | null | undefined;
+        emoji?: string | null | undefined;
+        cover?: string | null | undefined;
+        parentId?: string | null | undefined;
+        authorId?: number | null | undefined;
+        deletedAt?: Date | null | undefined;
+    }, {
+        slug: string;
+        id: string;
+        order: number;
+        title: string;
+        isPublished: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        searchIndex?: string | null | undefined;
+        emoji?: string | null | undefined;
+        cover?: string | null | undefined;
+        parentId?: string | null | undefined;
+        authorId?: number | null | undefined;
+        deletedAt?: Date | null | undefined;
+    }>, "many">;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        slug: string;
+        id: string;
+        order: number;
+        title: string;
+        isPublished: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        searchIndex?: string | null | undefined;
+        emoji?: string | null | undefined;
+        cover?: string | null | undefined;
+        parentId?: string | null | undefined;
+        authorId?: number | null | undefined;
+        deletedAt?: Date | null | undefined;
+    }[];
+    total: number;
+}, {
+    items: {
+        slug: string;
+        id: string;
+        order: number;
+        title: string;
+        isPublished: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        searchIndex?: string | null | undefined;
+        emoji?: string | null | undefined;
+        cover?: string | null | undefined;
+        parentId?: string | null | undefined;
+        authorId?: number | null | undefined;
+        deletedAt?: Date | null | undefined;
+    }[];
+    total: number;
+}>;
+export declare const fileSchema: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    mimeType: z.ZodString;
+    size: z.ZodNumber;
+    content: z.ZodString;
+    createdAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    size: number;
+    content: string;
+    createdAt: Date;
+    filename: string;
+    mimeType: string;
+}, {
+    id: string;
+    size: number;
+    content: string;
+    createdAt: Date;
+    filename: string;
+    mimeType: string;
+}>;
+export declare const uploadFileSchema: z.ZodObject<{
+    filename: z.ZodString;
+    mimeType: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    filename: string;
+    mimeType: string;
+}, {
+    content: string;
+    filename: string;
+    mimeType: string;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,oBAAoB,EAAE,GAAG,oBAAoB,EAAE,EAAE,CAAA;CAC5D;AAED,MAAM,MAAM,gBAAgB,GAAG,cAAc,EAAE,CAAA;AAE/C;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,gBAAgB,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,CAAA;CACxB;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,aAAa,CAAC,CAAA;AAEvE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAA;AAGrD,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAA;IACvB,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,eAAe,EAAE,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAezB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAA"}

package/dist/shared/types.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for validation
+ */
+export const documentSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    slug: z.string(),
+    content: z.any().describe('BlockNote JSON content'),
+    searchIndex: z.string().nullable().optional(),
+    emoji: z.string().nullable().optional(),
+    cover: z.string().nullable().optional(),
+    isPublished: z.boolean(),
+    parentId: z.string().nullable().optional(),
+    order: z.number(),
+    authorId: z.number().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    deletedAt: z.date().nullable().optional(),
+});
+export const createDocumentSchema = z.object({
+    title: z.string().min(1).max(255),
+    slug: z.string().min(1).max(255),
+    content: z.any().optional().default([]).describe('BlockNote JSON content'),
+    emoji: z.string().max(10).optional(),
+    cover: z.string().max(500).optional().nullable(),
+    isPublished: z.boolean().optional().default(true),
+    parentSlugs: z.array(z.string()).optional(),
+    authorId: z.number().optional(),
+});
+export const updateDocumentSchema = createDocumentSchema.partial();
+export const documentListSchema = z.object({
+    items: z.array(documentSchema.omit({ content: true })),
+    total: z.number(),
+});
+export const fileSchema = z.object({
+    id: z.string(),
+    filename: z.string(),
+    mimeType: z.string(),
+    size: z.number(),
+    content: z.string(),
+    createdAt: z.date(),
+});
+export const uploadFileSchema = z.object({
+    filename: z.string().min(1).max(255),
+    mimeType: z.string().min(1).max(100),
+    content: z.string().min(1).describe('Base64 encoded file content'),
+});

package/drizzle/migrations/0000_gray_monster_badoon.sql

@@ -0,0 +1,88 @@
+CREATE SCHEMA IF NOT EXISTS "docs";
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "docs"."document_presence" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"document_id" varchar(21) NOT NULL,
+	"user_id" varchar(255) NOT NULL,
+	"user_name" varchar(255),
+	"user_color" varchar(7),
+	"cursor_position" jsonb,
+	"selection" jsonb,
+	"last_seen_at" timestamp DEFAULT NOW() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "docs"."document_versions" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"document_id" varchar(21) NOT NULL,
+	"version_number" integer NOT NULL,
+	"change_description" text,
+	"title" varchar(255) NOT NULL,
+	"content" jsonb NOT NULL,
+	"emoji" varchar(10),
+	"cover" varchar(500),
+	"ydoc_state" text,
+	"created_by" varchar(255),
+	"created_by_name" varchar(255),
+	"created_at" timestamp DEFAULT NOW() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "docs"."documents" (
+	"id" varchar(21) PRIMARY KEY NOT NULL,
+	"title" varchar(255) NOT NULL,
+	"slug" varchar(255) NOT NULL,
+	"content" jsonb DEFAULT '[]' NOT NULL,
+	"search_index" text,
+	"emoji" varchar(10),
+	"cover" varchar(500),
+	"isPublished" boolean DEFAULT true NOT NULL,
+	"parentId" varchar(21),
+	"order" integer DEFAULT 0 NOT NULL,
+	"authorId" integer,
+	"ydoc_state" text,
+	"last_modified_by" varchar(255),
+	"last_modified_at" timestamp,
+	"createdAt" timestamp DEFAULT NOW() NOT NULL,
+	"updatedAt" timestamp DEFAULT NOW() NOT NULL,
+	"deletedAt" timestamp,
+	CONSTRAINT "documents_slug_unique" UNIQUE("slug")
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "docs"."files" (
+	"id" varchar(21) PRIMARY KEY NOT NULL,
+	"filename" varchar(255) NOT NULL,
+	"mimeType" varchar(100) NOT NULL,
+	"size" integer NOT NULL,
+	"content" text NOT NULL,
+	"createdAt" timestamp DEFAULT NOW() NOT NULL
+);
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "docs"."document_presence" ADD CONSTRAINT "document_presence_document_id_documents_id_fk" FOREIGN KEY ("document_id") REFERENCES "docs"."documents"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "docs"."document_versions" ADD CONSTRAINT "document_versions_document_id_documents_id_fk" FOREIGN KEY ("document_id") REFERENCES "docs"."documents"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "docs"."documents" ADD CONSTRAINT "documents_parentId_documents_id_fk" FOREIGN KEY ("parentId") REFERENCES "docs"."documents"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "presence_idx" ON "docs"."document_presence" USING btree ("document_id","user_id");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "last_seen_idx" ON "docs"."document_presence" USING btree ("last_seen_at");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "document_version_idx" ON "docs"."document_versions" USING btree ("document_id","version_number");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "version_created_at_idx" ON "docs"."document_versions" USING btree ("created_at");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "content_search_idx" ON "docs"."documents" USING gin ("content");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "title_search_idx" ON "docs"."documents" USING btree ("title");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "search_index_idx" ON "docs"."documents" USING btree ("search_index");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "deleted_at_idx" ON "docs"."documents" USING btree ("deletedAt");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "parent_id_idx" ON "docs"."documents" USING btree ("parentId");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "order_idx" ON "docs"."documents" USING btree ("order");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "filename_idx" ON "docs"."files" USING btree ("filename");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "mime_type_idx" ON "docs"."files" USING btree ("mimeType");