@zxsylph/dbml-formatter 1.0.4 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zxsylph/dbml-formatter",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "description": "",
   "files": [
     "bin",

package/src/cli.ts

@@ -6,23 +6,92 @@ import { format } from './formatter/formatter';
 const args = process.argv.slice(2);
 
 if (args.length === 0) {
-    console.error('Usage: dbml-fmt <file>');
+    console.error('Usage: dbml-formatter <file> | --folder <path> [--dry-run]');
     process.exit(1);
 }
 
-const filePath = args[0];
-const absPath = path.resolve(process.cwd(), filePath);
+const folderIndex = args.indexOf('--folder');
+const dryRunIndex = args.indexOf('--dry-run');
+const orderFieldIndex = args.indexOf('--order-field');
+const isDryRun = dryRunIndex !== -1;
+const orderField = orderFieldIndex !== -1;
 
-if (!fs.existsSync(absPath)) {
-    console.error(`File not found: ${absPath}`);
-    process.exit(1);
-}
+if (folderIndex !== -1) {
+    // Folder mode
+    const folderPath = args[folderIndex + 1];
+    if (!folderPath || folderPath.startsWith('--')) {
+        console.error('Error: --folder requires a path argument');
+        process.exit(1);
+    }
 
-try {
-    const content = fs.readFileSync(absPath, 'utf-8');
-    const formatted = format(content);
-    console.log(formatted);
-} catch (error) {
-    console.error('Error formatting file:', error);
-    process.exit(1);
+    const absFolderPath = path.resolve(process.cwd(), folderPath);
+    if (!fs.existsSync(absFolderPath) || !fs.statSync(absFolderPath).isDirectory()) {
+         console.error(`Directory not found: ${absFolderPath}`);
+         process.exit(1);
+    }
+
+    const getDbmlFiles = (dir: string): string[] => {
+        let results: string[] = [];
+        const list = fs.readdirSync(dir);
+        list.forEach(file => {
+            const filePath = path.join(dir, file);
+            const stat = fs.statSync(filePath);
+            if (stat && stat.isDirectory()) {
+                results = results.concat(getDbmlFiles(filePath));
+            } else {
+                if (file.endsWith('.dbml')) {
+                    results.push(filePath);
+                }
+            }
+        });
+        return results;
+    };
+
+    const files = getDbmlFiles(absFolderPath);
+    
+    if (files.length === 0) {
+        console.log(`No .dbml files found in ${absFolderPath}`);
+    } else {
+        files.forEach(file => {
+             try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const formatted = format(content, { orderField });
+                
+                if (isDryRun) {
+                    console.log(`\n--- Dry Run: ${file} ---`);
+                    console.log(formatted);
+                } else {
+                     fs.writeFileSync(file, formatted, 'utf-8');
+                     console.log(`Formatted: ${file}`);
+                }
+             } catch (err) {
+                 console.error(`Error formatting ${file}:`, err);
+             }
+        });
+    }
+
+} else {
+    // Single file mode
+    const filePath = args[0];
+    
+    if (filePath.startsWith('--')) {
+         console.error('Usage: dbml-formatter <file> | --folder <path> [--dry-run]');
+         process.exit(1);
+    }
+
+    const absPath = path.resolve(process.cwd(), filePath);
+
+    if (!fs.existsSync(absPath)) {
+        console.error(`File not found: ${absPath}`);
+        process.exit(1);
+    }
+
+    try {
+        const content = fs.readFileSync(absPath, 'utf-8');
+        const formatted = format(content, { orderField });
+        console.log(formatted);
+    } catch (error) {
+        console.error('Error formatting file:', error);
+        process.exit(1);
+    }
 }

package/src/formatter/formatter.ts

@@ -3,6 +3,7 @@ import { Token, TokenType, tokenize } from './tokenizer';
 export interface FormatterOptions {
     indentSize?: number;
     useTabs?: boolean;
+    orderField?: boolean;
 }
 
 export function format(input: string, options: FormatterOptions = {}): string {
@@ -161,6 +162,91 @@ export function format(input: string, options: FormatterOptions = {}): string {
                      } else {
                          output += '\n\n';
                      }
+                 } else {
+                     // NEW: If no table note, add empty Note: ""
+                     output += getIndent() + 'Note: ""\n\n';
+                 }
+
+                 // OPTIONAL: Sort Fields within groups
+                 if (options.orderField) {
+                     // 1. Normalize groups: Detach "Gap" (extra newlines) from content lines.
+                     // If a line ends with > 1 newline, split it into [ContentLine] + [EmptyLine]s.
+                     
+                     const normalized: Token[][] = [];
+                     
+                     for (const line of otherLinesGroups) {
+                         const last = line[line.length - 1];
+                         let hasExtraNewline = false;
+                         
+                         if (last && last.type === TokenType.Whitespace) {
+                             const newlineCount = (last.value.match(/\n/g) || []).length;
+                             if (newlineCount > 1) {
+                                  hasExtraNewline = true;
+                                  
+                                  // Create stripped line (1 newline)
+                                  const newLineTokens = [...line];
+                                  newLineTokens[newLineTokens.length - 1] = { 
+                                      ...last, 
+                                      value: last.value.replace(/\n+/g, '\n') 
+                                  };
+                                  normalized.push(newLineTokens);
+                                  
+                                  // Add spacer lines
+                                  for(let k=1; k < newlineCount; k++) {
+                                      normalized.push([{ type: TokenType.Whitespace, value: '\n', line: 0, column: 0 }]);
+                                  }
+                             }
+                         }
+                         
+                         if (!hasExtraNewline) {
+                             normalized.push(line);
+                         }
+                     }
+                     
+                     // Replace otherLinesGroups with normalized version
+                     otherLinesGroups.splice(0, otherLinesGroups.length, ...normalized);
+
+                     // 2. Group lines by "is content" and Sort
+                     
+                     // Helper to check if line is content
+                     const isContentLine = (line: Token[]) => {
+                         const m = line.filter(x => x.type !== TokenType.Whitespace && x.type !== TokenType.Comment);
+                         return m.length > 0;
+                     };
+                     
+                     let i = 0;
+                     while(i < otherLinesGroups.length) {
+                         if (isContentLine(otherLinesGroups[i])) {
+                             // Start of a block
+                             let j = i + 1;
+                             while(j < otherLinesGroups.length && isContentLine(otherLinesGroups[j])) {
+                                 j++;
+                             }
+                             // Range [i, j) is a content block to sort
+                             const block = otherLinesGroups.slice(i, j);
+                             // Sort block
+                             block.sort((a, b) => {
+                                 const getFirstWord = (toks: Token[]) => {
+                                     const t = toks.find(x => x.type === TokenType.Word || x.type === TokenType.String);
+                                     return t ? t.value.replace(/^"|"$/g, '').toLowerCase() : '';
+                                 };
+                                 const wa = getFirstWord(a);
+                                 const wb = getFirstWord(b);
+                                 if (wa < wb) return -1;
+                                 if (wa > wb) return 1;
+                                 return 0;
+                             });
+                             
+                             // Put back
+                             for(let k=0; k<block.length; k++) {
+                                 otherLinesGroups[i+k] = block[k];
+                             }
+                             
+                             i = j;
+                         } else {
+                             i++;
+                         }
+                     }
                  }
                  
                  // 5. Print other lines (Process Fields)
@@ -221,7 +307,88 @@ export function format(input: string, options: FormatterOptions = {}): string {
                          }
                      }
                      
