mssql-mcp 2.3.3 → 2.3.5

package/README.md

@@ -1,4 +1,4 @@
-# MS SQL Server MCP Server v2.3.2
+# MS SQL Server MCP Server v2.3.5
 
 🚀 **Model Context Protocol (MCP) server** for Microsoft SQL Server - compatible with Claude Desktop, Cursor, Windsurf and VS Code.
 

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.3";
+export declare const SERVER_VERSION = "2.3.5";
 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.3";
+export const SERVER_VERSION = "2.3.5";
 export const DEFAULT_PORT = 1433;
 export const DEFAULT_ENCRYPT = true;
 export const DEFAULT_TRUST_SERVER_CERTIFICATE = false;

package/dist/src/transports/stdio.js

@@ -2,12 +2,24 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { closePoolOnShutdown } from "../db/connection.js";
 export async function runStdioTransport(server) {
     const transport = new StdioServerTransport();
-    const shutdown = async (signal) => {
-        console.error(`\nShutting down (${signal})...`);
+    let shuttingDown = false;
+    const shutdown = async (reason) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.error(`\nShutting down (${reason})...`);
         await closePoolOnShutdown();
         console.error("Server stopped.");
         process.exit(0);
     };
+    // Per the MCP stdio spec, the client signals shutdown by closing the child's
+    // stdin; the server is expected to exit when stdin reaches EOF. Windows does
+    // not reliably deliver OS signals to child processes when the parent exits,
+    // so we must also react to stdin EOF and transport close, otherwise orphaned
+    // node processes accumulate. See https://github.com/BYMCS/mssql-mcp/issues/2
+    transport.onclose = () => shutdown("stdio-close");
+    process.stdin.on("end", () => shutdown("stdin-end"));
+    process.stdin.on("close", () => shutdown("stdin-close"));
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
     process.on("SIGUSR2", () => shutdown("SIGUSR2"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mssql-mcp",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "description": "MCP Server for MS SQL Server integration with Claude Desktop, Cursor, Windsurf and VS Code",
   "main": "dist/src/index.js",
   "type": "module",
@@ -8,7 +8,7 @@
     "mssql-mcp-server": "dist/src/index.js"
   },
   "files": [
-    "dist/**/*",
+    "dist/src/**/*",
     "README.md",
     "package.json"
   ],

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

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

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

@@ -1,180 +0,0 @@
-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

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

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

@@ -1,52 +0,0 @@
-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

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

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

@@ -1,106 +0,0 @@
-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/markdown.test.d.ts

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

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

@@ -1,90 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test } from "node:test";
-import { formatMarkdownTable, formatMarkdownList, formatMarkdownMultiRecordsets, } from "../../src/utils/markdown.js";
-function DateTimeOffset() { }
-function pad(value, width) {
-    return String(value).padStart(width, "0");
-}
-function formatUtcDateTime(date) {
-    return [
-        `${pad(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}`,
-        `${pad(date.getUTCHours(), 2)}:${pad(date.getUTCMinutes(), 2)}:${pad(date.getUTCSeconds(), 2)}.${pad(date.getUTCMilliseconds(), 3)}6938`,
-    ].join(" ");
-}
-test("formatMarkdownTable - renders header and rows", () => {
-    const rows = [
-        { name: "Users", schema: "dbo" },
-        { name: "Orders", schema: "sales" },
-    ];
-    const result = formatMarkdownTable(rows);
-    assert.ok(result.includes("| name | schema |"), "header row missing");
-    assert.ok(result.includes("| --- |"), "separator row missing");
-    assert.ok(result.includes("| Users | dbo |"), "data row 1 missing");
-    assert.ok(result.includes("| Orders | sales |"), "data row 2 missing");
-});
-test("formatMarkdownTable - includes title when provided", () => {
-    const rows = [{ id: 1 }];
-    const result = formatMarkdownTable(rows, "My Table");
-    assert.ok(result.startsWith("**My Table**"), "title missing");
-});
-test("formatMarkdownTable - empty rows returns no results message", () => {
-    const result = formatMarkdownTable([]);
-    assert.ok(result.includes("No results found."));
-});
-test("formatMarkdownTable - empty rows with title includes title", () => {
-    const result = formatMarkdownTable([], "Empty");
-    assert.ok(result.includes("**Empty**"));
-    assert.ok(result.includes("No results found."));
-});
-test("formatMarkdownTable - null/undefined values render as empty string", () => {
-    const rows = [{ id: 1, value: null, flag: undefined }];
-    const result = formatMarkdownTable(rows);
-    assert.ok(result.includes("| 1 |"));
-});
-test("formatMarkdownTable - pipe characters in cell values are escaped", () => {
-    const rows = [{ name: "foo | bar", status: "ok" }];
-    const result = formatMarkdownTable(rows);
-    assert.ok(result.includes("foo \\| bar"), "pipe not escaped");
-    assert.ok(!result.includes("foo | bar"), "raw pipe should not appear in data row");
-});
-test("formatMarkdownTable - newlines in cell values are replaced with space", () => {
-    const rows = [{ notes: "line1\nline2", other: "x" }];
-    const result = formatMarkdownTable(rows);
-    assert.ok(result.includes("line1 line2"), "newline not replaced");
-    assert.ok(!result.includes("line1\nline2"), "raw newline should not appear");
-});
-test("formatMarkdownTable - CRLF in cell values are replaced with space", () => {
-    const rows = [{ notes: "line1\r\nline2" }];
-    const result = formatMarkdownTable(rows);
-    assert.ok(result.includes("line1 line2"));
-});
-test("formatMarkdownTable - datetimeoffset values render without JS timezone string", () => {
-    const offsetTime = new Date(Date.UTC(2026, 3, 1, 10, 51, 23, 600));
-    Object.defineProperty(offsetTime, "nanosecondsDelta", { value: 0.0006938 });
-    const rows = Object.assign([{ offset_time: offsetTime }], {
-        columns: { offset_time: { type: DateTimeOffset, scale: 7 } },
-    });
-    const result = formatMarkdownTable(rows);
-    assert.ok(result.includes(formatUtcDateTime(offsetTime)));
-    assert.ok(!result.includes("GMT"));
-});
-test("formatMarkdownList - renders key-value pairs", () => {
-    const result = formatMarkdownList({ status: "connected", server: "localhost" });
-    assert.ok(result.includes("**status**: connected"));
-    assert.ok(result.includes("**server**: localhost"));
-});
-test("formatMarkdownList - includes title when provided", () => {
-    const result = formatMarkdownList({ x: 1 }, "Info");
-    assert.ok(result.startsWith("**Info**"));
-});
-test("formatMarkdownMultiRecordsets - renders multiple result sets", () => {
-    const rs1 = [{ id: 1 }];
-    const rs2 = [{ name: "foo" }];
-    const result = formatMarkdownMultiRecordsets([rs1, rs2]);
-    assert.ok(result.includes("Result Set 1"));
-    assert.ok(result.includes("Result Set 2"));
-});
-test("formatMarkdownMultiRecordsets - empty recordsets returns message", () => {
-    const result = formatMarkdownMultiRecordsets([]);
-    assert.ok(result.includes("No result sets returned."));
-});

package/dist/tests/unit/query-builders.test.d.ts

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

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

@@ -1,87 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test } from "node:test";
-import { buildSelectQuery, buildSelectWithWhereQuery, buildSchemaObjectsQuery, } from "../../src/db/query-builders.js";
-test("buildSelectQuery - basic SELECT *", () => {
-    const q = buildSelectQuery("dbo", "Users", null, null, 0, 20);
-    assert.ok(q.includes("[dbo].[Users]"));
-    assert.ok(q.includes("OFFSET 0 ROWS FETCH NEXT 20 ROWS ONLY"));
-    assert.ok(q.includes("SELECT *"));
-});
-test("buildSelectQuery - with columns projection", () => {
-    const q = buildSelectQuery("dbo", "Users", ["Id", "Name"], null, 0, 10);
-    assert.ok(q.includes("[Id], [Name]"));
-    assert.ok(!q.includes("SELECT *"));
-});
-test("buildSelectQuery - with orderBy", () => {
-    const q = buildSelectQuery("dbo", "Users", null, "Name ASC", 0, 20);
-    assert.ok(q.includes("ORDER BY Name ASC"));
-});
-test("buildSelectQuery - default ORDER BY fallback", () => {
-    const q = buildSelectQuery("dbo", "Users", null, null, 0, 20);
-    assert.ok(q.includes("ORDER BY (SELECT NULL)"));
-});
-test("buildSelectQuery - offset and limit", () => {
-    const q = buildSelectQuery("dbo", "Orders", null, null, 40, 10);
-    assert.ok(q.includes("OFFSET 40 ROWS FETCH NEXT 10 ROWS ONLY"));
-});
-test("buildSelectWithWhereQuery - includes WHERE", () => {
-    const q = buildSelectWithWhereQuery("dbo", "Orders", null, "Status = @status", null, 0, 20);
-    assert.ok(q.includes("WHERE Status = @status"));
-    assert.ok(q.includes("[dbo].[Orders]"));
-});
-test("buildSelectQuery - rejects invalid schema", () => {
-    assert.throws(() => buildSelectQuery("bad schema", "Users", null, null, 0, 20), /Invalid identifier/);
-});
-test("buildSelectQuery - rejects invalid table", () => {
-    assert.throws(() => buildSelectQuery("dbo", "bad table", null, null, 0, 20), /Invalid identifier/);
-});
-test("buildSchemaObjectsQuery - tables only", () => {
-    const q = buildSchemaObjectsQuery("tables");
-    assert.ok(q.includes("INFORMATION_SCHEMA.TABLES"));
-    assert.ok(!q.includes("INFORMATION_SCHEMA.VIEWS"));
-    assert.ok(!q.includes("ROUTINES"));
-});
-test("buildSchemaObjectsQuery - views only", () => {
-    const q = buildSchemaObjectsQuery("views");
-    assert.ok(q.includes("INFORMATION_SCHEMA.VIEWS"));
-    assert.ok(!q.includes("INFORMATION_SCHEMA.TABLES"));
-});
-test("buildSchemaObjectsQuery - all includes all types", () => {
-    const q = buildSchemaObjectsQuery("all");
-    assert.ok(q.includes("INFORMATION_SCHEMA.TABLES"));
-    assert.ok(q.includes("INFORMATION_SCHEMA.VIEWS"));
-    assert.ok(q.includes("ROUTINE_TYPE = 'PROCEDURE'"));
-    assert.ok(q.includes("ROUTINE_TYPE = 'FUNCTION'"));
-});
-test("buildSchemaObjectsQuery - with schema filter uses @schemaName", () => {
-    const q = buildSchemaObjectsQuery("all", "dbo");
-    assert.ok(q.includes("@schemaName"));
-});
-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/tool-contracts.test.d.ts

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

