mssql-mcp 2.3.2 → 2.3.3

package/dist/src/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const SERVER_NAME = "mssql-mcp-server";
-export declare const SERVER_VERSION = "2.3.2";
+export declare const SERVER_VERSION = "2.3.3";
 export declare const DEFAULT_PORT = 1433;
 export declare const DEFAULT_ENCRYPT = true;
 export declare const DEFAULT_TRUST_SERVER_CERTIFICATE = false;

package/dist/src/constants.js

@@ -1,5 +1,5 @@
 export const SERVER_NAME = "mssql-mcp-server";
-export const SERVER_VERSION = "2.3.2";
+export const SERVER_VERSION = "2.3.3";
 export const DEFAULT_PORT = 1433;
 export const DEFAULT_ENCRYPT = true;
 export const DEFAULT_TRUST_SERVER_CERTIFICATE = false;

package/dist/tests/unit/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/config.test.js

@@ -0,0 +1,180 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { ConfigSchema, loadHttpConfig, loadConfigFromEnv } from "../../src/config.js";
+// --- ConfigSchema ---
+test("ConfigSchema - applies default port 1433", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.port, 1433);
+});
+test("ConfigSchema - applies default encrypt true", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.encrypt, true);
+});
+test("ConfigSchema - applies default trustServerCertificate false", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.trustServerCertificate, false);
+});
+test("ConfigSchema - applies default connectionTimeout 30000", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.connectionTimeout, 30000);
+});
+test("ConfigSchema - applies default requestTimeout 30000", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.requestTimeout, 30000);
+});
+test("ConfigSchema - accepts overridden port", () => {
+    const result = ConfigSchema.parse({ server: "myserver", port: 1434 });
+    assert.equal(result.port, 1434);
+});
+test("ConfigSchema - accepts encrypt false", () => {
+    const result = ConfigSchema.parse({ server: "myserver", encrypt: false });
+    assert.equal(result.encrypt, false);
+});
+test("ConfigSchema - accepts trustServerCertificate true", () => {
+    const result = ConfigSchema.parse({ server: "myserver", trustServerCertificate: true });
+    assert.equal(result.trustServerCertificate, true);
+});
+test("ConfigSchema - throws on empty server string", () => {
+    assert.throws(() => ConfigSchema.parse({ server: "" }), /Server address is required/);
+});
+test("ConfigSchema - throws on missing server", () => {
+    assert.throws(() => ConfigSchema.parse({}));
+});
+test("ConfigSchema - throws on port out of range", () => {
+    assert.throws(() => ConfigSchema.parse({ server: "localhost", port: 0 }));
+    assert.throws(() => ConfigSchema.parse({ server: "localhost", port: 65536 }));
+});
+// --- loadHttpConfig ---
+test("loadHttpConfig - returns default host 127.0.0.1 when env not set", () => {
+    const savedHost = process.env.MCP_HOST;
+    const savedPort = process.env.MCP_PORT;
+    delete process.env.MCP_HOST;
+    delete process.env.MCP_PORT;
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.host, "127.0.0.1");
+    }
+    finally {
+        if (savedHost !== undefined)
+            process.env.MCP_HOST = savedHost;
+        if (savedPort !== undefined)
+            process.env.MCP_PORT = savedPort;
+    }
+});
+test("loadHttpConfig - returns default port 3001 when env not set", () => {
+    const savedHost = process.env.MCP_HOST;
+    const savedPort = process.env.MCP_PORT;
+    delete process.env.MCP_HOST;
+    delete process.env.MCP_PORT;
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.port, 3001);
+    }
+    finally {
+        if (savedHost !== undefined)
+            process.env.MCP_HOST = savedHost;
+        if (savedPort !== undefined)
+            process.env.MCP_PORT = savedPort;
+    }
+});
+test("loadHttpConfig - reads host from MCP_HOST", () => {
+    const savedHost = process.env.MCP_HOST;
+    process.env.MCP_HOST = "0.0.0.0";
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.host, "0.0.0.0");
+    }
+    finally {
+        if (savedHost !== undefined)
+            process.env.MCP_HOST = savedHost;
+        else
+            delete process.env.MCP_HOST;
+    }
+});
+test("loadHttpConfig - reads port from MCP_PORT", () => {
+    const savedPort = process.env.MCP_PORT;
+    process.env.MCP_PORT = "8080";
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.port, 8080);
+    }
+    finally {
+        if (savedPort !== undefined)
+            process.env.MCP_PORT = savedPort;
+        else
+            delete process.env.MCP_PORT;
+    }
+});
+// --- loadConfigFromEnv ---
+test("loadConfigFromEnv - throws when DB_SERVER not set", () => {
+    const saved = process.env.DB_SERVER;
+    delete process.env.DB_SERVER;
+    try {
+        assert.throws(() => loadConfigFromEnv());
+    }
+    finally {
+        if (saved !== undefined)
+            process.env.DB_SERVER = saved;
+    }
+});
+test("loadConfigFromEnv - reads DB_SERVER and applies defaults", () => {
+    const savedServer = process.env.DB_SERVER;
+    const savedEncrypt = process.env.DB_ENCRYPT;
+    process.env.DB_SERVER = "myserver";
+    delete process.env.DB_ENCRYPT;
+    try {
+        const config = loadConfigFromEnv();
+        assert.equal(config.server, "myserver");
+        assert.equal(config.port, 1433);
+        assert.equal(config.encrypt, true);
+        assert.equal(config.trustServerCertificate, false);
+    }
+    finally {
+        if (savedServer !== undefined)
+            process.env.DB_SERVER = savedServer;
+        else
+            delete process.env.DB_SERVER;
+        if (savedEncrypt !== undefined)
+            process.env.DB_ENCRYPT = savedEncrypt;
+    }
+});
+test("loadConfigFromEnv - DB_ENCRYPT=false disables encryption", () => {
+    const savedServer = process.env.DB_SERVER;
+    const savedEncrypt = process.env.DB_ENCRYPT;
+    process.env.DB_SERVER = "myserver";
+    process.env.DB_ENCRYPT = "false";
+    try {
+        const config = loadConfigFromEnv();
+        assert.equal(config.encrypt, false);
+    }
+    finally {
+        if (savedServer !== undefined)
+            process.env.DB_SERVER = savedServer;
+        else
+            delete process.env.DB_SERVER;
+        if (savedEncrypt !== undefined)
+            process.env.DB_ENCRYPT = savedEncrypt;
+        else
+            delete process.env.DB_ENCRYPT;
+    }
+});
+test("loadConfigFromEnv - DB_TRUST_SERVER_CERTIFICATE=true enables trust", () => {
+    const savedServer = process.env.DB_SERVER;
+    const savedTrust = process.env.DB_TRUST_SERVER_CERTIFICATE;
+    process.env.DB_SERVER = "myserver";
+    process.env.DB_TRUST_SERVER_CERTIFICATE = "true";
+    try {
+        const config = loadConfigFromEnv();
+        assert.equal(config.trustServerCertificate, true);
+    }
+    finally {
+        if (savedServer !== undefined)
+            process.env.DB_SERVER = savedServer;
+        else
+            delete process.env.DB_SERVER;
+        if (savedTrust !== undefined)
+            process.env.DB_TRUST_SERVER_CERTIFICATE = savedTrust;
+        else
+            delete process.env.DB_TRUST_SERVER_CERTIFICATE;
+    }
+});

