dbctx 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,9 @@
+# dbctx
+
+> AI Enriched Database Context for Humans & Coding Agents
+
+## Usage
+
+```
+npx dbctx [connection_string]
+```

package/package.json

@@ -1,43 +1,46 @@
 {
-    "name": "dbctx",
-    "version": "1.0.0",
-    "description": "dbctx CLI",
-    "type": "module",
-    "main": "dist/index.mjs",
-    "bin": {
-        "dbctx": "./dist/index.mjs"
-    },
-    "scripts": {
-        "start": "tsc && node ./dist/index.mjs",
-        "dev": "tsc --watch --preserveWatchOutput",
-        "build": "tsc",
-        "build:ts:watch": "tsc --watch --preserveWatchOutput"
-    },
-    "keywords": [],
-    "author": {
-        "name": "AirState",
-        "email": "hello@airstate.dev",
-        "url": "https://airstate.dev"
-    },
-    "license": "UNLICENSED",
-    "dependencies": {
-        "commander": "14.0.3",
-        "es-toolkit": "1.44.0",
-        "ink": "6.6.0",
-        "pg": "8.18.0",
-        "react": "19.2.4",
-        "winston": "3.19.0",
-        "zod": "4.3.6"
-    },
-    "devDependencies": {
-        "@types/node": "24.0.0",
-        "@types/pg": "8.16.0",
-        "@types/react": "19.2.10",
-        "concurrently": "9.2.1",
-        "cross-env": "7.0.3",
-        "typescript": "5.9.3"
-    },
-    "volta": {
-        "node": "24.0.0"
-    }
+  "name": "dbctx",
+  "version": "1.0.2",
+  "description": "dbctx CLI",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "bin": {
+    "dbctx": "./dist/index.mjs"
+  },
+  "keywords": [],
+  "author": {
+    "name": "AirState",
+    "email": "hello@airstate.dev",
+    "url": "https://airstate.dev"
+  },
+  "license": "UNLICENSED",
+  "dependencies": {
+    "commander": "14.0.3",
+    "es-toolkit": "1.44.0",
+    "ink": "6.6.0",
+    "pg": "8.18.0",
+    "react": "19.2.4",
+    "winston": "3.19.0",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "24.0.0",
+    "@types/pg": "8.16.0",
+    "@types/react": "19.2.10",
+    "concurrently": "9.2.1",
+    "cross-env": "7.0.3",
+    "typescript": "5.9.3"
+  },
+  "volta": {
+    "node": "24.0.0"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "start": "tsc && node ./dist/index.mjs",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "build": "tsc",
+    "build:ts:watch": "tsc --watch --preserveWatchOutput"
+  }
 }

package/.prettierrc.cjs

@@ -1,7 +0,0 @@
-module.exports = {
-    bracketSpacing: false,
-    jsxBracketSameLine: true,
-    singleQuote: true,
-    trailingComma: 'all',
-    tabWidth: 4,
-};

package/.turbo/turbo-build.log

@@ -1,5 +0,0 @@
-
-
-> dbctx@1.0.0 build /Users/omran/Projects/airstate/dbctx/apps/client
-> tsc
-

package/src/App.tsx

@@ -1,44 +0,0 @@
-import { Text, Box } from "ink";
-import type { ReactNode } from "react";
-import type { TSSLMode } from "./index.mjs";
-
-export type TConnectionConfig = {
-    connectionString?: string;
-    hostname?: string;
-    port?: number;
-    database?: string;
-    username?: string;
-    sslmode?: TSSLMode;
-    sslcert?: string;
-    sslkey?: string;
-    sslrootcert?: string;
-    sshHost?: string;
-    sshPort?: number;
-    sshUsername?: string;
-    sshPrivateKey?: string;
-};
-
-type TAppProps = {
-    config: TConnectionConfig;
-};
-
-export function App({ config }: TAppProps): ReactNode {
-    const connectionTarget = config.connectionString
-        ? config.connectionString.replace(/:[^:@]+@/, ":***@") // mask password
-        : `${config.hostname}:${config.port}/${config.database}`;
-
-    return (
-        <Box flexDirection="column" padding={1}>
-            <Box marginBottom={1}>
-                <Text color="cyan" bold>
-                    dbctx
-                </Text>
-                <Text dimColor> - AI generated docs from your application database</Text>
-            </Box>
-            <Box>
-                <Text dimColor>Connecting to: </Text>
-                <Text color="yellow">{connectionTarget}</Text>
-            </Box>
-        </Box>
-    );
-}

