prettier-plugin-tsql 0.6.0 → 0.6.2

package/dist/printer/ddl.js

@@ -1,11 +1,23 @@
-import { keyword, hardline, join, indent, group, softline, line, ifExistsDoc, commentsBlock, parenList, } from '@prettier-sql/core/printer/utils';
+import { keyword, hardline, join, indent, group, softline, line, ifExistsDoc, commentsBlock, parenList, } from '../_core/printer/utils.js';
 import { prop, propArr, propStr, propBool, schemaObjectName } from './helpers.js';
 // printNode / printBool / qexpr / printStatementWithComments are imported from statements.ts
 // — circular but safe in ESM (all imports are function references, never accessed during init)
-import { printStatementWithComments, printNode, printBool, qexpr } from './statements.js';
+import { printStatementWithComments, printNode, printBool, printBoolClause, qexpr } from './statements.js';
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
+/**
+ * When ScriptDOM sees `AS BEGIN...END` it wraps the body in a single
+ * BeginEndBlockStatement. Unwrap that one outer block so that proc/function/
+ * trigger printers can emit their own BEGIN/END delimiters cleanly, while
+ * a *standalone* BEGIN...END statement still prints with its own delimiters.
+ */
+function unwrapBodyBlock(stmts) {
+    if (stmts.length === 1 && stmts[0]?.type === 'BeginEndBlock') {
+        return propArr(stmts[0], 'statements');
+    }
+    return stmts;
+}
 /** Render ` NULL` / ` NOT NULL` from a tristate `nullable` prop value. */
 function nullablePart(nullable, opts) {
     if (nullable === true)
@@ -40,7 +52,7 @@ function printInlineIndex(node, opts) {
     const kind = propStr(node, 'kind'); // 'clustered', 'nonclustered', etc.
     const columns = propArr(node, 'columns');
     const includeColumns = node.props?.['includeColumns'];
-    const filterPredicate = propStr(node, 'filterPredicate');
+    const filterPredicateNode = prop(node, 'filterPredicate');
     const indexOptions = node.props?.['indexOptions'];
     const uniqueKw = isUnique ? [keyword('UNIQUE', opts), ' '] : '';
     const kindKw = kind ? [keyword(kind.toUpperCase(), opts), ' '] : '';
@@ -52,7 +64,7 @@ function printInlineIndex(node, opts) {
     const includePart = includeColumns?.length
         ? [' ', keyword('INCLUDE', opts), ' ', parenList(includeColumns)]
         : '';
-    const filterPart = filterPredicate ? [' ', keyword('WHERE', opts), ' ', filterPredicate] : '';
+    const filterPart = filterPredicateNode ? [' ', printBoolClause('WHERE', filterPredicateNode, opts)] : '';
     const withPart = indexOptions?.length ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')'] : '';
     return [
         keyword('INDEX', opts),
@@ -92,8 +104,18 @@ export function printCreateTable(node, opts) {
     const withPart = options && options.length > 0 ? [hardline, keyword('WITH', opts), ' ', parenList(options)] : '';
     const onFileGroup = propStr(node, 'onFileGroup');
     const textimageOn = propStr(node, 'textimageOn');
+    const fileStreamOn = propStr(node, 'fileStreamOn');
     const onPart = onFileGroup ? [hardline, keyword('ON', opts), ' ', onFileGroup] : '';
     const textimagePart = textimageOn ? [hardline, keyword('TEXTIMAGE_ON', opts), ' ', textimageOn] : '';
+    const fileStreamPart = fileStreamOn ? [hardline, keyword('FILESTREAM_ON', opts), ' ', fileStreamOn] : '';
+    // Graph table types (AS NODE / AS EDGE)
+    const asNode = node.props?.['asNode'];
+    const asEdge = node.props?.['asEdge'];
+    const graphPart = asNode
+        ? [' ', keyword('AS NODE', opts)]
+        : asEdge
+            ? [' ', keyword('AS EDGE', opts)]
+            : '';
     return group([
         keyword('CREATE TABLE', opts),
         ' ',
@@ -102,18 +124,27 @@ export function printCreateTable(node, opts) {
         indent([hardline, join([',', hardline], allDefs)]),
         hardline,
         ')',
+        graphPart,
         onPart,
+        fileStreamPart,
         textimagePart,
         withPart,
         ';',
     ]);
 }
 export function printColumnDef(node, opts) {
+    // Raw leaf (e.g. ENCRYPTED WITH — property names vary across ScriptDOM versions).
+    // The C# AstBuilder emits `Leaf("ColumnDefinition", col, rawText)` which sets
+    // `node.text` to the original column fragment and leaves `node.props` undefined.
+    if (!node.props)
+        return node.text ?? '/* column */';
     const name = propStr(node, 'name') ?? 'col';
-    // Computed column: Name AS expression [PERSISTED]
+    // Computed column: Name AS expression [PERSISTED] [NOT NULL|NULL]
     const computedExpr = prop(node, 'computedExpression');
     if (computedExpr) {
         const isPersisted = node.props?.['isPersisted'];
+        // Computed PERSISTED columns may have an explicit nullability constraint
+        const computedNullPart = nullablePart(node.props?.['nullable'], opts);
         return [
             name,
             ' ',
@@ -121,10 +152,13 @@ export function printColumnDef(node, opts) {
             ' ',
             printNode(computedExpr, opts),
             isPersisted ? [' ', keyword('PERSISTED', opts)] : '',
+            computedNullPart,
         ];
     }
     const dataType = propStr(node, 'dataType') ?? 'INT';
     const params = node.props?.['dataTypeParams'];
+    const xmlSchemaCollection = propStr(node, 'xmlSchemaCollection');
+    const xmlTypeOption = propStr(node, 'xmlTypeOption');
     // Read nullable as a tristate (true/false/undefined) — propBool only returns true/false.
     const isNullable = node.props?.['nullable'];
     const isIdentity = propBool(node, 'identity');
@@ -133,9 +167,18 @@ export function printColumnDef(node, opts) {
     const defaultValue = prop(node, 'defaultValue');
     const checkConstraint = prop(node, 'checkConstraint');
     const collation = propStr(node, 'collation');
-    const typeStr = Array.isArray(params) && params.length > 0
-        ? [keyword(dataType, opts), `(${params.join(', ')})`]
-        : keyword(dataType, opts);
+    const typeStr = (() => {
+        const baseType = keyword(dataType, opts);
+        if (Array.isArray(params) && params.length > 0) {
+            return [baseType, `(${params.join(', ')})`];
+        }
+        if (xmlSchemaCollection) {
+            // xml(CONTENT|DOCUMENT schema_collection) — CONTENT/DOCUMENT are optional keywords
+            const prefix = xmlTypeOption ? `${keyword(xmlTypeOption, opts)} ` : '';
+            return [baseType, '(', prefix, xmlSchemaCollection, ')'];
+        }
+        return baseType;
+    })();
     const parts = [name, ' ', typeStr];
     // COLLATE clause comes right after the data type
     if (collation)
@@ -144,6 +187,8 @@ export function printColumnDef(node, opts) {
         const seed = identitySeed ?? '1';
         const inc = identityIncrement ?? '1';
         parts.push(' ', keyword('IDENTITY', opts), `(${seed}, ${inc})`);
+        if (node.props?.['identityNotForReplication'])
+            parts.push(' ', keyword('NOT FOR REPLICATION', opts));
     }
     if (node.props?.['isRowGuidCol'])
         parts.push(' ', keyword('ROWGUIDCOL', opts));
@@ -179,8 +224,11 @@ export function printColumnDef(node, opts) {
         const maskFn = propStr(node, 'maskingFunction') ?? 'default()';
         parts.push(' ', keyword('MASKED WITH', opts), ' (', keyword('FUNCTION', opts), ` = '${maskFn}')`);
     }
-    if (defaultValue)
-        parts.push(' ', keyword('DEFAULT', opts), ' ', printNode(defaultValue, opts));
+    if (defaultValue) {
+        const defaultName = propStr(node, 'defaultConstraintName');
+        const defaultNamePrefix = defaultName ? [keyword('CONSTRAINT', opts), ' ', defaultName, ' '] : '';
+        parts.push(' ', defaultNamePrefix, keyword('DEFAULT', opts), ' ', printNode(defaultValue, opts));
+    }
     parts.push(nullablePart(isNullable, opts));
     if (checkConstraint) {
         const checkName = propStr(node, 'checkConstraintName');
@@ -201,9 +249,12 @@ export function printColumnDef(node, opts) {
                 : '';
         parts.push(' ', constraintNamePrefix, uqKw, clusteredKw);
     }
-    // Inline REFERENCES (column-level foreign key: col type REFERENCES Table(col))
+    // Inline REFERENCES (column-level foreign key: col type [CONSTRAINT name] REFERENCES Table(col))
     const foreignKey = node.props?.['foreignKey'];
     if (foreignKey) {
+        if (foreignKey.constraintName) {
+            parts.push(' ', keyword('CONSTRAINT', opts), ' ', foreignKey.constraintName);
+        }
         const refColsPart = foreignKey.refColumns?.length ? [' (', join(', ', foreignKey.refColumns), ')'] : '';
         parts.push(' ', keyword('REFERENCES', opts), ' ', schemaObjectName(foreignKey.refTable), refColsPart);
         if (foreignKey.deleteAction) {
@@ -244,11 +295,23 @@ export function printConstraintDef(node, opts) {
                 return [c.name, dir];
             });
             const colsDoc = parenList(colDocs);
-            return group([namePrefix, indent([softline, kw, ' ', clusteredKw, colsDoc])]);
+            const indexOptions = node.props?.['indexOptions'];
+            const withPart = indexOptions?.length
+                ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
+                : '';
+            return group([namePrefix, indent([softline, kw, ' ', clusteredKw, colsDoc]), withPart]);
         }
         case 'CheckConstraint': {
             const expr = prop(node, 'expression');
-            return [namePrefix, keyword('CHECK', opts), ' (', expr ? printBool(expr, opts) : '', ')'];
+            const nfr = propBool(node, 'notForReplication');
+            return [
+                namePrefix,
+                keyword('CHECK', opts),
+                nfr ? [' ', keyword('NOT FOR REPLICATION', opts)] : '',
+                ' (',
+                expr ? printBool(expr, opts) : '',
+                ')',
+            ];
         }
         case 'ForeignKeyConstraint': {
             const cols = Array.isArray(node.props?.['columns']) ? node.props?.['columns'] : [];
@@ -257,6 +320,7 @@ export function printConstraintDef(node, opts) {
             const refName = refTable ? schemaObjectName(refTable) : '';
             const deleteAction = propStr(node, 'deleteAction');
             const updateAction = propStr(node, 'updateAction');
+            const nfr = propBool(node, 'notForReplication');
             const refActionKw = (action) => keyword(action
                 .replace(/([A-Z])/g, ' $1')
                 .trim()
@@ -276,6 +340,7 @@ export function printConstraintDef(node, opts) {
                         ]),
                         deleteAction ? [line, keyword('ON DELETE', opts), ' ', refActionKw(deleteAction)] : '',
                         updateAction ? [line, keyword('ON UPDATE', opts), ' ', refActionKw(updateAction)] : '',
+                        nfr ? [line, keyword('NOT FOR REPLICATION', opts)] : '',
                     ]),
                 ]),
             ];
@@ -316,6 +381,11 @@ export function printAlterTable(node, opts) {
                 join([',', line], elements.map((e) => e.name)),
             ]),
         ]);
+        // WITH (ONLINE = ON, WAIT_AT_LOW_PRIORITY ...) on DROP CLUSTERED CONSTRAINT
+        const allDropOptions = elements.flatMap((e) => e.dropOptions ?? []);
+        const withPart = allDropOptions.length
+            ? [' ', keyword('WITH', opts), ' (', join(', ', allDropOptions), ')']
+            : '';
         return [
             keyword('ALTER TABLE', opts),
             ' ',
@@ -325,6 +395,7 @@ export function printAlterTable(node, opts) {
             ifExists ? [' ', keyword('IF EXISTS', opts)] : '',
             ' ',
             nameList,
+            withPart,
             ';',
         ];
     }
@@ -350,7 +421,49 @@ export function printAlterTable(node, opts) {
     }
     if (alterType === 'AlterTableAlterColumnStatement') {
         const column = propStr(node, 'column') ?? '';
+        const alterColumnOption = propStr(node, 'alterColumnOption');
+        const maskingFunction = propStr(node, 'maskingFunction');
+        // ADD/DROP modifier variants (no data type change, just add/remove a column property)
+        if (alterColumnOption) {
+            let optDoc;
+            if (alterColumnOption === 'AddMaskingFunction') {
+                // ALTER COLUMN col ADD MASKED WITH (FUNCTION = 'fn()')
+                const fn = maskingFunction ?? 'default()';
+                optDoc = [keyword('ADD MASKED WITH', opts), ' (', keyword('FUNCTION', opts), ` = '${fn}')`];
+            }
+            else {
+                const optMap = {
+                    DropMaskingFunction: 'DROP MASKED',
+                    AddSparse: 'ADD SPARSE',
+                    DropSparse: 'DROP SPARSE',
+                    AddRowGuidCol: 'ADD ROWGUIDCOL',
+                    DropRowGuidCol: 'DROP ROWGUIDCOL',
+                    AddHidden: 'ADD HIDDEN',
+                    DropHidden: 'DROP HIDDEN',
+                    AddPersisted: 'ADD PERSISTED',
+                    DropPersisted: 'DROP PERSISTED',
+                };
+                optDoc = keyword(optMap[alterColumnOption] ?? alterColumnOption.toUpperCase(), opts);
+            }
+            return [
+                keyword('ALTER TABLE', opts),
+                ' ',
+                name,
+                hardline,
+                keyword('ALTER COLUMN', opts),
+                ' ',
+                column,
+                ' ',
+                optDoc,
+                ';',
+            ];
+        }
+        // Normal type-change: ALTER COLUMN col newtype [COLLATE ...] [NULL|NOT NULL]
         const dataType = propStr(node, 'dataType') ?? '';
+        const collationAC = propStr(node, 'collation');
+        const collatePart = collationAC
+            ? [' ', keyword('COLLATE', opts), ' ', collationAC]
+            : '';
         const nullPart = nullablePart(node.props?.['nullable'], opts);
         return [
             keyword('ALTER TABLE', opts),
@@ -362,6 +475,7 @@ export function printAlterTable(node, opts) {
             column,
             ' ',
             keyword(dataType, opts),
+            collatePart,
             nullPart,
             ';',
         ];
@@ -407,9 +521,13 @@ export function printAlterTable(node, opts) {
         const sourcePartition = propStr(node, 'sourcePartition');
         const targetTable = prop(node, 'targetTable');
         const targetPartition = propStr(node, 'targetPartition');
+        const switchOptions = node.props?.['switchOptions'];
         const sourceDoc = sourcePartition ? [' ', keyword('PARTITION', opts), ' ', sourcePartition] : '';
         const targetDoc = targetTable ? schemaObjectName(targetTable) : '';
         const targetPartDoc = targetPartition ? [' ', keyword('PARTITION', opts), ' ', targetPartition] : '';
+        const switchOptDoc = switchOptions?.length
+            ? [' ', keyword('WITH', opts), ' (', join(', ', switchOptions), ')']
+            : '';
         return [
             keyword('ALTER TABLE', opts),
             ' ',
@@ -422,6 +540,7 @@ export function printAlterTable(node, opts) {
             ' ',
             targetDoc,
             targetPartDoc,
+            switchOptDoc,
             ';',
         ];
     }
@@ -444,7 +563,7 @@ export function printCreateIndex(node, opts) {
     const table = prop(node, 'table');
     const columns = propArr(node, 'columns');
     const includeColumns = node.props?.['includeColumns'];
-    const filterPredicate = propStr(node, 'filterPredicate');
+    const filterPredicateNode = prop(node, 'filterPredicate');
     const colDocs = columns.map((c) => {
         const colName = propStr(c, 'name') ?? c.text ?? '';
         const sort = propStr(c, 'sortOrder') ?? 'Ascending';
@@ -472,11 +591,15 @@ export function printCreateIndex(node, opts) {
     const includePart = Array.isArray(includeColumns) && includeColumns.length > 0
         ? [hardline, keyword('INCLUDE', opts), ' ', parenList(includeColumns)]
         : '';
-    const filterPart = filterPredicate ? [hardline, keyword('WHERE', opts), ' ', filterPredicate] : '';
+    const filterPart = filterPredicateNode
+        ? [hardline, printBoolClause('WHERE', filterPredicateNode, opts)]
+        : '';
     const indexOptions = node.props?.['indexOptions'];
     const withPart = indexOptions && indexOptions.length > 0
         ? [hardline, keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
         : '';
+    const onFileGroup = propStr(node, 'onFileGroup');
+    const fileGroupPart = onFileGroup ? [hardline, keyword('ON', opts), ' ', onFileGroup] : '';
     return group([
         keyword('CREATE', opts),
         ' ',
@@ -487,6 +610,7 @@ export function printCreateIndex(node, opts) {
         indexName,
         indent([hardline, onClause, includePart, filterPart]),
         withPart,
+        fileGroupPart,
         ';',
     ]);
 }
@@ -520,8 +644,8 @@ export function printAlterIndex(node, opts) {
         schemaObjectName(table),
         ' ',
         typeKw,
-        withPart,
         partitionPart,
+        withPart,
         ';',
     ];
 }
@@ -583,7 +707,11 @@ export function printCreateProcedure(node, opts) {
             parts.push(' ', keyword('READONLY', opts));
         return parts;
     });
-    const bodyDocs = body.map((s) => printStatementWithComments(s, opts));
+    // Natively compiled procs have a single BEGIN ATOMIC WITH (...) body statement.
+    const atomicBlock = body.length === 1 && body[0].type === 'BeginEndAtomicBlock' ? body[0] : null;
+    const atomicOptions = atomicBlock?.props?.['atomicOptions'];
+    const innerBody = atomicBlock ? propArr(atomicBlock, 'statements') : unwrapBodyBlock(body);
+    const bodyDocs = innerBody.map((s) => printStatementWithComments(s, opts));
     const preBody = commentsBlock(node.preBodyComments);
     const postParam = commentsBlock(node.postParamComments);
     const procKw = node.type === 'CreateOrAlterProcedureStatement'
@@ -591,6 +719,26 @@ export function printCreateProcedure(node, opts) {
         : node.type === 'AlterProcedureStatement'
             ? keyword('ALTER PROCEDURE', opts)
             : keyword('CREATE PROCEDURE', opts);
+    // CLR stored procedure: AS EXTERNAL NAME assembly.[class].method
+    const externalName = propStr(node, 'externalName');
+    if (externalName) {
+        return group([
+            procKw,
+            ' ',
+            schemaObjectName(prop(node, 'name')),
+            preBody,
+            parameters.length > 0 ? indent([hardline, join([',', hardline], paramDocs)]) : '',
+            postParam,
+            printModuleOptions(node, opts),
+            hardline,
+            keyword('AS', opts),
+            ' ',
+            keyword('EXTERNAL NAME', opts),
+            ' ',
+            externalName,
+            ';',
+        ]);
+    }
     return group([
         procKw,
         ' ',
@@ -602,7 +750,19 @@ export function printCreateProcedure(node, opts) {
         hardline,
         keyword('AS', opts),
         hardline,
-        keyword('BEGIN', opts),
+        ...(atomicOptions?.length
+            ? [
+                keyword('BEGIN', opts),
+                ' ',
+                keyword('ATOMIC', opts),
+                ' ',
+                keyword('WITH', opts),
+                ' (',
+                indent([hardline, join([',', hardline], atomicOptions)]),
+                hardline,
+                ')',
+            ]
+            : [keyword('BEGIN', opts)]),
         indent([hardline, join([hardline, hardline], bodyDocs)]),
         hardline,
         keyword('END', opts),
@@ -639,6 +799,25 @@ export function printCreateFunction(node, opts) {
         group(['(', parameters.length > 0 ? [indent([softline, join([',', line], paramDocs)]), softline] : '', ')']),
         postParam,
     ];
+    // CLR function: EXTERNAL NAME assembly.[class].method (no body)
+    const externalName = propStr(node, 'externalName');
+    if (externalName) {
+        return [
+            nameAndParamsNoOpts,
+            hardline,
+            keyword('RETURNS', opts),
+            ' ',
+            keyword(returnType, opts),
+            printModuleOptions(node, opts),
+            hardline,
+            keyword('AS', opts),
+            ' ',
+            keyword('EXTERNAL NAME', opts),
+            ' ',
+            externalName,
+            ';',
+        ];
+    }
     if (bodyType === 'table') {
         // Inline TVF: RETURNS TABLE [WITH options] AS RETURN (query) — no BEGIN/END
         const queryDoc = body && !Array.isArray(body) ? qexpr(body, opts) : '/* query */';
@@ -661,7 +840,7 @@ export function printCreateFunction(node, opts) {
         ];
     }
     // Scalar or multi-statement TVF — both use BEGIN...END
-    const stmts = Array.isArray(body) ? body.map((s) => printStatementWithComments(s, opts)) : [];
+    const stmts = Array.isArray(body) ? unwrapBodyBlock(body).map((s) => printStatementWithComments(s, opts)) : [];
     const bodyDoc = join([hardline, hardline], stmts);
     let retTypePart;
     if (bodyType === 'inline-table') {
@@ -757,7 +936,13 @@ export function printCreateTrigger(node, opts) {
         : '';
     const notForReplication = propBool(node, 'notForReplication');
     const notForReplicationDoc = notForReplication ? [hardline, keyword('NOT FOR REPLICATION', opts)] : '';
-    const bodyDocs = propArr(node, 'body').map((s) => printStatementWithComments(s, opts));
+    const bodyDocs = unwrapBodyBlock(propArr(node, 'body')).map((s) => printStatementWithComments(s, opts));
+    const triggerScope = propStr(node, 'triggerScope'); // 'Database' or 'Server' for DDL triggers
+    const onTarget = triggerScope === 'Database'
+        ? keyword('DATABASE', opts)
+        : triggerScope === 'Server'
+            ? keyword('ALL SERVER', opts)
+            : schemaObjectName(prop(node, 'onName'));
     return [
         kw,
         ' ',
@@ -765,7 +950,7 @@ export function printCreateTrigger(node, opts) {
         hardline,
         keyword('ON', opts),
         ' ',
-        schemaObjectName(prop(node, 'onName')),
+        onTarget,
         hardline,
         typeKw,
         ' ',
@@ -1058,7 +1243,7 @@ export function printCreateColumnStoreIndex(node, opts) {
     const clustered = node.props?.['clustered'];
     const onName = prop(node, 'onName');
     const columns = node.props?.['columns'];
-    const filterPredicate = propStr(node, 'filterPredicate');
+    const filterPredicateNode = prop(node, 'filterPredicate');
     const options = node.props?.['options'];
     const clusterKw = clustered === true
         ? [keyword('CLUSTERED', opts), ' ']
@@ -1070,8 +1255,8 @@ export function printCreateColumnStoreIndex(node, opts) {
     if (columns?.length) {
         parts.push([' ', parenList(columns)]);
     }
-    if (filterPredicate)
-        parts.push([hardline, keyword('WHERE', opts), ' ', filterPredicate]);
+    if (filterPredicateNode)
+        parts.push([hardline, printBoolClause('WHERE', filterPredicateNode, opts)]);
     if (options?.length) {
         parts.push([
             hardline,
@@ -1119,15 +1304,15 @@ export function printCreateStatistics(node, opts) {
     const name = propStr(node, 'name') ?? '';
     const onName = prop(node, 'onName');
     const columns = node.props?.['columns'];
-    const filterPredicate = propStr(node, 'filterPredicate');
+    const filterPredicateNode = prop(node, 'filterPredicate');
     const options = node.props?.['options'];
     const parts = [keyword('CREATE STATISTICS', opts), ' ', name];
     parts.push([hardline, keyword('ON', opts), ' ', onName ? schemaObjectName(onName) : '']);
     if (columns?.length) {
         parts.push([' ', parenList(columns)]);
     }
-    if (filterPredicate)
-        parts.push([hardline, keyword('WHERE', opts), ' ', filterPredicate]);
+    if (filterPredicateNode)
+        parts.push([hardline, printBoolClause('WHERE', filterPredicateNode, opts)]);
     if (options?.length)
         parts.push([hardline, withOptionsClause(options, opts)]);
     parts.push(';');