package/dist/tests/unit/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/errors.test.js

@@ -0,0 +1,52 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { McpToolError, toActionableError, toolError } from "../../src/utils/errors.js";
+test("toolError - wraps message with error emoji", () => {
+    const result = toolError("connection failed");
+    assert.equal(result.content[0].type, "text");
+    assert.ok(result.content[0].text.includes("❌"));
+    assert.ok(result.content[0].text.includes("connection failed"));
+});
+test("toolError - sets isError flag to true", () => {
+    const result = toolError("oops");
+    assert.equal(result.isError, true);
+});
+test("toolError - content type is always 'text'", () => {
+    const result = toolError("msg");
+    assert.equal(result.content.length, 1);
+    assert.equal(result.content[0].type, "text");
+});
+test("toActionableError - extracts message from Error instance", () => {
+    const err = new Error("connection refused");
+    assert.equal(toActionableError(err), "connection refused");
+});
+test("toActionableError - converts plain string to string", () => {
+    assert.equal(toActionableError("plain string"), "plain string");
+});
+test("toActionableError - converts number to string", () => {
+    assert.equal(toActionableError(42), "42");
+});
+test("toActionableError - converts null to string", () => {
+    assert.equal(toActionableError(null), "null");
+});
+test("McpToolError - has correct name", () => {
+    const err = new McpToolError("test error");
+    assert.equal(err.name, "McpToolError");
+});
+test("McpToolError - is instanceof Error", () => {
+    const err = new McpToolError("test error");
+    assert.ok(err instanceof Error);
+});
+test("McpToolError - stores message", () => {
+    const err = new McpToolError("something failed");
+    assert.equal(err.message, "something failed");
+});
+test("McpToolError - stores cause when provided", () => {
+    const cause = new Error("original cause");
+    const err = new McpToolError("wrapper", cause);
+    assert.equal(err.cause, cause);
+});
+test("McpToolError - cause is undefined when not provided", () => {
+    const err = new McpToolError("no cause");
+    assert.equal(err.cause, undefined);
+});