package/src/components/Error.tsx

@@ -1,16 +0,0 @@
-import { Text, Box } from "ink";
-import type { ReactNode } from "react";
-
-interface ErrorProps {
-    message: string;
-}
-
-export function Error({ message }: ErrorProps): ReactNode {
-    return (
-        <Box>
-            <Text color="red" bold>
-                Error: {message}
-            </Text>
-        </Box>
-    );
-}

package/src/db/analyze.mts

@@ -1,22 +0,0 @@
-import type { Pool } from "pg";
-
-export const analyzeRelation = async (pool: Pool, relationName: string): Promise<void> => {
-    // Validate relation exists and get properly quoted name to prevent SQL injection
-    const validation = await pool.query<{ quoted_name: string }>(
-        `
-        SELECT format('%I', c.relname) AS quoted_name
-        FROM pg_catalog.pg_class c
-        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-        WHERE n.nspname = 'public'
-            AND c.relname = $1
-            AND c.relkind IN ('r', 'p', 'm')
-        `,
-        [relationName]
-    );
-
-    if (validation.rows.length === 0) {
-        throw new Error(`Relation "${relationName}" not found in public schema`);
-    }
-
-    await pool.query(`ANALYZE public.${validation.rows[0].quoted_name}`);
-};

package/src/db/attributes.mts

@@ -1,58 +0,0 @@
-import type { Pool } from "pg";
-
-export type TAttributeKind = "regular" | "generated";
-
-export type TGeneratedStorage = "stored" | "virtual";
-
-export type TAttributeInfo = {
-    attribute_name: string;
-    data_type: string;
-    is_nullable: boolean;
-    has_default: boolean;
-    default_expression: string | null;
-    kind: TAttributeKind;
-    generated_storage: TGeneratedStorage | null;
-    generated_expression: string | null;
-    comment: string | null;
-};
-
-export const fetchRelationAttributes = async (pool: Pool, relationName: string): Promise<TAttributeInfo[]> => {
-    const result = await pool.query<TAttributeInfo>(
-        `
-        SELECT
-            a.attname AS attribute_name,
-            format_type(a.atttypid, a.atttypemod) AS data_type,
-            NOT a.attnotnull AS is_nullable,
-            ad.adbin IS NOT NULL AS has_default,
-            CASE
-                WHEN a.attgenerated = '' AND ad.adbin IS NOT NULL THEN pg_get_expr(ad.adbin, ad.adrelid)
-                ELSE NULL
-            END AS default_expression,
-            CASE a.attgenerated
-                WHEN '' THEN 'regular'
-                ELSE 'generated'
-            END AS kind,
-            CASE a.attgenerated
-                WHEN 's' THEN 'stored'
-                WHEN 'v' THEN 'virtual'
-                ELSE NULL
-            END AS generated_storage,
-            CASE
-                WHEN a.attgenerated != '' THEN pg_get_expr(ad.adbin, ad.adrelid)
-                ELSE NULL
-            END AS generated_expression,
-            col_description(c.oid, a.attnum) AS comment
-        FROM pg_catalog.pg_class c
-        JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
-        LEFT JOIN pg_catalog.pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
-        WHERE c.relname = $1
-            AND c.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
-            AND a.attnum > 0
-            AND NOT a.attisdropped
-        ORDER BY a.attnum
-        `,
-        [relationName]
-    );
-
-    return result.rows;
-};

package/src/db/enums.mts

