dbdiagram 0.3.2 → 0.4.1

package/README.md

@@ -55,6 +55,21 @@ dbdiagram init --entry schema.dbml --workspace-url myteam --project-url myteam/m
 
 ---
 
+### Validate
+
+Validate a local DBML file and report errors, warnings, and infos.
+
+**Options:**
+
+- `--json` — Output result as JSON
+
+```sh
+dbdiagram validate schema.dbml                         # validate a local DBML file
+dbdiagram validate schema.dbml --json                  # output the result as JSON
+```
+
+---
+
 ### Push
 
 Push a local DBML file to create or update a diagram on dbdiagram.io.

package/dist/actions/build/build-document.action.js

@@ -3,14 +3,15 @@ import { log, spinner } from '@clack/prompts';
 import { DBDOCS_CONFIGS } from '../../config.js';
 import { getCredential } from '../../config/credential-manager.js';
 import { DOCUMENT_SOURCE_TYPE } from '../../constants/document.constant.js';
-import { AUTH_NOT_LOGGED_IN, DBML_PARSE_ERROR, FILE_READ_ERROR, PROJECT_NAME_INVALID, PROJECT_NAME_MISSING, SOURCE_MISSING, VERSION_NAME_INVALID, WORKSPACE_NAME_INVALID, WORKSPACE_NAME_MISSING, } from '../../constants/cli-error.constant.js';
+import { AUTH_NOT_LOGGED_IN, FILE_READ_ERROR, PROJECT_NAME_INVALID, PROJECT_NAME_MISSING, SOURCE_MISSING, VERSION_NAME_INVALID, WORKSPACE_NAME_INVALID, WORKSPACE_NAME_MISSING, } from '../../constants/cli-error.constant.js';
 import { CliError } from '../../errors/cli.error.js';
 import { portalIntegration } from '../../integrations/portal/portal.integration.js';
 import { trackEvent } from '../../services/telemetry.service.js';
 import { prepareBuildDocumentData } from '../../services/dbml/dbml.service.js';
 import { getCliErrorMessageFromCode, toCliError } from '../../utils/cli-error.util.js';
