@cuongph.dev/dbdocgen 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,292 @@
+import { z } from 'zod';
+
+type DatabaseDialect = "postgres" | "mysql" | "mariadb" | "sqlite" | "mssql" | "unknown";
+type Confidence = "high" | "medium" | "low";
+type EnrichedText = {
+    value: string;
+    source: "db_comment" | "backend_source" | "ai";
+    confidence: Confidence;
+    needsReview: boolean;
+};
+type WarningDoc = {
+    code: string;
+    message: string;
+    target?: string;
+    severity: "info" | "warning" | "error";
+};
+type ReviewTodo = {
+    type: "table" | "column" | "relationship" | "ai" | "parser";
+    target: string;
+    issue: string;
+    suggestion?: string;
+    source: "schema" | "backend_source" | "ai" | "parser";
+};
+type ColumnDoc = {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: string;
+    isPrimaryKey: boolean;
+    isForeignKey: boolean;
+    comment?: string;
+    description?: EnrichedText;
+};
+type ForeignKeyDoc = {
+    name?: string;
+    columns: string[];
+    referencedTable: string;
+    referencedColumns: string[];
+};
+type IndexDoc = {
+    name: string;
+    table: string;
+    columns: string[];
+    unique: boolean;
+};
+type RelationshipDoc = {
+    fromTable: string;
+    fromColumn: string;
+    toTable: string;
+    toColumn: string;
+    constraintName?: string;
+    source: "schema" | "ai_suggestion";
+    needsReview: boolean;
+};
+type TableDoc = {
+    name: string;
+    schema?: string;
+    comment?: string;
+    description?: EnrichedText;
+    columns: ColumnDoc[];
+    primaryKeys: string[];
+    foreignKeys: ForeignKeyDoc[];
+    indexes: IndexDoc[];
+    reviewTodos: ReviewTodo[];
+};
+type DatabaseDoc = {
+    dialect: DatabaseDialect;
+    tables: TableDoc[];
+    relationships: RelationshipDoc[];
+    indexes: IndexDoc[];
+    warnings: WarningDoc[];
+};
+
+declare const databaseDocSchema: z.ZodObject<{
+    dialect: z.ZodEnum<{
+        postgres: "postgres";
+        mysql: "mysql";
+        mariadb: "mariadb";
+        sqlite: "sqlite";
+        mssql: "mssql";
+        unknown: "unknown";
+    }>;
+    tables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        schema: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+            source: z.ZodEnum<{
+                db_comment: "db_comment";
+                backend_source: "backend_source";
+                ai: "ai";
+            }>;
+            confidence: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            needsReview: z.ZodBoolean;
+        }, z.core.$strip>>;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            nullable: z.ZodBoolean;
+            defaultValue: z.ZodOptional<z.ZodString>;
+            isPrimaryKey: z.ZodBoolean;
+            isForeignKey: z.ZodBoolean;
+            comment: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodObject<{
+                value: z.ZodString;
+                source: z.ZodEnum<{
+                    db_comment: "db_comment";
+                    backend_source: "backend_source";
+                    ai: "ai";
+                }>;
+                confidence: z.ZodEnum<{
+                    high: "high";
+                    medium: "medium";
+                    low: "low";
+                }>;
+                needsReview: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        primaryKeys: z.ZodArray<z.ZodString>;
+        foreignKeys: z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodString>;
+            referencedTable: z.ZodString;
+            referencedColumns: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        indexes: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            table: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            unique: z.ZodBoolean;
+        }, z.core.$strip>>;
+        reviewTodos: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                ai: "ai";
+                table: "table";
+                column: "column";
+                relationship: "relationship";
+                parser: "parser";
+            }>;
+            target: z.ZodString;
+            issue: z.ZodString;
+            suggestion: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                backend_source: "backend_source";
+                ai: "ai";
+                parser: "parser";
+                schema: "schema";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        fromTable: z.ZodString;
+        fromColumn: z.ZodString;
+        toTable: z.ZodString;
+        toColumn: z.ZodString;
+        constraintName: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            schema: "schema";
+            ai_suggestion: "ai_suggestion";
+        }>;
+        needsReview: z.ZodBoolean;
+    }, z.core.$strip>>;
+    indexes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        table: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        unique: z.ZodBoolean;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            error: "error";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare const outputFormatSchema: z.ZodEnum<{
+    excel: "excel";
+    markdown: "markdown";
+    html: "html";
+    diagram: "diagram";
+    word: "word";
+}>;
+declare const outputLanguageSchema: z.ZodEnum<{
+    en: "en";
+    jp: "jp";
+}>;
+declare const dbdocgenConfigSchema: z.ZodObject<{
+    schema: z.ZodDefault<z.ZodString>;
+    dialect: z.ZodOptional<z.ZodEnum<{
+        postgres: "postgres";
+        mysql: "mysql";
+        mariadb: "mariadb";
+        sqlite: "sqlite";
+        mssql: "mssql";
+        unknown: "unknown";
+    }>>;
+    outDir: z.ZodDefault<z.ZodString>;
+    output: z.ZodDefault<z.ZodObject<{
+        formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            excel: "excel";
+            markdown: "markdown";
+            html: "html";
+            diagram: "diagram";
+            word: "word";
+        }>>>;
+        language: z.ZodDefault<z.ZodEnum<{
+            en: "en";
+            jp: "jp";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type OutputFormat = z.infer<typeof outputFormatSchema>;
+type OutputLanguage = z.infer<typeof outputLanguageSchema>;
+type DbdocgenConfig = z.infer<typeof dbdocgenConfigSchema>;
+
+type CliConfigOptions = {
+    schema?: string;
+    dialect?: "postgres" | "mysql" | "mariadb" | "sqlite" | "mssql" | "unknown";
+    outDir?: string;
+    formats?: OutputFormat[];
+    configPath?: string;
+};
+type LoadConfigInput = {
+    cwd: string;
+    cliOptions: CliConfigOptions;
+};
+declare function loadConfig(input: LoadConfigInput): Promise<DbdocgenConfig>;
+
+type ParseSqlSchemaOptions = {
+    dialect?: DatabaseDialect;
+};
+declare function parseSqlSchema(sql: string, options?: ParseSqlSchemaOptions): Promise<DatabaseDoc>;
+
+type ExportOptions = {
+    outDir: string;
+    language?: OutputLanguage;
+};
+declare function exportExcelDictionary(doc: DatabaseDoc, options: ExportOptions): Promise<void>;
+
+type DiagramExportOptions = {
+    outDir: string;
+};
+declare function exportMermaidDiagram(doc: DatabaseDoc, options: DiagramExportOptions): Promise<void>;
+declare function renderMermaid(doc: DatabaseDoc): string;
+
+type MarkdownExportOptions = {
+    outDir: string;
+    language?: OutputLanguage;
+};
+declare function exportMarkdownDocs(doc: DatabaseDoc, options: MarkdownExportOptions): Promise<void>;
+
+type HtmlExportOptions = {
+    outDir: string;
+    language?: OutputLanguage;
+};
+declare function exportHtmlDocs(doc: DatabaseDoc, options: HtmlExportOptions): Promise<void>;
+
+type WordExportOptions = {
+    outDir: string;
+    language?: OutputLanguage;
+};
+declare function exportWordDocument(doc: DatabaseDoc, options: WordExportOptions): Promise<void>;
+
+type GenerateDbDocsOptions = {
+    schema: string;
+    outDir: string;
+    dialect?: DatabaseDialect;
+    output: {
+        formats: OutputFormat[];
+        language?: OutputLanguage;
+    };
+    onProgress?: (event: {
+        step: string;
+        message: string;
+        detail?: Record<string, unknown>;
+    }) => void;
+};
+declare function generateDbDocs(options: GenerateDbDocsOptions): Promise<DatabaseDoc>;
+
+declare const version = "0.1.0";
+
+export { type ColumnDoc, type Confidence, type DatabaseDialect, type DatabaseDoc, type DbdocgenConfig, type EnrichedText, type ForeignKeyDoc, type GenerateDbDocsOptions, type IndexDoc, type OutputFormat, type RelationshipDoc, type ReviewTodo, type TableDoc, type WarningDoc, databaseDocSchema, exportExcelDictionary, exportHtmlDocs, exportMarkdownDocs, exportMermaidDiagram, exportWordDocument, generateDbDocs, loadConfig, parseSqlSchema, renderMermaid, version };