@@ -1,43 +0,0 @@
-import type { Pool } from "pg";
-import { groupBy } from "es-toolkit";
-
-type TEnumValueRow = {
-    enum_name: string;
-    value: string;
-    sort_order: number;
-    comment: string | null;
-};
-
-export type TEnumInfo = {
-    values: string[];
-    comment: string | null;
-};
-
-export type TGroupedEnums = Record<string, TEnumInfo>;
-
-export const fetchPublicEnums = async (pool: Pool): Promise<TGroupedEnums> => {
-    const result = await pool.query<TEnumValueRow>(`
-        SELECT
-            t.typname AS enum_name,
-            e.enumlabel AS value,
-            e.enumsortorder AS sort_order,
-            obj_description(t.oid, 'pg_type') AS comment
-        FROM pg_catalog.pg_type t
-        JOIN pg_catalog.pg_enum e ON t.oid = e.enumtypid
-        JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
-        WHERE n.nspname = 'public'
-        ORDER BY enum_name, sort_order
-    `);
-
-    const grouped = groupBy(result.rows, (row) => row.enum_name);
-
-    return Object.fromEntries(
-        Object.entries(grouped).map(([name, rows]) => [
-            name,
-            {
-                values: rows.map((r) => r.value),
-                comment: rows[0]?.comment ?? null,
-            },
-        ])
-    );
-};

package/src/db/file-stats.mts

@@ -1,57 +0,0 @@
-import type { Pool } from "pg";
-
-export type TRelationFileStats = {
-    relation_name: string;
-    file_path: string | null;
-    modification_time: Date;
-    size_bytes: number;
-    is_partitioned: boolean;
-    partition_count: number | null;
-};
-
-export const fetchRelationFileStats = async (pool: Pool, relationName: string): Promise<TRelationFileStats> => {
-    const result = await pool.query<TRelationFileStats>(
-        `
-        WITH target AS (
-            SELECT c.oid, c.relname, c.relkind
-            FROM pg_catalog.pg_class c
-            JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-            WHERE n.nspname = 'public'
-                AND c.relname = $1
-                AND c.relkind IN ('r', 'p', 'm')
-        ),
-        partition_stats AS (
-            SELECT
-                (pg_stat_file(pg_relation_filepath(child.oid))).modification AS modification_time,
-                (pg_stat_file(pg_relation_filepath(child.oid))).size AS size_bytes
-            FROM target t
-            JOIN pg_catalog.pg_inherits i ON i.inhparent = t.oid
-            JOIN pg_catalog.pg_class child ON child.oid = i.inhrelid
-            WHERE t.relkind = 'p'
-        )
-        SELECT
-            t.relname AS relation_name,
-            CASE
-                WHEN t.relkind = 'p' THEN NULL
-                ELSE pg_relation_filepath(t.oid)
-            END AS file_path,
-            CASE
-                WHEN t.relkind = 'p' THEN (SELECT MAX(modification_time) FROM partition_stats)
-                ELSE (pg_stat_file(pg_relation_filepath(t.oid))).modification
-            END AS modification_time,
-            CASE
-                WHEN t.relkind = 'p' THEN (SELECT COALESCE(SUM(size_bytes), 0) FROM partition_stats)
-                ELSE (pg_stat_file(pg_relation_filepath(t.oid))).size
-            END AS size_bytes,
-            t.relkind = 'p' AS is_partitioned,
-            CASE
-                WHEN t.relkind = 'p' THEN (SELECT COUNT(*) FROM partition_stats)
-                ELSE NULL
-            END AS partition_count
-        FROM target t
-        `,
-        [relationName]
-    );
-
-    return result.rows[0];
-};

package/src/db/foreign-keys.mts

