@zxsylph/dbml-formatter 1.0.10 → 1.0.12

package/README.md

@@ -0,0 +1,94 @@
+# @zxsylph/dbml-formatter
+
+A powerful and flexible formatter for [DBML (Database Markup Language)](https://dbml.dbdiagram.io/home/) files. This tool helps keep your DBML schemas clean, consistent, and readable by applying standard formatting rules, alignment, and optional enhancements.
+
+## Features
+
+- **Standard Formatting**: Applies consistent spacing and indentation to tables, fields, indexes, and relationships.
+- **Alignment**:
+  - Automatically aligns field data types for better readability.
+  - Aligns field settings (e.g., `[pk, increment]`) for a clean columnar look.
+- **Field Sorting** (Optional): Sorts fields within groups alphabetically.
+- **Note Management** (Optional): Automatically adds empty notes to fields and tables if they are missing.
+- **Batch Processing**: Supports formatting individual files or entire directories recursively.
+- **Dry Run**: Preview changes without modifying files.
+
+## Installation
+
+You can use the formatter directly via `npx` without installation:
+
+```bash
+npx @zxsylph/dbml-formatter <file-or-options>
+```
+
+Or install it globally:
+
+```bash
+npm install -g @zxsylph/dbml-formatter
+```
+
+## Usage
+
+### Format a Single File
+
+Prints the formatted result to `stdout`.
+
+```bash
+npx @zxsylph/dbml-formatter schema.dbml
+```
+
+### Format a Directory
+
+Formats all `.dbml` files in the specified directory (and subdirectories) **in place**.
+
+```bash
+npx @zxsylph/dbml-formatter --folder ./database
+```
+
+### Options & Flags
+
+| Flag              | Description                                                                                    |
+| ----------------- | ---------------------------------------------------------------------------------------------- |
+| `--folder <path>` | Specifies a directory to recursively find and format `.dbml` files. Updates files in place.    |
+| `--dry-run`       | Use with `--folder` to preview formatting changes in the console instead of overwriting files. |
+| `--order-field`   | Sorts fields within their logical groups (separated by blank lines) in ascending order.        |
+| `--add-note`      | Automatically adds `Note: ''` to tables and fields that don't have one.                        |
+
+### Examples
+
+**1. Basic file formatting (output to console):**
+
+```bash
+npx @zxsylph/dbml-formatter schema.dbml > formatted_schema.dbml
+```
+
+**2. Format an entire project directory:**
+
+```bash
+npx @zxsylph/dbml-formatter --folder ./src/db
+```
+
+**3. Format with field sorting and extra notes:**
+
+```bash
+npx @zxsylph/dbml-formatter --folder ./src/db --order-field --add-note
+```
+
+**4. Preview changes for a folder:**
+
+```bash
+npx @zxsylph/dbml-formatter --folder ./src/db --dry-run
+```
+
+## Formatting Rules
+
+The formatter applies the following styles:
+
+- **Indentation**: 2 spaces.
+- **Spacing**: Removes extra empty lines inside table bodies.
+- **Alignment**: Vertically aligns data types and column settings `[...]`.
+- **Hoisting**: Moves table-level notes to the top of the table definition.
+
+## License
+
+ISC

package/package.json

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

package/src/formatter/formatter.ts

@@ -185,44 +185,46 @@ export function format(input: string, options: FormatterOptions = {}): string {
                      }
                  }
 
+                 // OPTIONAL: Sort Fields within groups
+                 // 1. Normalize groups: Detach "Gap" (extra newlines) from content lines.
+                 {
+                      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);
+                 }
+
                  // 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
                      
@@ -544,8 +546,23 @@ export function format(input: string, options: FormatterOptions = {}): string {
                      }
                  };
 
-                 // Align globally across all lines in the table (ignoring inter-field grouping)
-                 alignFieldBlock(otherLinesGroups);
+                 // Align by grouping (split by empty lines)
+                 let currentBlock: Token[][] = [];
+                 for (const line of otherLinesGroups) {
+                     const isWhitespace = line.every(t => t.type === TokenType.Whitespace);
+                     // console.log('Line tokens:', line.map(t => t.type + ':' + JSON.stringify(t.value)), 'isWhitespace:', isWhitespace);
+                     if (isWhitespace) {
+                         if (currentBlock.length > 0) {
+                             alignFieldBlock(currentBlock);
+                             currentBlock = [];
+                         }
+                     } else {
+                         currentBlock.push(line);
+                     }
+                 }
+                 if (currentBlock.length > 0) {
+                     alignFieldBlock(currentBlock);
+                 }
 
                  // 5c. Print Pass
                  for (let lgIdx = 0; lgIdx < otherLinesGroups.length; lgIdx++) {

package/src/repro_alignment.ts

@@ -0,0 +1,33 @@
+import { format } from "./formatter/formatter";
+import * as assert from "assert";
+
+const input = `Table users {
+  id integer
+  username varchar
+
+  email varchar
+  created_at timestamp
+}`;
+
+const expected = `Table users {
+  id       "integer"
+  username "varchar"
+
+  email      "varchar"
+  created_at "timestamp"
+}
+`;
+
+const actual = format(input);
+
+console.log("Expected:");
+console.log(expected);
+console.log("Actual:");
+console.log(actual);
+
+if (actual === expected) {
+  console.log("Test Passed");
+} else {
+  console.error("Test Failed");
+  process.exit(1);
+}