dbdiagram 0.1.0

package/dist/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { load } from './commands/command.loader.js';
+import { createProgram } from './program.js';
+import { globalPreAction } from './hooks/global.hook.js';
+const bootstrap = async () => {
+    const program = createProgram();
+    load(program);
+    program.hook('preAction', globalPreAction);
+    await program.parseAsync(process.argv);
+};
+bootstrap();

package/dist/integrations/portal/portal-http.integration.js

@@ -0,0 +1,27 @@
+import axios from 'axios';
+import { getAccessToken } from '../../config/credential-manager.js';
+import { PORTAL_URLS } from '../../config.js';
+import { PortalApiError } from '../../errors/portal-api.error.js';
+const axiosInstance = axios.create({
+    baseURL: `${PORTAL_URLS.apiUrl}/portal`,
+    headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+        Accept: 'application/json; charset=utf-8',
+    },
+});
+axiosInstance.interceptors.request.use((config) => {
+    const token = getAccessToken();
+    if (token) {
+        config.headers.Authorization = token;
+    }
+    return config;
+}, (error) => {
+    return Promise.reject(error);
+});
+axiosInstance.interceptors.response.use((response) => response, (error) => {
+    if (axios.isAxiosError(error)) {
+        return Promise.reject(PortalApiError.fromAxios(error));
+    }
+    return Promise.reject(error);
+});
+export { axiosInstance as portalHttpClient };

package/dist/integrations/portal/portal.integration.js

@@ -0,0 +1,68 @@
+import { portalHttpClient } from './portal-http.integration.js';
+const CLI_BASE_PATH = '/cli';
+async function getCurrentUser() {
+    const { data } = await portalHttpClient.get(`${CLI_BASE_PATH}/me`);
+    return data;
+}
+async function createDiagram(req) {
+    const { name, dbml, workspaceId, vizData } = req;
+    const params = workspaceId ? { workspace: workspaceId } : undefined;
+    const { data } = await portalHttpClient.post(`${CLI_BASE_PATH}/diagrams`, { name, dbml, vizData }, { params });
+    return data;
+}
+async function createDocument(req) {
+    const { data } = await portalHttpClient.post(`${CLI_BASE_PATH}/projects`, req);
+    return data;
+}
+async function updateDiagram(req) {
+    const { name, dbml, vizData } = req;
+    const { data } = await portalHttpClient.put(`${CLI_BASE_PATH}/diagrams/${req.diagramId}`, { name, dbml, vizData });
+    return data;
+}
+async function getDiagram(diagramId) {
+    const { data } = await portalHttpClient.get(`${CLI_BASE_PATH}/diagrams/${diagramId}`);
+    return data;
+}
+async function deleteDiagram(diagramId) {
+    await portalHttpClient.delete(`${CLI_BASE_PATH}/diagrams/${diagramId}`);
+    return;
+}
+async function listDiagrams(workspaceId) {
+    const params = workspaceId ? { workspace: workspaceId } : undefined;
+    const { data } = await portalHttpClient.get(`${CLI_BASE_PATH}/diagrams`, { params });
+    return data;
+}
+async function listWorkspaces() {
+    const { data } = await portalHttpClient.get(`${CLI_BASE_PATH}/workspaces`);
+    return data;
+}
+async function listWorkspaceProjects(name) {
+    const { data } = await portalHttpClient.get(`/cli/workspaces/${name}/projects`);
+    return data;
+}
+async function generateToken(req) {
+    const { data } = await portalHttpClient.post(`${CLI_BASE_PATH}/tokens`, req);
+    return data;
+}
+async function listTokens() {
+    const { data } = await portalHttpClient.get(`${CLI_BASE_PATH}/tokens`);
+    return data;
+}
+async function deleteToken(id) {
+    await portalHttpClient.delete(`/cli/tokens/${id}`);
+    return;
+}
+export const portalIntegration = {
+    getCurrentUser,
+    createDiagram,
+    updateDiagram,
+    createDocument,
+    getDiagram,
+    deleteDiagram,
+    listDiagrams,
+    listWorkspaces,
+    listWorkspaceProjects,
+    generateToken,
+    listTokens,
+    deleteToken,
+};