@@ -1,61 +0,0 @@
-import type { Pool } from "pg";
-
-type TForeignKeyAction = "NO ACTION" | "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT";
-
-export type TForeignKeyInfo = {
-    constraint_name: string;
-    attributes: string[];
-    referenced_relation: string;
-    referenced_attributes: string[];
-    on_update: TForeignKeyAction;
-    on_delete: TForeignKeyAction;
-    comment: string | null;
-};
-
-export const fetchRelationForeignKeys = async (pool: Pool, relationName: string): Promise<TForeignKeyInfo[]> => {
-    const result = await pool.query<TForeignKeyInfo>(
-        `
-        SELECT
-            con.conname AS constraint_name,
-            ARRAY(
-                SELECT a.attname
-                FROM unnest(con.conkey) WITH ORDINALITY AS cols(attnum, ord)
-                JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = cols.attnum
-                ORDER BY cols.ord
-            ) AS attributes,
-            ref_cl.relname AS referenced_relation,
-            ARRAY(
-                SELECT a.attname
-                FROM unnest(con.confkey) WITH ORDINALITY AS cols(attnum, ord)
-                JOIN pg_attribute a ON a.attrelid = con.confrelid AND a.attnum = cols.attnum
-                ORDER BY cols.ord
-            ) AS referenced_attributes,
-            CASE con.confupdtype
-                WHEN 'a' THEN 'NO ACTION'
-                WHEN 'r' THEN 'RESTRICT'
-                WHEN 'c' THEN 'CASCADE'
-                WHEN 'n' THEN 'SET NULL'
-                WHEN 'd' THEN 'SET DEFAULT'
-            END AS on_update,
-            CASE con.confdeltype
-                WHEN 'a' THEN 'NO ACTION'
-                WHEN 'r' THEN 'RESTRICT'
-                WHEN 'c' THEN 'CASCADE'
-                WHEN 'n' THEN 'SET NULL'
-                WHEN 'd' THEN 'SET DEFAULT'
-            END AS on_delete,
-            obj_description(con.oid, 'pg_constraint') AS comment
-        FROM pg_catalog.pg_constraint con
-        JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
-        JOIN pg_catalog.pg_class ref_cl ON ref_cl.oid = con.confrelid
-        JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
-        WHERE con.contype = 'f'
-            AND n.nspname = 'public'
-            AND cl.relname = $1
-        ORDER BY con.conname
-        `,
-        [relationName]
-    );
-
-    return result.rows;
-};

package/src/db/index.mts

@@ -1,9 +0,0 @@
-export { fetchPublicRelations, type TRelationType, type TRelationInfo, type TGroupedRelations } from "./relations.mjs";
-export { fetchRelationAttributes, type TAttributeKind, type TGeneratedStorage, type TAttributeInfo } from "./attributes.mjs";
-export { fetchPublicEnums, type TEnumInfo, type TGroupedEnums } from "./enums.mjs";
-export { fetchRelationIndexes, type TIndexInfo } from "./indexes.mjs";
-export { fetchRelationForeignKeys, type TForeignKeyInfo } from "./foreign-keys.mjs";
-export { fetchPostgresVersion, type TPostgresVersion, fetchDatabaseIdentifier, type TDatabaseIdentifier } from "./version.mjs";
-export { fetchRelationFileStats, type TRelationFileStats } from "./file-stats.mjs";
-export { analyzeRelation } from "./analyze.mjs";
-export { fetchRelationStats, type TRelationStats, type TAttributeStats } from "./stats.mjs";

package/src/db/indexes.mts

@@ -1,57 +0,0 @@
-import type { Pool } from "pg";
-
-export type TIndexInfo = {
-    index_name: string;
-    relation_name: string;
-    is_unique: boolean;
-    is_primary: boolean;
-    is_exclusion: boolean;
-    is_partial: boolean;
-    partial_predicate: string | null;
-    attributes: string[];
-    exclusion_operators: string[] | null;
-    definition: string;
-    comment: string | null;
-};
-
-export const fetchRelationIndexes = async (pool: Pool, relationName: string): Promise<TIndexInfo[]> => {
-    const result = await pool.query<TIndexInfo>(
-        `
-        SELECT
-            i.relname AS index_name,
-            t.relname AS relation_name,
-            ix.indisunique AS is_unique,
-            ix.indisprimary AS is_primary,
-            ix.indisexclusion AS is_exclusion,
-            ix.indpred IS NOT NULL AS is_partial,
-            pg_get_expr(ix.indpred, ix.indrelid) AS partial_predicate,
-            ARRAY(
-                SELECT pg_get_indexdef(ix.indexrelid, k + 1, true)
-                FROM generate_subscripts(ix.indkey, 1) AS k
-                ORDER BY k
-            ) AS attributes,
-            CASE
-                WHEN ix.indisexclusion THEN (
-                    SELECT ARRAY_AGG(op.oprname ORDER BY ord.n)
-                    FROM pg_constraint con
-                    CROSS JOIN LATERAL unnest(con.conexclop) WITH ORDINALITY AS ord(opoid, n)
-                    JOIN pg_operator op ON op.oid = ord.opoid
-                    WHERE con.conindid = ix.indexrelid
-                )
-                ELSE NULL
-            END AS exclusion_operators,
-            pg_get_indexdef(ix.indexrelid) AS definition,
-            obj_description(i.oid, 'pg_class') AS comment
-        FROM pg_catalog.pg_index ix
-        JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_catalog.pg_class t ON t.oid = ix.indrelid
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace
-        WHERE n.nspname = 'public'
-            AND t.relname = $1
-        ORDER BY i.relname
-        `,
-        [relationName]
-    );
-
-    return result.rows;
-};

