@zxsylph/dbml-formatter 1.0.4 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zxsylph/dbml-formatter",
-  "version": "1.0.4",
+  "version": "1.0.10",
   "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, addNote: args.includes('--add-note') });
+                
+                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, addNote: args.includes('--add-note') });
+        console.log(formatted);
+    } catch (error) {
+        console.error('Error formatting file:', error);
+        process.exit(1);
+    }
 }

package/src/formatter/formatter.ts

@@ -3,6 +3,8 @@ import { Token, TokenType, tokenize } from './tokenizer';
 export interface FormatterOptions {
     indentSize?: number;
     useTabs?: boolean;
+    orderField?: boolean;
+    addNote?: boolean;
 }
 
 export function format(input: string, options: FormatterOptions = {}): string {
@@ -143,6 +145,21 @@ export function format(input: string, options: FormatterOptions = {}): string {
                          otherLinesGroups.push(currentGroup);
                      }
                  }
+
+                 // NEW: Trim leading and trailing empty lines (whitespace-only groups) from otherLinesGroups
+                 // Note: we do not touch tableNoteTokens here.
+                 
+                 const isWhitespaceGroup = (g: Token[]) => g.every(t => t.type === TokenType.Whitespace);
+                 
+                 // Trim start
+                 while (otherLinesGroups.length > 0 && isWhitespaceGroup(otherLinesGroups[0])) {
+                     otherLinesGroups.shift();
+                 }
+                 
+                 // Trim end
+                 while (otherLinesGroups.length > 0 && isWhitespaceGroup(otherLinesGroups[otherLinesGroups.length - 1])) {
+                     otherLinesGroups.pop();
+                 }
                  
                  // 4. Print Table Note first (if exists)
                  if (tableNoteTokens.length > 0) {
@@ -161,9 +178,98 @@ export function format(input: string, options: FormatterOptions = {}): string {
                      } else {
                          output += '\n\n';
                      }
+                 } else {
+                     // NEW: If no table note, add empty Note: ""
+                     if (options.addNote) {
+                        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)
+                 // 5. Process Fields (Transform -> Align -> Print)
+                 
+                 // 5a. Transformation Pass
                  for (let lgIdx = 0; lgIdx < otherLinesGroups.length; lgIdx++) {
                      const lineTokens = otherLinesGroups[lgIdx];
                      // Check for Field Settings `[...]` reordering
@@ -221,7 +327,85 @@ export function format(input: string, options: FormatterOptions = {}): string {
                          }
                      }
                      
-                     // 6. Apply "Quote Data Types" logic
+                     // 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 && options.addNote) {
+                          // 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", ":", "\"\"", ","
+                                  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: ""]`.
+                              
+                              // 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);
+                              }
+                          }
+                      }
+
+                     // Apply "Quote Data Types" logic
                     let wordCount = 0;
                     for (const t of lineTokens) {
                          // Only count words before `[`?
@@ -231,39 +415,148 @@ export function format(input: string, options: FormatterOptions = {}): string {
                              if (wordCount === 2) {
                                  // Quote this token!
                                  t.value = `"${t.value}"`; 
-                                 // Note: we are modifying the token object directly in the buffer.
                              }
                          }
                          if (t.type === TokenType.String && wordCount < 2) { 
-                             // Strings count as words/tokens for position?
-                             // Example `name "varchar"` -> "varchar" IS the string.
                              wordCount++; 
                          }
                     }
+                 }
 
-                    // Ensure previous line enforced newline if missing?
-                    // processTokens appends tokens. If tokens lack newline, it might merge?
-                    // `lineTokens` usually comes from `currentGroup` which ended with newline token (except last one).
-                    // If last group lacks newline, and we print next group...
-                    
-                    // Check if output buffer needs separation?
-                    // processTokens logic respects local newlines inside `lineTokens`.
-                    // But if `lineTokens` (last group) didn't have newline, we append.
-                    
-                    output += processTokens(lineTokens, indentLevel, indentChar, indentSize, true);
-                    
-                    // Heuristic: If we just printed a line group, and it didn't generate a newline at end,
-                    // AND there is another group coming, insert newline?
-                    // But `processTokens` output might end with proper indent? No.
+                 // 5b. Alignment Pass
+                 const isFieldLine = (tokens: Token[]) => {
+                     const m = tokens.filter(t => t.type !== TokenType.Whitespace && t.type !== TokenType.Comment);
+                     if (m.length < 2) return false;
+                     const first = m[0].value.toLowerCase();
+                     if (first === 'indexes' || first === 'note') return false;
+                     if (tokens.some(t => t.type === TokenType.Symbol && t.value === '{')) return false;
+                     return true;
+                 };
+
+                 const alignFieldBlock = (blockLines: Token[][]) => {
+                     // 1. Collect info suitable for alignment
+                     interface RowInfo {
+                         lineTokens: Token[];
+                         nameTokenIdx: number;
+                         typeStartIdx: number;
+                         typeEndIdx: number; // exclusive
+                         settingsStartIdx: number;
+                         
+                         nameWidth: number;
+                         typeWidth: number;
+                     }
+                     
+                     const rows: RowInfo[] = [];
+                     
+                     for (const line of blockLines) {
+                         // Find Name Token (First meaningful)
+                         let nameIdx = -1;
+                         for(let k=0; k<line.length; k++) {
+                             if (line[k].type !== TokenType.Whitespace && line[k].type !== TokenType.Comment) {
+                                 nameIdx = k;
+                                 break;
+                             }
+                         }
+                         if (nameIdx === -1) continue;
+                         
+                         // Find Settings Start `[`
+                         let settingsIdx = -1;
+                         for(let k=0; k<line.length; k++) {
+                             if (line[k].type === TokenType.Symbol && line[k].value === '[') {
+                                 settingsIdx = k;
+                                 break;
+                             }
+                         }
+                         
+                         // Determine Type Range
+                         // Type is between Name and Settings (or End of Line)
+                         let typeStart = nameIdx + 1;
+                         while(typeStart < line.length && (line[typeStart].type === TokenType.Whitespace || line[typeStart].type === TokenType.Comment)) {
+                             typeStart++;
+                         }
+
+                         let typeEnd = settingsIdx;
+                         if (typeEnd === -1) {
+                             // No settings, type ends at the last meaningful token of the line
+                             let lastMeaningful = -1;
+                             for(let k=line.length-1; k >= 0; k--) {
+                                 if (line[k].type !== TokenType.Whitespace && line[k].type !== TokenType.Comment) {
+                                     lastMeaningful = k;
+                                     break;
+                                 }
+                             }
+                             
+                             if (lastMeaningful > nameIdx) {
+                                 typeEnd = lastMeaningful + 1; // exclusive
+                             } else {
+                                 continue; 
+                             }
+                         }
+                         
+                         if (typeStart >= typeEnd) continue;
+                          
+                         // Calculate Widths
+                         const nameWidth = line[nameIdx].value.length;
+                         
+                         // Dry run type width
+                         const typeTokens = line.slice(typeStart, typeEnd);
+                         const typeStr = processTokens(typeTokens, 0, ' ', 2, false); 
+                         const typeWidth = typeStr.length;
+                         
+                         rows.push({
+                             lineTokens: line,
+                             nameTokenIdx: nameIdx,
+                             typeStartIdx: typeStart,
+                             typeEndIdx: typeEnd,
+                             settingsStartIdx: settingsIdx,
+                             nameWidth,
+                             typeWidth
+                         });
+                     }
+                     
+                     if (rows.length === 0) return;
+                     
+                     // 2. Calc Max Widths
+                     const maxNameWidth = Math.max(...rows.map(r => r.nameWidth));
+                     const maxTypeWidth = Math.max(...rows.map(r => r.typeWidth));
+                     
+                     // 3. Apply Padding
+                     for (const row of rows) {
+                         // Pad Name
+                         const namePad = (maxNameWidth - row.nameWidth) + 1; // +1 for minimum space
+                         const nameTok = row.lineTokens[row.nameTokenIdx];
+                         nameTok.padRight = namePad;
+                         
+                         // Pad Type (Last token of type sequence)
+                         // Only needed if there is something after (settings)
+                         if (row.settingsStartIdx !== -1) {
+                             const typePad = (maxTypeWidth - row.typeWidth) + 1;
+                             // Find the last meaningful token of Type sequence
+                             let lastTypeTokIdx = row.typeEndIdx - 1;
+                             while(lastTypeTokIdx >= row.typeStartIdx && (row.lineTokens[lastTypeTokIdx].type === TokenType.Whitespace || row.lineTokens[lastTypeTokIdx].type === TokenType.Comment)) {
+                                 lastTypeTokIdx--;
+                             }
+                             
+                             if (lastTypeTokIdx >= row.typeStartIdx) {
+                                 row.lineTokens[lastTypeTokIdx].padRight = typePad;
+                             }
+                         }
+                     }
+                 };
+
+                 // Align globally across all lines in the table (ignoring inter-field grouping)
+                 alignFieldBlock(otherLinesGroups);
+
+                 // 5c. Print Pass
+                 for (let lgIdx = 0; lgIdx < otherLinesGroups.length; lgIdx++) {
+                     const lineTokens = otherLinesGroups[lgIdx];
+                     output += processTokens(lineTokens, indentLevel, indentChar, indentSize, true);
                     
-                    // Let's check `output`.
-                    if (lgIdx < otherLinesGroups.length - 1) {
-                        if (!output.endsWith('\n')) {
-                             // This implies the group didn't end with newline token.
-                             // Force it.
-                             output += '\n';
-                        }
-                    }
+                     if (lgIdx < otherLinesGroups.length - 1) {
+                         if (!output.endsWith('\n')) {
+                              output += '\n';
+                         }
+                     }
                  }
                  
                  // End block
@@ -429,12 +722,15 @@ function processTokens(
 ): string {
     
     let localOutput = '';
-    let currentIndentLevel = baseIndentLevel;
     const oneIndent = indentChar.repeat(indentSize);
-    const getLocalIndent = () => oneIndent.repeat(Math.max(0, currentIndentLevel));
     
-    // ... multiline stack and checkArrayMultiline ...
-     const checkArrayMultiline = (startIdx: number): boolean => {
+    // Stack of indentation strings. Start with base indent.
+    const indentStack: string[] = [oneIndent.repeat(Math.max(0, baseIndentLevel))];
+    
+    // Helper to get current indentation
+    const getCurrentIndent = () => indentStack[indentStack.length - 1];
+    
+    const checkArrayMultiline = (startIdx: number): boolean => {
          let depth = 1;
          let hasComma = false;
          for (let k = startIdx + 1; k < tokens.length; k++) {
@@ -467,10 +763,10 @@ function processTokens(
             continue;
         }
 
-        // Corrected Spacing/Indent Logic for processTokens:
+        // Spacing/Indent Logic
         if (localOutput.length === 0 || localOutput.endsWith('\n')) {
              if (token.value !== '}') {
-                 localOutput += getLocalIndent();
+                 localOutput += getCurrentIndent();
              }
         } else {
              // Not start of line
@@ -491,27 +787,69 @@ function processTokens(
              case TokenType.Symbol:
                  if (token.value === '{') {
                       localOutput += '{\n';
-                      currentIndentLevel++;
+                      indentStack.push(getCurrentIndent() + oneIndent);
                  } else if (token.value === '}') {
                       if (!localOutput.endsWith('\n')) localOutput += '\n';
-                      currentIndentLevel--;
-                      localOutput += getLocalIndent() + '}';
+                      if (indentStack.length > 1) indentStack.pop();
+                      localOutput += getCurrentIndent() + '}';
                  } else if (token.value === '[') {
                       const isMultiline = checkArrayMultiline(i);
                       multilineArrayStack.push(isMultiline);
+                      
+                      const preBracketLength = localOutput.length;
+                      const lastNewline = localOutput.lastIndexOf('\n');
+                      
                       localOutput += '[';
+                      
                       if (isMultiline) {
-                          localOutput += '\n';
-                          currentIndentLevel++;
+                          // Calculate visual column for Anchor
+                          let visualColOfBracket = 0;
+                          for(let c=lastNewline + 1; c < preBracketLength; c++) {
+                               if (localOutput[c] === '\t') visualColOfBracket += (indentSize - (visualColOfBracket % indentSize));
+                               else visualColOfBracket += 1;
+                          }
+                          
+                          const anchorIndent = ' '.repeat(visualColOfBracket);
+                          // Push Anchor first (for the closing bracket)
+                          indentStack.push(anchorIndent);
+                          // Push Anchor + Indent (for the content)
+                          indentStack.push(anchorIndent + oneIndent);
+                          
+                          localOutput += '\n'; 
                       }
                  } else if (token.value === ']') {
-                      const isMultiline = multilineArrayStack.pop();
-                      if (isMultiline) {
-                          if (!localOutput.endsWith('\n')) localOutput += '\n';
-                          currentIndentLevel--;
-                          if (localOutput.endsWith('\n')) localOutput += getLocalIndent();
-                      }
-                      localOutput += ']';
+                       const isMultiline = multilineArrayStack.pop();
+                       if (isMultiline) {
+                           // We are currently at Content Indent level (top of stack).
+                           // But for the closing bracket, we want to go back to Anchor Indent level.
+                           
+                           // First, remove Content Indent from stack
+                           indentStack.pop();
+                           
+                           // Now top of stack is Anchor Indent.
+                           const anchorIndent = getCurrentIndent();
+                           
+                           // Check what's currently on the last line.
+                           // The main loop might have already added indentation (Content Indent).
+                           const lastNewline = localOutput.lastIndexOf('\n');
+                           const lastLineFormatted = localOutput.substring(lastNewline + 1);
+                           
+                           if (lastLineFormatted.trim().length === 0) {
+                               // usage-case: The line is empty or just contains the indentation added by the loop.
+                               // We should replace that indentation with our Anchor Indent.
+                               localOutput = localOutput.substring(0, lastNewline + 1) + anchorIndent;
+                           } else {
+                               // There is content on this line. We need a new line.
+                               localOutput += '\n' + anchorIndent;
+                           }
+                           
+                           localOutput += ']';
+                           
+                           // Finally, pop the Anchor Indent so we return to previous base indent
+                           indentStack.pop();
+                       } else {
+                           localOutput += ']';
+                       }
                  } else if (token.value === ',') {
                       localOutput += ',';
                       const currentMultiline = multilineArrayStack.length > 0 && multilineArrayStack[multilineArrayStack.length - 1];
@@ -522,21 +860,21 @@ function processTokens(
                  break;
              
              case TokenType.Word:
-                  // Handle keyword PascalCase in buffer
-                  if (token.value.toLowerCase() === 'table') token.value = 'Table';
-                  if (token.value.toLowerCase() === 'ref') token.value = 'Ref';
-                  if (token.value.toLowerCase() === 'note') {
-                       // Peek locally inside tokens list
-                        let nextIdx = i + 1;
-                        while(nextIdx < tokens.length && (tokens[nextIdx].type === TokenType.Whitespace || tokens[nextIdx].type === TokenType.Comment)) {
-                            nextIdx++;
-                        }
-                        if (nextIdx < tokens.length && tokens[nextIdx].type === TokenType.Symbol && tokens[nextIdx].value === ':') {
-                            token.value = 'Note';
-                        }
-                  }
-                  localOutput += token.value;
-                  break;
+                   // Handle keyword PascalCase
+                   if (token.value.toLowerCase() === 'table') token.value = 'Table';
+                   if (token.value.toLowerCase() === 'ref') token.value = 'Ref';
+                   if (token.value.toLowerCase() === 'note') {
+                        // Peek locally inside tokens list
+                         let nextIdx = i + 1;
+                         while(nextIdx < tokens.length && (tokens[nextIdx].type === TokenType.Whitespace || tokens[nextIdx].type === TokenType.Comment)) {
+                             nextIdx++;
+                         }
+                         if (nextIdx < tokens.length && tokens[nextIdx].type === TokenType.Symbol && tokens[nextIdx].value === ':') {
+                             token.value = 'Note';
+                         }
+                   }
+                   localOutput += token.value;
+                   break;
 
              case TokenType.String:
                 let val = token.value;
@@ -549,8 +887,12 @@ function processTokens(
                 break;
                 
              default:
-                localOutput += token.value;
-                break;
+                  localOutput += token.value;
+                  break;
+        }
+        
+        if (token.padRight) {
+             localOutput += ' '.repeat(token.padRight);
         }
     }
     

package/src/formatter/tokenizer.ts

@@ -12,6 +12,7 @@ export interface Token {
     value: string;
     line: number;
     column: number;
+    padRight?: number;
 }
 
 export function tokenize(input: string): Token[] {

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);
+}