@moxn/kb-migrate 0.4.7 → 0.4.9

package/dist/client.d.ts

@@ -80,6 +80,61 @@ export declare class MoxnClient {
      * Assign a tag to a document.
      */
     assignTag(documentId: string, tagId: string, branchId: string): Promise<void>;
+    /**
+     * List all KB databases for the tenant.
+     */
+    listDatabases(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string | null;
+    }>>;
+    /**
+     * Get fully resolved database with columns, options, and document property values.
+     */
+    resolveDatabase(databaseId: string): Promise<{
+        databaseId: string;
+        databaseName: string;
+        columns: Array<{
+            id: string;
+            name: string;
+            type: 'select' | 'multi_select';
+            position: number;
+            newOptionParentPath: string | null;
+            options: Array<{
+                tagId: string;
+                tagName: string;
+                tagPath: string;
+                tagColor: string | null;
+            }>;
+        }>;
+        documents: Array<{
+            documentId: string;
+            documentName: string | null;
+            documentPath: string | null;
+            properties: Record<string, {
+                columnId: string;
+                columnName: string;
+                columnType: 'select' | 'multi_select';
+                values: Array<{
+                    tagId: string;
+                    tagName: string;
+                    tagPath: string;
+                    tagColor: string | null;
+                }>;
+            }>;
+        }>;
+    }>;
+    /**
+     * Get Notion database mapping for a KB database.
+     */
+    getNotionDatabaseMapping(kbDatabaseId: string): Promise<{
+        mapping: {
+            id: string;
+            kbDatabaseId: string;
+            notionDatabaseId: string;
+            notionDatabaseTitle: string | null;
+        } | null;
+    }>;
     /**
      * Create or upsert a Notion database mapping.
      */

package/dist/client.js

@@ -401,6 +401,44 @@ export class MoxnClient {
             throw new Error(body.error || `Failed to assign tag: ${response.status}`);
         }
     }
+    /**
+     * List all KB databases for the tenant.
+     */
+    async listDatabases() {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/databases`, {
+            headers: { 'x-api-key': this.apiKey },
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to list databases: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.databases;
+    }
+    /**
+     * Get fully resolved database with columns, options, and document property values.
+     */
+    async resolveDatabase(databaseId) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/databases/${databaseId}/resolve`, {
+            headers: { 'x-api-key': this.apiKey },
+        });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to resolve database: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get Notion database mapping for a KB database.
+     */
+    async getNotionDatabaseMapping(kbDatabaseId) {
+        const response = await fetch(`${this.apiUrl}/api/v1/kb/notion-mappings/databases/by-kb-database/${kbDatabaseId}`, { headers: { 'x-api-key': this.apiKey } });
+        if (!response.ok) {
+            const body = await response.json().catch(() => ({}));
+            throw new Error(body.error || `Failed to get database mapping: ${response.status}`);
+        }
+        return response.json();
+    }
     /**
      * Create or upsert a Notion database mapping.
      */

package/dist/export-notion.js

@@ -7,9 +7,11 @@
  * Pass 1: Create/update all Notion pages (content without cross-references)
  * Pass 2: Resolve KB path references to Notion page IDs and append link blocks
  */
+import { Client } from '@notionhq/client';
 import { MoxnClient } from './client.js';
 import { matchesDateFilter } from './date-filter.js';
 import { NotionExportTarget } from './targets/notion.js';
+import { exportDatabase } from './targets/notion-database-export.js';
 export async function runNotionExport(options) {
     const startTime = Date.now();
     // Create Moxn client for reading docs
@@ -107,6 +109,58 @@ export async function runNotionExport(options) {
         }
     }
     // ============================================