package/dist/tests/unit/tool-contracts.test.js

@@ -1,95 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test } from "node:test";
-import { toolSuccess, toolSuccessMarkdown } from "../../src/utils/errors.js";
-import { buildPaginationMeta, clampLimit } from "../../src/utils/pagination.js";
-import { formatJson, truncatePayload } from "../../src/utils/format.js";
-function DateTime2() { }
-function pad(value, width) {
-    return String(value).padStart(width, "0");
-}
-function formatLocalDateTime(date) {
-    return [
-        `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1, 2)}-${pad(date.getDate(), 2)}`,
-        `${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}6938`,
-    ].join(" ");
-}
-test("clampLimit - defaults to DEFAULT_PAGE_SIZE (20)", () => {
-    assert.equal(clampLimit(undefined), 20);
-});
-test("clampLimit - enforces max (200)", () => {
-    assert.equal(clampLimit(9999), 200);
-    assert.equal(clampLimit(201), 200);
-});
-test("clampLimit - enforces min (1)", () => {
-    assert.equal(clampLimit(0), 1);
-    assert.equal(clampLimit(-5), 1);
-});
-test("clampLimit - passes through valid value", () => {
-    assert.equal(clampLimit(50), 50);
-    assert.equal(clampLimit(1), 1);
-    assert.equal(clampLimit(200), 200);
-});
-test("buildPaginationMeta - has_more true when count === limit", () => {
-    const p = buildPaginationMeta(20, 20, 0);
-    assert.equal(p.has_more, true);
-    assert.equal(p.next_offset, 20);
-    assert.equal(p.offset, 0);
-    assert.equal(p.count, 20);
-    assert.equal(p.limit, 20);
-});
-test("buildPaginationMeta - has_more false when count < limit", () => {
-    const p = buildPaginationMeta(5, 20, 0);
-    assert.equal(p.has_more, false);
-    assert.equal(p.next_offset, null);
-});
-test("buildPaginationMeta - includes total_count when provided", () => {
-    const p = buildPaginationMeta(20, 20, 0, 100);
-    assert.equal(p.total_count, 100);
-});
-test("buildPaginationMeta - next_offset uses offset correctly", () => {
-    const p = buildPaginationMeta(20, 20, 40);
-    assert.equal(p.next_offset, 60);
-});
-test("truncatePayload - no truncation for small data", () => {
-    const data = [{ id: 1 }, { id: 2 }];
-    const result = truncatePayload(data, 100_000);
-    assert.equal(result.truncated, false);
-    assert.equal(result.data.length, 2);
-    assert.equal(result.truncation_message, undefined);
-});
-test("truncatePayload - truncates when over byte limit", () => {
-    const largeRow = { data: "x".repeat(1000) };
-    const rows = Array.from({ length: 200 }, (_, i) => ({ ...largeRow, id: i }));
-    const result = truncatePayload(rows, 10_000);
-    assert.equal(result.truncated, true);
-    assert.ok(result.data.length < 200, `Expected < 200 rows, got ${result.data.length}`);
-    assert.ok(result.truncation_message?.includes("truncated"));
-    assert.ok(result.truncation_message?.includes("200"));
-});
-test("truncatePayload - empty array not truncated", () => {
-    const result = truncatePayload([], 100_000);
-    assert.equal(result.truncated, false);
-    assert.equal(result.data.length, 0);
-});
-test("formatJson - recordset datetime values use SQL-like formatting", () => {
-    const serverTime = new Date(2026, 3, 1, 10, 51, 23, 600);
-    Object.defineProperty(serverTime, "nanosecondsDelta", { value: 0.0006938 });
-    const rows = Object.assign([{ server_time: serverTime }], {
-        columns: { server_time: { type: DateTime2, scale: 7 } },
-    });
-    const result = formatJson({ recordset: rows });
-    assert.ok(result.includes(formatLocalDateTime(serverTime)));
-    assert.ok(!result.includes("GMT"));
-    assert.ok(!result.includes("T10:51:23"));
-});
-test("toolSuccessMarkdown - returns text content without structuredContent", () => {
-    const result = toolSuccessMarkdown("| col |\n| --- |\n| value |");
-    assert.equal(result.content[0].type, "text");
-    assert.ok(result.content[0].text.includes("| col |"));
-    assert.equal(result.structuredContent, undefined);
-});
-test("toolSuccess - keeps structuredContent for json-style responses", () => {
-    const result = toolSuccess("{\n  \"ok\": true\n}", { ok: true });
-    assert.equal(result.content[0].type, "text");
-    assert.equal(result.structuredContent?.ok, true);
-});

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

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

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