-import { formatDbmlError, getDbmlVersion } from '../../utils/dbml.util.js';
-import { displayError, getOutputFormat, printJson } from '../../utils/output.util.js';
+import { getDbmlVersion } from '../../utils/dbml.util.js';
+import { DbmlParseError } from '../../errors/dbml-parse.error.js';
+import { displayDbmlParseError, displayError, getOutputFormat, printJson } from '../../utils/output.util.js';
 import { validateProjectUrlName, validateVersionName, validateWorkspaceUrlName, } from '../../utils/validation.util.js';
 const DOCUMENT_SOURCE_CLIENT_TYPE = 'dbdiagram-cli';
 export async function documentAction(options) {
@@ -84,7 +85,13 @@ export async function documentAction(options) {
     }
     catch (error) {
         process.exitCode = 1;
-        return displayError(new CliError(DBML_PARSE_ERROR, `Failed to parse DBML: ${formatDbmlError(error)}`), getOutputFormat(options.json));
+        if (error instanceof DbmlParseError) {
+            const label = options.source.type === DOCUMENT_SOURCE_TYPE.FILE
+                ? options.source.value
+                : 'DBML';
+            return displayDbmlParseError(error.errors, label, getOutputFormat(options.json));
+        }
+        return displayError(toCliError(error), getOutputFormat(options.json));
     }
     const s = spinner();
     s.start('Building document on dbdocs...');

package/dist/actions/push.action.js

@@ -9,9 +9,9 @@ import { preparePushDiagramData } from '../services/dbml/dbml.service.js';
 import { DBDIAGRAM_CONFIGS } from '../config.js';
 import { CliError } from '../errors/cli.error.js';
 import { getCliErrorMessageFromCode, toCliError } from '../utils/cli-error.util.js';
-import { AUTH_NOT_LOGGED_IN, FILE_PATH_MISSING, FILE_READ_ERROR, DBML_PARSE_ERROR, } from '../constants/cli-error.constant.js';
-import { displayError, getOutputFormat, printJson } from '../utils/output.util.js';
-import { formatDbmlError } from '../utils/dbml.util.js';
+import { AUTH_NOT_LOGGED_IN, FILE_PATH_MISSING, FILE_READ_ERROR, } from '../constants/cli-error.constant.js';
+import { displayDbmlParseError, displayError, getOutputFormat, printJson } from '../utils/output.util.js';
+import { DbmlParseError } from '../errors/dbml-parse.error.js';
 export async function pushAction(filepath, options, thisCommand) {
     const credential = getCredential();
     if (!credential) {
@@ -38,7 +38,10 @@ export async function pushAction(filepath, options, thisCommand) {
     }
     catch (error) {
         process.exitCode = 1;
-        return displayError(new CliError(DBML_PARSE_ERROR, `Failed to parse DBML: ${formatDbmlError(error)}`), getOutputFormat(options.json));
+        if (error instanceof DbmlParseError) {
+            return displayDbmlParseError(error.errors, resolvedFilepath, getOutputFormat(options.json));
+        }
+        return displayError(toCliError(error), getOutputFormat(options.json));
     }
     const vizPath = deriveDiagramVizPathFromDBML(resolvedFilepath);
     const vizResult = await readDiagramVizFile(vizPath);

package/dist/actions/validate.action.js

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { log } from '@clack/prompts';
+import { FILE_PATH_MISSING, FILE_READ_ERROR, VALIDATE_ERROR_HINT } from '../constants/cli-error.constant.js';
+import { CliError } from '../errors/cli.error.js';
+import { DbmlParseError } from '../errors/dbml-parse.error.js';
+import { parseDbml } from '../services/dbml/dbml.service.js';
+import { getCliErrorMessageFromCode, toCliError } from '../utils/cli-error.util.js';
+import { countDiagnosticLabel, diagnosticRenderSection } from '../utils/dbml.util.js';
+import { displayDbmlParseError, displayError, getOutputFormat, printJson } from '../utils/output.util.js';
+export async function validateAction(filepath, options, thisCommand) {
+    const format = getOutputFormat(options.json);
+    const resolvedFilepath = thisCommand.args[0] || filepath;
+    if (!resolvedFilepath) {
+        process.exitCode = 1;
+        return displayError(new CliError(FILE_PATH_MISSING, getCliErrorMessageFromCode(FILE_PATH_MISSING)), format);
+    }
+    let dbml;
+    try {
+        dbml = await readFile(resolvedFilepath, 'utf8');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.exitCode = 1;
+        return displayError(new CliError(FILE_READ_ERROR, `Failed to read file: ${message}`), format);
+    }
+    try {
+        const { warnings, infos } = await parseDbml(dbml);
+        if (format === 'json') {
+            printJson({ valid: true, warnings, infos });
+            return;
+        }
+        const counts = [];
+        if (warnings.length > 0)
+            counts.push(`${warnings.length} ${countDiagnosticLabel(warnings.length, 'warning')}`);
+        if (infos.length > 0)
+            counts.push(`${infos.length} ${countDiagnosticLabel(infos.length, 'info')}`);
+        const summary = counts.length > 0 ? `${counts.join(', ')}.` : 'No issues found.';
+        log.success(`${resolvedFilepath} is valid. ${summary}`);
+        if (warnings.length > 0)
+            log.warn(diagnosticRenderSection(warnings, 'warning'));
+        if (infos.length > 0)
+            log.info(diagnosticRenderSection(infos, 'info'));
+    }
+    catch (error) {
+        process.exitCode = 1;
+        if (error instanceof DbmlParseError) {
+            return displayDbmlParseError(error.errors, resolvedFilepath, format, VALIDATE_ERROR_HINT);
+        }
+        return displayError(toCliError(error), format);
+    }
+}

package/dist/commands/command.loader.js

@@ -1,6 +1,7 @@
 import { registerAuthCommand } from './auth/auth.command.js';
 import { registerBuildCommand } from './build/build.command.js';
 import { registerPushCommand } from './push.command.js';
+import { registerValidateCommand } from './validate.command.js';
 import { registerPullCommand } from './pull.command.js';
 import { registerDeleteCommand } from './delete.command.js';
 import { registerListCommand } from './list/list.command.js';
@@ -10,6 +11,7 @@ export function load(program) {
     registerInitCommand(program);
     registerAuthCommand(program);
     registerPushCommand(program);
+    registerValidateCommand(program);
     registerPullCommand(program);
     registerListCommand(program);
     registerDeleteCommand(program);

package/dist/commands/validate.command.js

@@ -0,0 +1,11 @@
+import { validateAction } from '../actions/validate.action.js';
+import { validatePreAction } from '../hooks/validate.hook.js';
+export function registerValidateCommand(program) {
+    program
+        .command('validate')
+        .description('Validate a local DBML file and report errors, warnings, and infos')
+        .argument('[filepath]', 'Path to the DBML file to validate')
+        .option('--json', 'Output as JSON')
+        .hook('preAction', validatePreAction)
+        .action(validateAction);
+}

package/dist/config.js

@@ -16,3 +16,4 @@ export const TELEMETRY_CONFIGS = {
     collectorUrl: process.env.TRACKING_COLLECTOR_URL || 'https://snowplow.holistics.io',
     appId: process.env.TRACKING_APP_ID || 'dbdiagram-cli',
 };
+export const DBML_PARSE_TIMEOUT_MS = 10_000;

package/dist/constants/cli-error.constant.js

@@ -79,3 +79,4 @@ export const PORTAL_TO_CLI_CODE = {
     internal_server_error: INTERNAL_SERVER_ERROR,
     unexpected_request_error: NETWORK_ERROR,
 };
+export const VALIDATE_ERROR_HINT = 'Fix these errors and re-run to check for warnings and infos.';

package/dist/errors/dbml-parse.error.js

@@ -0,0 +1,9 @@
+export class DbmlParseError extends Error {
+    errors;
+    constructor(errors) {
+        super('Failed to parse DBML');
+        this.errors = errors;
+        this.name = 'DbmlParseError';
+        Error.captureStackTrace?.(this, DbmlParseError);
+    }
+}

package/dist/hooks/validate.hook.js

@@ -0,0 +1,12 @@
+import { getSettings } from '../config/settings-manager.js';
+export function resolveValidateArgsFlags(cmd, settings) {
+    if (!cmd.args[0] && settings.dbml?.entry) {
+        cmd.args[0] = settings.dbml.entry;
+    }
+}
+export function validatePreAction(thisCommand) {
+    const settings = getSettings();
+    if (!settings)
+        return;
+    resolveValidateArgsFlags(thisCommand, settings);
+}

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

@@ -1,25 +1,41 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Worker } from 'node:worker_threads';
+import { DbmlParseError } from '../../errors/dbml-parse.error.js';
+import { DBML_PARSE_TIMEOUT_MS } from '../../config.js';
 const workerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'dbml.worker.js');
-function parseDbml(content) {
+export function parseDbml(content) {
     return new Promise((resolve, reject) => {
         const worker = new Worker(workerPath, { execArgv: process.execArgv });
+        let settled = false;
+        const timeout = setTimeout(() => {
+            settled = true;
+            worker.terminate();
+            reject(new Error(`DBML parser timed out after ${DBML_PARSE_TIMEOUT_MS}ms`));
+        }, DBML_PARSE_TIMEOUT_MS);
         worker.postMessage(content);
-        worker.on('message', (msg) => {
+        worker.on('message', (message) => {
+            settled = true;
+            clearTimeout(timeout);
             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;
+            if (message.errors)
+                reject(new DbmlParseError(message.errors));
+            else if (message.data)
+                resolve(message.data);
+            else
+                reject(new Error('DBML parser worker sent a message with neither data nor errors'));
+        });
+        worker.on('error', (error) => {
+            settled = true;
+            clearTimeout(timeout);
+            reject(error);
+        });
+        worker.on('exit', (code) => {
+            if (!settled) {
+                clearTimeout(timeout);
+                reject(new Error(`DBML parser worker exited unexpectedly with code ${code}`));
             }
-            reject(err);
         });
-        worker.on('error', reject);
     });
 }
 export function prepareBuildDocumentData(content) {

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

@@ -1,40 +1,61 @@
 import { parentPort } from 'node:worker_threads';
-import { Parser } from '@dbml/core';
+import { Parser, DEFAULT_ENTRY } from '@dbml/core';
 import removeMd from 'remove-markdown';
+function toDiagnostic(diagnostic) {
+    const { code, diagnostic: message, nodeOrToken: { startPos, endPos } } = diagnostic;
+    return {
+        code,
+        message,
+        start: {
+            line: startPos.line + 1,
+            column: startPos.column + 1,
+        },
+        end: {
+            line: endPos.line + 1,
+            column: endPos.column + 1,
+        },
+        fixes: (diagnostic.quickFixes ?? []).map((fix) => ({
+            title: fix.title,
+            edits: fix.edits.map((edit) => ({
+                start: edit.start,
+                end: edit.end,
+                newText: edit.newText,
+            })),
+        })),
+    };
+}
 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 } : {}),
-            },
-        });
+    const parser = new Parser();
+    parser.setDbmlSource(DEFAULT_ENTRY, content);
+    const report = parser.DBMLCompiler.interpretFile(DEFAULT_ENTRY);
+    const errors = report.getErrors();
+    if (errors.length > 0) {
+        parentPort?.postMessage({ errors: errors.map(toDiagnostic) });
+        return;
     }
+    const database = Parser.parseJSONToDatabase(report.getValue() || {});
+    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,
+            warnings: report.getWarnings().map(toDiagnostic),
+            infos: report.getInfos().map(toDiagnostic),
+        },
+    });
 });