+    // Pass 1.5: Export databases
+    // ============================================
+    if (!options.dryRun) {
+        // Collect unique database IDs from exported documents
+        const databaseIdsToExport = new Set();
+        for (const { detail: doc } of docDetails) {
+            for (const section of doc.sections) {
+                for (const block of section.content) {
+                    if (block.blockType === 'database_embed' && block.databaseId) {
+                        databaseIdsToExport.add(block.databaseId);
+                    }
+                }
+            }
+        }
+        if (databaseIdsToExport.size > 0) {
+            console.log(`\nPass 1.5: Exporting ${databaseIdsToExport.size} databases to Notion...`);
+            const dbCtx = {
+                notionClient: new Client({ auth: options.notionToken }),
+                moxnClient: client,
+                conflictStrategy: options.conflictStrategy,
+                dryRun: options.dryRun,
+            };
+            let dbCreated = 0, dbUpdated = 0, dbSkipped = 0, dbFailed = 0;
+            for (const dbId of databaseIdsToExport) {
+                try {
+                    // Use the parent page ID as the target for database creation
+                    const parentPageId = options.parentPageId;
+                    const result = await exportDatabase(dbCtx, dbId, parentPageId);
+                    const icon = { created: '\u2713', updated: '\u21bb', skipped: '-', failed: '\u2717' }[result.status];
+                    console.log(`  ${icon} ${result.status}: ${result.kbDatabaseName} (${result.entriesCreated} entries)`);
+                    if (result.error)
+                        console.log(`    Error: ${result.error}`);
+                    if (result.status === 'created')
+                        dbCreated++;
+                    else if (result.status === 'updated')
+                        dbUpdated++;
+                    else if (result.status === 'skipped')
+                        dbSkipped++;
+                    else if (result.status === 'failed')
+                        dbFailed++;
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    console.log(`  \u2717 failed: database ${dbId}`);
+                    console.log(`    Error: ${msg}`);
+                    dbFailed++;
+                }
+            }
+            console.log(`\nDatabases: ${dbCreated} created, ${dbUpdated} updated, ${dbSkipped} skipped, ${dbFailed} failed`);
+        }
+    }
+    // ============================================
     // Pass 2: Resolve cross-references
     // ============================================
     if (!options.dryRun) {

package/dist/targets/index.d.ts

@@ -3,3 +3,4 @@
  */
 export { ExportTarget, type ExportTargetConfig, type ExportTargetResult, type ExportTargetLog } from './base.js';
 export { NotionExportTarget, type NotionExportConfig } from './notion.js';
+export { exportDatabase, type DatabaseExportResult, type DatabaseExportContext } from './notion-database-export.js';

package/dist/targets/index.js

@@ -3,3 +3,4 @@
  */
 export { ExportTarget } from './base.js';
 export { NotionExportTarget } from './notion.js';
+export { exportDatabase } from './notion-database-export.js';

package/dist/targets/notion-database-export.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Notion Database Export
+ *
+ * Exports KB databases to Notion databases.
+ * Handles:
+ * - Creating new Notion databases from KB database schemas
+ * - Updating existing Notion databases (clear + recreate entries)
+ * - Column mapping (select/multi_select backed by tags -> Notion select/multi_select)
+ * - Color mapping (hex -> Notion color names)
+ * - Entry creation with correct property values
+ */
+import { Client } from '@notionhq/client';
+import type { MoxnClient } from '../client.js';
+export interface DatabaseExportResult {
+    kbDatabaseId: string;
+    kbDatabaseName: string;
+    notionDatabaseId: string;
+    status: 'created' | 'updated' | 'skipped' | 'failed';
+    entriesCreated: number;
+    error?: string;
+}
+export interface DatabaseExportContext {
+    notionClient: Client;
+    moxnClient: MoxnClient;
+    conflictStrategy: 'skip' | 'update';
+    dryRun: boolean;
+}
+/**
+ * Export a single KB database to Notion.
+ *
+ * @param ctx Export context with Notion client, Moxn client, and options
+ * @param kbDatabaseId KB database ID to export
+ * @param parentNotionPageId Notion page ID to create the database under
+ * @returns Export result
+ */
+export declare function exportDatabase(ctx: DatabaseExportContext, kbDatabaseId: string, parentNotionPageId: string): Promise<DatabaseExportResult>;

package/dist/targets/notion-database-export.js

@@ -0,0 +1,251 @@
+/**
+ * Notion Database Export
+ *
+ * Exports KB databases to Notion databases.
+ * Handles:
+ * - Creating new Notion databases from KB database schemas
+ * - Updating existing Notion databases (clear + recreate entries)
+ * - Column mapping (select/multi_select backed by tags -> Notion select/multi_select)
+ * - Color mapping (hex -> Notion color names)
+ * - Entry creation with correct property values
+ */
+const RATE_LIMIT_MS = 350;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Reverse mapping: hex color -> Notion color name
+const HEX_TO_NOTION_COLOR = {
+    '#6B7280': 'gray',
+    '#92400E': 'brown',
+    '#F97316': 'orange',
+    '#EAB308': 'yellow',
+    '#22C55E': 'green',
+    '#3B82F6': 'blue',
+    '#8B5CF6': 'purple',
+    '#EC4899': 'pink',
+    '#EF4444': 'red',
+};
+function hexToNotionColor(hex) {
+    if (!hex)
+        return 'default';
+    return HEX_TO_NOTION_COLOR[hex.toUpperCase()] ?? HEX_TO_NOTION_COLOR[hex] ?? 'default';
+}
+/**
+ * Export a single KB database to Notion.
+ *
+ * @param ctx Export context with Notion client, Moxn client, and options
+ * @param kbDatabaseId KB database ID to export
+ * @param parentNotionPageId Notion page ID to create the database under
+ * @returns Export result
+ */
+export async function exportDatabase(ctx, kbDatabaseId, parentNotionPageId) {
+    try {
+        // 1. Fetch resolved database from KB API
+        const resolved = await ctx.moxnClient.resolveDatabase(kbDatabaseId);
+        // 2. Check for existing Notion database mapping
+        let existingMapping = null;
+        try {
+            const mappingResult = await ctx.moxnClient.getNotionDatabaseMapping(kbDatabaseId);
+            existingMapping = mappingResult.mapping;
+        }
+        catch {
+            // No mapping found -- that's fine
+        }
+        // 3. Handle conflict strategy
+        if (existingMapping) {
+            if (ctx.conflictStrategy === 'skip') {
+                return {
+                    kbDatabaseId,
+                    kbDatabaseName: resolved.databaseName,
+                    notionDatabaseId: existingMapping.notionDatabaseId,
+                    status: 'skipped',
+                    entriesCreated: 0,
+                };
+            }
+            if (ctx.dryRun) {
+                return {
+                    kbDatabaseId,
+                    kbDatabaseName: resolved.databaseName,
+                    notionDatabaseId: existingMapping.notionDatabaseId,
+                    status: 'updated',
+                    entriesCreated: resolved.documents.length,
+                };
+            }
+            // Update existing: archive all pages, then recreate entries
+            const entriesCreated = await updateExistingNotionDatabase(ctx, existingMapping.notionDatabaseId, resolved);
+            return {
+                kbDatabaseId,
+                kbDatabaseName: resolved.databaseName,
+                notionDatabaseId: existingMapping.notionDatabaseId,
+                status: 'updated',
+                entriesCreated,
+            };
+        }
+        // 4. No existing mapping -- create new Notion database
+        if (ctx.dryRun) {
+            return {
+                kbDatabaseId,
+                kbDatabaseName: resolved.databaseName,
+                notionDatabaseId: 'dry-run',
+                status: 'created',
+                entriesCreated: resolved.documents.length,
+            };
+        }
+        const { notionDatabaseId, dataSourceId } = await createNotionDatabase(ctx, parentNotionPageId, resolved);
+        // 5. Create entries
+        const entriesCreated = await createDatabaseEntries(ctx, dataSourceId, resolved);
+        // 6. Upsert mapping
+        await ctx.moxnClient.createNotionDatabaseMapping({
+            kbDatabaseId,
+            notionDatabaseId: notionDatabaseId.replace(/-/g, ''),
+            notionDatabaseTitle: resolved.databaseName,
+        });
+        return {
+            kbDatabaseId,
+            kbDatabaseName: resolved.databaseName,
+            notionDatabaseId: notionDatabaseId.replace(/-/g, ''),
+            status: 'created',
+            entriesCreated,
+        };
+    }
+    catch (error) {
+        return {
+            kbDatabaseId,
+            kbDatabaseName: 'Unknown',
+            notionDatabaseId: '',
+            status: 'failed',
+            entriesCreated: 0,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Create a new Notion database with the correct schema.
+ */
+async function createNotionDatabase(ctx, parentPageId, resolved) {
+    // Build properties from KB columns
+    const properties = {};
+    for (const col of resolved.columns) {
+        const options = col.options.map((opt) => ({
+            name: opt.tagName,
+            color: hexToNotionColor(opt.tagColor),
+        }));
+        if (col.type === 'select') {
+            properties[col.name] = {
+                type: 'select',
+                select: { options },
+            };
+        }
+        else if (col.type === 'multi_select') {
+            properties[col.name] = {
+                type: 'multi_select',
+                multi_select: { options },
+            };
+        }
+    }
+    await sleep(RATE_LIMIT_MS);
+    // Use client.request() for v5 API compatibility
+    // Properties go under initial_data_source.properties (not top-level)
+    const response = (await ctx.notionClient.request({
+        method: 'post',
+        path: 'databases',
+        body: {
+            parent: { type: 'page_id', page_id: parentPageId },
+            title: [{ type: 'text', text: { content: resolved.databaseName } }],
+            initial_data_source: { properties },
+        },
+    }));
+    const notionDatabaseId = response.id;
+    const dataSourceId = response.data_sources?.[0]?.id ?? notionDatabaseId;
+    return { notionDatabaseId, dataSourceId };
+}
+/**
+ * Update an existing Notion database by archiving all pages and recreating entries.
+ */
+async function updateExistingNotionDatabase(ctx, notionDatabaseId, resolved) {
+    // Archive existing pages (Notion v5: query database, archive each page)
+    await sleep(RATE_LIMIT_MS);
+    let hasMore = true;
+    let startCursor;
+    while (hasMore) {
+        const queryResult = await ctx.notionClient.databases.query({
+            database_id: notionDatabaseId,
+            start_cursor: startCursor,
+            page_size: 100,
+        });
+        for (const page of queryResult.results) {
+            await sleep(RATE_LIMIT_MS);
+            try {
+                await ctx.notionClient.pages.update({
+                    page_id: page.id,
+                    archived: true,
+                });
+            }
+            catch {
+                // Continue if individual archive fails
+            }
+        }
+        hasMore = queryResult.has_more;
+        startCursor = queryResult.next_cursor ?? undefined;
+    }
+    // Now get the data_source_id for entry creation
+    // Query the database to get its data_sources
+    await sleep(RATE_LIMIT_MS);
+    const dbInfo = (await ctx.notionClient.request({
+        method: 'get',
+        path: `databases/${notionDatabaseId}`,
+    }));
+    const dataSourceId = dbInfo.data_sources?.[0]?.id ?? notionDatabaseId;
+    // Create new entries
+    return createDatabaseEntries(ctx, dataSourceId, resolved);
+}
+/**
+ * Create database entries as Notion pages.
+ */
+async function createDatabaseEntries(ctx, dataSourceId, resolved) {
+    let created = 0;
+    for (const doc of resolved.documents) {
+        try {
+            // Build property values for this entry
+            const properties = {
+                // Title property (always "Name" for databases)
+                Name: {
+                    type: 'title',
+                    title: [{ type: 'text', text: { content: doc.documentName ?? 'Untitled' } }],
+                },
+            };
+            // Add column values
+            for (const [colName, propValue] of Object.entries(doc.properties)) {
+                if (propValue.values.length === 0)
+                    continue;
+                if (propValue.columnType === 'select') {
+                    properties[colName] = {
+                        type: 'select',
+                        select: { name: propValue.values[0].tagName },
+                    };
+                }
+                else if (propValue.columnType === 'multi_select') {
+                    properties[colName] = {
+                        type: 'multi_select',
+                        multi_select: propValue.values.map((v) => ({ name: v.tagName })),
+                    };
+                }
+            }
+            await sleep(RATE_LIMIT_MS);
+            // Create entry as page with data_source_id parent
+            await ctx.notionClient.request({
+                method: 'post',
+                path: 'pages',
+                body: {
+                    parent: { type: 'data_source_id', data_source_id: dataSourceId },
+                    properties,
+                },
+            });
+            created++;
+        }
+        catch (error) {
+            console.error(`  Warning: Failed to create entry "${doc.documentName}": ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    return created;
+}

package/dist/targets/notion.js

@@ -46,6 +46,22 @@ function extractKBPathReferences(text) {
     });
     return { cleanedText, references };
 }
+/**
+ * Strip invalid internal links from markdown text.
+ * Notion rejects links that aren't valid URLs (e.g., relative KB paths
+ * like "some/relative/path"). Convert them to plain text.
+ */
+function stripInvalidLinks(text) {
+    // Match markdown links [text](url) where url is NOT a valid URL
+    return text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, displayText, url) => {
+        // Keep links that look like valid URLs (http/https/mailto/tel)
+        if (/^(https?:\/\/|mailto:|tel:|#)/.test(url)) {
+            return match;
+        }
+        // Strip relative/internal paths — just keep the display text
+        return displayText;
+    });
+}
 /**
  * Convert a KB document's sections into a single markdown string.
  * Section names become H2 headings (mirrors the import convention).
@@ -56,6 +72,7 @@ function extractKBPathReferences(text) {
 function sectionsToMarkdown(sections, options) {
     const parts = [];
     const allReferences = [];
+    const databaseIds = [];
     const extractRefs = options?.extractReferences ?? false;
     for (const section of sections) {
         parts.push(`## ${section.name}\n`);
@@ -67,6 +84,9 @@ function sectionsToMarkdown(sections, options) {
                     text = cleanedText;
                     allReferences.push(...references);
                 }
+                // Strip relative/internal links that aren't valid URLs
+                // (Notion rejects links without a protocol)
+                text = stripInvalidLinks(text);
                 parts.push(text);
                 parts.push('');
             }
@@ -82,9 +102,16 @@ function sectionsToMarkdown(sections, options) {
                 parts.push(`[${block.filename || 'data.csv'}](${block.url})`);
                 parts.push('');
             }
+            else if (block.blockType === 'database_embed' && block.databaseId) {
+                // Collect database ID for Pass 1.5 export
+                databaseIds.push(block.databaseId);
+                // Add a placeholder in the markdown
+                parts.push(`> **[Database]** *(exported as inline database)*`);
+                parts.push('');
+            }
         }
     }
-    return { markdown: parts.join('\n').trim(), references: allReferences };
+    return { markdown: parts.join('\n').trim(), references: allReferences, databaseIds };
 }
 // Max 100 blocks per API call
 const MAX_BLOCKS_PER_APPEND = 100;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxn/kb-migrate",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Migration tool for importing documents into Moxn Knowledge Base from local files, Notion, Google Docs, and more",
   "type": "module",
   "main": "dist/index.js",