metabase-exporter 1.0.0

package/README.md

@@ -0,0 +1,45 @@
+# Metabase-Replicator
+
+Export/import collections from one Metabase instance to one or more target Metabase instances.
+
+## Features
+
+- Clone collections (with hierarchy) from source → multiple targets
+
+## Prerequisites
+
+- Node.js 18+
+
+## Install
+
+```bash
+npm i
+```
+
+## Usage (CLI)
+
+Run the tool with source credentials and one or more target credentials.
+
+```bash
+node src/index.js   --source_creds '{
+    "baseUrl": "https://source.metabase.example",
+    "userName": "admin@source",
+    "password": "******"
+  }'   --target_creds '[
+    {
+      "baseUrl": "https://target1.metabase.example",
+      "userName": "admin@target1",
+      "password": "******"
+    },
+    {
+      "baseUrl": "https://target2.metabase.example",
+      "userName": "admin@target2",
+      "password": "******"
+    }
+  ]'
+```
+
+### CLI Flags
+
+- `--source_creds` (required): JSON object with `baseUrl`, `userName`, `password`
+- `--target_creds` (required): JSON array of objects, each with `baseUrl`, `userName`, `password`

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "metabase-exporter",
+  "version": "1.0.0",
+  "bin": {
+    "metabase-exporter": "./src/index.js"
+  },
+  "description": "This is the cli tool which clones reports from single source metabse account to multiple destination accounts.",
+  "dependencies": {
+    "axios": "^1.12.2",
+    "commander": "^14.0.2"
+  },
+  "keywords": ["cli"],
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const program = new Command();
+
+const MetabaseService = require('./services/MetabaseService');
+    
+
+function sortTheCollectionasedOnHierachy(collectionList){
+    const sortedCollectionList = [];
+    let visitedCount = collectionList.length;
+    const visitedCollection = new Set()
+
+    while (visitedCount > 0) {
+        for (const collection of collectionList) {
+            if ((visitedCollection.has(collection.parent_id) || collection.parent_id == null) && !visitedCollection.has(collection.id)) {
+                visitedCount--;
+                visitedCollection.add(collection.id);
+                sortedCollectionList.push(collection);
+            }
+        }
+    }
+    return sortedCollectionList;
+}
+
+(async () => {
+    try {
+        program
+            .name('metabase-migrate')
+            .description('Metabase migrate CLI (parsing only)')
+            .requiredOption('--source_creds <json>', 'JSON: {"baseUrl":"...","userName":"...","password":"..."}')
+            .requiredOption('--target_creds <json>', 'JSON array: [{"baseUrl":"...","userName":"...","password":"..."}]');
+
+        program.parse(process.argv);
+
+        const opts = program.opts();
+
+        const sourceCreds = JSON.parse(opts.source_creds);
+        const targetCreds = JSON.parse(opts.target_creds);
+
+
+        if (!(sourceCreds.baseUrl && sourceCreds.userName && sourceCreds.password)) { 
+            throw new Error(`Invalid input formate`);
+        }
+        const source = new MetabaseService(sourceCreds);
+        
+        if (!targetCreds.length) throw new Error(`Invalid input formate`);
+
+        await source.login();
+
+        const collectionListSummary = await source.getCollections();
+        const collectionList = [];
+        for (const clSummary of collectionListSummary) {
+            collectionList.push(await source.getCollection(clSummary.id));
+        }
+        // console.log(collectionList.map((cl) => { return { parentId: cl.parent_id, id: cl.id }; }));
+        const sortedList = sortTheCollectionasedOnHierachy(collectionList);
+
+        for (const targetCred of targetCreds) { 
+            try {
+                const target = new MetabaseService(targetCred);
+                await target.login();
+                
+                // This stores the card, field, and table IDs from both the source and target Metabase instances in a single class.
+                await source.mapEntities(target);
+                for (const collection of sortedList) {
+                        if (!collection.is_sample
+                            && !collection.personal_owner_id
+                            && collection.name != 'Automatically Generated Dashboards'
+                            && !collection.is_personal
+                        ) {
+                            await source.cloneCollection(source, collection.id, collection.parent_id, target);
+                        }
+                }
+
+                await source.cloneRemainingDependentItems(source, target);
+
+                for (const collection of sortedList) { 
+                    if (!collection.is_sample
+                        && !collection.personal_owner_id
+                        && collection.name != 'Automatically Generated Dashboards'
+                        && !collection.is_personal
+                    ) {
+                        await source.cloneDashboards(source, collection.id, target);
+                    }  
+                }
+                await target.logout();
+            }
+            catch (err) { 
+                console.error(err);
+                console.error(`Login failed for ${targetCred.baseUrl}`);
+                console.error(`Skipping the replication`);
+            }
+        }
+        await source.logout();
+    }
+    catch (err) {
+        console.log('error occured', err);
+    }
+
+})();
+