package/src/db/relations.mts

@@ -1,35 +0,0 @@
-import type { Pool } from "pg";
-import { groupBy } from "es-toolkit";
-
-export type TRelationType = "partitioned_table" | "table" | "view" | "materialized_view";
-
-export type TRelationInfo = {
-    name: string;
-    type: TRelationType;
-    comment: string | null;
-};
-
-export type TGroupedRelations = Record<TRelationType, TRelationInfo[]>;
-
-export const fetchPublicRelations = async (pool: Pool): Promise<TGroupedRelations> => {
-    const result = await pool.query<TRelationInfo>(`
-        SELECT relname AS name,
-            CASE relkind
-                WHEN 'p' THEN 'partitioned_table'
-                WHEN 'r' THEN 'table'
-                WHEN 'v' THEN 'view'
-                WHEN 'm' THEN 'materialized_view'
-            END AS type,
-            obj_description(oid, 'pg_class') AS comment
-        FROM pg_catalog.pg_class
-        WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
-            AND (
-                relkind = 'p'
-                OR (relkind = 'r' AND NOT relispartition)
-                OR relkind IN ('v', 'm')
-            )
-        ORDER BY type, name
-    `);
-
-    return groupBy(result.rows, (row) => row.type) as TGroupedRelations;
-};

package/src/db/stats.mts

@@ -1,51 +0,0 @@
-import type { Pool } from "pg";
-
-export type TAttributeStats = {
-    attribute_name: string;
-    estimated_distinct: number;
-};
-
-export type TRelationStats = {
-    relation_name: string;
-    estimated_row_count: number;
-    attributes: TAttributeStats[];
-};
-
-export const fetchRelationStats = async (pool: Pool, relationName: string): Promise<TRelationStats> => {
-    const result = await pool.query<TAttributeStats & { relation_name: string; estimated_row_count: number }>(
-        `
-        SELECT
-            s.tablename AS relation_name,
-            c.reltuples::bigint AS estimated_row_count,
-            s.attname AS attribute_name,
-            CASE
-                WHEN s.n_distinct > 0 THEN s.n_distinct
-                ELSE abs(s.n_distinct) * c.reltuples
-            END::bigint AS estimated_distinct
-        FROM pg_catalog.pg_stats s
-        JOIN pg_catalog.pg_class c ON c.relname = s.tablename
-        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace AND n.nspname = s.schemaname
-        WHERE s.schemaname = 'public'
-            AND s.tablename = $1
-        ORDER BY s.attnum
-        `,
-        [relationName]
-    );
-
-    if (result.rows.length === 0) {
-        return {
-            relation_name: relationName,
-            estimated_row_count: 0,
-            attributes: [],
-        };
-    }
-
-    return {
-        relation_name: result.rows[0].relation_name,
-        estimated_row_count: result.rows[0].estimated_row_count,
-        attributes: result.rows.map(({ attribute_name, estimated_distinct }) => ({
-            attribute_name,
-            estimated_distinct,
-        })),
-    };
-};

package/src/db/version.mts

@@ -1,34 +0,0 @@
-import type { Pool } from "pg";
-
-export type TPostgresVersion = {
-    version: string;
-    version_num: number;
-};
-
-export const fetchPostgresVersion = async (pool: Pool): Promise<TPostgresVersion> => {
-    const result = await pool.query<TPostgresVersion>(`
-        SELECT
-            current_setting('server_version') AS version,
-            current_setting('server_version_num')::int AS version_num
-    `);
-
-    return result.rows[0];
-};
-
-export type TDatabaseIdentifier = {
-    system_identifier: string;
-    database_oid: number;
-    database_name: string;
-};
-
-export const fetchDatabaseIdentifier = async (pool: Pool): Promise<TDatabaseIdentifier> => {
-    const result = await pool.query<TDatabaseIdentifier>(`
-        SELECT
-            system_identifier::text AS system_identifier,
-            (SELECT oid::int FROM pg_database WHERE datname = current_database()) AS database_oid,
-            current_database() AS database_name
-        FROM pg_control_system()
-    `);
-
-    return result.rows[0];
-};

