dbdiagram 0.1.2 → 0.3.0

package/dist/actions/push.action.js

@@ -1,28 +1,27 @@
 import { readFile } from 'node:fs/promises';
-import { log, spinner } from '@clack/prompts';
+import { spinner } from '@clack/prompts';
 import { getCredential } from '../config/credential-manager.js';
-import { NOT_LOGGED_IN_MESSAGE } from '../constants/auth-message.constant.js';
 import { portalIntegration } from '../integrations/portal/portal.integration.js';
+import { trackEvent } from '../services/telemetry.service.js';
 import { deriveDiagramVizPathFromDBML, readDiagramVizFile } from '../services/viz/diagram-viz-file.service.js';
-import { getVizReadErrorMessage } from '../utils/diagram-viz-error.util.js';
 import { toServerFormat } from '../services/viz/diagram-viz-converter.service.js';
 import { preparePushDiagramData } from '../services/dbml/dbml.service.js';
 import { DBDIAGRAM_CONFIGS } from '../config.js';
-import { isPortalApiError, getPortalApiErrorMessage } from '../utils/portal-error.util.js';
-import { printJson } from '../utils/output.util.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';
 export async function pushAction(filepath, options, thisCommand) {
     const credential = getCredential();
     if (!credential) {
-        log.error(NOT_LOGGED_IN_MESSAGE);
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(AUTH_NOT_LOGGED_IN, getCliErrorMessageFromCode(AUTH_NOT_LOGGED_IN)), getOutputFormat(options.json));
     }
     const resolvedFilepath = thisCommand.args[0] || filepath;
     if (!resolvedFilepath) {
-        log.error('Missing required argument: filepath. Provide it as an argument or set dbml.entry in settings.');
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(FILE_PATH_MISSING, getCliErrorMessageFromCode(FILE_PATH_MISSING)), getOutputFormat(options.json));
     }
     let dbml;
     try {
@@ -30,18 +29,16 @@ export async function pushAction(filepath, options, thisCommand) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        log.error(`Failed to read file: ${message}`);
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(FILE_READ_ERROR, `Failed to read file: ${message}`), getOutputFormat(options.json));
     }
     let preparedPushData;
     try {
         preparedPushData = await preparePushDiagramData(dbml);
     }
     catch (error) {
-        log.error(`Failed to parse DBML: ${formatDbmlError(error)}`);
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(DBML_PARSE_ERROR, `Failed to parse DBML: ${formatDbmlError(error)}`), getOutputFormat(options.json));
     }
     const vizPath = deriveDiagramVizPathFromDBML(resolvedFilepath);
     const vizResult = await readDiagramVizFile(vizPath);
@@ -50,23 +47,30 @@ export async function pushAction(filepath, options, thisCommand) {
         const { diagramViews } = preparedPushData;
         vizData = toServerFormat(vizResult.state, diagramViews);
     }
