dbctx 1.0.0

package/src/db/foreign-keys.mts

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,116 @@
+#!/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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,104 @@
+{
+    "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"
+    }
+}