package/dist/tests/unit/format.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/format.test.js

@@ -0,0 +1,106 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { formatDisplayValue, normalizeOutput } from "../../src/utils/format.js";
+// Type stubs — getTypeName() uses function.name lowercased,
+// or falls back to object.name property.
+const DateType = { name: "Date" };
+const TimeType = { name: "Time" };
+function pad(value, width) {
+    return String(value).padStart(width, "0");
+}
+function formatLocalDate(d) {
+    return `${pad(d.getFullYear(), 4)}-${pad(d.getMonth() + 1, 2)}-${pad(d.getDate(), 2)}`;
+}
+function formatLocalTime(d) {
+    return `${pad(d.getHours(), 2)}:${pad(d.getMinutes(), 2)}:${pad(d.getSeconds(), 2)}`;
+}
+function formatLocalDateTime(d) {
+    return `${formatLocalDate(d)} ${formatLocalTime(d)}`;
+}
+// --- formatDisplayValue ---
+test("formatDisplayValue - null returns empty string", () => {
+    assert.equal(formatDisplayValue(null), "");
+});
+test("formatDisplayValue - undefined returns empty string", () => {
+    assert.equal(formatDisplayValue(undefined), "");
+});
+test("formatDisplayValue - string returns itself", () => {
+    assert.equal(formatDisplayValue("hello"), "hello");
+});
+test("formatDisplayValue - number returns string representation", () => {
+    assert.equal(formatDisplayValue(42), "42");
+    assert.equal(formatDisplayValue(3.14), "3.14");
+});
+test("formatDisplayValue - boolean returns string representation", () => {
+    assert.equal(formatDisplayValue(true), "true");
+    assert.equal(formatDisplayValue(false), "false");
+});
+test("formatDisplayValue - object returns JSON string", () => {
+    assert.equal(formatDisplayValue({ a: 1 }), JSON.stringify({ a: 1 }));
+});
+// --- normalizeOutput: SQL date types ---
+test("normalizeOutput - 'date' type returns date-only string", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { type: DateType });
+    assert.equal(result, formatLocalDate(d));
+});
+test("normalizeOutput - 'time' type with scale=0 returns time without fraction", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 0);
+    const result = normalizeOutput(d, { type: TimeType, scale: 0 });
+    assert.equal(result, "10:51:23");
+});
+test("normalizeOutput - 'time' type with scale=3 includes milliseconds", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { type: TimeType, scale: 3 });
+    assert.equal(result, "10:51:23.600");
+});
+test("normalizeOutput - datetime with scale=0 returns no fraction", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { scale: 0 });
+    assert.equal(result, `${formatLocalDate(d)} ${formatLocalTime(d)}`);
+});
+test("normalizeOutput - datetime with scale=3 returns 3-digit fraction", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { scale: 3 });
+    assert.equal(result, `${formatLocalDateTime(d)}.600`);
+});
+test("normalizeOutput - datetime with no column metadata trims trailing zeros", () => {
+    // 600ms → base "6000000" → trimmed to "6"
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d);
+    assert.ok(result.startsWith(formatLocalDate(d)));
+    assert.ok(!result.endsWith("0"), `Trailing zeros not trimmed: ${result}`);
+});
+test("normalizeOutput - datetime with zero milliseconds and no scale returns no fraction", () => {
+    // 0ms → base "0000000" → trimmed to "" → no fraction
+    const d = new Date(2026, 3, 1, 10, 51, 23, 0);
+    const result = normalizeOutput(d);
+    assert.equal(result, `${formatLocalDateTime(d)}`);
+});
+// --- normalizeOutput: primitives & structures ---
+test("normalizeOutput - passes through number", () => {
+    assert.equal(normalizeOutput(42), 42);
+});
+test("normalizeOutput - passes through string", () => {
+    assert.equal(normalizeOutput("hello"), "hello");
+});
+test("normalizeOutput - passes through null", () => {
+    assert.equal(normalizeOutput(null), null);
+});
+test("normalizeOutput - passes through boolean", () => {
+    assert.equal(normalizeOutput(true), true);
+});
+test("normalizeOutput - normalizes Date inside plain object", () => {
+    const d = new Date(2026, 3, 1, 10, 0, 0, 0);
+    const result = normalizeOutput({ created: d });
+    assert.equal(result.created, `${formatLocalDateTime(d)}`);
+});
+test("normalizeOutput - normalizes array of primitives unchanged", () => {
+    const result = normalizeOutput([1, "two", null]);
+    assert.deepEqual(result, [1, "two", null]);
+});
+test("normalizeOutput - normalizes Date values inside array", () => {
+    const d = new Date(2026, 3, 1, 10, 0, 0, 0);
+    const result = normalizeOutput([d]);
+    assert.equal(result[0], `${formatLocalDateTime(d)}`);
+});