package/dist/libs/portal/client.js

@@ -0,0 +1,114 @@
+import { createHash, randomBytes } from 'crypto';
+import axios from 'axios';
+import { PORTAL_AUTH_ERROR_CODES, PortalAuthenticationError } from './errors.js';
+import { startLoopbackServer } from './server.js';
+const STATE_BYTES_LENGTH = 32;
+const CODE_VERIFIER_BYTES_LENGTH = 32;
+const generateLoginState = () => randomBytes(STATE_BYTES_LENGTH).toString('base64url');
+const generateCodeVerifier = () => randomBytes(CODE_VERIFIER_BYTES_LENGTH).toString('base64url');
+const generateCodeChallenge = (codeVerifier) => {
+    const hash = createHash('sha256');
+    hash.update(codeVerifier);
+    return hash.digest().toString('base64url');
+};
+const generateLoginUrl = (params) => {
+    const { baseUrl, redirectUri, codeChallenge, state, clientId } = params;
+    const url = new URL('/login', baseUrl);
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('redirect_uri', redirectUri);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('code_challenge', codeChallenge);
+    url.searchParams.set('state', state);
+    url.searchParams.set('prompt', 'select_account');
+    return url;
+};
+async function exchangeCodeForToken(params) {
+    const { apiHost, code, codeVerifier, redirectUri, clientId } = params;
+    try {
+        const { data } = await axios.post(`${apiHost}/portal/auth/token`, {
+            grantType: 'authorization_code',
+            redirectUri,
+            clientId,
+            code,
+            codeVerifier,
+        });
+        return data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            const description = error.response
+                ? error.response.data?.message || ''
+                : error.message || '';
+            throw new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.exchangeFailed, description);
+        }
+        throw new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.exchangeFailed, error instanceof Error ? error.message : '');
+    }
+}
+export async function initAuthClient(options) {
+    const { loginUrl, loginApiUrl, clientId, loginTimeoutMs, callbackHtmlPaths } = options;
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = generateLoginState();
+    const { baseUrl, close: closeLoopbackServer, loginCompletePromise } = await startLoopbackServer({
+        callbackHtmlPaths,
+    });
+    const redirectUri = `${baseUrl}/callback`;
+    const portalLoginUrl = generateLoginUrl({
+        baseUrl: loginUrl,
+        redirectUri,
+        codeChallenge,
+        state,
+        clientId,
+    });
+    const getLoginUrl = () => portalLoginUrl.toString();
+    const obtainTokens = async () => {
+        let timeoutId;
+        let sigintHandler;
+        try {
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.loginTimeout));
+                }, loginTimeoutMs);
+            });
+            const cancellationPromise = new Promise((_, reject) => {
+                sigintHandler = () => {
+                    reject(new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.loginCancelled));
+                };
+                process.once('SIGINT', sigintHandler);
+            });
+            const { code, state: returnedState } = await Promise.race([
+                loginCompletePromise,
+                timeoutPromise,
+                cancellationPromise,
+            ]);
+            if (state !== returnedState) {
+                throw new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.stateMismatch);
+            }
+            const { accessToken } = await exchangeCodeForToken({
+                apiHost: loginApiUrl,
+                code,
+                codeVerifier,
+                redirectUri,
+                clientId,
+            });
+            return { accessToken };
+        }
+        catch (error) {
+            if (error instanceof PortalAuthenticationError)
+                throw error;
+            throw new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.unknownError, error instanceof Error ? error.message : '');
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (sigintHandler)
+                process.removeListener('SIGINT', sigintHandler);
+            closeLoopbackServer();
+        }
+    };
+    return {
+        getLoginUrl,
+        obtainTokens,
+        cleanup: () => { closeLoopbackServer(); },
+    };
+}

package/dist/libs/portal/errors.js