package/src/index.mts

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { render } from "ink";
-import { Error } from "./components/Error.js";
-import { App, type TConnectionConfig } from "./App.js";
-import { validatePathOptions, type TPathValidationError } from "./validatePaths.mjs";
-
-export type TSSLMode = "disable" | "allow" | "prefer" | "require" | "verify-ca" | "verify-full";
-
-export interface ConnectionOptions {
-    hostname?: string;
-    port?: number;
-    database?: string;
-    username?: string;
-    sslmode?: TSSLMode;
-    sslcert?: string;
-    sslkey?: string;
-    sslrootcert?: string;
-    sshHost?: string;
-    sshPort?: number;
-    sshUsername?: string;
-    sshPrivateKey?: string;
-}
-
-const program = new Command();
-
-program
-    .name("dbctx")
-    .description("AI generated docs from your application database")
-    .version("1.0.0")
-    .argument("[connection-string]", "PostgreSQL connection string (env: DATABASE_URL)")
-    .option("-h, --hostname <host>", "database hostname (env: PGHOST, default: localhost)")
-    .option("-p, --port <port>", "database port (env: PGPORT, default: 5432)", parseInt)
-    .option("-d, --database <name>", "database name (env: PGDATABASE, default: postgres)")
-    .option("-U, --username <user>", "database username (env: PGUSER, default: postgres)")
-    .option("--sslmode <mode>", "SSL mode: disable|allow|prefer|require|verify-ca|verify-full (env: PGSSLMODE, default: prefer)")
-    .option("--sslcert <path>", "path to client certificate (env: PGSSLCERT)")
-    .option("--sslkey <path>", "path to client private key (env: PGSSLKEY)")
-    .option("--sslrootcert <path>", "path to root CA certificate (env: PGSSLROOTCERT)")
-    .option("--ssh-host <host>", "SSH tunnel host (bastion/jump server)")
-    .option("--ssh-port <port>", "SSH tunnel port (default: 22)", parseInt)
-    .option("--ssh-username <user>", "SSH tunnel username (default: $USER)")
-    .option("--ssh-private-key <path>", "path to SSH private key (default: ~/.ssh/id_rsa)")
-    .action((connectionString: string | undefined, options: ConnectionOptions) => {
-        const hasConnectionString = Boolean(connectionString);
-        const hasIndividualOptions = Boolean(
-            options.hostname || options.port || options.database || options.username
-        );
-
-        if (hasConnectionString && hasIndividualOptions) {
-            render(
-                Error({
-                    message:
-                        "Cannot use both connection string and individual options (-h, -p, -d, -U). Use one or the other.",
-                })
-            );
-
-            process.exit(1);
-        }
-
-        // Validate path options exist on filesystem
-        const { errors: pathErrors, expandedPaths } = validatePathOptions(options);
-
-        if (pathErrors.length > 0) {
-            const errorMessages = pathErrors
-                .map(({ option, path }: TPathValidationError) => `  ${option}: ${path}`)
-                .join("\n");
-
-            render(
-                Error({
-                    message: `The following paths do not exist:\n${errorMessages}`,
-                })
-            );
-
-            process.exit(1);
-        }
-
-        // Replace original paths with expanded paths (~ resolved to home directory)
-        const validatedOptions: ConnectionOptions = {
-            ...options,
-            ...expandedPaths,
-        };
-
-        if (hasIndividualOptions) {
-            const requiredOptions = [
-                { key: "hostname", flag: "-h/--hostname" },
-                { key: "port", flag: "-p/--port" },
-                { key: "database", flag: "-d/--database" },
-                { key: "username", flag: "-U/--username" },
-            ] as const;
-
-            const missing = requiredOptions
-                .filter(({ key }) => !validatedOptions[key])
-                .map(({ flag }) => flag);
-
-            if (missing.length > 0) {
-                render(
-                    Error({
-                        message: `Missing required options: ${missing.join(", ")}`,
-                    })
-                );
-
-                process.exit(1);
-            }
-        }
-
-        // All validations passed - build config and render the app
-        const config: TConnectionConfig = {
-            connectionString,
-            ...validatedOptions,
-        };
-
-        render(App({ config }));
-    });
-
-program.parse();