@@ -1,63 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test } from "node:test";
-import { isValidIdentifier, validateIdentifier, bracketIdentifier, validateOrderBy, } from "../../src/db/validators.js";
-test("isValidIdentifier - valid names", () => {
-    assert.ok(isValidIdentifier("dbo"));
-    assert.ok(isValidIdentifier("MyTable"));
-    assert.ok(isValidIdentifier("_private"));
-    assert.ok(isValidIdentifier("table_123"));
-    assert.ok(isValidIdentifier("a$b"));
-    assert.ok(isValidIdentifier("col#1"));
-    assert.ok(isValidIdentifier("_@col"));
-});
-test("isValidIdentifier - invalid names", () => {
-    assert.ok(!isValidIdentifier(""));
-    assert.ok(!isValidIdentifier("1table"));
-    assert.ok(!isValidIdentifier("ta ble"));
-    assert.ok(!isValidIdentifier("ta'ble"));
-    assert.ok(!isValidIdentifier("ta;ble"));
-    assert.ok(!isValidIdentifier("ta--ble"));
-    assert.ok(!isValidIdentifier("ta/*ble"));
-    assert.ok(!isValidIdentifier("ta\nble"));
-});
-test("validateIdentifier - throws on invalid", () => {
-    assert.throws(() => validateIdentifier("bad name", "test"), /Invalid test/);
-    assert.throws(() => validateIdentifier("1start", "test"), /Invalid test/);
-});
-test("validateIdentifier - returns valid name", () => {
-    assert.equal(validateIdentifier("dbo", "schema"), "dbo");
-});
-test("bracketIdentifier - wraps valid name", () => {
-    assert.equal(bracketIdentifier("dbo"), "[dbo]");
-    assert.equal(bracketIdentifier("MyTable"), "[MyTable]");
-    assert.equal(bracketIdentifier("_col"), "[_col]");
-});
-test("bracketIdentifier - throws on invalid", () => {
-    assert.throws(() => bracketIdentifier("bad name"), /Invalid identifier/);
-    assert.throws(() => bracketIdentifier("1bad"), /Invalid identifier/);
-});
-test("validateOrderBy - valid clauses", () => {
-    assert.equal(validateOrderBy("Name ASC"), "Name ASC");
-    assert.equal(validateOrderBy("Id DESC, Name ASC"), "Id DESC, Name ASC");
-    assert.equal(validateOrderBy("CreatedAt"), "CreatedAt");
-    assert.equal(validateOrderBy("[Id] DESC"), "[Id] DESC");
-    assert.equal(validateOrderBy("t.Name"), "t.Name");
-});
-test("validateOrderBy - invalid clauses", () => {
-    assert.throws(() => validateOrderBy("1+1"), /Invalid ORDER BY/);
-    assert.throws(() => validateOrderBy("Name; DROP TABLE"), /Invalid ORDER BY/);
-    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("_"));
-});