@@ -0,0 +1,20 @@
+export const PORTAL_AUTH_ERROR_CODES = {
+    loginTimeout: 'LOGIN_TIMEOUT',
+    loginCancelled: 'LOGIN_CANCELLED',
+    stateMismatch: 'STATE_MISMATCH',
+    invalidCallback: 'INVALID_CALLBACK',
+    exchangeFailed: 'EXCHANGE_FAILED',
+    loopbackServerError: 'LOOPBACK_SERVER_ERROR',
+    unknownError: 'UNKNOWN_ERROR',
+};
+export class PortalAuthenticationError extends Error {
+    errorCode;
+    errorDescription;
+    constructor(errorCode, errorDescription = '') {
+        super(errorCode);
+        this.name = 'PortalAuthenticationError';
+        this.errorCode = errorCode;
+        this.errorDescription = errorDescription;
+        Error.captureStackTrace?.(this, PortalAuthenticationError);
+    }
+}

package/dist/libs/portal/index.js

@@ -0,0 +1,2 @@
+export { initAuthClient } from './client.js';
+export { PORTAL_AUTH_ERROR_CODES, PortalAuthenticationError } from './errors.js';

package/dist/libs/portal/server.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import { createServer } from 'http';
+import { PORTAL_AUTH_ERROR_CODES, PortalAuthenticationError } from './errors.js';
+const LOOPBACK_ADDRESS = '127.0.0.1';
+const AUTO_ASSIGNED_PORT = 0;
+const DEFAULT_HTTP_HEADERS = {
+    'Content-Type': 'text/html; charset=utf-8',
+};
+export const startLoopbackServer = ({ callbackHtmlPaths }) => {
+    const successHtml = fs.readFileSync(callbackHtmlPaths.success, 'utf-8');
+    const errorHtml = fs.readFileSync(callbackHtmlPaths.error, 'utf-8');
+    return new Promise((resolve, reject) => {
+        let isServerClosed = false;
+        let loginResolve;
+        let loginReject;
+        const loginCompletePromise = new Promise((res, rej) => {
+            loginResolve = res;
+            loginReject = rej;
+        });
+        const server = createServer();
+        const closeServer = () => {
+            if (!isServerClosed && server) {
+                isServerClosed = true;
+                server.closeAllConnections();
+                server.close();
+            }
+        };
+        server.on('error', (err) => {
+            closeServer();
+            reject(new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.loopbackServerError, err.message || ''));
+        });
+        server.on('request', (req, res) => {
+            const reqUrl = new URL(req.url ?? '', `http://${req.headers.host}`);
+            const { pathname } = reqUrl;
+            switch (pathname) {
+                case '/callback': {
+                    const code = reqUrl.searchParams.get('code');
+                    const state = reqUrl.searchParams.get('state');
+                    if (!code || !state) {
+                        res.writeHead(400, DEFAULT_HTTP_HEADERS);
+                        res.end(errorHtml);
+                        closeServer();
+                        loginReject(new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.invalidCallback));
+                        return;
+                    }
+                    res.writeHead(200, DEFAULT_HTTP_HEADERS);
+                    res.end(successHtml);
+                    loginResolve({ code, state });
+                    break;
+                }
+                default: {
+                    res.writeHead(404, DEFAULT_HTTP_HEADERS);
+                    res.end();
+                    closeServer();
+                    loginReject(new PortalAuthenticationError(PORTAL_AUTH_ERROR_CODES.invalidCallback));
+                    return;
+                }
+            }
+        });
+        server.listen(AUTO_ASSIGNED_PORT, LOOPBACK_ADDRESS, () => {
+            const { port } = server.address();
+            resolve({
+                port,
+                baseUrl: `http://${LOOPBACK_ADDRESS}:${port}`,
+                loginCompletePromise,
+                close: closeServer,
+            });
+        });
+    });
+};

package/dist/program.js

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import packageJson from '../package.json' with { type: 'json' };
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('dbdiagram')
+        .description('CLI tool for working with the dbx ecosystem (dbdiagram, dbdocs)')
+        .version(`${packageJson.name} ${packageJson.version}`, '-v, --version', 'Output the version number')
+        .helpOption('-h, --help', 'Show help information')
+        .enablePositionalOptions(true)
+        .action(() => {
+        program.help();
+    })
+        .showHelpAfterError(true);
+    return program;
+}