package/dist/types/dbml-diagnostic.type.js

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

package/dist/utils/dbml.util.js

@@ -1,30 +1,26 @@
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import pluralize from 'pluralize';
 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);
-}
+export const countDiagnosticLabel = (count, noun) => {
+    return pluralize(noun, count);
+};
+export const diagnosticRenderLine = (diagnostic) => {
+    const location = `(line ${diagnostic.start.line}, column ${diagnostic.start.column})`;
+    return [
+        `  - ${diagnostic.message} ${location} [${diagnostic.code}]`,
+        ...diagnostic.fixes.map((fix) => `      fix: ${fix.title}`),
+    ];
+};
+export const diagnosticRenderSection = (diagnostics, noun) => {
+    return [
+        `${countDiagnosticLabel(diagnostics.length, noun)}:`,
+        ...diagnostics.flatMap(diagnosticRenderLine),
+    ].join('\n');
+};

package/dist/utils/output.util.js

@@ -1,6 +1,8 @@
 import Table from 'cli-table3';
 import { log } from '@clack/prompts';
+import { DBML_PARSE_ERROR } from '../constants/cli-error.constant.js';
 import { logConsole } from './logger.util.js';
+import { countDiagnosticLabel, diagnosticRenderLine } from './dbml.util.js';
 export const getOutputFormat = (json) => (json ? 'json' : 'plain');
 export function printJson(data) {
     logConsole(JSON.stringify(data, null, 2));
@@ -47,3 +49,14 @@ export function printTable(data, config) {
     }
     logConsole(table.toString());
 }
+export const displayDbmlParseError = (errors, label, format, hint) => {
+    const message = `Failed to parse ${label}. ${errors.length} ${countDiagnosticLabel(errors.length, 'error')}.`;
+    if (format === 'json') {
+        printJson({ errorCode: DBML_PARSE_ERROR, message, errors });
+        return;
+    }
+    const lines = [message, ...errors.flatMap(diagnosticRenderLine)];
+    if (hint)
+        lines.push('', hint);
+    log.error(lines.join('\n'));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbdiagram",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "main": "dist/index.js",
   "bin": {
     "dbdiagram": "dist/index.js"
@@ -39,12 +39,14 @@
     "dotenv": "^16.4.0",
     "luxon": "^3.7.2",
     "open": "^11.0.0",
+    "pluralize": "^8.0.0",
     "remove-markdown": "^0.6.4"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/luxon": "^3.7.1",
     "@types/node": "^25.7.0",
+    "@types/pluralize": "^0.0.33",
     "@vitest/coverage-v8": "^4.1.0",
     "danger": "^13.0.10",
     "danger-plugin-istanbul-coverage": "^1.6.2",