@moxn/kb-migrate 0.4.26 → 0.4.28

package/dist/index.js

@@ -487,6 +487,13 @@ program
                     console.error(`  Error pre-creating database "${dbImport.schema.name}": ${error instanceof Error ? error.message : error}`);
                 }
             }
+            // Also add any other existing mappings (e.g. linked DB → source mappings
+            // from prior imports) so they're available during extraction
+            for (const [notionId, kbId] of existingMappings) {
+                if (!databaseIdMap.has(notionId)) {
+                    databaseIdMap.set(notionId, kbId);
+                }
+            }
             // Make the map available during extraction
             source.setDatabaseIdMap(databaseIdMap);
             console.log(`  ${databaseIdMap.size} database(s) ready for embed resolution.\n`);
@@ -509,6 +516,7 @@ program
                     // Non-fatal — will create new databases
                 }
                 let inlineCreated = 0;
+                let linkedResolved = 0;
                 for (const [notionDbId, title] of unresolvedDbs) {
                     // Skip if already mapped (could happen if previously imported)
                     if (databaseIdMap.has(notionDbId) || currentMappings.has(notionDbId)) {
@@ -552,12 +560,44 @@ program
                         console.log(`  Created inline database: ${schema.name || title} (${kbDb.id}) — ${entries.length} entries`);
                     }
                     catch (error) {
-                        console.warn(`  Warning: Failed to create inline database "${title}" (${notionDbId}): ${error instanceof Error ? error.message : error}`);
+                        // Check if this is a linked database — resolve to its source
+                        const errMsg = error instanceof Error ? error.message : String(error);
+                        if (errMsg.includes('linked database')) {
+                            const sourceDbId = await notionApi.resolveLinkedDatabaseSource(notionDbId);
+                            if (sourceDbId) {
+                                // Look up the source database in our mappings
+                                const kbDbId = databaseIdMap.get(sourceDbId) || currentMappings.get(sourceDbId);
+                                if (kbDbId) {
+                                    databaseIdMap.set(notionDbId, kbDbId);
+                                    // Store mapping so future imports resolve during pre-create
+                                    try {
+                                        await inlineClient.createNotionDatabaseMapping({
+                                            kbDatabaseId: kbDbId,
+                                            notionDatabaseId: notionDbId,
+                                            notionDatabaseTitle: title,
+                                        });
+                                    }
+                                    catch {
+                                        // Non-fatal
+                                    }
+                                    linkedResolved++;
+                                    console.log(`  Resolved linked database "${title}" (${notionDbId}) → source ${sourceDbId} → KB ${kbDbId}`);
+                                    continue;
+                                }
+                            }
+                            console.warn(`  Warning: Linked database "${title}" (${notionDbId}) — could not resolve source`);
+                        }
+                        else {
+                            console.warn(`  Warning: Failed to create inline database "${title}" (${notionDbId}): ${errMsg}`);
+                        }
                     }
                 }
                 if (inlineCreated > 0) {
                     console.log(`  Created ${inlineCreated} inline database(s). Re-run with --on-conflict update to resolve embeds.`);
                 }
+                if (linkedResolved > 0) {
+                    console.log(`  Resolved ${linkedResolved} linked database(s) to existing source databases.`);
+                }
             }
         }
         // Step 4: Resolve cross-references (between page migration and database finalization)

package/dist/sources/notion-api.d.ts

@@ -225,6 +225,12 @@ export declare class NotionApiClient {
     searchDatabases(): Promise<NotionDatabase[]>;
     /** Get a database schema by ID. */
     getDatabase(databaseId: string): Promise<NotionDatabase>;
+    /**
+     * For a linked database, resolve the source database ID by querying
+     * one entry and reading its parent.database_id.
+     * Returns null if the database is empty or not queryable.
+     */
+    resolveLinkedDatabaseSource(linkedDbId: string): Promise<string | null>;
     /**
      * Query all entries (pages) in a database.
      */

package/dist/sources/notion-api.js

@@ -101,6 +101,26 @@ export class NotionApiClient {
     async getDatabase(databaseId) {
         return this.request('GET', `/databases/${databaseId}`);
     }
+    /**
+     * For a linked database, resolve the source database ID by querying
+     * one entry and reading its parent.database_id.
+     * Returns null if the database is empty or not queryable.
+     */
+    async resolveLinkedDatabaseSource(linkedDbId) {
+        try {
+            const response = await this.request('POST', `/databases/${linkedDbId}/query`, { page_size: 1 });
+            if (response.results.length > 0) {
+                const entry = response.results[0];
+                if (entry.parent?.type === 'database_id' && entry.parent.database_id) {
+                    return entry.parent.database_id.replace(/-/g, '');
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Query all entries (pages) in a database.
      */

package/dist/sources/notion-blocks.js

@@ -112,7 +112,7 @@ async function convertBlock(block, client, pagePathMap, visitedSyncedBlocks, dat
             // Just note it in the content.
             break;
         case 'child_database':
-            results.push(...convertChildDatabase(block, databaseIdMap, unresolvedChildDatabases));
+            results.push(...(await convertChildDatabase(block, client, databaseIdMap, unresolvedChildDatabases)));
             break;
         case 'synced_block':
             results.push(...(await convertSyncedBlock(block, client, pagePathMap, visitedSyncedBlocks, databaseIdMap, unsupportedBlocks, unresolvedChildDatabases)));
@@ -278,7 +278,7 @@ async function convertToggle(block, client, pagePathMap, visitedSyncedBlocks, da
     }
     return results;
 }
-function convertChildDatabase(block, databaseIdMap, unresolvedChildDatabases) {
+async function convertChildDatabase(block, client, databaseIdMap, unresolvedChildDatabases) {
     const cd = block;
     const title = cd.child_database?.title || 'Untitled Database';
     const notionDbId = normalizeId(block.id);
@@ -287,6 +287,19 @@ function convertChildDatabase(block, databaseIdMap, unresolvedChildDatabases) {
     if (kbDatabaseId) {
         return [{ blockType: 'database_embed', databaseId: kbDatabaseId }];
     }
+    // Try to resolve as a linked database: query one entry to find the source DB
+    if (databaseIdMap) {
+        const sourceDbId = await client.resolveLinkedDatabaseSource(notionDbId);
+        if (sourceDbId) {
+            const sourceKbDbId = databaseIdMap.get(sourceDbId);
+            if (sourceKbDbId) {
+                // Cache for future blocks in this extraction
+                databaseIdMap.set(notionDbId, sourceKbDbId);
+                console.log(`  Resolved linked database "${title}" → source KB ${sourceKbDbId}`);
+                return [{ blockType: 'database_embed', databaseId: sourceKbDbId }];
+            }
+        }
+    }
     // No mapping available — collect for later creation and emit text placeholder
     if (unresolvedChildDatabases) {
         unresolvedChildDatabases.set(notionDbId, title);

package/package.json

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