package/dist/services/dbml/dbml.service.js

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+const workerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'dbml.worker.js');
+function parseDbml(content) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerPath, { execArgv: process.execArgv });
+        worker.postMessage(content);
+        worker.on('message', (msg) => {
+            worker.terminate();
+            if (!msg.error) {
+                resolve(msg.data);
+                return;
+            }
+            const { message, diags } = msg.error;
+            const err = new Error(message);
+            if (diags) {
+                err.diags = msg.error.diags;
+            }
+            reject(err);
+        });
+        worker.on('error', reject);
+    });
+}
+export function prepareBuildDocumentData(content) {
+    return parseDbml(content);
+}
+export function preparePushDiagramData(content) {
+    return parseDbml(content);
+}

package/dist/services/dbml/dbml.worker.js

@@ -0,0 +1,40 @@
+import { parentPort } from 'node:worker_threads';
+import { Parser } from '@dbml/core';
+import removeMd from 'remove-markdown';
+parentPort?.on('message', (content) => {
+    try {
+        const parser = new Parser();
+        const database = parser.parse(content, 'dbmlv2');
+        const { name: dbName = '', note: dbDescription = '' } = database;
+        const name = dbName.trim();
+        const description = (dbDescription ?? '').trim() !== '' ? removeMd(dbDescription).trim() : '';
+        const shallowSchema = database.schemas.map((schema) => ({
+            name: schema.name,
+            tables: schema.tables.map((table) => table.name),
+        }));
+        const normalizedDatabase = database.normalize();
+        const diagramViews = database.diagramViews.map((view) => ({
+            name: view.name,
+            visibleEntities: view.visibleEntities,
+        }));
+        parentPort?.postMessage({
+            data: {
+                name,
+                description,
+                shallowSchema,
+                normalizedDatabase,
+                database,
+                diagramViews,
+            },
+        });
+    }
+    catch (error) {
+        const { diags } = error;
+        parentPort?.postMessage({
+            error: {
+                message: error instanceof Error ? error.message : String(error),
+                ...(diags !== undefined ? { diags } : {}),
+            },
+        });
+    }
+});

package/dist/services/file.service.js

@@ -0,0 +1,6 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export const writeFileWithDir = async (filePath, data, encoding = 'utf8') => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, data, encoding);
+};

package/dist/services/viz/diagram-viz-converter.service.js

@@ -0,0 +1,67 @@
+import { DIAGRAM_VIZ_FILE_VERSIONS } from '../../constants/dot-dbdiagram-dir.constant.js';
+export const migrateDiagramVizV1ToV2 = (v1) => {
+    return {
+        version: DIAGRAM_VIZ_FILE_VERSIONS.v2,
+        darkMode: v1.darkMode,
+        gridEnabling: v1.gridEnabling,
+        currentViewName: null,
+        defaultView: {
+            detailLevel: v1.detailLevel,
+            tablePositions: v1.tablePositions,
+            tableGroupCollapseStates: v1.tableGroupCollapseStates,
+            stickyNoteLayouts: v1.stickyNoteLayouts,
+            referencePaths: v1.referencePaths,
+        },
+        views: {},
+    };
+};
+export const toServerFormat = (state, diagramViews) => {
+    const { defaultView, views } = state;
+    const viewEntitiesMap = new Map(diagramViews?.map((v) => [v.name, v.visibleEntities]));
+    return {
+        diagram: { tables: defaultView.tablePositions },
+        referencePaths: defaultView.referencePaths,
+        stickyNoteLayouts: defaultView.stickyNoteLayouts,
+        tableGroups: defaultView.tableGroupCollapseStates,
+        detailLevel: defaultView.detailLevel,
+        visibleEntities: viewEntitiesMap.get('Default'),
+        views: Object.entries(views).map(([name, view]) => ({
+            name,
+            detailLevel: view.detailLevel,
+            tablePositions: view.tablePositions,
+            tableGroupCollapsedStates: view.tableGroupCollapseStates,
+            stickyNoteLayouts: view.stickyNoteLayouts,
+            referencePaths: view.referencePaths,
+            visibleEntities: viewEntitiesMap.get(name),
+        })),
+    };
+};
+const viewFromServer = (view) => {
+    return {
+        detailLevel: (view.detailLevel ?? ''),
+        tablePositions: view.tablePositions ?? [],
+        tableGroupCollapseStates: view.tableGroupCollapsedStates ?? [],
+        stickyNoteLayouts: view.stickyNoteLayouts ?? [],
+        referencePaths: view.referencePaths ?? [],
+    };
+};
+export const fromServerFormat = (serverData, existing) => {
+    const views = {};
+    for (const view of serverData.views) {
+        views[view.name] = viewFromServer(view);
+    }
+    return {
+        version: DIAGRAM_VIZ_FILE_VERSIONS.v2,
+        darkMode: existing?.darkMode ?? true,
+        gridEnabling: existing?.gridEnabling ?? false,
+        currentViewName: existing?.currentViewName ?? null,
+        defaultView: {
+            detailLevel: serverData.detailLevel,
+            tablePositions: serverData.diagram.tables,
+            tableGroupCollapseStates: serverData.tableGroups,
+            stickyNoteLayouts: serverData.stickyNoteLayouts,
+            referencePaths: serverData.referencePaths,
+        },
+        views,
+    };
+};