package/dist/tests/unit/query-builders.test.js

@@ -61,3 +61,27 @@ test("buildSchemaObjectsQuery - without schema filter has no @schemaName", () =>
     const q = buildSchemaObjectsQuery("tables");
     assert.ok(!q.includes("@schemaName"));
 });
+test("buildSchemaObjectsQuery - procedures only", () => {
+    const q = buildSchemaObjectsQuery("procedures");
+    assert.ok(q.includes("ROUTINE_TYPE = 'PROCEDURE'"));
+    assert.ok(!q.includes("INFORMATION_SCHEMA.TABLES"));
+    assert.ok(!q.includes("INFORMATION_SCHEMA.VIEWS"));
+    assert.ok(!q.includes("ROUTINE_TYPE = 'FUNCTION'"));
+});
+test("buildSchemaObjectsQuery - functions only", () => {
+    const q = buildSchemaObjectsQuery("functions");
+    assert.ok(q.includes("ROUTINE_TYPE = 'FUNCTION'"));
+    assert.ok(!q.includes("INFORMATION_SCHEMA.TABLES"));
+    assert.ok(!q.includes("ROUTINE_TYPE = 'PROCEDURE'"));
+});
+test("buildSelectWithWhereQuery - with column projection", () => {
+    const q = buildSelectWithWhereQuery("dbo", "Orders", ["Id", "Status"], "Status = @status", null, 0, 10);
+    assert.ok(q.includes("[Id], [Status]"));
+    assert.ok(q.includes("WHERE Status = @status"));
+    assert.ok(!q.includes("SELECT *"));
+});
+test("buildSelectWithWhereQuery - with orderBy", () => {
+    const q = buildSelectWithWhereQuery("dbo", "Orders", null, "Total > @min", "Total DESC", 0, 20);
+    assert.ok(q.includes("ORDER BY Total DESC"));
+    assert.ok(q.includes("WHERE Total > @min"));
+});

package/dist/tests/unit/validators.test.js

@@ -49,3 +49,15 @@ test("validateOrderBy - invalid clauses", () => {
     assert.throws(() => validateOrderBy("Name UNION SELECT"), /Invalid ORDER BY/);
     assert.throws(() => validateOrderBy("Name--comment"), /Invalid ORDER BY/);
 });
+test("isValidIdentifier - 128-char identifier is valid (at limit)", () => {
+    const name = "a" + "x".repeat(127); // 1 + 127 = 128 chars
+    assert.ok(isValidIdentifier(name));
+});
+test("isValidIdentifier - 129-char identifier is invalid (over limit)", () => {
+    const name = "a" + "x".repeat(128); // 1 + 128 = 129 chars
+    assert.ok(!isValidIdentifier(name));
+});
+test("isValidIdentifier - single char identifier is valid", () => {
+    assert.ok(isValidIdentifier("a"));
+    assert.ok(isValidIdentifier("_"));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mssql-mcp",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "description": "MCP Server for MS SQL Server integration with Claude Desktop, Cursor, Windsurf and VS Code",
   "main": "dist/src/index.js",
   "type": "module",
@@ -31,7 +31,7 @@
     "clean": "rimraf dist",
     "prepublishOnly": "npm run clean && npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "node --test dist/tests/unit/validators.test.js dist/tests/unit/query-builders.test.js dist/tests/unit/tool-contracts.test.js dist/tests/unit/markdown.test.js",
+    "test": "node --test dist/tests/unit/validators.test.js dist/tests/unit/query-builders.test.js dist/tests/unit/tool-contracts.test.js dist/tests/unit/markdown.test.js dist/tests/unit/errors.test.js dist/tests/unit/config.test.js dist/tests/unit/format.test.js",
     "ci": "npm run typecheck && npm run build && npm test"
   },
   "keywords": [
@@ -50,11 +50,11 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.28.0",
     "dotenv": "^16.3.1",
-    "mssql": "^11.0.1",
+    "mssql": "^12.5.5",
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@types/mssql": "^9.1.7",
+    "@types/mssql": "^12.3.0",
     "@types/node": "^20.0.0",
     "cross-env": "^7.0.3",
     "rimraf": "^5.0.0",