-                     // 6. Apply "Quote Data Types" logic
+                     // 6. Apply "Empty Field Note" logic
+                     const meaningful = lineTokens.filter(t => t.type !== TokenType.Whitespace && t.type !== TokenType.Comment);
+                     // Heuristic: Is this a field? 
+                     // It should have at least 2 tokens (Name, Type). 
+                     // It should NOT be 'indexes'.
+                     // It should NOT contain '{' (which would imply a block start like indexes { )
+                     
+                     let isField = false;
+                     if (meaningful.length >= 2) {
+                         const firstWord = meaningful[0].value.toLowerCase();
+                         if (firstWord !== 'indexes' && firstWord !== 'note') {
+                              // Check for braces in original lineTokens to avoid sub-blocks
+                              const hasBrace = lineTokens.some(t => t.type === TokenType.Symbol && t.value === '{');
+                              if (!hasBrace) {
+                                  isField = true;
+                              }
+                         }
+                     }
+                     
+                     if (isField) {
+                         // Find settings block
+                         let openBracketIdx = -1;
+                         let closeBracketIdx = -1;
+                         for(let idx=0; idx<lineTokens.length; idx++) {
+                             if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === '[') openBracketIdx = idx;
+                             if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === ']') closeBracketIdx = idx;
+                         }
+                         
+                         if (openBracketIdx !== -1 && closeBracketIdx !== -1 && closeBracketIdx > openBracketIdx) {
+                             // Settings exist. Check if 'note' is present.
+                             const inside = lineTokens.slice(openBracketIdx + 1, closeBracketIdx);
+                             let hasNote = false;
+                             
+                             // Simple token scan for 'note' word
+                             // Ideally we should parse comma groups, but 'note' keyword is reserved in settings.
+                             for (const t of inside) {
+                                 if (t.type === TokenType.Word && t.value.toLowerCase() === 'note') {
+                                     hasNote = true;
+                                     break;
+                                 }
+                             }
+                             
+                             if (!hasNote) {
+                                 // Insert `note: ""` at the beginning of settings
+                                 // We need to insert: "note", ":", "\"\"", ","
+                                 // REMOVED explicit spaces
+                                 const newTokens: Token[] = [
+                                     { type: TokenType.Word, value: 'note', line: 0, column: 0 },
+                                     { type: TokenType.Symbol, value: ':', line: 0, column: 0 },
+                                     { type: TokenType.String, value: '""', line: 0, column: 0 },
+                                     { type: TokenType.Symbol, value: ',', line: 0, column: 0 }
+                                 ];
+                                 lineTokens.splice(openBracketIdx + 1, 0, ...newTokens);
+                             }
+                         } else {
+                             // No settings exist. Append ` [note: ""]`.
+                             // REMOVED explicit spaces
+                             
+                             // Find last meaningful token index
+                             let lastMeaningfulIdx = -1;
+                             for (let idx = lineTokens.length - 1; idx >= 0; idx--) {
+                                 if (lineTokens[idx].type !== TokenType.Whitespace && lineTokens[idx].type !== TokenType.Comment) {
+                                     lastMeaningfulIdx = idx;
+                                     break;
+                                 }
+                             }
+                             
+                             if (lastMeaningfulIdx !== -1) {
+                                 const appendTokens: Token[] = [
+                                     { type: TokenType.Symbol, value: '[', line: 0, column: 0 },
+                                     { type: TokenType.Word, value: 'note', line: 0, column: 0 },
+                                     { type: TokenType.Symbol, value: ':', line: 0, column: 0 },
+                                     { type: TokenType.String, value: '""', line: 0, column: 0 },
+                                     { type: TokenType.Symbol, value: ']', line: 0, column: 0 }
+                                 ];
+                                 lineTokens.splice(lastMeaningfulIdx + 1, 0, ...appendTokens);
+                             }
+                         }
+                     }
+
+                     // 7. Apply "Quote Data Types" logic
+
                     let wordCount = 0;
                     for (const t of lineTokens) {
                          // Only count words before `[`?

package/src/repro_field_issue.ts

@@ -0,0 +1,34 @@
+import { format } from './formatter/formatter';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const filePath = path.join(__dirname, '../test_folder/repro_empty_note_field.dbml');
+const content = fs.readFileSync(filePath, 'utf-8');
+
+const formatted = format(content);
+
+console.log('--- Formatted Output ---');
+console.log(formatted);
+
+// Robust check:
+// We just check if the output contains `Note: ""` or `note: ""` for each field name.
+// Since the output might be multiline, we can't just filter lines.
+// We scan the text.
+
+const requiredFields = ['id', 'username', 'email'];
+let allPresent = true;
+
+// Just check globally if we have 3 empty notes + the table note?
+// Table note is also `Note: ""`
+// So we expect 4 `Note: ""` or `note: ""`
+const matches = formatted.match(/Note:\s*""/gi);
+const count = matches ? matches.length : 0;
+
+console.log(`Found ${count} empty notes.`);
+
+if (count >= 4) { // 1 for table + 3 for fields
+    console.log('SUCCESS: Empty notes added to fields.');
+} else {
+    console.error('FAILURE: Empty notes NOT added to fields (or not enough).');
+    process.exit(1);
+}

package/src/repro_issue.ts

@@ -0,0 +1,18 @@
+import { format } from './formatter/formatter';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const filePath = path.join(__dirname, '../test_folder/repro_empty_note.dbml');
+const content = fs.readFileSync(filePath, 'utf-8');
+
+const formatted = format(content);
+
+console.log('--- Formatted Output ---');
+console.log(formatted);
+
+if (formatted.includes('Note: ""')) {
+    console.log('SUCCESS: Empty note added.');
+} else {
+    console.error('FAILURE: Empty note NOT added.');
+    process.exit(1);
+}