package/dist/services/viz/diagram-viz-file.service.js

@@ -0,0 +1,43 @@
+import { readFile } from 'node:fs/promises';
+import { writeFileWithDir } from '../file.service.js';
+import { DBML_EXTENSION, DIAGRAM_VIZ_EXTENSION, DIAGRAM_VIZ_FILE_VERSIONS, } from '../../constants/dot-dbdiagram-dir.constant.js';
+import { DIAGRAM_VIZ_READ_ERROR } from '../../constants/viz-read-error.constant.js';
+import { migrateDiagramVizV1ToV2 } from './diagram-viz-converter.service.js';
+export const deriveDiagramVizPathFromDBML = (dbmlFilePath) => {
+    const base = dbmlFilePath.endsWith(DBML_EXTENSION)
+        ? dbmlFilePath.slice(0, -DBML_EXTENSION.length)
+        : dbmlFilePath;
+    return `${base}${DIAGRAM_VIZ_EXTENSION}`;
+};
+export const readDiagramVizFile = async (vizPath) => {
+    let raw;
+    try {
+        raw = await readFile(vizPath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { ok: false, errorCode: DIAGRAM_VIZ_READ_ERROR.file_not_found };
+        }
+        return { ok: false, errorCode: DIAGRAM_VIZ_READ_ERROR.read_error };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, errorCode: DIAGRAM_VIZ_READ_ERROR.invalid_json };
+    }
+    const { version } = parsed;
+    if (version === DIAGRAM_VIZ_FILE_VERSIONS.v2) {
+        return { ok: true, state: parsed };
+    }
+    if (version === undefined || version === DIAGRAM_VIZ_FILE_VERSIONS.v1) {
+        const migrated = migrateDiagramVizV1ToV2(parsed);
+        await writeDiagramVizFile(vizPath, migrated);
+        return { ok: true, state: migrated };
+    }
+    return { ok: false, errorCode: DIAGRAM_VIZ_READ_ERROR.unknown_version };
+};
+export const writeDiagramVizFile = async (vizPath, state) => {
+    await writeFileWithDir(vizPath, JSON.stringify(state, null, 2));
+};

package/dist/types/config.type.js

@@ -0,0 +1 @@
+export {};

package/dist/types/diagram-viz.type.js

@@ -0,0 +1,6 @@
+export var DetailLevel;
+(function (DetailLevel) {
+    DetailLevel["Tables"] = "Tables";
+    DetailLevel["Keys"] = "Keys";
+    DetailLevel["All"] = "All";
+})(DetailLevel || (DetailLevel = {}));