-    else {
-        const message = getVizReadErrorMessage(vizResult.errorCode, vizPath);
-        log.warn(message);
-    }
     const s = spinner();
     s.start('Pushing diagram to dbdiagram...');
     try {
+        const currentUser = await portalIntegration.getCurrentUser();
         let diagramId;
         if (!options.new && options.diagramId) {
             ({ diagramId } = await portalIntegration.updateDiagram({
                 diagramId: options.diagramId, name: options.name, dbml, vizData,
             }));
+            trackEvent({
+                name: 'cli_diagram_push',
+                properties: { action: 'update', diagramId, workspaceId: options.workspace ?? null },
+                userId: currentUser.id.toString(),
+            });
         }
         else {
             ({ diagramId } = await portalIntegration.createDiagram({
                 name: options.name, dbml, workspaceId: options.workspace, vizData,
             }));
+            trackEvent({
+                name: 'cli_diagram_push',
+                properties: { action: 'create', diagramId, workspaceId: options.workspace ?? null },
+                userId: currentUser.id.toString(),
+            });
         }
         const diagramUrl = `${DBDIAGRAM_CONFIGS.baseUrl}/d/${diagramId}`;
         if (options.json) {
@@ -79,13 +83,7 @@ export async function pushAction(filepath, options, thisCommand) {
     }
     catch (error) {
         s.stop('Failed to push diagram.');
-        if (isPortalApiError(error)) {
-            log.error(getPortalApiErrorMessage(error));
-        }
-        else {
-            const message = error instanceof Error ? error.message : String(error);
-            log.error(message);
-        }
+        displayError(toCliError(error), getOutputFormat(options.json));
         process.exitCode = 1;
     }
 }

package/dist/actions/tokens/token-delete.action.js

@@ -1,21 +1,20 @@
-import { confirm, isCancel, log, spinner } from '@clack/prompts';
+import { confirm, isCancel, spinner } from '@clack/prompts';
 import { getCredential } from '../../config/credential-manager.js';
-import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { CliError } from '../../errors/cli.error.js';
+import { getCliErrorMessageFromCode, toCliError } from '../../utils/cli-error.util.js';
+import { AUTH_NOT_LOGGED_IN, CONFIRMATION_REQUIRED } from '../../constants/cli-error.constant.js';
 import { portalIntegration } from '../../integrations/portal/portal.integration.js';
-import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
-import { printJson } from '../../utils/output.util.js';
+import { displayError, getOutputFormat, printJson } from '../../utils/output.util.js';
 export async function tokenDeleteAction(tokenId, options) {
     const credential = getCredential();
     if (!credential) {
-        log.error(NOT_LOGGED_IN_MESSAGE);
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(AUTH_NOT_LOGGED_IN, getCliErrorMessageFromCode(AUTH_NOT_LOGGED_IN)), getOutputFormat(options.json));
     }
     if (!options.force) {
         if (!process.stdout.isTTY) {
-            log.error('Use -f to force delete in non-interactive environment.');
             process.exitCode = 1;
-            return;
+            return displayError(new CliError(CONFIRMATION_REQUIRED, getCliErrorMessageFromCode(CONFIRMATION_REQUIRED)), getOutputFormat(options.json));
         }
         const shouldDelete = await confirm({
             message: `Delete token '${tokenId}'?`,
@@ -39,12 +38,7 @@ export async function tokenDeleteAction(tokenId, options) {
     }
     catch (error) {
         s.stop('Failed to delete token.');
-        if (isPortalApiError(error)) {
-            log.error(getPortalApiErrorMessage(error));
-        }
-        else {
-            log.error(error instanceof Error ? error.message : String(error));
-        }
+        displayError(toCliError(error), getOutputFormat(options.json));
         process.exitCode = 1;
     }
 }

package/dist/actions/tokens/token-generate.action.js

@@ -1,12 +1,13 @@
 import os from 'node:os';
-import { log, spinner } from '@clack/prompts';
+import { spinner } from '@clack/prompts';
 import packageJson from '../../../package.json' with { type: 'json' };
 import { getCredential } from '../../config/credential-manager.js';
-import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { AUTH_NOT_LOGGED_IN } from '../../constants/cli-error.constant.js';
+import { CliError } from '../../errors/cli.error.js';
 import { portalIntegration } from '../../integrations/portal/portal.integration.js';
-import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
-import { printJson } from '../../utils/output.util.js';
+import { getCliErrorMessageFromCode, toCliError } from '../../utils/cli-error.util.js';
 import { logConsole } from '../../utils/logger.util.js';
+import { displayError, getOutputFormat, printJson } from '../../utils/output.util.js';
 const PLATFORM_NAMES = {
     darwin: 'macOS',
     win32: 'Windows',
@@ -19,9 +20,8 @@ export function generateDefaultTokenName() {
 export async function tokenGenerateAction(opts) {
     const credential = getCredential();
     if (!credential) {
-        log.error(NOT_LOGGED_IN_MESSAGE);
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(AUTH_NOT_LOGGED_IN, getCliErrorMessageFromCode(AUTH_NOT_LOGGED_IN)), getOutputFormat(opts.json));
     }
     const name = opts.name ?? generateDefaultTokenName();
     const s = spinner();
@@ -41,12 +41,7 @@ export async function tokenGenerateAction(opts) {
     }
     catch (error) {
         s.stop('Failed to generate token.');
-        if (isPortalApiError(error)) {
-            log.error(getPortalApiErrorMessage(error));
-        }
-        else {
-            log.error(error instanceof Error ? error.message : String(error));
-        }
+        displayError(toCliError(error), getOutputFormat(opts.json));
         process.exitCode = 1;
     }
 }

package/dist/actions/tokens/token-list.action.js

@@ -1,17 +1,16 @@
-import { log, spinner } from '@clack/prompts';
-import { DateTime } from 'luxon';
+import { spinner } from '@clack/prompts';
 import { getCredential } from '../../config/credential-manager.js';
-import { NOT_LOGGED_IN_MESSAGE } from '../../constants/auth-message.constant.js';
+import { AUTH_NOT_LOGGED_IN } from '../../constants/cli-error.constant.js';
+import { CliError } from '../../errors/cli.error.js';
 import { portalIntegration } from '../../integrations/portal/portal.integration.js';
-import { isPortalApiError, getPortalApiErrorMessage } from '../../utils/portal-error.util.js';
-import { computeColWidths } from '../../utils/table.util.js';
-import { printJson, printTable } from '../../utils/output.util.js';
+import { getCliErrorMessageFromCode, toCliError } from '../../utils/cli-error.util.js';
+import { formatShortDateTime } from '../../utils/date.util.js';
+import { displayError, getOutputFormat, printJson, printTable } from '../../utils/output.util.js';
 export async function tokenListAction(opts) {
     const credential = getCredential();
     if (!credential) {
-        log.error(NOT_LOGGED_IN_MESSAGE);
         process.exitCode = 1;
-        return;
+        return displayError(new CliError(AUTH_NOT_LOGGED_IN, getCliErrorMessageFromCode(AUTH_NOT_LOGGED_IN)), getOutputFormat(opts.json));
     }
     const s = spinner();
     s.start('Fetching tokens...');
@@ -25,8 +24,8 @@ export async function tokenListAction(opts) {
         const mappedData = tokens.map((t) => ({
             id: t.id,
             name: t.name,
-            createdAt: DateTime.fromISO(t.createdAt).toLocaleString(DateTime.DATETIME_SHORT),
-            lastUsedAt: t.lastUsedAt ? DateTime.fromISO(t.lastUsedAt).toLocaleString(DateTime.DATETIME_SHORT) : 'Never',
+            createdAt: formatShortDateTime(t.createdAt),
+            lastUsedAt: t.lastUsedAt ? formatShortDateTime(t.lastUsedAt) : 'Never',
         }));
         if (opts.json) {
             printJson(mappedData);
@@ -34,19 +33,13 @@ export async function tokenListAction(opts) {
         else {
             printTable(mappedData, {
                 head: ['ID', 'Name', 'Created at', 'Last used'],
-                colWidths: computeColWidths([0.2, 0.45, 0.17, 0.18]),
                 rowMapper: (t) => [t.id, t.name, t.createdAt, t.lastUsedAt],
             });
         }
     }
     catch (error) {
         s.stop('Failed to fetch tokens.');
-        if (isPortalApiError(error)) {
-            log.error(getPortalApiErrorMessage(error));
-        }
-        else {
-            log.error(error instanceof Error ? error.message : String(error));
-        }
+        displayError(toCliError(error), getOutputFormat(opts.json));
         process.exitCode = 1;
     }
 }

package/dist/commands/auth/auth-logout.command.js

@@ -3,5 +3,6 @@ export function registerLogoutCommand(auth) {
     auth
         .command('logout')
         .description('Clear the local stored credentials and log out')
+        .option('--json', 'Output as JSON')
         .action(logoutAction);
 }

package/dist/commands/auth/auth.command.js

@@ -8,7 +8,7 @@ export function registerAuthCommand(program) {
         .addHelpText('after', '\nAlternatively, set the DBDIAGRAM_TOKEN env var to authenticate with a\n' +
         'CLI token (see: dbdiagram tokens generate).')
         .action(() => {
-        auth.help();
+        auth.outputHelp();
     });
     registerLoginCommand(auth);
     registerLogoutCommand(auth);

package/dist/commands/build/build.command.js

@@ -4,7 +4,7 @@ export function registerBuildCommand(program) {
         .command('build')
         .description('Publish documentation to dbdocs.io')
         .action(() => {
-        build.help();
+        build.outputHelp();
     });
     registerDocumentCommand(build);
 }

package/dist/commands/tokens/tokens.command.js

@@ -7,7 +7,7 @@ export function registerTokensCommand(program) {
         .description('Manage your CLI tokens')
         .addHelpText('after', '\nSet a token value as DBDIAGRAM_TOKEN env var to authenticate without browser login.')
         .action(() => {
-        tokens.help();
+        tokens.outputHelp();
     });
     registerTokenGenerateCommand(tokens);
     registerTokenListCommand(tokens);

package/dist/config/credential-manager.js

@@ -1,40 +1,27 @@
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { DOT_DBDIAGRAM_DIR, CREDENTIALS_FILE_NAME } from '../constants/dot-dbdiagram-dir.constant.js';
+import { getGlobalCredentialsFilePath, getGlobalDir, getProjectCredentialsFilePath, readAndParseJsonFileSafe, } from '../utils/file.util.js';
 let cachedCredential = null;
-function readJsonSafe(filePath) {
-    try {
-        const contents = fs.readFileSync(filePath, 'utf8');
-        return JSON.parse(contents);
-    }
-    catch {
-        return null;
-    }
-}
 export function resolveCredential() {
     if (process.env.DBDIAGRAM_TOKEN) {
         cachedCredential = { token: process.env.DBDIAGRAM_TOKEN };
         return cachedCredential;
     }
-    const projectPath = path.join(process.cwd(), DOT_DBDIAGRAM_DIR, CREDENTIALS_FILE_NAME);
-    const projectCred = readJsonSafe(projectPath);
-    if (projectCred && typeof projectCred.token === 'string') {
-        cachedCredential = { token: projectCred.token };
+    const projectCredential = readAndParseJsonFileSafe(getProjectCredentialsFilePath());
+    if (projectCredential && typeof projectCredential.token === 'string') {
+        cachedCredential = { token: projectCredential.token };
         return cachedCredential;
     }
-    const userPath = path.join(os.homedir(), DOT_DBDIAGRAM_DIR, CREDENTIALS_FILE_NAME);
-    const userCred = readJsonSafe(userPath);
-    if (userCred && typeof userCred.token === 'string') {
-        cachedCredential = { token: userCred.token };
+    const globalCredential = readAndParseJsonFileSafe(getGlobalCredentialsFilePath());
+    if (globalCredential && typeof globalCredential.token === 'string') {
+        cachedCredential = { token: globalCredential.token };
         return cachedCredential;
     }
     cachedCredential = null;
     return null;
 }
 export function storeCredential(token) {
-    const dir = path.join(os.homedir(), DOT_DBDIAGRAM_DIR);
-    const filePath = path.join(dir, CREDENTIALS_FILE_NAME);
+    const dir = getGlobalDir();
+    const filePath = getGlobalCredentialsFilePath();
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(filePath, JSON.stringify({ token }, null, 2), { mode: 0o600 });
     cachedCredential = { token };
@@ -46,7 +33,7 @@ export function getAccessToken() {
     return cachedCredential?.token ?? null;
 }
 export function clearCredential() {
-    const filePath = path.join(os.homedir(), DOT_DBDIAGRAM_DIR, CREDENTIALS_FILE_NAME);
+    const filePath = getGlobalCredentialsFilePath();
     fs.rmSync(filePath, { force: true });
     cachedCredential = null;
 }

package/dist/config/settings-manager.js

@@ -1,12 +1,8 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { DOT_DBDIAGRAM_DIR, SETTINGS_FILE_NAME } from '../constants/dot-dbdiagram-dir.constant.js';
+import { getProjectDir, getSettingsFilePath, readAndParseJsonFileSafe } from '../utils/file.util.js';
 let cachedSettings = null;
-function settingsPath() {
-    return path.join(process.cwd(), DOT_DBDIAGRAM_DIR, SETTINGS_FILE_NAME);
-}
 export function settingsExists() {
-    return fs.existsSync(settingsPath());
+    return fs.existsSync(getSettingsFilePath());
 }
 export function defaultSettings() {
     return {
@@ -15,30 +11,17 @@ export function defaultSettings() {
         document: { source: 'file', workspaceUrlName: '', projectUrlName: '' },
     };
 }
-export function readSettings() {
-    try {
-        const contents = fs.readFileSync(settingsPath(), 'utf8');
-        return JSON.parse(contents);
-    }
-    catch {
-        return null;
-    }
-}
-export function writeSettings(data) {
-    const dir = path.join(process.cwd(), DOT_DBDIAGRAM_DIR);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(settingsPath(), JSON.stringify(data, null, 2), 'utf8');
+export const readSettings = () => {
+    return readAndParseJsonFileSafe(getSettingsFilePath());
+};
+export const writeSettings = (data) => {
+    fs.mkdirSync(getProjectDir(), { recursive: true });
+    fs.writeFileSync(getSettingsFilePath(), JSON.stringify(data, null, 2), 'utf8');
     cachedSettings = data;
-}
-export function resolveSettings() {
-    try {
-        const contents = fs.readFileSync(settingsPath(), 'utf8');
-        cachedSettings = JSON.parse(contents);
-    }
-    catch {
-        cachedSettings = null;
-    }
-}
-export function getSettings() {
+};
+export const resolveSettings = () => {
+    cachedSettings = readAndParseJsonFileSafe(getSettingsFilePath());
+};
+export const getSettings = () => {
     return cachedSettings;
-}
+};

package/dist/config.js

@@ -12,3 +12,7 @@ export const DBDIAGRAM_CONFIGS = {
 export const DBDOCS_CONFIGS = {
     baseUrl: process.env.DBDOCS_BASE_URL || 'https://dbdocs.io',
 };
+export const TELEMETRY_CONFIGS = {
+    collectorUrl: process.env.TRACKING_COLLECTOR_URL || 'https://snowplow.holistics.io',
+    appId: process.env.TRACKING_APP_ID || 'dbdiagram-cli',
+};

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

@@ -0,0 +1,81 @@
+export const AUTH_NOT_LOGGED_IN = 'auth_not_logged_in';
+export const AUTH_INVALID_CREDENTIALS = 'auth_invalid_credentials';
+export const AUTH_LOGIN_TIMEOUT = 'auth_login_timeout';
+export const AUTH_LOGIN_CANCELLED = 'auth_login_cancelled';
+export const AUTH_LOGIN_STATE_MISMATCH = 'auth_login_state_mismatch';
+export const AUTH_LOGIN_INVALID_CALLBACK = 'auth_login_invalid_callback';
+export const AUTH_LOGIN_EXCHANGE_FAILED = 'auth_login_exchange_failed';
+export const AUTH_LOGIN_SERVER_ERROR = 'auth_login_server_error';
+export const AUTH_LOGIN_FAILED = 'auth_login_failed';
+export const AUTH_LOGOUT_FAILED = 'auth_logout_failed';
+export const DIAGRAM_ID_MISSING = 'diagram_id_missing';
+export const DIAGRAM_NOT_FOUND = 'diagram_not_found';
+export const DIAGRAM_PERMISSION_DENIED = 'diagram_permission_denied';
+export const DIAGRAM_LIMIT_EXCEEDED = 'diagram_limit_exceeded';
+export const WORKSPACE_NAME_MISSING = 'workspace_name_missing';
+export const WORKSPACE_NAME_INVALID = 'workspace_name_invalid';
+export const WORKSPACE_NOT_FOUND = 'workspace_not_found';
+export const WORKSPACE_PERMISSION_DENIED = 'workspace_permission_denied';
+export const PROJECT_NAME_MISSING = 'project_name_missing';
+export const PROJECT_NAME_INVALID = 'project_name_invalid';
+export const VERSION_NAME_INVALID = 'version_name_invalid';
+export const TOKEN_NOT_FOUND = 'token_not_found';
+export const TOKEN_LIMIT_EXCEEDED = 'token_limit_exceeded';
+export const FILE_PATH_MISSING = 'file_path_missing';
+export const FILE_READ_ERROR = 'file_read_error';
+export const SOURCE_MISSING = 'source_missing';
+export const DBML_PARSE_ERROR = 'dbml_parse_error';
+export const CONFIRMATION_REQUIRED = 'confirmation_required';
+export const VALIDATION_FAILED = 'validation_failed';
+export const INTERNAL_SERVER_ERROR = 'internal_server_error';
+export const NETWORK_ERROR = 'network_error';
+export const UNEXPECTED_ERROR = 'unexpected_error';
+export const REAUTH_MESSAGE = [
+    'Authentication failed: your credentials are invalid or expired.',
+    '  - If you set DBDIAGRAM_TOKEN, replace it with a valid token'
+        + ' (it takes precedence, so unset it to use `dbdiagram auth login` instead).',
+    '  - Otherwise, run `dbdiagram auth login` to re-authenticate.',
+].join('\n');
+export const NOT_LOGGED_IN_MESSAGE = 'Not logged in. Run `dbdiagram auth login`, or set DBDIAGRAM_TOKEN, to authenticate.';
+export const CLI_ERROR_MESSAGES = {
+    [AUTH_NOT_LOGGED_IN]: NOT_LOGGED_IN_MESSAGE,
+    [AUTH_INVALID_CREDENTIALS]: REAUTH_MESSAGE,
+    [AUTH_LOGIN_TIMEOUT]: 'Login timed out. Please try again.',
+    [AUTH_LOGIN_CANCELLED]: 'Login cancelled.',
+    [AUTH_LOGIN_STATE_MISMATCH]: 'Authentication failed: security validation error. Please try again.',
+    [AUTH_LOGIN_INVALID_CALLBACK]: 'Authentication failed: invalid callback received. Please try again.',
+    [AUTH_LOGIN_EXCHANGE_FAILED]: 'Authentication failed: could not exchange token. Please try again.',
+    [AUTH_LOGIN_SERVER_ERROR]: 'Authentication failed: could not start local server. '
+        + 'Another process may be using the required port. Please try again.',
+    [AUTH_LOGIN_FAILED]: 'Authentication failed: an unexpected error occurred.',
+    [DIAGRAM_ID_MISSING]: 'Missing required flag: --diagram-id',
+    [DIAGRAM_NOT_FOUND]: 'Diagram not found.',
+    [DIAGRAM_PERMISSION_DENIED]: 'You do not have permission to perform this action on this diagram.',
+    [DIAGRAM_LIMIT_EXCEEDED]: 'Diagram limit exceeded for your current plan.',
+    [WORKSPACE_NAME_MISSING]: 'Workspace url name is required. Use --project <workspace>/<project> '
+        + 'or set workspaceUrlName in settings.json',
+    [WORKSPACE_NOT_FOUND]: 'Workspace not found.',
+    [WORKSPACE_PERMISSION_DENIED]: 'You do not have permission to access this workspace.',
+    [PROJECT_NAME_MISSING]: 'Project name/url name is required. Use --project <workspace>/<project> '
+        + 'or set projectUrlName in settings.json',
+    [TOKEN_NOT_FOUND]: 'Token not found.',
+    [TOKEN_LIMIT_EXCEEDED]: 'Token limit reached. Delete an existing token before creating a new one.',
+    [FILE_PATH_MISSING]: 'Missing required argument: filepath. Provide it as an argument or set dbml.entry in settings.json.',
+    [SOURCE_MISSING]: 'One source must be specified: --from-file or --from-diagram',
+    [CONFIRMATION_REQUIRED]: 'Confirmation required. Pass --force (-f) to delete in a non-interactive environment.',
+    [INTERNAL_SERVER_ERROR]: 'An internal server error occurred. Please try again later.',
+    [NETWORK_ERROR]: 'Network error: could not reach the server. Check your connection and try again.',
+};
+export const PORTAL_TO_CLI_CODE = {
+    diagram_not_found: DIAGRAM_NOT_FOUND,
+    diagram_permission_denied_view: DIAGRAM_PERMISSION_DENIED,
+    diagram_permission_denied_edit: DIAGRAM_PERMISSION_DENIED,
+    diagram_permission_denied_delete: DIAGRAM_PERMISSION_DENIED,
+    diagram_limit_exceeded: DIAGRAM_LIMIT_EXCEEDED,
+    workspace_not_found: WORKSPACE_NOT_FOUND,
+    workspace_permission_denied_view: WORKSPACE_PERMISSION_DENIED,
+    token_not_found: TOKEN_NOT_FOUND,
+    token_limit_exceeded: TOKEN_LIMIT_EXCEEDED,
+    internal_server_error: INTERNAL_SERVER_ERROR,
+    unexpected_request_error: NETWORK_ERROR,
+};

package/dist/constants/dot-dbdiagram-dir.constant.js

@@ -7,3 +7,4 @@ export const DIAGRAM_VIZ_FILE_VERSIONS = {
     v1: '1.0.0',
     v2: '2.0.0',
 };
+export const TELEMETRY_FILE_NAME = 'telemetry.json';

package/dist/errors/cli.error.js

@@ -0,0 +1,9 @@
+export class CliError extends Error {
+    errorCode;
+    constructor(errorCode, message) {
+        super(message);
+        this.errorCode = errorCode;
+        this.name = 'CliError';
+        Error.captureStackTrace?.(this, CliError);
+    }
+}

package/dist/errors/portal-api.error.js

@@ -15,6 +15,7 @@ export class PortalApiError extends Error {
         this.data = data;
         this.type = type;
         this.name = 'PortalApiError';
+        Error.captureStackTrace?.(this, PortalApiError);
     }
     static fromAxios(error) {
         if (error.response) {

package/dist/hooks/global.hook.js

@@ -1,6 +1,13 @@
 import { resolveCredential } from '../config/credential-manager.js';
 import { resolveSettings } from '../config/settings-manager.js';
-export function globalPreAction(_thisCommand, _actionCommand) {
+import { flushTelemetry, initTelemetry, trackEvent } from '../services/telemetry.service.js';
+import { resolveCommandName } from '../utils/command-name.util.js';
+export function globalPreAction(_thisCommand, actionCommand) {
     resolveCredential();
     resolveSettings();
+    initTelemetry();
+    trackEvent({ name: 'cli_command_run', properties: { command: resolveCommandName(actionCommand) } });
+}
+export function globalPostAction() {
+    flushTelemetry();
 }

package/dist/index.js

@@ -1,12 +1,32 @@
 #!/usr/bin/env node
 import 'dotenv/config';
+import { CommanderError } from 'commander';
 import { load } from './commands/command.loader.js';
 import { createProgram } from './program.js';
-import { globalPreAction } from './hooks/global.hook.js';
+import { globalPostAction, globalPreAction } from './hooks/global.hook.js';
+import { flushTelemetry, initTelemetry, trackEvent } from './services/telemetry.service.js';
+const getAttemptedCommand = () => {
+    const operands = process.argv.slice(2).filter((arg) => !arg.startsWith('-'));
+    return operands.length ? operands.join(' ') : 'unknown';
+};
 const bootstrap = async () => {
     const program = createProgram();
     load(program);
     program.hook('preAction', globalPreAction);
-    await program.parseAsync(process.argv);
+    program.hook('postAction', globalPostAction);
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (!(error instanceof CommanderError))
+            throw error;
+        if (error.code === 'commander.unknownCommand' ||
+            error.code === 'commander.excessArguments') {
+            initTelemetry();
+            trackEvent({ name: 'cli_command_run', properties: { command: getAttemptedCommand() } });
+            flushTelemetry();
+        }
+        process.exitCode = error.exitCode;
+    }
 };
 bootstrap();

package/dist/integrations/telemetry/telemetry.integration.js

@@ -0,0 +1,77 @@
+import { buildSelfDescribingEvent, newTracker } from '@snowplow/node-tracker';
+import { TELEMETRY_CONFIGS } from '../../config.js';
+export const constructSnowplowSchemaUrl = (name, version = '1-0-0') => `iglu:io.dbdiagram/${name}/jsonschema/${version}`;
+let tracker;
+export const getTracker = () => {
+    if (tracker)
+        return tracker;
+    tracker = newTracker({
+        namespace: 'cli',
+        appId: TELEMETRY_CONFIGS.appId,
+        encodeBase64: true,
+    }, {
+        endpoint: TELEMETRY_CONFIGS.collectorUrl,
+        eventMethod: 'post',
+        bufferSize: 1,
+        retryFailedRequests: false,
+        onRequestFailure: () => { },
+        onRequestSuccess() { },
+    });
+    return tracker;
+};
+export const toEventData = (event) => {
+    const { name, properties } = event;
+    switch (name) {
+        case 'cli_command_run':
+            return { command: properties.command };
+        case 'cli_diagram_push': {
+            const { action, diagramId, workspaceId } = properties;
+            return {
+                action,
+                diagram_id: diagramId,
+                workspace_id: workspaceId,
+            };
+        }
+        case 'cli_document_build': {
+            const { workspaceUrlName, projectUrlName } = properties;
+            return {
+                workspace_url_name: workspaceUrlName,
+                project_url_name: projectUrlName,
+            };
+        }
+    }
+};
+export const toClientContextEntity = (client) => ({
+    schema: constructSnowplowSchemaUrl('cli_client_context'),
+    data: {
+        device_id: client.deviceId,
+        invocation_id: client.invocationId,
+        cli_version: client.cliVersion,
+        node_version: client.nodeVersion,
+        os: client.os,
+        arch: client.arch,
+        actor: client.actor,
+        ...(client.agentName ? { agent_name: client.agentName } : {}),
+        environment: client.environment,
+    },
+});
+export const toUserContextEntity = (userId) => ({
+    schema: constructSnowplowSchemaUrl('cli_user_context'),
+    data: { user_id: userId },
+});
+export const send = (events, client) => {
+    const tracker = getTracker();
+    const clientContextEntity = toClientContextEntity(client);
+    for (const event of events) {
+        const contexts = [clientContextEntity];
+        if ('userId' in event) {
+            contexts.push(toUserContextEntity(event.userId));
+        }
+        tracker.track(buildSelfDescribingEvent({
+            event: { schema: constructSnowplowSchemaUrl(event.name), data: toEventData(event) },
+        }), contexts, { type: 'ttm', value: event.timestamp });
+    }
+};
+export const telemetryIntegration = {
+    send,
+};