prettier-plugin-tsql 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mike Schall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+# prettier-plugin-tsql
+
+> **Alpha quality — do not use in production. Use at your own risk.**
+
+A [Prettier](https://prettier.io) plugin that formats T-SQL (SQL Server) using Microsoft's official `Microsoft.SqlServer.TransactSql.ScriptDom` parser — the same parser SQL Server itself uses.
+
+## Features
+
+Parses T-SQL via the official ScriptDom library (no hand-rolled grammar). Configurable keyword casing, layout density, and comma style. Preserves `--` and `/* */` comments — trailing, leading, inside procedure bodies, between parameters and `AS`. Emits `go` batch separators where required. Integrates with editor extensions that support Prettier (VS Code, etc.).
+
+**DML**
+
+- `SELECT`, `INSERT`, `UPDATE`, `DELETE`
+- `MERGE INTO … USING … ON … WHEN MATCHED/NOT MATCHED`
+- `OUTPUT` / `OUTPUT INTO` on `INSERT`, `UPDATE`, `DELETE`, and `MERGE` (including `$action`, `inserted.*`, `deleted.*`)
+- CTEs, `UNION`/`UNION ALL`, subqueries, derived tables
+- `CASE` expressions (simple and searched), `IN`/`NOT IN`
+- `TOP (n)`, `TOP (n) PERCENT`, `TOP (n) WITH TIES`
+- `PIVOT` / `UNPIVOT`
+- `FOR XML` (`AUTO`, `PATH`, `RAW`, `EXPLICIT`, `XMLSCHEMA`, `ELEMENTS`, `ROOT`, `TYPE`, etc.) and `FOR JSON` (`AUTO`, `PATH`, `ROOT`, `INCLUDE_NULL_VALUES`, `WITHOUT_ARRAY_WRAPPER`)
+- `TABLESAMPLE [SYSTEM] (n PERCENT|ROWS) [REPEATABLE(seed)]`
+- Temporal table queries — `FOR SYSTEM_TIME AS OF`, `FROM … TO`, `BETWEEN … AND`, `CONTAINED IN`, `ALL`
+- Joins: `INNER`, `LEFT`, `RIGHT`, `FULL OUTER`, `CROSS JOIN`, `CROSS APPLY`, `OUTER APPLY`; multiple joins, multi-predicate `ON`, self-joins, parenthesized joins, derived table joins
+- Table-valued functions (TVFs) in `FROM` clauses; table hints (`WITH (NOLOCK)`, etc.)
+- Window functions with `OVER` clause — `PARTITION BY`, `ORDER BY`, full frame support (`ROWS`/`RANGE BETWEEN … AND …`, `UNBOUNDED PRECEDING/FOLLOWING`, `CURRENT ROW`); `IGNORE NULLS`/`RESPECT NULLS`; named window references; named `WINDOW` clause
+- Ordered set aggregates: `WITHIN GROUP (ORDER BY …)` for `STRING_AGG`, `PERCENTILE_CONT`/`PERCENTILE_DISC`, etc.
+- Expression functions: `CAST`, `CONVERT`, `TRY_CAST`, `TRY_CONVERT` (with full data type including length/precision), `IIF`, `COALESCE`, `NULLIF`, `AT TIME ZONE`, `IS [NOT] DISTINCT FROM`, `TRIM(LEADING|TRAILING|BOTH …)`, `PARSE`, `TRY_PARSE`
+- Sequence expressions: `NEXT VALUE FOR sequence [OVER (…)]`
+- JSON functions: `JSON_OBJECT(key: value, …)`, `JSON_ARRAY(…)`, `JSON_ARRAYAGG(… ORDER BY …)` with `ABSENT|NULL ON NULL`
+- Full-text predicates: `CONTAINS`/`FREETEXT` (single column, multi-column, wildcard, `LANGUAGE`); `CONTAINSTABLE`/`FREETEXTTABLE` as join sources
+- Rowset functions: `OPENJSON` and `OPENXML` with `WITH` schema declarations; `OPENJSON` row-path and `AS JSON` columns; `OPENROWSET` provider and `OPENROWSET(BULK …)` forms
+- Built-in functions formatted as standard function calls: `GREATEST`, `LEAST`, `DATE_BUCKET`, `DATETRUNC`, `GENERATE_SERIES`, `LEFT_SHIFT`, `RIGHT_SHIFT`, `BIT_COUNT`, `GET_BIT`, `SET_BIT`, `APPROX_PERCENTILE_CONT`, `APPROX_PERCENTILE_DISC`, `JSON_PATH_EXISTS`, `STRING_SPLIT`, `ISJSON`, `LTRIM`, `RTRIM`
+
+**DDL**
+
+- `CREATE TABLE` (columns, constraints, computed columns `AS expr [PERSISTED]`, `WITH` options such as `DATA_COMPRESSION`, `MEMORY_OPTIMIZED`), `ALTER TABLE` (ADD/DROP column, ADD/DROP/ENABLE/DISABLE constraint), `CREATE INDEX` (UNIQUE/CLUSTERED/NONCLUSTERED, ASC/DESC, INCLUDE), `ALTER INDEX … REBUILD/REORGANIZE/DISABLE`
+- `CREATE/ALTER/CREATE OR ALTER PROCEDURE`, `CREATE/ALTER/CREATE OR ALTER FUNCTION`, `CREATE/ALTER/CREATE OR ALTER VIEW`
+- `CREATE/ALTER TRIGGER` (DML triggers: AFTER/INSTEAD OF INSERT/UPDATE/DELETE)
+- `CREATE/ALTER/DROP SEQUENCE` with full options (START WITH, INCREMENT BY, MINVALUE/NO MINVALUE, MAXVALUE/NO MAXVALUE, CYCLE/NO CYCLE, CACHE/NO CACHE)
+- `BULK INSERT … FROM … WITH (options)`
+- `CREATE TYPE … FROM …` (scalar UDDTs) and `CREATE TYPE … AS TABLE (…)` (table-valued parameters)
+- `CREATE SYNONYM` / `DROP SYNONYM` (with `IF EXISTS`)
+- `CREATE SCHEMA` (with optional `AUTHORIZATION`), `ALTER SCHEMA … TRANSFER` (plain objects, `TYPE::`, `XML SCHEMA COLLECTION::`), `DROP SCHEMA` (with `IF EXISTS`)
+- `CREATE PARTITION FUNCTION` (RANGE LEFT/RIGHT, boundary values), `ALTER PARTITION FUNCTION` (SPLIT/MERGE RANGE), `DROP PARTITION FUNCTION`
+- `CREATE PARTITION SCHEME` (AS PARTITION, ALL TO / TO filegroup list), `ALTER PARTITION SCHEME` (NEXT USED), `DROP PARTITION SCHEME`
+- `DROP TABLE/PROCEDURE/VIEW/FUNCTION/INDEX/TRIGGER/SEQUENCE/SYNONYM/SCHEMA` (with `IF EXISTS`)
+- `DROP DATABASE` (with `IF EXISTS`, multiple databases)
+- `CREATE DATABASE` (with optional `COLLATE`, file group specs, snapshot)
+- `ALTER DATABASE` — `SET` (any option with proper keyword reconstruction), `COLLATE`, `MODIFY NAME`, `ADD/REMOVE FILE`, `ADD/REMOVE FILEGROUP`, `MODIFY FILE`, `MODIFY FILEGROUP`, `REBUILD LOG`, `SCOPED CONFIGURATION SET/CLEAR`
+
+**Database Administration**
+
+- `DBCC` commands — any command name, literal arguments, `WITH` options
+- `BACKUP DATABASE` / `BACKUP LOG` — `TO DISK/TAPE/URL`, `MIRROR TO`, `WITH` options
+- `RESTORE DATABASE` / `RESTORE LOG` / `RESTORE FILELISTONLY` / `RESTORE HEADERONLY` / `RESTORE VERIFYONLY` — `FROM DISK/TAPE/URL`, `WITH` options
+
+**Procedural / Control Flow**
+
+- `USE`, `SET NOCOUNT/ANSI_NULLS/QUOTED_IDENTIFIER/XACT_ABORT/…` ON/OFF, `SET IDENTITY_INSERT`, `SET TRANSACTION ISOLATION LEVEL`, `SET STATISTICS`, `WAITFOR DELAY/TIME`
+- `DECLARE`, `SET @var`, `SET ROWCOUNT`, `PRINT`, `RETURN`, `EXECUTE`, `TRUNCATE TABLE`
+- `IF`/`ELSE`, `WHILE`, `BREAK`, `CONTINUE`, `GOTO`/label, `THROW`, `RAISERROR`, `TRY/CATCH`
+- `BEGIN`/`COMMIT`/`ROLLBACK TRANSACTION`
+- `DECLARE CURSOR` / `OPEN` / `FETCH NEXT/PRIOR/FIRST/LAST/ABSOLUTE/RELATIVE` / `CLOSE` / `DEALLOCATE`
+- `EXECUTE AS` (CALLER / USER / LOGIN / SELF / OWNER, with `WITH NO REVERT`) / `REVERT`
+- `CREATE/ALTER PROCEDURE` and `CREATE/ALTER FUNCTION` `WITH` options: `ENCRYPTION`, `RECOMPILE`, `EXECUTE AS`
+
+**Security**
+
+- `GRANT` / `DENY` / `REVOKE` — all securable classes (OBJECT, SCHEMA, DATABASE, SERVER, LOGIN, USER, ROLE, ASSEMBLY, …), column lists, WITH GRANT OPTION, CASCADE, GRANT OPTION FOR, AS clause, multiple principals
+- `CREATE/ALTER/DROP USER` — FOR LOGIN, WITHOUT LOGIN, FROM EXTERNAL PROVIDER, WITH options
+- `CREATE/ALTER/DROP LOGIN` — password (HASHED/MUST_CHANGE), FROM WINDOWS, FROM CERTIFICATE/ASYMMETRIC KEY, ENABLE/DISABLE, ADD/DROP CREDENTIAL
+- `CREATE/ALTER/DROP ROLE` — AUTHORIZATION owner, ADD/DROP MEMBER, WITH NAME rename
+
+## Pending implementation
+
+The constructs below are parsed correctly but emitted as-is (original source text preserved). Open a ticket to request formatting support for any of these.
+
+### DDL object model
+
+- Ledger table syntax — `CREATE TABLE ... WITH (LEDGER = ON, ...)` table options
+- Assemblies (`CREATE/ALTER/DROP ASSEMBLY`)
+- XML schema collections (`CREATE/ALTER/DROP XML SCHEMA COLLECTION`)
+- Full-text catalogs and indexes (`CREATE/ALTER/DROP FULLTEXT CATALOG`, `CREATE/ALTER/DROP FULLTEXT INDEX`)
+
+### Service Broker
+
+- `CREATE/ALTER/DROP QUEUE`, `SEND`, `RECEIVE`, `CREATE/ALTER/DROP SERVICE`, `CREATE/ALTER/DROP CONTRACT`, `CREATE/ALTER/DROP MESSAGE TYPE`, `CREATE/ALTER/DROP ROUTE`
+
+### Extended Events
+
+- `CREATE/ALTER/DROP EVENT SESSION`
+
+### Cryptography
+
+- `CREATE/ALTER/DROP CERTIFICATE`, `CREATE/ALTER/DROP SYMMETRIC KEY`, `CREATE/ALTER/DROP ASYMMETRIC KEY`, `OPEN/CLOSE MASTER KEY`
+
+### High Availability
+
+- `CREATE/ALTER/DROP AVAILABILITY GROUP`, `CREATE/ALTER/DROP ENDPOINT`
+
+### External Data
+
+- `CREATE/ALTER/DROP EXTERNAL TABLE`, `CREATE/ALTER/DROP EXTERNAL DATA SOURCE`, `CREATE/ALTER/DROP EXTERNAL FILE FORMAT`, `CREATE/ALTER/DROP EXTERNAL RESOURCE POOL`
+
+### Audit
+
+- `CREATE/ALTER/DROP SERVER AUDIT`, `CREATE/ALTER/DROP DATABASE AUDIT SPECIFICATION`, `CREATE/ALTER/DROP SERVER AUDIT SPECIFICATION`
+
+## Requirements
+
+- Node.js 20+
+- [.NET 8+ Runtime](https://dotnet.microsoft.com/download/dotnet/8.0) (the SDK is only needed for building from source)
+- Prettier 3.x (peer dependency)
+
+## Installation
+
+```bash
+npm install --save-dev prettier-plugin-tsql prettier
+```
+
+> The package ships with the compiled .NET DLL — no separate `dotnet` build step is needed when installing from npm.
+
+## Configuration
+
+Add the plugin to your Prettier config:
+
+```js
+// prettier.config.js
+export default {
+    plugins: ['prettier-plugin-tsql'],
+    sqlKeywordCase: 'lower',
+    sqlDensity: 'standard',
+    sqlCommaStyle: 'trailing',
+};
+```
+
+Or in `.prettierrc`:
+
+```json
+{
+    "plugins": ["prettier-plugin-tsql"],
+    "sqlKeywordCase": "lower",
+    "sqlDensity": "standard",
+    "sqlCommaStyle": "trailing"
+}
+```
+
+## Options
+
+| Option           | Default    | Choices                           |
+| ---------------- | ---------- | --------------------------------- |
+| `sqlKeywordCase` | `lower`    | `upper`, `lower`, `preserve`      |
+| `sqlDensity`     | `standard` | `compact`, `standard`, `spacious` |
+| `sqlCommaStyle`  | `trailing` | `trailing`, `leading`             |
+
+See [docs/options.md](docs/options.md) for full details and examples.
+
+## Quick Example
+
+**Input**
+
+<!-- prettier-ignore -->
+```sql
+SELECT Books.BookId,Books.Title,Books.Price,Authors.LastName FROM Books INNER JOIN Authors ON Books.AuthorId=Authors.Id WHERE Books.InStock=1 ORDER BY Books.Title ASC;
+```
+
+**Output** (default options)
+
+```sql
+select
+    Books.BookId,
+    Books.Title,
+    Books.Price,
+    Authors.LastName
+from
+    Books
+    inner join Authors on Books.AuthorId = Authors.Id
+where Books.InStock = 1
+order by Books.Title asc;
+```
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md) — installation, build from source, editor setup
+- [Options Reference](docs/options.md) — all options with before/after examples
+- [Formatting Rules](docs/formatting.md) — how each SQL construct is formatted
+- [Architecture](docs/architecture.md) — how the plugin works internally
+
+## Building from Source
+
+```bash
+git clone <repo>
+cd prettier-plugin-tsql
+npm install
+npm run build      # builds .NET DLL and TypeScript
+npm test
+```
+
+See [Getting Started](docs/getting-started.md) for full details.

package/bin/dotnet/SqlScriptDom.deps.json

@@ -0,0 +1,41 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v8.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v8.0": {
+      "SqlScriptDom/1.0.0": {
+        "dependencies": {
+          "Microsoft.SqlServer.TransactSql.ScriptDom": "170.179.0"
+        },
+        "runtime": {
+          "SqlScriptDom.dll": {}
+        }
+      },
+      "Microsoft.SqlServer.TransactSql.ScriptDom/170.179.0": {
+        "runtime": {
+          "lib/net8.0/Microsoft.SqlServer.TransactSql.ScriptDom.dll": {
+            "assemblyVersion": "17.0.0.0",
+            "fileVersion": "17.0.179.0"
+          }
+        }
+      }
+    }
+  },
+  "libraries": {
+    "SqlScriptDom/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Microsoft.SqlServer.TransactSql.ScriptDom/170.179.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FfxZGiMiJYLK5qWj0fqE2kEpx0QpH0wd/2FQM+k8ZleXM/3C2TiqkQJU4uGQQXLxHU7BEfL1GCPDCa3Qp7GUHA==",
+      "path": "microsoft.sqlserver.transactsql.scriptdom/170.179.0",
+      "hashPath": "microsoft.sqlserver.transactsql.scriptdom.170.179.0.nupkg.sha512"
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'prettier';
+import type { SqlNode } from './parser/types.js';
+declare const plugin: Plugin<SqlNode>;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAMjD,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,OAAO,CAc3B,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+import { languages } from './language.js';
+import { options } from './options.js';
+import { parse, locStart, locEnd } from './parser/index.js';
+import { printer } from './printer/index.js';
+const plugin = {
+    languages,
+    parsers: {
+        tsql: {
+            parse,
+            astFormat: 'tsql-ast',
+            locStart,
+            locEnd,
+        },
+    },
+    printers: {
+        'tsql-ast': printer,
+    },
+    options,
+};
+export default plugin;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/plugin/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,MAAM,MAAM,GAAoB;IAC5B,SAAS;IACT,OAAO,EAAE;QACL,IAAI,EAAE;YACF,KAAK;YACL,SAAS,EAAE,UAAU;YACrB,QAAQ;YACR,MAAM;SACT;KACJ;IACD,QAAQ,EAAE;QACN,UAAU,EAAE,OAAO;KACtB;IACD,OAAO;CACV,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/language.d.ts

@@ -0,0 +1,3 @@
+import type { SupportLanguage } from 'prettier';
+export declare const languages: SupportLanguage[];
+//# sourceMappingURL=language.d.ts.map

package/dist/language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../src/plugin/language.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,eAAO,MAAM,SAAS,EAAE,eAAe,EAOtC,CAAC"}

package/dist/language.js

@@ -0,0 +1,9 @@
+export const languages = [
+    {
+        name: 'T-SQL',
+        parsers: ['tsql'],
+        extensions: ['.sql', '.tsql'],
+        vscodeLanguageIds: ['sql'],
+    },
+];
+//# sourceMappingURL=language.js.map

package/dist/language.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language.js","sourceRoot":"","sources":["../src/plugin/language.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAsB;IACxC;QACI,IAAI,EAAE,OAAO;QACb,OAAO,EAAE,CAAC,MAAM,CAAC;QACjB,UAAU,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QAC7B,iBAAiB,EAAE,CAAC,KAAK,CAAC;KAC7B;CACJ,CAAC"}

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import type { SupportOption } from 'prettier';
+export declare const options: Record<string, SupportOption>;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/plugin/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAiCjD,CAAC"}

package/dist/options.js

@@ -0,0 +1,35 @@
+export const options = {
+    sqlKeywordCase: {
+        type: 'choice',
+        category: 'SQL',
+        default: 'lower',
+        description: 'Casing for SQL keywords',
+        choices: [
+            { value: 'upper', description: 'UPPERCASE keywords' },
+            { value: 'lower', description: 'lowercase keywords' },
+            { value: 'preserve', description: 'Preserve original casing' },
+        ],
+    },
+    sqlDensity: {
+        type: 'choice',
+        category: 'SQL',
+        default: 'standard',
+        description: 'Controls how spread out the formatting is',
+        choices: [
+            { value: 'compact', description: 'Fits as much as possible on each line, wrapping at printWidth' },
+            { value: 'standard', description: 'One clause per line; single predicates stay inline' },
+            { value: 'spacious', description: 'Every predicate on its own line, even single ones' },
+        ],
+    },
+    sqlCommaStyle: {
+        type: 'choice',
+        category: 'SQL',
+        default: 'trailing',
+        description: 'Comma position in column lists (leading is not yet implemented)',
+        choices: [
+            { value: 'trailing', description: 'Trailing comma: col1,' },
+            { value: 'leading', description: 'Leading comma: , col1 (not yet implemented — behaves as trailing)' },
+        ],
+    },
+};
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../src/plugin/options.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,OAAO,GAAkC;IAClD,cAAc,EAAE;QACZ,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,yBAAyB;QACtC,OAAO,EAAE;YACL,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE;YACrD,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE;YACrD,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,0BAA0B,EAAE;SACjE;KACa;IAClB,UAAU,EAAE;QACR,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,UAAU;QACnB,WAAW,EAAE,2CAA2C;QACxD,OAAO,EAAE;YACL,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,+DAA+D,EAAE;YAClG,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,oDAAoD,EAAE;YACxF,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,mDAAmD,EAAE;SAC1F;KACa;IAClB,aAAa,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,UAAU;QACnB,WAAW,EAAE,iEAAiE;QAC9E,OAAO,EAAE;YACL,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,uBAAuB,EAAE;YAC3D,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,mEAAmE,EAAE;SACzG;KACa;CACrB,CAAC"}

package/dist/parser/index.d.ts

@@ -0,0 +1,5 @@
+import type { SqlNode } from './types.js';
+export declare function parse(text: string): SqlNode;
+export declare function locStart(node: SqlNode): number;
+export declare function locEnd(node: SqlNode): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/parser/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,YAAY,CAAC;AAiDxD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAsB3C;AAuOD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAE9C;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAE5C"}

package/dist/parser/index.js

@@ -0,0 +1,263 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// node-api-dotnet is a native CommonJS module; use createRequire for ESM compat.
+let dotnetModule = null;
+function loadDotnet() {
+    if (dotnetModule)
+        return dotnetModule;
+    const require = createRequire(import.meta.url);
+    const dotnet = require('node-api-dotnet');
+    // Resolve DLL path relative to this file's location:
+    //   compiled:  dist/parser/index.js  → ../../bin/dotnet
+    //   source:    src/plugin/parser/index.ts → ../../../bin/dotnet
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    const isCompiled = thisDir.endsWith(path.join('dist', 'parser')) || thisDir.endsWith('dist/parser');
+    const dllPath = isCompiled
+        ? path.resolve(thisDir, '../../bin/dotnet/SqlScriptDom.dll')
+        : path.resolve(thisDir, '../../../bin/dotnet/SqlScriptDom.dll');
+    // Only cache the module after a successful load.
+    try {
+        dotnet.load(dllPath);
+    }
+    catch (e) {
+        throw new Error(`prettier-plugin-tsql: failed to load SqlScriptDom.dll from "${dllPath}". ` +
+            `Make sure .NET 8+ is installed and the package was installed correctly. ` +
+            `Original error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    dotnetModule = dotnet;
+    return dotnetModule;
+}
+// ---------------------------------------------------------------------------
+// Public parse entry point
+// ---------------------------------------------------------------------------
+export function parse(text) {
+    const { SqlParser } = loadDotnet().PrettierTsql;
+    const result = JSON.parse(SqlParser.Parse(text));
+    if (result.errors?.length) {
+        const e = result.errors[0];
+        throw new SyntaxError(`T-SQL parse error at ${e.line}:${e.column}: ${e.message}`);
+    }
+    if (!result.ast) {
+        throw new Error('Parser returned no AST and no errors');
+    }
+    if (result.comments?.length) {
+        attachComments(result.ast, result.comments, text);
+    }
+    return result.ast;
+}
+// ---------------------------------------------------------------------------
+// Comment attachment
+//
+// Comments from ScriptDom are separate from the AST.  We attach them to AST
+// nodes in three passes so the printer can emit them in the right position.
+//
+//   Pass 1 — Trailing same-line comments (-- style):
+//     Find line comments on the same source line as a statement or INSERT row
+//     and store them as node.trailingComment.
+//
+//   Pass 2 — Leading / pre-body comments:
+//     For each remaining comment, find the first statement that starts after
+//     the comment ends and store it as node.leadingComments[].
+//     Comments that fall physically *inside* a statement's span are routed to
+//     node.preBodyComments[] (before the body) or node.postParamComments[]
+//     (after the last parameter but before AS/BEGIN).
+//     Comments after the last statement in the file attach to the last
+//     statement's trailingComment so they are never silently dropped.
+//
+//   Pass 3 — Intra-statement comments (commented-out predicates, etc.):
+//     Any comment still inside a statement's span is attached to the nearest
+//     surrounding AST descendant — preferring the forward neighbour as a
+//     leadingComment when that neighbour is a statement node, otherwise the
+//     backward neighbour as a trailingComment.
+// ---------------------------------------------------------------------------
+function attachComments(ast, comments, text) {
+    const used = new Set();
+    const batches = (ast.props?.['batches'] ?? []);
+    const allStatements = batches.flatMap((b) => (b.props?.['statements'] ?? []));
+    attachSameLineTrailing(batches, comments, text, used);
+    attachLeadingAndPreBody(allStatements, comments, used);
+    attachIntraStatement(batches, comments, used);
+}
+// Pass 1: trailing line comments on the same source line as a statement.
+function attachSameLineTrailing(batches, comments, text, used) {
+    for (const batch of batches) {
+        const statements = (batch.props?.['statements'] ?? []);
+        for (const stmt of statements) {
+            // For INSERT … VALUES, also check each row for its own trailing comment.
+            if (stmt.type === 'InsertStatement') {
+                const source = stmt.props?.['source'];
+                if (source?.type === 'ValuesSource') {
+                    for (const row of (source.props?.['rows'] ?? [])) {
+                        const c = findTrailingLineComment(row, comments, text, used);
+                        if (c) {
+                            row.trailingComment = c.text;
+                            used.add(c);
+                        }
+                    }
+                }
+            }
+            const c = findTrailingLineComment(stmt, comments, text, used);
+            if (c) {
+                stmt.trailingComment = c.text;
+                used.add(c);
+            }
+        }
+    }
+}
+// Pass 2: leading comments (standalone lines before a statement) and
+// pre-body comments (inside a statement but before its body start).
+function attachLeadingAndPreBody(allStatements, comments, used) {
+    const unusedSorted = comments.filter((c) => !used.has(c)).sort((a, b) => a.startOffset - b.startOffset);
+    for (const c of unusedSorted) {
+        // Check whether the comment is physically inside a statement's span.
+        const container = allStatements.find((s) => c.startOffset > s.startOffset && c.endOffset <= s.endOffset);
+        if (container) {
+            // The comment is inside a statement. Route it to preBodyComments or
+            // postParamComments if it falls before the body start boundary.
+            //
+            // bodyStart (added by AstBuilder) = StatementList.StartOffset, which
+            // ScriptDom sets to the BEGIN keyword — the boundary between
+            // "header / params" and "body".  For CREATE VIEW we fall back to
+            // the body node's own startOffset.
+            const bodyStartProp = container.props?.['bodyStart'];
+            const bodyProp = container.props?.['body'];
+            const bodyNode = !Array.isArray(bodyProp) &&
+                bodyProp != null &&
+                typeof bodyProp === 'object' &&
+                'startOffset' in bodyProp
+                ? bodyProp
+                : undefined;
+            const beforePoint = typeof bodyStartProp === 'number' ? bodyStartProp : bodyNode?.startOffset;
+            if (beforePoint !== undefined && c.endOffset <= beforePoint) {
+                // Distinguish "before parameter list" from "after last parameter".
+                const paramsProp = container.props?.['parameters'];
+                const params = Array.isArray(paramsProp) ? paramsProp : [];
+                const lastParam = params.at(-1);
+                if (lastParam && c.startOffset > lastParam.endOffset) {
+                    // e.g. /*WITH ENCRYPTION*/ after params but before AS
+                    container.postParamComments = container.postParamComments ?? [];
+                    container.postParamComments.push(c.text);
+                }
+                else {
+                    // Banner / descriptive comment before the param list
+                    container.preBodyComments = container.preBodyComments ?? [];
+                    container.preBodyComments.push(c.text);
+                }
+                used.add(c);
+            }
+            // Do not re-attach this comment as a leading comment elsewhere.
+            continue;
+        }
+        // Not inside any statement — attach to the first statement that starts
+        // after this comment.
+        const target = allStatements.find((s) => s.startOffset >= c.endOffset);
+        if (target) {
+            target.leadingComments = target.leadingComments ?? [];
+            target.leadingComments.push(c.text);
+            used.add(c);
+        }
+        else {
+            // Comment appears after all statements (end of file).
+            // Attach to the last statement so it is never silently dropped.
+            const last = allStatements.at(-1);
+            if (last) {
+                last.trailingComment = last.trailingComment ? last.trailingComment + '\n' + c.text : c.text;
+                used.add(c);
+            }
+        }
+    }
+}
+// Pass 3: intra-statement comments (e.g. commented-out WHERE predicates).
+function attachIntraStatement(batches, comments, used) {
+    for (const batch of batches) {
+        const statements = (batch.props?.['statements'] ?? []);
+        for (const stmt of statements) {
+            const internal = comments
+                .filter((c) => !used.has(c) && c.startOffset >= stmt.startOffset && c.endOffset <= stmt.endOffset)
+                .sort((a, b) => a.startOffset - b.startOffset);
+            if (internal.length === 0)
+                continue;
+            const descendants = [];
+            collectDescendants(stmt, descendants);
+            for (const c of internal) {
+                // Find the nearest backward neighbour (highest endOffset ≤ comment start)
+                // and the nearest forward neighbour (lowest startOffset ≥ comment end).
+                let best = null;
+                let bestForward = null;
+                for (const node of descendants) {
+                    if (node.endOffset <= c.startOffset) {
+                        if (!best || node.endOffset >= best.endOffset)
+                            best = node;
+                    }
+                    if (node.startOffset >= c.endOffset) {
+                        if (!bestForward || node.startOffset < bestForward.startOffset)
+                            bestForward = node;
+                    }
+                }
+                // Prefer attaching as a leading comment to the next statement node.
+                // printStatementWithComments will emit it before the statement body
+                // (e.g. a comment between BEGIN and the first SELECT).
+                if (bestForward?.type.endsWith('Statement')) {
+                    bestForward.leadingComments = bestForward.leadingComments ?? [];
+                    bestForward.leadingComments.push(c.text);
+                    used.add(c);
+                }
+                else if (best) {
+                    best.trailingComment = best.trailingComment ? best.trailingComment + '\n' + c.text : c.text;
+                    used.add(c);
+                }
+                else {
+                    // No suitable neighbour — fall back to the containing statement.
+                    stmt.leadingComments = stmt.leadingComments ?? [];
+                    stmt.leadingComments.push(c.text);
+                    used.add(c);
+                }
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Recursively collect all descendant nodes into result (including node itself). */
+function collectDescendants(node, result) {
+    result.push(node);
+    const props = node.props;
+    if (!props)
+        return;
+    for (const val of Object.values(props)) {
+        if (!val)
+            continue;
+        if (Array.isArray(val)) {
+            for (const item of val) {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    collectDescendants(item, result);
+                }
+            }
+        }
+        else if (typeof val === 'object' && 'type' in val) {
+            collectDescendants(val, result);
+        }
+    }
+}
+/**
+ * Find a line comment (`-- ...`) that starts on the same source line as node
+ * and has not already been consumed.
+ */
+function findTrailingLineComment(node, comments, text, used) {
+    return comments.find((c) => c.type === 'line' &&
+        !used.has(c) &&
+        c.startOffset >= node.endOffset &&
+        !text.substring(node.endOffset, c.startOffset).includes('\n'));
+}
+// ---------------------------------------------------------------------------
+// Prettier loc helpers
+// ---------------------------------------------------------------------------
+export function locStart(node) {
+    return node.startOffset;
+}
+export function locEnd(node) {
+    return node.endOffset;
+}
+//# sourceMappingURL=index.js.map