package/src/services/CardService.js

@@ -0,0 +1,57 @@
+const mapperService = require('./fieldMappeerService');
+
+class CardService { 
+    CloningTheDatasetQuery(srcQuery) { 
+        this.cloneQuery(srcQuery);
+        return srcQuery;
+    }
+
+    cloneQuery(srcQuery) { 
+        if (Array.isArray(srcQuery)) {
+            for (let i = 0; i < srcQuery.length; i++) {
+                if (Array.isArray(srcQuery[i])) this.cloneQuery(srcQuery[i]);
+
+                else if (typeof srcQuery[i] == 'object') {
+                    this.cloneQuery(srcQuery[i]);
+                }
+                else {
+                    if (srcQuery[i] == 'field') {
+                        const targetField = mapperService.getFieldId(srcQuery[i + 1]); 
+                        if (targetField) srcQuery[i + 1] = targetField;
+                    };
+                }
+            }
+        }
+
+        else if(typeof srcQuery == 'object') {
+            const keys = Object.keys(srcQuery);
+            for (const key of keys) {
+                if (Array.isArray(srcQuery[key])) this.cloneQuery(srcQuery[key]);
+
+                else if (typeof srcQuery[key] == 'object') this.cloneQuery(srcQuery[key]);
+
+                else {
+                    if (key == 'source-table') srcQuery[key] = this.createNewId(srcQuery[key]);
+
+                    if (key == 'database') srcQuery[key] = mapperService.getDatabaseId(srcQuery[key]);
+                }
+            }
+        }
+    }
+
+    createNewId(sourceTableId) { 
+        if (typeof sourceTableId == 'string') { 
+            const suffix = sourceTableId.split("__")[1];
+            const prefix = sourceTableId.split("__")[0];
+
+            const tableId = `${prefix}__${mapperService.getCardId(parseInt(suffix))}`;
+            return tableId;
+        }
+
+        return mapperService.getTableId(sourceTableId);
+    }
+    
+}
+
+
+module.exports = new CardService();

package/src/services/MetabaseService.js