package/src/logger.mts

@@ -1,10 +0,0 @@
-import winston from 'winston';
-
-export const logger = winston.createLogger({
-    level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
-    format: winston.format.combine(
-        winston.format.timestamp(),
-        winston.format.json(),
-    ),
-    transports: [new winston.transports.Console()],
-});

package/src/schemas/index.mts

@@ -1,102 +0,0 @@
-import {z} from 'zod';
-
-const relationAttribute = z
-    .object({
-        name: z.string(),
-        data_type: z.string(),
-        is_nullable: z.boolean(),
-        comment: z.string().nullable(),
-    })
-    .and(
-        z.discriminatedUnion('kind', [
-            z.discriminatedUnion('has_default', [
-                z.object({
-                    kind: z.literal('regular'),
-                    has_default: z.literal(false),
-                }),
-                z.object({
-                    kind: z.literal('regular'),
-                    has_default: z.literal(true),
-                    default_expression: z.string(),
-                }),
-            ]),
-            z.object({
-                kind: z.literal('generated'),
-                generated_storage: z.enum(['stored', 'virtual']),
-                generated_expression: z.string(),
-            }),
-        ]),
-    );
-
-const indexInfo = z
-    .object({
-        index_name: z.string(),
-        relation_name: z.string(),
-        attributes: z.array(z.string()),
-        definition: z.string(),
-        comment: z.string().nullable(),
-    })
-    .and(
-        z.discriminatedUnion('index_kind', [
-            z.object({ index_kind: z.literal('primary') }),
-            z.object({ index_kind: z.literal('unique') }),
-            z.object({
-                index_kind: z.literal('exclusion'),
-                exclusion_operators: z.array(z.string()),
-            }),
-            z.object({ index_kind: z.literal('plain') }),
-        ]),
-    )
-    .and(
-        z.discriminatedUnion('is_partial', [
-            z.object({ is_partial: z.literal(false) }),
-            z.object({
-                is_partial: z.literal(true),
-                partial_predicate: z.string(),
-            }),
-        ]),
-    );
-
-const reference = z.object({
-    constraint_name: z.string(),
-    attributes: z.array(z.string()),
-    referenced_relation: z.string(),
-    referenced_attributes: z.array(z.string()),
-    on_update: z.enum([
-        'NO ACTION',
-        'RESTRICT',
-        'CASCADE',
-        'SET NULL',
-        'SET DEFAULT',
-    ]),
-    on_delete: z.enum([
-        'NO ACTION',
-        'RESTRICT',
-        'CASCADE',
-        'SET NULL',
-        'SET DEFAULT',
-    ]),
-    comment: z.string().nullable(),
-});
-
-const relation = z.object({
-    name: z.string(),
-    comment: z.string().nullable(),
-    kind: z.enum(['partitioned_table', 'table', 'view', 'materialized_view']),
-    summary: z.string().optional(),
-    details: z.string().optional(),
-    attributes: z.record(z.string(), relationAttribute),
-    references: z.record(z.string(), reference),
-    indexes: z.record(z.string(), indexInfo),
-});
-
-const relations = z.record(z.string(), relation);
-
-const database = z.object({
-    type: z.enum(['postgresql']),
-    name: z.string(),
-    comment: z.string().nullable(),
-    summary: z.string().optional(),
-    details: z.string().optional(),
-    relations: relations,
-});

package/src/validatePaths.mts