package/dist/types/integrations/portal.type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/dbml.util.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+export function getDbmlVersion() {
+    const require = createRequire(import.meta.url);
+    const entry = require.resolve('@dbml/core');
+    const pkg = JSON.parse(readFileSync(path.resolve(path.dirname(entry), '..', 'package.json'), 'utf8'));
+    return pkg.version;
+}
+export function parseDbmlDiags(error) {
+    if (!error || typeof error !== 'object' || !Array.isArray(error.diags)) {
+        return [];
+    }
+    const { diags } = error;
+    return diags
+        .map((d) => {
+        const loc = d.location?.start;
+        const locStr = loc ? ` (line ${loc.line}, column ${loc.column})` : '';
+        return d.message ? `${d.message}${locStr}` : '';
+    })
+        .filter(Boolean);
+}
+export function formatDbmlError(error) {
+    const diags = parseDbmlDiags(error);
+    if (diags.length > 0)
+        return `\n  - ${diags.join('\n  - ')}`;
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}

package/dist/utils/diagram-viz-error.util.js

@@ -0,0 +1,11 @@
+import { DIAGRAM_VIZ_READ_ERROR } from '../constants/viz-read-error.constant.js';
+const VIZ_READ_ERROR_MESSAGES = {
+    [DIAGRAM_VIZ_READ_ERROR.read_error]: (path) => `Failed to read viz file ${path}, skipping viz data.`,
+    [DIAGRAM_VIZ_READ_ERROR.invalid_json]: (path) => `Viz file ${path} is not valid JSON, skipping viz data.`,
+    [DIAGRAM_VIZ_READ_ERROR.file_not_found]: (path) => `Viz file ${path} is not found, skipping viz data.`,
+    [DIAGRAM_VIZ_READ_ERROR.unknown_version]: (path) => `Viz file ${path} has an unrecognized version, skipping viz data.`,
+};
+export const getVizReadErrorMessage = (errorCode, vizPath) => {
+    const mapping = VIZ_READ_ERROR_MESSAGES[errorCode];
+    return mapping ? mapping(vizPath) : `Unknown error while reading diagram viz file ${vizPath}`;
+};

package/dist/utils/logger.util.js

@@ -0,0 +1,3 @@
+export const logConsole = (...args) => {
+    console.log(...args);
+};

package/dist/utils/output.util.js

@@ -0,0 +1,18 @@
+import Table from 'cli-table3';
+import { logConsole } from './logger.util.js';
+export function printJson(data) {
+    logConsole(JSON.stringify(data, null, 2));
+}
+export function printTable(data, config) {
+    const table = new Table({
+        head: config.head,
+        style: { head: [] },
+        colWidths: config.colWidths,
+        wordWrap: true,
+        wrapOnWordBoundary: false,
+    });
+    for (const item of data) {
+        table.push(config.rowMapper(item));
+    }
+    logConsole(table.toString());
+}

package/dist/utils/portal-error.util.js

@@ -0,0 +1,18 @@
+import { PortalApiError } from '../errors/portal-api.error.js';
+import { PORTAL_ERROR_MESSAGES, VALIDATION_INVALID_PAYLOAD } from '../errors/portal-error-codes.js';
+export function isPortalApiError(error) {
+    return error instanceof PortalApiError;
+}
+export function getPortalApiErrorMessage(error) {
+    if (error.errorCode.startsWith('auth_')) {
+        return [
+            'Authentication failed: your credentials are invalid or expired. Try one of:',
+            '  - Replace DBDIAGRAM_TOKEN with a valid token',
+            '  - Unset DBDIAGRAM_TOKEN, then run `dbdiagram auth login` to re-authenticate',
+        ].join('\n');
+    }
+    if (error.errorCode === VALIDATION_INVALID_PAYLOAD) {
+        return error.message;
+    }
+    return PORTAL_ERROR_MESSAGES[error.errorCode] ?? `An unexpected error occurred [${error.errorCode}]`;
+}

package/dist/utils/table.util.js

@@ -0,0 +1,10 @@
+export function computeColWidths(fractions) {
+    const terminalWidth = process.stdout.columns || 100;
+    const numCols = fractions.length;
+    const overhead = numCols * 3 + 1;
+    const available = Math.max(terminalWidth - overhead, numCols * 5);
+    const widths = fractions.map((f) => Math.max(Math.floor(available * f), 5));
+    const used = widths.reduce((a, b) => a + b, 0);
+    widths[widths.length - 1] += available - used;
+    return widths;
+}