@@ -0,0 +1,418 @@
+const axios = require('axios');
+
+const mapperService = require('./fieldMappeerService');
+const CardService = require('./CardService')
+
+class MetabaseService {
+    #token;
+
+    constructor({ baseUrl, userName, password, token } = {}) {
+        this.baseUrl = String(baseUrl || '').replace(/\/+$/, '');
+        this.userName = userName;
+        this.password = password;
+        this.#token = token;
+        this.parentIdsMapping = new Map();
+    }
+
+    get headers() {
+        return {
+            'X-Metabase-Session': this.#token,
+            'Content-Type': 'application/json'
+        };
+    }
+
+    async login(username = this.userName, password = this.password) {
+        if (this.#token) return;
+        const { data } = await axios.post(`${this.baseUrl}/api/session`, { username, password });
+        if (!data?.id) throw new Error('Login failed');
+        this.#token = data.id;
+    }
+
+    async logout() {
+        if (!this.#token) return;
+        try {
+            await axios.delete(`${this.baseUrl}/api/session`, { headers: this.headers });
+        } catch (_) { }
+        this.#token = undefined;
+    }
+
+    async listCollections() {
+        const { data } = await axios.get(`${this.baseUrl}/api/collection`, { headers: this.headers });
+        return (data || []).filter(c => c.namespace !== 'personal');
+    }
+
+    async getCollection(collectionID) {
+        const { data } = await axios.get(`${this.baseUrl}/api/collection/${collectionID}`, {
+            headers: this.headers
+        });
+        return data;
+    }
+
+    async getCollections() {
+        const { data } = await axios.get(`${this.baseUrl}/api/collection`, {
+            headers: this.headers
+        });
+        return data;
+    }
+
+    async getDashboards() { 
+        const { data } = await axios.get(`${this.baseUrl}/api/dashboard`, {
+            headers: this.headers
+        });
+        return data;        
+    }
+
+    async getCollectionItems(collectionID) {
+        const { data } = await axios.get(`${this.baseUrl}/api/collection/${collectionID}/items`, {
+            headers: this.headers,
+        });
+        return data?.data ?? [];
+    }
+
+    async createCollection({ name, parent_id = null, description = null }) {
+        const { data } = await axios.post(
+            `${this.baseUrl}/api/collection`,
+            { name, parent_id, description },
+            { headers: this.headers }
+        );
+        return data;
+    }
+
+    async ensureCollection({ name, parent_id }) {
+        return this.createCollection({ name, parent_id });
+    }
+
+    async getCard(cardID) {
+        const { data } = await axios.get(`${this.baseUrl}/api/card/${cardID}`, {
+            headers: this.headers
+        });
+        return data;
+    }
+
+    async getCards() {
+        const { data } = await axios.get(`${this.baseUrl}/api/card`, {
+            headers: this.headers
+        });
+        return data;
+    }
+
+    async createCard(cardData) {
+        try {
+            const { data } = await axios.post(`${this.baseUrl}/api/card`, cardData, {
+                headers: this.headers
+            });
+            return data;
+        }
+        catch (err) { 
+            console.log(`error creating card`, err);
+        }
+    }
+
+    // ---------- Dashboards ----------
+    async getDashboard(dashboardID) {
+        const { data } = await axios.get(`${this.baseUrl}/api/dashboard/${dashboardID}`, {
+            headers: this.headers
+        });
+        return data;
+    }
+
+    async createDashboard({ name, description = null, collection_id, parameters = [] }) {
+        const { data } = await axios.post(
+            `${this.baseUrl}/api/dashboard`,
+            { name, description, collection_id, parameters, parameter_mappings: [] },
+            { headers: this.headers }
+        );
+        return data; // { id, ... }
+    }
+
+    deepCopy = x => JSON.parse(JSON.stringify(x ?? null));
+
+    async getDatabases() {
+        const { data } = await axios.get(`${this.baseUrl}/api/database?include=tables`, {
+            headers: this.headers
+        });
+        return data.data;    
+    }
+
+    async mapEntities(targetInstance) { 
+        try {
+            const sourceDatabases = await this.getDatabases();
+            const targetDatabases = await targetInstance.getDatabases();
+            for (const sd of sourceDatabases) {
+                for (const td of targetDatabases) {
+                    if (sd.name !== td.name) continue;
+                    mapperService.mapDatabaseId(sd.id, td.id);
+                    const sourceTables = sd.tables;
+                    const targetTables = td.tables;
+                
+                    for (const sT of sourceTables) {
+                        for (const tT of targetTables) {
+                            if (sT.name !== tT.name) continue;
+                            mapperService.mapTableId(sT.id, tT.id);
+                        }
+                    }
+
+                    const sourceFields = await this.getFields(sd.id);
+                    const targetFields = await targetInstance.getFields(td.id);
+
+                    for (const sF of sourceFields) {
+                        for (const tF of targetFields) {
+                            if (tF.table_id == mapperService.getTableId(sF.table_id) && sF.name === tF.name)
+                                mapperService.mapFieldId(sF.id, tF.id);
+                        }
+                    }
+                }
+            }
+
+            const cards = await targetInstance.getCards();
+            const dashboards = await targetInstance.getDashboards();
+            
+            for (const card of cards) mapperService.setCardByName(card.name, card);
+            for (const dashboard of dashboards) mapperService.setDashBoardByName(dashboard.name, dashboard);
+        }
+        catch (error) { 
+            console.log("Error in mapping Entitites", error);
+            throw new Error("Error in mapping Entities");
+        }
+    }
+
+    async getFields(dbId) {
+        const { data } = await axios.get(
+            `${this.baseUrl}/api/database/${dbId}/fields`,
+            { headers: this.headers }
+        );
+        return data;
+    }
+
+    async cloneCollection(sourceInstance, sourceCollectionId, collectionParentId, targetInstance) {
+        const srcCollection = await sourceInstance.getCollection(sourceCollectionId);
+        try {
+            console.log(`Creating the collection ${srcCollection.name}...`);
+
+            const targetCollections = await targetInstance.listCollections();
+            const foundedCollection = targetCollections.find(tg => tg.name == srcCollection.name);
+           
+            if (foundedCollection) { 
+                this.parentIdsMapping.set(srcCollection.id, foundedCollection.id);
+                mapperService.mapCollectionId(sourceCollectionId, foundedCollection.id);
+                console.log(`${srcCollection.name} Already exists`);
+                return;
+            }
+
+            const targetCollection = await targetInstance.ensureCollection({
+                name: srcCollection.name,
+                parent_id: this.parentIdsMapping.get(collectionParentId),
+            });
+
+            this.parentIdsMapping.set(srcCollection.id, targetCollection.id);
+
+            mapperService.mapCollectionId(sourceCollectionId, targetCollection.id);
+
+            console.log(`${srcCollection.name} created`);
+        }
+        catch (err) { 
+            console.log(err);
+            console.log(`Error while creating collection ${srcCollection.name}`);
+        }
+    }
+
+    async cloneRemainingDependentItems(sourceInstance, targetInstance) { 
+        try {
+            const cards = await this.getCards();
+            let nonDependentCards = cards.filter((card) => !card.source_card_id);
+            let dependeCards = cards.filter((card) => card.source_card_id);
+
+            await this.cloneCardsWhichAreDependent(nonDependentCards, targetInstance);
+            await this.cloneCardsWhichAreDependent(dependeCards, targetInstance);
+        }
+        catch (err) { 
+            console.log(err);
+        }
+    }
+
+
+    async cloneDashboards(sourceInstance, sourceCollectionId, targetInstance) {
+        const collectionItems = await this.getCollectionItems(sourceCollectionId);
+
+        const targetCollectionId = mapperService.getCollectionId(sourceCollectionId);
+        
+        const items = collectionItems.filter((item) => item.model == 'dashboard');
+        for (const item of items) {
+            const srcDashboard = await sourceInstance.getDashboard(item.id);
+
+            if (!srcDashboard) {
+                console.warn(`${srcDashboard.id} was not found in existing metabase instance`);
+                continue;
+            };
+
+            const targetDashboardPayload = {
+                description: srcDashboard.description,
+                collection_position: srcDashboard.collection_position,
+                enable_embedding: false,
+                collection_id: targetCollectionId,
+                name: srcDashboard.name,
+                width: srcDashboard.width,
+                caveats: srcDashboard.caveats,
+                can_restore: srcDashboard.can_restore,
+                parameters: this.deepCopy(srcDashboard.parameters),
+                auto_apply_filters: !!srcDashboard.auto_apply_filters
+            };
+
+            let createdDashboard;
+            const existingTargetDashboard = mapperService.getDashBoardByName(srcDashboard.name);
+            if (existingTargetDashboard && existingTargetDashboard.collection_id == mapperService.getCollectionId(srcDashboard.collection_id)) { 
+                createdDashboard = await targetInstance.updateDashBoard(existingTargetDashboard.id, targetDashboardPayload);
+            }
+            else createdDashboard = await targetInstance.createDashboard(targetDashboardPayload);
+
+            const tabsPayload = [];
+            let tabId = -1;
+            const tabIdMapping = new Map();
+            for (const tab of srcDashboard?.tabs) {
+                tabsPayload.push({
+                    id: tabId,
+                    dashboard_id: createdDashboard.id,
+                    name: tab.name,
+                    position: tab.position,
+                });
+                tabIdMapping.set(tab.id, tabId--);
+            }
+
+            const dashCardsPayloads = [];
+            let tempid = -1;
+            for (const srcDashcard of srcDashboard?.dashcards) {
+                const newCardId = mapperService.getCardId(srcDashcard.card_id);
+
+                if (!newCardId) {
+                    console.warn(`${createdDashboard.name} doesn't have card id for target instance so skipping this dashboard cloning..`);
+                    return;
+                }
+
+                const destinationCard = await targetInstance.getCard(newCardId);
+                destinationCard.dashboard_id = createdDashboard.id;
+                await targetInstance.updateCard(newCardId, destinationCard);
+
+                const dashCardPaylod = {
+                    id: tempid--,
+                    size_x: srcDashcard.size_x,
+                    size_y: srcDashcard.size_y,
+                    dashboard_tab_id: tabIdMapping.get(srcDashcard.dashboard_tab_id),
+                    row: srcDashcard.row,
+                    col: srcDashcard.col,
+                    visualization_settings: this.deepCopy(srcDashcard.visualization_settings),
+                };
+
+                if (srcDashcard.card_id) {
+                    dashCardPaylod.card_id = newCardId;
+                    dashCardPaylod.parameter_mappings = srcDashcard.parameter_mappings.map((pm) => { const copy = this.deepCopy(pm); copy.card_id = newCardId; return copy; });
+                } 
+
+                if (srcDashcard.card) { 
+                    dashCardPaylod.card = destinationCard
+                }
+                dashCardsPayloads.push(dashCardPaylod);
+            };
+
+            createdDashboard.dashcards = dashCardsPayloads;
+            createdDashboard.tabs = tabsPayload;
+
+            await targetInstance.updateDashBoard(createdDashboard.id, createdDashboard);
+        }
+    }
+
+    async cloneCardsWhichAreDependent(items, targetInstance) {
+        for (const item of items) {
+            if (mapperService.getCardId(item.id)) continue;
+            const srcCard = await this.getCard(item.id);
+            const targetCollectionId = mapperService.getCollectionId(srcCard.collection_id);
+
+            if (srcCard.collection_id && !targetCollectionId) { 
+                // console.warn(`${srcCard.name} does not have collection id for target instance so skipping the cloning.`);
+                continue;
+            }
+
+            console.log(`cloning the card ${srcCard.name}`);
+            await this.copyThisCard(srcCard, targetInstance, targetCollectionId);
+        }
+    }
+
+    async copyThisCard(srcCard, targetInstance, targetCollectionId) {
+        const cardPayload = {
+            name: srcCard.name,
+            description: srcCard.description ?? null,
+            collection_id: targetCollectionId,
+            display: srcCard.display,
+            visualization_settings: this.deepCopy(srcCard.visualization_settings) || {},
+            parameter_mappings: this.deepCopy(srcCard.parameter_mappings),
+            dataset_query: this.deepCopy(srcCard.dataset_query) || {},
+            type: srcCard.type || null,
+            cache_ttl: srcCard.cache_ttl ?? null,
+            archived: false,
+            collection_position: srcCard?.collection_position || null,
+        };
+        if (srcCard.source_card_id) { 
+            const targetSourceCardId = mapperService.getCardId(srcCard.source_card_id);
+            if (!targetSourceCardId) { 
+                console.warn(`${srcCard.name} does not have source_card_id for target instance to skipping the cloning`);
+                return;
+            }
+
+            cardPayload.source_card_id = targetSourceCardId;
+        }
+
+        cardPayload.dataset_query = CardService.CloningTheDatasetQuery(srcCard.dataset_query);
+
+        const existingCardWithSameName = mapperService.getCardByName(srcCard.name);
+        if (existingCardWithSameName &&
+            (
+                mapperService.getCollectionId(srcCard.collection_id) == existingCardWithSameName.collection_id
+                || (srcCard.collection_id == null && existingCardWithSameName.collection_id == null)
+            )){
+            await targetInstance.updateCard(existingCardWithSameName.id, cardPayload);
+            mapperService.mapCardId(srcCard.id, existingCardWithSameName.id);
+            return;
+        }
+
+        const targetCard = await targetInstance.createCard(cardPayload);
+        mapperService.mapCardId(srcCard.id, targetCard.id);
+    }
+    
+    async updateDashBoard(dashboardId, payload) {
+        const { data } = await axios.put(
+            `${this.baseUrl}/api/dashboard/${dashboardId}`,
+            payload,
+            { headers: this.headers }
+        );
+        return data;    
+    }
+
+    async updateCard(cardId, data) { 
+         await axios.put(`${this.baseUrl}/api/card/${cardId}`,
+            data,
+            { headers: this.headers }
+        );
+  
+    }
+
+    // async deleteduplicateCards() {
+    //     const cards = await this.getCards();
+    //     const cardsToDelete = cards.filter((c) => c.created_at.includes('2025-12-10'));
+
+    //     let count = cardsToDelete.length - 1;
+
+    //     while (count >= 0) { 
+    //         console.log(cardsToDelete[count].name);
+    //         await this.deleteCard(cardsToDelete[count].id);
+    //         count--;
+    //     }
+    // }
+
+    // async deleteCard(cardId) { 
+    //     await axios.delete(`${this.baseUrl}/api/card/${cardId}`, {
+    //         headers: this.headers
+    //     });
+    // }
+
+}
+
+module.exports = MetabaseService;