@@ -1,77 +0,0 @@
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-
-type TPathValidationResult =
-    | { valid: true; expandedPath: string }
-    | { valid: false; error: string };
-
-type TPathOptionKey = "sslcert" | "sslkey" | "sslrootcert" | "sshPrivateKey";
-
-export type TPathValidationError = {
-    option: string;
-    path: string;
-    error: string;
-};
-
-const expandTilde = (path: string): string =>
-    path.startsWith("~/") || path === "~"
-        ? path.replace(/^~/, homedir())
-        : path;
-
-const normalizePath = (path: string): string =>
-    resolve(expandTilde(path));
-
-const validatePathExists = (path: string): TPathValidationResult => {
-    const expandedPath = normalizePath(path);
-
-    return existsSync(expandedPath)
-        ? { valid: true, expandedPath }
-        : { valid: false, error: `Path does not exist: ${path}` };
-};
-
-const PATH_OPTION_LABELS: Record<TPathOptionKey, string> = {
-    sslcert: "--sslcert",
-    sslkey: "--sslkey",
-    sslrootcert: "--sslrootcert",
-    sshPrivateKey: "--ssh-private-key",
-};
-
-export const validatePathOptions = <T extends Partial<Record<TPathOptionKey, string>>>(
-    options: T
-): { errors: TPathValidationError[]; expandedPaths: Partial<Record<TPathOptionKey, string>> } => {
-    const pathKeys: TPathOptionKey[] = ["sslcert", "sslkey", "sslrootcert", "sshPrivateKey"];
-
-    const results = pathKeys
-        .filter((key) => options[key] !== undefined)
-        .map((key) => {
-            const path = options[key] as string;
-            const result = validatePathExists(path);
-
-            return {
-                key,
-                path,
-                result,
-            };
-        });
-
-    const errors = results
-        .filter((r) => !r.result.valid)
-        .map((r) => ({
-            option: PATH_OPTION_LABELS[r.key],
-            path: r.path,
-            error: (r.result as { valid: false; error: string }).error,
-        }));
-
-    const expandedPaths = results
-        .filter((r) => r.result.valid)
-        .reduce(
-            (acc, r) => ({
-                ...acc,
-                [r.key]: (r.result as { valid: true; expandedPath: string }).expandedPath,
-            }),
-            {} as Partial<Record<TPathOptionKey, string>>
-        );
-
-    return { errors, expandedPaths };
-};

package/tsconfig.json

@@ -1,104 +0,0 @@
-{
-    "include": ["./src/**/*", "./src/**/*.json"],
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "nodenext",
-        "rootDir": "./src",
-        "moduleResolution": "nodenext",
-        "outDir": "./dist",
-        "sourceRoot": "./src",
-        "lib": ["ESNext"],
-        /* Visit https://aka.ms/tsconfig.json to read more about this file */
-
-        /* Projects */
-        "incremental": true /* Enable incremental compilation */,
-        "composite": true /* Enable constraints that allow a TypeScript project to be used with project references. */,
-        // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
-        // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
-        // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-        // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-        /* Language and Environment */
-        // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-        "experimentalDecorators": true /* Enable experimental support for TC39 stage 2 draft decorators. */,
-        "emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
-        // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
-        // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-        // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
-        // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
-        // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-        // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-
-        /* Modules */
-
-        // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-        // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-        // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-        // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
-        // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-        // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-        "resolveJsonModule": true /* Enable importing .json files */,
-        // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
-
-        /* JavaScript Support */
-        "allowJs": false /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */,
-        "checkJs": false /* Enable error reporting in type-checked JavaScript files. */,
-        // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
-
-        /* Emit */
-        "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
-        "declarationMap": true /* Create sourcemaps for d.ts files. */,
-        // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-        //     "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-        // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
-
-        // "removeComments": true,                           /* Disable emitting comments. */
-        // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-        // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-        // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
-        // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-        // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-        "inlineSourceMap": true /* Include sourcemap files inside the emitted JavaScript. */,
-        "inlineSources": true /* Include source code in the sourcemaps inside the emitted JavaScript. */,
-        // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-        // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-        // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
-        // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
-        // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-        // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
-        // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-
-        /* Interop Constraints */
-        // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-        "allowSyntheticDefaultImports": true /* Allow 'import x from y' when a module doesn't have a default export. */,
-        "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
-        // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-        "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
-
-        /* Type Checking */
-        "strict": true /* Enable all strict type-checking options. */,
-        // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
-        // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
-        // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-        // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
-        // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-        // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
-        // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
-        // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-        // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
-        // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
-        // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-        // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-        // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-        // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
-        // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-        // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
-        // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-        // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-        /* Completeness */
-        // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-        "skipLibCheck": true,
-        "jsx": "react-jsx"
-    }
-}