@sqb/mssql-dialect 5.0.6 → 6.0.0

package/README.md

@@ -6,30 +6,25 @@
 
 [![NPM Version][npm-image]][npm-url]
 [![NPM Downloads][downloads-image]][downloads-url]
-[![Build Status][travis-image]][travis-url]
+[![CI Tests][ci-test-image]][ci-test-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
-[![Dependencies][dependencies-image]][dependencies-url]
-[![DevDependencies][devdependencies-image]][devdependencies-url]
-[![Package Quality][quality-image]][quality-url]
 
 ## About SQB
 
 SQB is an extensible, multi-dialect SQL query builder and Database connection wrapper for NodeJS.
 
-## Main goals
+## About @sqb/mssql-dialect
 
-- Single code base for any sql based database
-- Powerful and simplified query coding scheme
-- Fast applications with low memory requirements
-- Let applications work with large data tables efficiently
-- Support latest JavaScript language standards
-- Lightweight and extensible framework.
+This package registers the `mssql` SQL serialization dialect (a `SerializerExtension` for
+[`@sqb/builder`](../builder)) used by [`@sqb/mssql`](../mssql). It is loaded automatically when
+`@sqb/mssql` is imported, so you normally don't need to depend on it directly.
 
-You can report bugs and discuss features on the [GitHub issues](https://github.com/sqbjs/sqb/issues) page
-
-Thanks to all of the great [contributions](https://github.com/sqbjs/sqb/graphs/contributors) to the project.
-
-You may want to check detailed [DOCUMENTATION](https://sqbjs.github.io/sqb/)
+It adapts query output to T-SQL: `@name` parameter placeholders instead of `:name`, `OFFSET ...
+ROWS [FETCH NEXT ... ROWS ONLY]` instead of `LIMIT`/`OFFSET` (SQL Server requires an `ORDER BY`
+before `OFFSET`, which the dialect adds automatically when a query needs pagination but has none),
+and SQL Server's own reserved-word list. `RETURNING` is rewritten into SQL Server's native `OUTPUT
+INSERTED.col` / `OUTPUT DELETED.col` clause rather than being stripped, since SQL Server has no
+`RETURNING` keyword but its `OUTPUT` clause achieves the same thing without a follow-up `SELECT`.
 
 ## Installation
 
@@ -39,7 +34,7 @@ $ npm install @sqb/mssql-dialect --save
 
 ## Node Compatibility
 
-- node >= 16.x
+- node >= 20.x
 
 ### License
 
@@ -47,17 +42,9 @@ SQB is available under [MIT](LICENSE) license.
 
 [npm-image]: https://img.shields.io/npm/v/@sqb/mssql-dialect.svg
 [npm-url]: https://npmjs.org/package/@sqb/mssql-dialect
-[travis-image]: https://img.shields.io/travis/sqbjs/@sqb/mssql-dialect/master.svg
-[travis-url]: https://travis-ci.org/sqbjs/@sqb/mssql-dialect
-[coveralls-image]: https://img.shields.io/coveralls/sqbjs/@sqb/mssql-dialect/master.svg
-[coveralls-url]: https://coveralls.io/r/sqbjs/@sqb/mssql-dialect
 [downloads-image]: https://img.shields.io/npm/dm/@sqb/mssql-dialect.svg
 [downloads-url]: https://npmjs.org/package/@sqb/mssql-dialect
-[gitter-image]: https://badges.gitter.im/sqbjs/@sqb/mssql-dialect.svg
-[gitter-url]: https://gitter.im/sqbjs/@sqb/mssql-dialect?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-[dependencies-image]: https://david-dm.org/sqbjs/@sqb/mssql-dialect/status.svg
-[dependencies-url]: https://david-dm.org/sqbjs/@sqb/mssql-dialect
-[devdependencies-image]: https://david-dm.org/sqbjs/@sqb/mssql-dialect/dev-status.svg
-[devdependencies-url]: https://david-dm.org/sqbjs/@sqb/mssql-dialect?type=dev
-[quality-image]: http://npm.packagequality.com/shield/@sqb/mssql-dialect.png
-[quality-url]: http://packagequality.com/#?package=@sqb/mssql-dialect
+[ci-test-image]: https://github.com/panates/sqb/actions/workflows/test.yml/badge.svg
+[ci-test-url]: https://github.com/panates/sqb/actions/workflows/test.yml
+[coveralls-image]: https://coveralls.io/repos/github/sqbjs/sqb/badge.svg?branch=master
+[coveralls-url]: https://coveralls.io/github/sqbjs/sqb?branch=master

package/ms-sql-serializer.d.ts

@@ -1,8 +1,13 @@
 import { type DefaultSerializeFunction, SerializationType, SerializeContext, type SerializerExtension } from '@sqb/builder';
 export declare class MSSqlSerializer implements SerializerExtension {
     dialect: string;
-    isReservedWord(ctx: any, s: any): any;
+    reservedWords: Set<string>;
+    isReservedWord(_: any, s: any): any;
     serialize(ctx: SerializeContext, type: SerializationType | string, o: any, defFn: DefaultSerializeFunction): string | undefined;
     private _serializeSelect;
+    private _serializeComparison;
+    private _serializeBooleanValue;
+    private _serializeStringValue;
+    private _serializeReturning;
     private _serializeParameter;
 }

package/ms-sql-serializer.js

@@ -1,14 +1,151 @@
-import { SerializationType, SerializeContext, } from '@sqb/builder';
-const reservedWords = ['comment'];
+import { isParam, OperatorType, SerializationType, SerializeContext, } from '@sqb/builder';
+// T-SQL reserved keywords (Reserved Keywords (Transact-SQL), learn.microsoft.com)
+// that are not already covered by SerializeContext's base reservedWords list.
+const reservedWords = new Set([
+    'any',
+    'backup',
+    'begin',
+    'break',
+    'browse',
+    'bulk',
+    'checkpoint',
+    'close',
+    'clustered',
+    'coalesce',
+    'collate',
+    'comment',
+    'commit',
+    'compute',
+    'contains',
+    'containstable',
+    'continue',
+    'convert',
+    'cross',
+    'current',
+    'current_date',
+    'current_time',
+    'current_timestamp',
+    'current_user',
+    'cursor',
+    'database',
+    'dbcc',
+    'deallocate',
+    'declare',
+    'deny',
+    'disk',
+    'distributed',
+    'double',
+    'dump',
+    'errlvl',
+    'escape',
+    'except',
+    'exec',
+    'execute',
+    'exists',
+    'exit',
+    'external',
+    'fetch',
+    'file',
+    'fillfactor',
+    'freetext',
+    'freetexttable',
+    'function',
+    'goto',
+    'grant',
+    'holdlock',
+    'identity',
+    'identity_insert',
+    'identitycol',
+    'if',
+    'intersect',
+    'kill',
+    'lineno',
+    'load',
+    'national',
+    'nocheck',
+    'nonclustered',
+    'nullif',
+    'of',
+    'off',
+    'offsets',
+    'open',
+    'opendatasource',
+    'openquery',
+    'openrowset',
+    'openxml',
+    'option',
+    'over',
+    'percent',
+    'pivot',
+    'plan',
+    'precision',
+    'print',
+    'proc',
+    'procedure',
+    'public',
+    'raiserror',
+    'read',
+    'readtext',
+    'reconfigure',
+    'replication',
+    'restore',
+    'restrict',
+    'return',
+    'revert',
+    'revoke',
+    'rollback',
+    'rowcount',
+    'rowguidcol',
+    'rule',
+    'save',
+    'securityaudit',
+    'semantickeyphrasetable',
+    'semanticsimilaritydetailstable',
+    'semanticsimilaritytable',
+    'session_user',
+    'set',
+    'setuser',
+    'shutdown',
+    'some',
+    'statistics',
+    'system_user',
+    'tablesample',
+    'textsize',
+    'top',
+    'tran',
+    'transaction',
+    'trigger',
+    'truncate',
+    'try_convert',
+    'tsequal',
+    'unpivot',
+    'updatetext',
+    'use',
+    'values',
+    'varying',
+    'view',
+    'waitfor',
+    'while',
+    'writetext',
+]);
 export class MSSqlSerializer {
     dialect = 'mssql';
-    isReservedWord(ctx, s) {
-        return (s && typeof s === 'string' && reservedWords.includes(s.toLowerCase()));
+    reservedWords = reservedWords;
+    isReservedWord(_, s) {
+        return s && typeof s === 'string' && reservedWords.has(s.toLowerCase());
     }
     serialize(ctx, type, o, defFn) {
         switch (type) {
             case SerializationType.SELECT_QUERY:
                 return this._serializeSelect(ctx, o, defFn);
+            case SerializationType.COMPARISON_EXPRESSION:
+                return this._serializeComparison(ctx, o, defFn);
+            case SerializationType.BOOLEAN_VALUE:
+                return this._serializeBooleanValue(ctx, o);
+            case SerializationType.STRING_VALUE:
+                return this._serializeStringValue(ctx, o, defFn);
+            case SerializationType.RETURNING_BLOCK:
+                return this._serializeReturning();
             case SerializationType.EXTERNAL_PARAMETER:
                 return this._serializeParameter(ctx, o, defFn);
             default:
@@ -19,13 +156,95 @@ export class MSSqlSerializer {
         let out = defFn(ctx, o);
         const limit = o.limit || 0;
         const offset = Math.max(o.offset || 0, 0);
-        if (offset)
+        if (limit || offset) {
+            // OFFSET/FETCH is only valid when preceded by an ORDER BY clause.
+            if (!o.orderBy)
+                out += '\nORDER BY (SELECT NULL)';
             out += '\nOFFSET ' + offset + ' ROWS';
-        if (limit)
-            out += (!offset ? '\n' : ' ') + 'FETCH NEXT ' + limit + ' ROWS ONLY';
+            if (limit)
+                out += ' FETCH NEXT ' + limit + ' ROWS ONLY';
+        }
         return out;
     }
+    _serializeComparison(ctx, o, defFn) {
+        if (isParam(o.orgRight)) {
+            const n = o.orgRight._name;
+            const v = ctx.orgParams?.[n];
+            if (Array.isArray(v)) {
+                o.right.isParam = false;
+                if (o.operatorType === 'eq')
+                    return defFn(ctx, {
+                        ...o,
+                        operatorType: OperatorType.in,
+                        symbol: 'in',
+                    });
+                if (o.operatorType === 'ne')
+                    return defFn(ctx, {
+                        ...o,
+                        operatorType: OperatorType.notIn,
+                        symbol: 'not in',
+                    });
+            }
+        }
+        if ((o.right?.expression && o.right?.expression === 'null') ||
+            (o.right &&
+                o.right?.value == null &&
+                (!o.right.expression || o.right.expression.startsWith('@')))) {
+            if (o.right.expression?.startsWith('@')) {
+                const s = o.right.expression.substring(1);
+                if (ctx.params)
+                    delete ctx.params[s];
+                if (ctx.preparedParams)
+                    delete ctx.preparedParams[s];
+                if (ctx.paramOptions)
+                    delete ctx.paramOptions[s];
+                o.right.expression = 'null';
+                o.right.isParam = false;
+            }
+            if (o.operatorType === 'eq')
+                return defFn(ctx, {
+                    ...o,
+                    operatorType: OperatorType.is,
+                    symbol: 'is',
+                });
+            if (o.operatorType === 'ne')
+                return defFn(ctx, {
+                    ...o,
+                    operatorType: OperatorType.isNot,
+                    symbol: 'is not',
+                });
+        }
+        return defFn(ctx, o);
+    }
+    _serializeBooleanValue(_ctx, o) {
+        return o == null ? 'null' : o ? '1' : '0';
+    }
+    _serializeStringValue(ctx, o, defFn) {
+        // T-SQL's implicit conversion of ISO 8601 strings carrying a timezone
+        // offset (e.g. from JSON test fixtures) into `datetime`/`date` is
+        // unreliable, so normalize to 'yyyy-mm-dd hh:mm:ss' ourselves.
+        if (typeof o === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(o)) {
+            const d = new Date(o);
+            if (!isNaN(d.getTime()))
+                return ctx.dateToSQL(d);
+        }
+        return defFn(ctx, o);
+    }
+    _serializeReturning() {
+        // T-SQL has no RETURNING clause; the OUTPUT clause it uses instead
+        // must be positioned before WHERE/VALUES rather than at the end of
+        // the statement, so it is injected at the connection layer instead.
+        return '';
+    }
     _serializeParameter(ctx, o, defFn) {
+        if (ctx.rootQuery._type === SerializationType.SELECT_QUERY ||
+            ctx.rootQuery._type === SerializationType.DELETE_QUERY) {
+            const v = ctx.params?.[o.name];
+            if (Array.isArray(v)) {
+                delete ctx.params?.[o.name];
+                return ctx.anyToSQL(v);
+            }
+        }
         defFn(ctx, o);
         return '@' + o.name;
     }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@sqb/mssql-dialect",
   "description": "SQB serialization extension for MS-SQL database",
-  "version": "5.0.6",
+  "version": "6.0.0",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@sqb/builder": "^5.0.6"
+    "@sqb/builder": "^6.0.0"
   },
   "type": "module",
   "module": "./index.js",