prettier-plugin-tsql 0.5.0 → 0.6.0

package/dist/printer/ddl.js

@@ -1,4 +1,4 @@
-import { keyword, hardline, join, indent, group, softline, line, ifExistsDoc, commentsBlock, parenList } from './utils.js';
+import { keyword, hardline, join, indent, group, softline, line, ifExistsDoc, commentsBlock, parenList, } from '@prettier-sql/core/printer/utils';
 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)
@@ -33,22 +33,67 @@ function withOptionsClause(options, opts) {
 // ---------------------------------------------------------------------------
 // CREATE TABLE
 // ---------------------------------------------------------------------------
+/** Inline INDEX definition within CREATE TABLE body. */
+function printInlineIndex(node, opts) {
+    const indexName = propStr(node, 'indexName') ?? '';
+    const isUnique = node.props?.['unique'];
+    const kind = propStr(node, 'kind'); // 'clustered', 'nonclustered', etc.
+    const columns = propArr(node, 'columns');
+    const includeColumns = node.props?.['includeColumns'];
+    const filterPredicate = propStr(node, 'filterPredicate');
+    const indexOptions = node.props?.['indexOptions'];
+    const uniqueKw = isUnique ? [keyword('UNIQUE', opts), ' '] : '';
+    const kindKw = kind ? [keyword(kind.toUpperCase(), opts), ' '] : '';
+    const colDocs = columns.map((c) => {
+        const colName = propStr(c, 'name') ?? '';
+        const sort = propStr(c, 'sortOrder') ?? 'Ascending';
+        return sort === 'Descending' ? [colName, ' ', keyword('DESC', opts)] : [colName, ' ', keyword('ASC', opts)];
+    });
+    const includePart = includeColumns?.length
+        ? [' ', keyword('INCLUDE', opts), ' ', parenList(includeColumns)]
+        : '';
+    const filterPart = filterPredicate ? [' ', keyword('WHERE', opts), ' ', filterPredicate] : '';
+    const withPart = indexOptions?.length ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')'] : '';
+    return [
+        keyword('INDEX', opts),
+        ' ',
+        indexName,
+        ' ',
+        uniqueKw,
+        kindKw,
+        parenList(colDocs),
+        includePart,
+        filterPart,
+        withPart,
+    ];
+}
 export function printCreateTable(node, opts) {
     const columns = propArr(node, 'columns');
     const constraints = propArr(node, 'constraints');
     const options = node.props?.['options'];
+    const systemTimePeriod = node.props?.['systemTimePeriod'];
+    const indexes = propArr(node, 'indexes');
     const allDefs = [
         ...columns.map((col) => printColumnDef(col, opts)),
         ...constraints.map((c) => printConstraintDef(c, opts)),
+        ...indexes.map((idx) => printInlineIndex(idx, opts)),
     ];
-    const withPart = options && options.length > 0
-        ? [
-            hardline,
-            keyword('WITH', opts),
-            ' ',
-            parenList(options),
-        ]
-        : '';
+    // PERIOD FOR SYSTEM_TIME (ValidFrom, ValidTo) — always last in the table body
+    if (systemTimePeriod) {
+        allDefs.push([
+            keyword('PERIOD FOR SYSTEM_TIME', opts),
+            ' (',
+            systemTimePeriod.startColumn,
+            ', ',
+            systemTimePeriod.endColumn,
+            ')',
+        ]);
+    }
+    const withPart = options && options.length > 0 ? [hardline, keyword('WITH', opts), ' ', parenList(options)] : '';
+    const onFileGroup = propStr(node, 'onFileGroup');
+    const textimageOn = propStr(node, 'textimageOn');
+    const onPart = onFileGroup ? [hardline, keyword('ON', opts), ' ', onFileGroup] : '';
+    const textimagePart = textimageOn ? [hardline, keyword('TEXTIMAGE_ON', opts), ' ', textimageOn] : '';
     return group([
         keyword('CREATE TABLE', opts),
         ' ',
@@ -57,6 +102,8 @@ export function printCreateTable(node, opts) {
         indent([hardline, join([',', hardline], allDefs)]),
         hardline,
         ')',
+        onPart,
+        textimagePart,
         withPart,
         ';',
     ]);
@@ -84,18 +131,94 @@ export function printColumnDef(node, opts) {
     const identitySeed = propStr(node, 'identitySeed');
     const identityIncrement = propStr(node, 'identityIncrement');
     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 parts = [name, ' ', typeStr];
+    // COLLATE clause comes right after the data type
+    if (collation)
+        parts.push(' ', keyword('COLLATE', opts), ' ', collation);
     if (isIdentity) {
         const seed = identitySeed ?? '1';
         const inc = identityIncrement ?? '1';
         parts.push(' ', keyword('IDENTITY', opts), `(${seed}, ${inc})`);
     }
+    if (node.props?.['isRowGuidCol'])
+        parts.push(' ', keyword('ROWGUIDCOL', opts));
+    // SPARSE / FILESTREAM / COLUMN_SET
+    if (node.props?.['isSparse'])
+        parts.push(' ', keyword('SPARSE', opts));
+    if (node.props?.['isFileStream'])
+        parts.push(' ', keyword('FILESTREAM', opts));
+    if (node.props?.['isColumnSet'])
+        parts.push(' ', keyword('COLUMN_SET FOR ALL_SPARSE_COLUMNS', opts));
+    // Temporal table: GENERATED ALWAYS AS ROW START / ROW END [HIDDEN]
+    const generatedAlways = propStr(node, 'generatedAlways');
+    if (generatedAlways) {
+        const gaMap = {
+            RowStart: 'ROW START',
+            RowEnd: 'ROW END',
+            UserIdStart: 'USER ID START',
+            UserIdEnd: 'USER ID END',
+            UserNameStart: 'USER NAME START',
+            UserNameEnd: 'USER NAME END',
+            TransactionIdStart: 'TRANSACTION ID START',
+            TransactionIdEnd: 'TRANSACTION ID END',
+            SequenceNumberStart: 'SEQUENCE NUMBER START',
+            SequenceNumberEnd: 'SEQUENCE NUMBER END',
+        };
+        const gaKw = gaMap[generatedAlways] ?? generatedAlways.toUpperCase();
+        parts.push(' ', keyword('GENERATED ALWAYS AS', opts), ' ', keyword(gaKw, opts));
+    }
+    if (node.props?.['isHidden'])
+        parts.push(' ', keyword('HIDDEN', opts));
+    // Dynamic data masking
+    if (node.props?.['isMasked']) {
+        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));
     parts.push(nullablePart(isNullable, opts));
+    if (checkConstraint) {
+        const checkName = propStr(node, 'checkConstraintName');
+        const checkPrefix = checkName ? [keyword('CONSTRAINT', opts), ' ', checkName, ' '] : '';
+        parts.push(' ', checkPrefix, keyword('CHECK', opts), ' (', printBool(checkConstraint, opts), ')');
+    }
+    // Inline PRIMARY KEY / UNIQUE constraint (e.g. in table variable declarations)
+    const uniqueConstraint = node.props?.['uniqueConstraint'];
+    if (uniqueConstraint) {
+        const constraintNamePrefix = uniqueConstraint.constraintName
+            ? [keyword('CONSTRAINT', opts), ' ', uniqueConstraint.constraintName, ' ']
+            : '';
+        const uqKw = uniqueConstraint.isPrimaryKey ? keyword('PRIMARY KEY', opts) : keyword('UNIQUE', opts);
+        const clusteredKw = uniqueConstraint.clustered === true
+            ? [' ', keyword('CLUSTERED', opts)]
+            : uniqueConstraint.clustered === false
+                ? [' ', keyword('NONCLUSTERED', opts)]
+                : '';
+        parts.push(' ', constraintNamePrefix, uqKw, clusteredKw);
+    }
+    // Inline REFERENCES (column-level foreign key: col type REFERENCES Table(col))
+    const foreignKey = node.props?.['foreignKey'];
+    if (foreignKey) {
+        const refColsPart = foreignKey.refColumns?.length ? [' (', join(', ', foreignKey.refColumns), ')'] : '';
+        parts.push(' ', keyword('REFERENCES', opts), ' ', schemaObjectName(foreignKey.refTable), refColsPart);
+        if (foreignKey.deleteAction) {
+            parts.push(' ', keyword('ON DELETE', opts), ' ', keyword(foreignKey.deleteAction
+                .replace(/([A-Z])/g, ' $1')
+                .trim()
+                .toUpperCase(), opts));
+        }
+        if (foreignKey.updateAction) {
+            parts.push(' ', keyword('ON UPDATE', opts), ' ', keyword(foreignKey.updateAction
+                .replace(/([A-Z])/g, ' $1')
+                .trim()
+                .toUpperCase(), opts));
+        }
+    }
     return parts;
 }
 export function printConstraintDef(node, opts) {
@@ -104,10 +227,24 @@ export function printConstraintDef(node, opts) {
     switch (node.type) {
         case 'UniqueConstraint': {
             const isPK = propBool(node, 'isPrimaryKey');
-            const cols = Array.isArray(node.props?.['columns']) ? node.props?.['columns'] : [];
+            const clustered = node.props?.['clustered'];
+            // Only emit CLUSTERED/NONCLUSTERED when explicitly specified in DDL
+            const clusteredKw = clustered === true
+                ? [keyword('CLUSTERED', opts), ' ']
+                : clustered === false
+                    ? [keyword('NONCLUSTERED', opts), ' ']
+                    : '';
             const kw = isPK ? keyword('PRIMARY KEY', opts) : keyword('UNIQUE', opts);
-            const colsDoc = parenList(cols);
-            return group([namePrefix, indent([softline, kw, ' ', colsDoc])]);
+            // Columns are now {name, order} objects; fall back to plain strings for compat
+            const rawCols = Array.isArray(node.props?.['columns']) ? node.props['columns'] : [];
+            const colDocs = rawCols.map((c) => {
+                if (typeof c === 'string')
+                    return c;
+                const dir = c.order === 'Descending' ? [' ', keyword('DESC', opts)] : '';
+                return [c.name, dir];
+            });
+            const colsDoc = parenList(colDocs);
+            return group([namePrefix, indent([softline, kw, ' ', clusteredKw, colsDoc])]);
         }
         case 'CheckConstraint': {
             const expr = prop(node, 'expression');
@@ -230,13 +367,10 @@ export function printAlterTable(node, opts) {
         ];
     }
     if (alterType === 'AlterTableSetStatement') {
-        // Convert camelCase enum names to SQL_KEYWORD style: LockEscalation → LOCK_ESCALATION
-        const toSqlKw = (s) => s
-            .replace(/([A-Z])/g, '_$1')
-            .replace(/^_/, '')
-            .toUpperCase();
+        // Options come pre-serialized from SerializeTableOption (e.g. "lock_escalation = table",
+        // "system_versioning = on (history_table = dbo.Tbl)"). Render them verbatim — applying
+        // keyword() casing would uppercase embedded schema/table names.
         const options = (node.props?.['options'] ?? []);
-        const optDocs = options.map((o) => [keyword(toSqlKw(o.kind), opts), ' = ', keyword(toSqlKw(o.value), opts)]);
         return [
             keyword('ALTER TABLE', opts),
             ' ',
@@ -244,7 +378,7 @@ export function printAlterTable(node, opts) {
             hardline,
             keyword('SET', opts),
             ' (',
-            join(', ', optDocs),
+            join(', ', options),
             ')',
             ';',
         ];
@@ -291,6 +425,14 @@ export function printAlterTable(node, opts) {
             ';',
         ];
     }
+    if (alterType === 'AlterTableTriggerModificationStatement') {
+        const enable = propBool(node, 'enable');
+        const triggerAll = node.props?.['triggerAll'];
+        const triggerNames = node.props?.['triggerNames'];
+        const verb = enable ? keyword('ENABLE TRIGGER', opts) : keyword('DISABLE TRIGGER', opts);
+        const targets = triggerAll ? keyword('ALL', opts) : join(', ', triggerNames ?? []);
+        return [keyword('ALTER TABLE', opts), ' ', name, hardline, verb, ' ', targets, ';'];
+    }
     return [keyword('ALTER TABLE', opts), ' ', name, ' /* ', alterType, ' */;'];
 }
 // ---------------------------------------------------------------------------
@@ -299,10 +441,10 @@ export function printAlterTable(node, opts) {
 export function printCreateIndex(node, opts) {
     const indexName = propStr(node, 'indexName') ?? 'idx';
     const isUnique = propBool(node, 'unique');
-    const isClustered = propBool(node, 'clustered');
     const table = prop(node, 'table');
     const columns = propArr(node, 'columns');
     const includeColumns = node.props?.['includeColumns'];
+    const filterPredicate = propStr(node, 'filterPredicate');
     const colDocs = columns.map((c) => {
         const colName = propStr(c, 'name') ?? c.text ?? '';
         const sort = propStr(c, 'sortOrder') ?? 'Ascending';
@@ -310,8 +452,14 @@ export function printCreateIndex(node, opts) {
             ? [colName, ' ', keyword('DESC', opts)]
             : [colName, ' ', keyword('ASC', opts)];
     });
-    const uniqueKw = isUnique ? keyword('UNIQUE ', opts) : '';
-    const clusteredKw = isClustered ? keyword('CLUSTERED ', opts) : keyword('NONCLUSTERED ', opts);
+    const uniqueKw = isUnique ? [keyword('UNIQUE', opts), ' '] : '';
+    // Preserve CLUSTERED / NONCLUSTERED exactly as written; omit when not specified.
+    const clusteredProp = node.props?.['clustered'];
+    const clusteredKw = clusteredProp === true
+        ? [keyword('CLUSTERED', opts), ' ']
+        : clusteredProp === false
+            ? [keyword('NONCLUSTERED', opts), ' ']
+            : '';
     const onClause = [
         keyword('ON', opts),
         ' ',
@@ -322,21 +470,23 @@ export function printCreateIndex(node, opts) {
         ')',
     ];
     const includePart = Array.isArray(includeColumns) && includeColumns.length > 0
-        ? [
-            hardline,
-            keyword('INCLUDE', opts),
-            ' ',
-            parenList(includeColumns),
-        ]
+        ? [hardline, keyword('INCLUDE', opts), ' ', parenList(includeColumns)]
+        : '';
+    const filterPart = filterPredicate ? [hardline, keyword('WHERE', opts), ' ', filterPredicate] : '';
+    const indexOptions = node.props?.['indexOptions'];
+    const withPart = indexOptions && indexOptions.length > 0
+        ? [hardline, keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
         : '';
     return group([
-        keyword('CREATE ', opts),
+        keyword('CREATE', opts),
+        ' ',
         uniqueKw,
         clusteredKw,
         keyword('INDEX', opts),
         ' ',
         indexName,
-        indent([hardline, onClause, includePart]),
+        indent([hardline, onClause, includePart, filterPart]),
+        withPart,
         ';',
     ]);
 }
@@ -354,6 +504,12 @@ export function printAlterIndex(node, opts) {
         Set: 'SET',
     };
     const typeKw = keyword(typeKwMap[alterType] ?? alterType.toUpperCase(), opts);
+    const indexOptions = node.props?.['indexOptions'];
+    const partition = propStr(node, 'partition');
+    const withPart = indexOptions && indexOptions.length > 0
+        ? [' ', keyword('WITH', opts), ' (', join(', ', indexOptions), ')']
+        : '';
+    const partitionPart = partition ? [' ', keyword('PARTITION', opts), ' = ', partition] : '';
     return [
         keyword('ALTER INDEX', opts),
         ' ',
@@ -364,6 +520,8 @@ export function printAlterIndex(node, opts) {
         schemaObjectName(table),
         ' ',
         typeKw,
+        withPart,
+        partitionPart,
         ';',
     ];
 }
@@ -410,10 +568,13 @@ export function printCreateProcedure(node, opts) {
     const paramDocs = parameters.map((p) => {
         const pName = propStr(p, 'name') ?? '@p';
         const dt = propStr(p, 'dataType') ?? 'INT';
+        const isUdt = propBool(p, 'isUdt');
         const isOutput = propBool(p, 'output');
         const isReadonly = propBool(p, 'readonly');
         const defaultVal = prop(p, 'defaultValue');
-        const parts = [pName, ' ', keyword(dt, opts)];
+        // UDT names are identifiers, not SQL keywords — skip keyword-casing
+        const dtDoc = isUdt ? dt : keyword(dt, opts);
+        const parts = [pName, ' ', dtDoc];
         if (defaultVal)
             parts.push(' = ', printNode(defaultVal, opts));
         if (isOutput)
@@ -459,7 +620,9 @@ export function printCreateFunction(node, opts) {
     const paramDocs = parameters.map((p) => {
         const pName = propStr(p, 'name') ?? '@p';
         const dt = propStr(p, 'dataType') ?? 'INT';
-        return [pName, ' ', keyword(dt, opts)];
+        const isUdt = propBool(p, 'isUdt');
+        // UDT names are identifiers — skip keyword-casing
+        return [pName, ' ', isUdt ? dt : keyword(dt, opts)];
     });
     const preBody = commentsBlock(node.preBodyComments);
     const postParam = commentsBlock(node.postParamComments);
@@ -468,25 +631,24 @@ export function printCreateFunction(node, opts) {
         : node.type === 'AlterFunctionStatement'
             ? keyword('ALTER FUNCTION', opts)
             : keyword('CREATE FUNCTION', opts);
-    const nameAndParams = [
+    const nameAndParamsNoOpts = [
         fnKw,
         ' ',
         schemaObjectName(prop(node, 'name')),
         preBody,
         group(['(', parameters.length > 0 ? [indent([softline, join([',', line], paramDocs)]), softline] : '', ')']),
         postParam,
-        printModuleOptions(node, opts),
     ];
     if (bodyType === 'table') {
-        // Inline TVF: RETURNS TABLE AS RETURN (query) — no BEGIN/END
-        // returnType raw text contains the SELECT, not the word TABLE — hardcode TABLE
+        // Inline TVF: RETURNS TABLE [WITH options] AS RETURN (query) — no BEGIN/END
         const queryDoc = body && !Array.isArray(body) ? qexpr(body, opts) : '/* query */';
         return [
-            nameAndParams,
-            ' ',
+            nameAndParamsNoOpts,
+            hardline,
             keyword('RETURNS', opts),
             ' ',
             keyword('TABLE', opts),
+            printModuleOptions(node, opts),
             hardline,
             keyword('AS', opts),
             hardline,
@@ -519,12 +681,15 @@ export function printCreateFunction(node, opts) {
     else {
         retTypePart = keyword(returnType, opts);
     }
+    // WITH options come AFTER RETURNS (per T-SQL syntax):
+    // CREATE FUNCTION ... (params) RETURNS type WITH options AS BEGIN ... END
     return [
-        nameAndParams,
-        ' ',
+        nameAndParamsNoOpts,
+        hardline,
         keyword('RETURNS', opts),
         ' ',
         retTypePart,
+        printModuleOptions(node, opts),
         hardline,
         keyword('AS', opts),
         hardline,
@@ -547,9 +712,7 @@ export function printCreateView(node, opts) {
         : node.type === 'AlterViewStatement'
             ? keyword('ALTER VIEW', opts)
             : keyword('CREATE VIEW', opts);
-    const colsPart = columns?.length
-        ? [' ', parenList(columns)]
-        : '';
+    const colsPart = columns?.length ? [' ', parenList(columns)] : '';
     const withPart = withOptions?.length
         ? [
             hardline,
@@ -559,6 +722,8 @@ export function printCreateView(node, opts) {
         ]
         : '';
     const preBodyPart = commentsBlock(node.preBodyComments);
+    const withCheckOption = node.props?.['withCheckOption'];
+    const checkOptionPart = withCheckOption ? [hardline, keyword('WITH CHECK OPTION', opts)] : '';
     return group([
         kw,
         ' ',
@@ -570,6 +735,7 @@ export function printCreateView(node, opts) {
         keyword('AS', opts),
         hardline,
         body ? qexpr(body, opts) : '',
+        checkOptionPart,
         ';',
     ]);
 }
@@ -589,6 +755,8 @@ export function printCreateTrigger(node, opts) {
     const actionList = Array.isArray(actions)
         ? join(', ', actions.map((a) => keyword(a.toUpperCase(), 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));
     return [
         kw,
@@ -602,6 +770,7 @@ export function printCreateTrigger(node, opts) {
         typeKw,
         ' ',
         actionList,
+        notForReplicationDoc,
         hardline,
         keyword('AS', opts),
         hardline,
@@ -749,9 +918,14 @@ export function printDropObjects(objType, node, opts) {
     ];
 }
 export function printDropIndex(node, opts) {
+    const ifExists = propBool(node, 'ifExists');
     const indices = propArr(node, 'indices');
     const indexDocs = indices.map((idx) => [propStr(idx, 'name') ?? '', ' ', keyword('ON', opts), ' ', schemaObjectName(prop(idx, 'table'))]);
-    return group([keyword('DROP INDEX', opts), ' ', join([',', hardline], indexDocs), ';']);
+    const ifExistsPart = ifExists ? [' ', keyword('IF EXISTS', opts)] : '';
+    if (indexDocs.length === 1) {
+        return [keyword('DROP INDEX', opts), ifExistsPart, ' ', indexDocs[0], ';'];
+    }
+    return [keyword('DROP INDEX', opts), ifExistsPart, indent([hardline, join([',', hardline], indexDocs)]), ';'];
 }
 // ---------------------------------------------------------------------------
 // CREATE / DROP SYNONYM
@@ -964,7 +1138,10 @@ export function printUpdateStatistics(node, opts) {
     const subElements = node.props?.['subElements'];
     const options = node.props?.['options'];
     const parts = [keyword('UPDATE STATISTICS', opts), ' ', table ? schemaObjectName(table) : ''];
-    if (subElements?.length)
+    // Single stat name: no parens needed. Multiple: wrap in parens.
+    if (subElements?.length === 1)
+        parts.push([' ', subElements[0]]);
+    else if (subElements?.length)
         parts.push([' ', parenList(subElements)]);
     if (options?.length)
         parts.push([hardline, withOptionsClause(options, opts)]);