@eamonboyle/mssql-mcp 1.1.0 → 1.2.0

package/dist/__tests__/db.test.js

@@ -1,204 +1,204 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-const mssqlMockState = vi.hoisted(() => ({
-    poolConfigs: [],
-    requestObject: { kind: "mock-request" },
-    connectCalls: vi.fn(),
-    closeCalls: vi.fn(),
-    requestCalls: vi.fn(),
-}));
-// Mock mssql to avoid loading native deps and transitive issues in test env
-vi.mock("mssql", () => {
-    class MockConnectionPool {
-        constructor(config) {
-            this.config = config;
-            this.connected = false;
-            mssqlMockState.poolConfigs.push(config);
-        }
-        async connect() {
-            this.connected = true;
-            mssqlMockState.connectCalls(this.config);
-            return this;
-        }
-        async close() {
-            this.connected = false;
-            mssqlMockState.closeCalls(this.config);
-        }
-        request() {
-            mssqlMockState.requestCalls(this.config);
-            return mssqlMockState.requestObject;
-        }
-    }
-    return {
-        default: {
-            ConnectionPool: MockConnectionPool,
-        },
-    };
-});
-import { getAllowedDatabases, getSqlRequest, resolveDatabaseName } from "../db.js";
-describe("getAllowedDatabases", () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        process.env = { ...originalEnv };
-        mssqlMockState.poolConfigs.length = 0;
-        mssqlMockState.connectCalls.mockClear();
-        mssqlMockState.closeCalls.mockClear();
-        mssqlMockState.requestCalls.mockClear();
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    it("returns DATABASE_NAME when DATABASES is not set", () => {
-        delete process.env.DATABASES;
-        process.env.DATABASE_NAME = "MyDb";
-        expect(getAllowedDatabases()).toEqual(["MyDb"]);
-    });
-    it("returns empty array when neither DATABASES nor DATABASE_NAME is set", () => {
-        delete process.env.DATABASES;
-        delete process.env.DATABASE_NAME;
-        expect(getAllowedDatabases()).toEqual([]);
-    });
-    it("returns empty array when DATABASE_NAME is empty string", () => {
-        delete process.env.DATABASES;
-        process.env.DATABASE_NAME = "";
-        expect(getAllowedDatabases()).toEqual([]);
-    });
-    it("returns DATABASES split by comma when set", () => {
-        process.env.DATABASES = "ProdDB,StagingDB,AnalyticsDB";
-        expect(getAllowedDatabases()).toEqual([
-            "ProdDB",
-            "StagingDB",
-            "AnalyticsDB",
-        ]);
-    });
-    it("trims whitespace from DATABASES entries", () => {
-        process.env.DATABASES = "  ProdDB , StagingDB , AnalyticsDB  ";
-        expect(getAllowedDatabases()).toEqual([
-            "ProdDB",
-            "StagingDB",
-            "AnalyticsDB",
-        ]);
-    });
-    it("filters out empty entries from DATABASES", () => {
-        process.env.DATABASES = "ProdDB,,StagingDB,";
-        expect(getAllowedDatabases()).toEqual(["ProdDB", "StagingDB"]);
-    });
-    it("prefers DATABASES over DATABASE_NAME when both set", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        process.env.DATABASE_NAME = "OtherDb";
-        expect(getAllowedDatabases()).toEqual(["ProdDB", "StagingDB"]);
-    });
-});
-describe("resolveDatabaseName", () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        process.env = { ...originalEnv };
-        mssqlMockState.poolConfigs.length = 0;
-        mssqlMockState.connectCalls.mockClear();
-        mssqlMockState.closeCalls.mockClear();
-        mssqlMockState.requestCalls.mockClear();
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    it("returns param when valid and in allowed list", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        expect(resolveDatabaseName("ProdDB")).toBe("ProdDB");
-        expect(resolveDatabaseName("StagingDB")).toBe("StagingDB");
-    });
-    it("returns DATABASE_NAME when param omitted and DATABASES not set", () => {
-        process.env.DATABASE_NAME = "DefaultDb";
-        delete process.env.DATABASES;
-        expect(resolveDatabaseName()).toBe("DefaultDb");
-    });
-    it("returns DATABASE_NAME when it is in DATABASES", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        process.env.DATABASE_NAME = "StagingDB";
-        expect(resolveDatabaseName()).toBe("StagingDB");
-    });
-    it("returns the first DATABASES entry when DATABASE_NAME is omitted", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        delete process.env.DATABASE_NAME;
-        expect(resolveDatabaseName()).toBe("ProdDB");
-    });
-    it("returns param when param provided and in allowed list", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        process.env.DATABASE_NAME = "ProdDB";
-        expect(resolveDatabaseName("StagingDB")).toBe("StagingDB");
-    });
-    it("falls back to the first DATABASES entry when DATABASE_NAME is not included in DATABASES", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        process.env.DATABASE_NAME = "OtherDb";
-        expect(resolveDatabaseName()).toBe("ProdDB");
-    });
-    it("returns null when param not in allowed list", () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        expect(resolveDatabaseName("OtherDb")).toBeNull();
-    });
-    it("returns null when param is empty and DATABASE_NAME not set", () => {
-        delete process.env.DATABASE_NAME;
-        delete process.env.DATABASES;
-        expect(resolveDatabaseName()).toBeNull();
-        expect(resolveDatabaseName("")).toBeNull();
-    });
-    it("returns resolved name when no DATABASES set (only DATABASE_NAME allowed)", () => {
-        delete process.env.DATABASES;
-        process.env.DATABASE_NAME = "MyDb";
-        expect(resolveDatabaseName()).toBe("MyDb");
-        expect(resolveDatabaseName("MyDb")).toBe("MyDb");
-        expect(resolveDatabaseName("AnyDb")).toBeNull();
-    });
-    it("trims whitespace from param", () => {
-        process.env.DATABASES = "ProdDB";
-        expect(resolveDatabaseName("  ProdDB  ")).toBe("ProdDB");
-    });
-    it("returns null when neither DATABASE_NAME nor DATABASES is configured", () => {
-        delete process.env.DATABASE_NAME;
-        delete process.env.DATABASES;
-        expect(resolveDatabaseName()).toBeNull();
-    });
-});
-describe("getSqlRequest", () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        process.env = { ...originalEnv };
-        mssqlMockState.poolConfigs.length = 0;
-        mssqlMockState.connectCalls.mockClear();
-        mssqlMockState.closeCalls.mockClear();
-        mssqlMockState.requestCalls.mockClear();
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    it("returns a helpful error when no database access is configured", async () => {
-        delete process.env.DATABASE_NAME;
-        delete process.env.DATABASES;
-        const result = await getSqlRequest();
-        expect(result.error).toBe("Invalid or disallowed database. Set DATABASE_NAME or DATABASES to configure database access. Use the databaseName parameter to target a specific configured database.");
-    });
-    it("returns allowed databases in the error when a disallowed database is requested", async () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        const result = await getSqlRequest("OtherDb");
-        expect(result.error).toBe("Invalid or disallowed database. Allowed: ProdDB, StagingDB. Use the databaseName parameter to target a specific configured database.");
-    });
-    it("returns a request using the resolved default database", async () => {
-        process.env.DATABASES = "ProdDBDefault,StagingDB";
-        delete process.env.DATABASE_NAME;
-        const result = await getSqlRequest();
-        expect(result.error).toBeUndefined();
-        expect(result.request).toBe(mssqlMockState.requestObject);
-        expect(mssqlMockState.poolConfigs).toContainEqual(expect.objectContaining({ database: "ProdDBDefault" }));
-        expect(mssqlMockState.connectCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDBDefault" }));
-        expect(mssqlMockState.requestCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDBDefault" }));
-    });
-    it("falls back to the first allowed database when DATABASE_NAME is disallowed", async () => {
-        process.env.DATABASES = "ProdDB,StagingDB";
-        process.env.DATABASE_NAME = "OtherDb";
-        const result = await getSqlRequest();
-        expect(result.error).toBeUndefined();
-        expect(result.request).toBe(mssqlMockState.requestObject);
-        expect(mssqlMockState.poolConfigs).toContainEqual(expect.objectContaining({ database: "ProdDB" }));
-        expect(mssqlMockState.connectCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDB" }));
-        expect(mssqlMockState.requestCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDB" }));
-    });
-});
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+const mssqlMockState = vi.hoisted(() => ({
+    poolConfigs: [],
+    requestObject: { kind: "mock-request" },
+    connectCalls: vi.fn(),
+    closeCalls: vi.fn(),
+    requestCalls: vi.fn(),
+}));
+// Mock mssql to avoid loading native deps and transitive issues in test env
+vi.mock("mssql", () => {
+    class MockConnectionPool {
+        constructor(config) {
+            this.config = config;
+            this.connected = false;
+            mssqlMockState.poolConfigs.push(config);
+        }
+        async connect() {
+            this.connected = true;
+            mssqlMockState.connectCalls(this.config);
+            return this;
+        }
+        async close() {
+            this.connected = false;
+            mssqlMockState.closeCalls(this.config);
+        }
+        request() {
+            mssqlMockState.requestCalls(this.config);
+            return mssqlMockState.requestObject;
+        }
+    }
+    return {
+        default: {
+            ConnectionPool: MockConnectionPool,
+        },
+    };
+});
+import { getAllowedDatabases, getSqlRequest, resolveDatabaseName } from "../db.js";
+describe("getAllowedDatabases", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        mssqlMockState.poolConfigs.length = 0;
+        mssqlMockState.connectCalls.mockClear();
+        mssqlMockState.closeCalls.mockClear();
+        mssqlMockState.requestCalls.mockClear();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it("returns DATABASE_NAME when DATABASES is not set", () => {
+        delete process.env.DATABASES;
+        process.env.DATABASE_NAME = "MyDb";
+        expect(getAllowedDatabases()).toEqual(["MyDb"]);
+    });
+    it("returns empty array when neither DATABASES nor DATABASE_NAME is set", () => {
+        delete process.env.DATABASES;
+        delete process.env.DATABASE_NAME;
+        expect(getAllowedDatabases()).toEqual([]);
+    });
+    it("returns empty array when DATABASE_NAME is empty string", () => {
+        delete process.env.DATABASES;
+        process.env.DATABASE_NAME = "";
+        expect(getAllowedDatabases()).toEqual([]);
+    });
+    it("returns DATABASES split by comma when set", () => {
+        process.env.DATABASES = "ProdDB,StagingDB,AnalyticsDB";
+        expect(getAllowedDatabases()).toEqual([
+            "ProdDB",
+            "StagingDB",
+            "AnalyticsDB",
+        ]);
+    });
+    it("trims whitespace from DATABASES entries", () => {
+        process.env.DATABASES = "  ProdDB , StagingDB , AnalyticsDB  ";
+        expect(getAllowedDatabases()).toEqual([
+            "ProdDB",
+            "StagingDB",
+            "AnalyticsDB",
+        ]);
+    });
+    it("filters out empty entries from DATABASES", () => {
+        process.env.DATABASES = "ProdDB,,StagingDB,";
+        expect(getAllowedDatabases()).toEqual(["ProdDB", "StagingDB"]);
+    });
+    it("prefers DATABASES over DATABASE_NAME when both set", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        process.env.DATABASE_NAME = "OtherDb";
+        expect(getAllowedDatabases()).toEqual(["ProdDB", "StagingDB"]);
+    });
+});
+describe("resolveDatabaseName", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        mssqlMockState.poolConfigs.length = 0;
+        mssqlMockState.connectCalls.mockClear();
+        mssqlMockState.closeCalls.mockClear();
+        mssqlMockState.requestCalls.mockClear();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it("returns param when valid and in allowed list", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        expect(resolveDatabaseName("ProdDB")).toBe("ProdDB");
+        expect(resolveDatabaseName("StagingDB")).toBe("StagingDB");
+    });
+    it("returns DATABASE_NAME when param omitted and DATABASES not set", () => {
+        process.env.DATABASE_NAME = "DefaultDb";
+        delete process.env.DATABASES;
+        expect(resolveDatabaseName()).toBe("DefaultDb");
+    });
+    it("returns DATABASE_NAME when it is in DATABASES", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        process.env.DATABASE_NAME = "StagingDB";
+        expect(resolveDatabaseName()).toBe("StagingDB");
+    });
+    it("returns the first DATABASES entry when DATABASE_NAME is omitted", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        delete process.env.DATABASE_NAME;
+        expect(resolveDatabaseName()).toBe("ProdDB");
+    });
+    it("returns param when param provided and in allowed list", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        process.env.DATABASE_NAME = "ProdDB";
+        expect(resolveDatabaseName("StagingDB")).toBe("StagingDB");
+    });
+    it("falls back to the first DATABASES entry when DATABASE_NAME is not included in DATABASES", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        process.env.DATABASE_NAME = "OtherDb";
+        expect(resolveDatabaseName()).toBe("ProdDB");
+    });
+    it("returns null when param not in allowed list", () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        expect(resolveDatabaseName("OtherDb")).toBeNull();
+    });
+    it("returns null when param is empty and DATABASE_NAME not set", () => {
+        delete process.env.DATABASE_NAME;
+        delete process.env.DATABASES;
+        expect(resolveDatabaseName()).toBeNull();
+        expect(resolveDatabaseName("")).toBeNull();
+    });
+    it("returns resolved name when no DATABASES set (only DATABASE_NAME allowed)", () => {
+        delete process.env.DATABASES;
+        process.env.DATABASE_NAME = "MyDb";
+        expect(resolveDatabaseName()).toBe("MyDb");
+        expect(resolveDatabaseName("MyDb")).toBe("MyDb");
+        expect(resolveDatabaseName("AnyDb")).toBeNull();
+    });
+    it("trims whitespace from param", () => {
+        process.env.DATABASES = "ProdDB";
+        expect(resolveDatabaseName("  ProdDB  ")).toBe("ProdDB");
+    });
+    it("returns null when neither DATABASE_NAME nor DATABASES is configured", () => {
+        delete process.env.DATABASE_NAME;
+        delete process.env.DATABASES;
+        expect(resolveDatabaseName()).toBeNull();
+    });
+});
+describe("getSqlRequest", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        mssqlMockState.poolConfigs.length = 0;
+        mssqlMockState.connectCalls.mockClear();
+        mssqlMockState.closeCalls.mockClear();
+        mssqlMockState.requestCalls.mockClear();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it("returns a helpful error when no database access is configured", async () => {
+        delete process.env.DATABASE_NAME;
+        delete process.env.DATABASES;
+        const result = await getSqlRequest();
+        expect(result.error).toBe("Invalid or disallowed database. Set DATABASE_NAME or DATABASES to configure database access. Use the databaseName parameter to target a specific configured database.");
+    });
+    it("returns allowed databases in the error when a disallowed database is requested", async () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        const result = await getSqlRequest("OtherDb");
+        expect(result.error).toBe("Invalid or disallowed database. Allowed: ProdDB, StagingDB. Use the databaseName parameter to target a specific configured database.");
+    });
+    it("returns a request using the resolved default database", async () => {
+        process.env.DATABASES = "ProdDBDefault,StagingDB";
+        delete process.env.DATABASE_NAME;
+        const result = await getSqlRequest();
+        expect(result.error).toBeUndefined();
+        expect(result.request).toBe(mssqlMockState.requestObject);
+        expect(mssqlMockState.poolConfigs).toContainEqual(expect.objectContaining({ database: "ProdDBDefault" }));
+        expect(mssqlMockState.connectCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDBDefault" }));
+        expect(mssqlMockState.requestCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDBDefault" }));
+    });
+    it("falls back to the first allowed database when DATABASE_NAME is disallowed", async () => {
+        process.env.DATABASES = "ProdDB,StagingDB";
+        process.env.DATABASE_NAME = "OtherDb";
+        const result = await getSqlRequest();
+        expect(result.error).toBeUndefined();
+        expect(result.request).toBe(mssqlMockState.requestObject);
+        expect(mssqlMockState.poolConfigs).toContainEqual(expect.objectContaining({ database: "ProdDB" }));
+        expect(mssqlMockState.connectCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDB" }));
+        expect(mssqlMockState.requestCalls).toHaveBeenCalledWith(expect.objectContaining({ database: "ProdDB" }));
+    });
+});
 //# sourceMappingURL=db.test.js.map

package/dist/__tests__/promptRegistry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=promptRegistry.test.d.ts.map

package/dist/__tests__/promptRegistry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptRegistry.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/promptRegistry.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/promptRegistry.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { registerPrompts } from "../promptRegistry.js";
+describe("promptRegistry", () => {
+    it("registers prompt callbacks without a fallback branch", () => {
+        const callbacks = new Map();
+        const server = {
+            registerPrompt(name, _meta, callback) {
+                callbacks.set(name, callback);
+            },
+        };
+        registerPrompts(server, { isReadOnly: false });
+        const callback = callbacks.get("review_write_operation");
+        expect(callback).toBeDefined();
+        expect(callback?.({
+            operation: "delete inactive users",
+            databaseName: "AppDb",
+        })).toMatchObject({
+            description: "Review a proposed change and identify safety checks before running it.",
+        });
+    });
+    it("review_write_operation tells the assistant not to bypass when read-only", () => {
+        const callbacks = new Map();
+        const server = {
+            registerPrompt(name, _meta, callback) {
+                callbacks.set(name, callback);
+            },
+        };
+        registerPrompts(server, { isReadOnly: true });
+        const callback = callbacks.get("review_write_operation");
+        const result = callback({
+            operation: "DELETE FROM dbo.Users WHERE id = 1",
+            databaseName: "AppDb",
+        });
+        const text = result.messages[0].content.text;
+        expect(text).toContain("read-only");
+        expect(text).toMatch(/sqlcmd|SSMS/i);
+        expect(text).toMatch(/STOP|Do not execute/i);
+    });
+});
+//# sourceMappingURL=promptRegistry.test.js.map

package/dist/__tests__/promptRegistry.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptRegistry.test.js","sourceRoot":"","sources":["../../src/__tests__/promptRegistry.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC9D,MAAM,SAAS,GAAG,IAAI,GAAG,EAAqD,CAAC;QAC/E,MAAM,MAAM,GAAG;YACb,cAAc,CACZ,IAAY,EACZ,KAAc,EACd,QAAmD;gBAEnD,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAChC,CAAC;SACF,CAAC;QAEF,eAAe,CAAC,MAAe,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;QAExD,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;QACzD,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QAC/B,MAAM,CACJ,QAAQ,EAAE,CAAC;YACT,SAAS,EAAE,uBAAuB;YAClC,YAAY,EAAE,OAAO;SACtB,CAAC,CACH,CAAC,aAAa,CAAC;YACd,WAAW,EACT,wEAAwE;SAC3E,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yEAAyE,EAAE,GAAG,EAAE;QACjF,MAAM,SAAS,GAAG,IAAI,GAAG,EAAqD,CAAC;QAC/E,MAAM,MAAM,GAAG;YACb,cAAc,CACZ,IAAY,EACZ,KAAc,EACd,QAAmD;gBAEnD,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAChC,CAAC;SACF,CAAC;QAEF,eAAe,CAAC,MAAe,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QAEvD,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,wBAAwB,CAAE,CAAC;QAC1D,MAAM,MAAM,GAAG,QAAQ,CAAC;YACtB,SAAS,EAAE,oCAAoC;YAC/C,YAAY,EAAE,OAAO;SACtB,CAAkD,CAAC;QAEpD,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QACpC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACrC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/__tests__/resourceRegistry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resourceRegistry.test.d.ts.map

package/dist/__tests__/resourceRegistry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceRegistry.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/resourceRegistry.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/resourceRegistry.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from "vitest";
+const resourceRegistryMockState = vi.hoisted(() => ({
+    listDatabaseTables: vi.fn(async () => [
+        { schemaName: "dbo", tableName: "Users" },
+    ]),
+    listDatabaseObjects: vi.fn(async () => []),
+}));
+vi.mock("../schema.js", () => ({
+    describeDatabaseObject: vi.fn(),
+    describeTableSchema: vi.fn(),
+    listDatabaseObjects: resourceRegistryMockState.listDatabaseObjects,
+    listDatabaseTables: resourceRegistryMockState.listDatabaseTables,
+}));
+import { registerResources } from "../resourceRegistry.js";
+describe("resourceRegistry", () => {
+    it("caches database listing reads for a short TTL", async () => {
+        const handlers = new Map();
+        const server = {
+            registerResource(name, _resource, _meta, handler) {
+                handlers.set(name, handler);
+            },
+        };
+        registerResources(server, {
+            serverName: "mssql-mcp-server",
+            serverVersion: "1.2.0",
+            isReadOnly: false,
+            allowedDatabases: ["AppDb"],
+            toolNames: [],
+            maxRows: 100,
+            queryTimeoutMs: 30000,
+        });
+        const readTables = handlers.get("AppDb_tables");
+        expect(readTables).toBeDefined();
+        await readTables?.(new URL("mssql://database/AppDb/tables"));
+        await readTables?.(new URL("mssql://database/AppDb/tables"));
+        expect(resourceRegistryMockState.listDatabaseTables).toHaveBeenCalledTimes(1);
+        expect(resourceRegistryMockState.listDatabaseObjects).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=resourceRegistry.test.js.map

package/dist/__tests__/resourceRegistry.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceRegistry.test.js","sourceRoot":"","sources":["../../src/__tests__/resourceRegistry.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAElD,MAAM,yBAAyB,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IAClD,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC;QACpC,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE;KAC1C,CAAC;IACF,mBAAmB,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,CAAC;CAC3C,CAAC,CAAC,CAAC;AAEJ,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC;IAC7B,sBAAsB,EAAE,EAAE,CAAC,EAAE,EAAE;IAC/B,mBAAmB,EAAE,EAAE,CAAC,EAAE,EAAE;IAC5B,mBAAmB,EAAE,yBAAyB,CAAC,mBAAmB;IAClE,kBAAkB,EAAE,yBAAyB,CAAC,kBAAkB;CACjE,CAAC,CAAC,CAAC;AAEJ,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAChC,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;QAC7D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA0C,CAAC;QACnE,MAAM,MAAM,GAAG;YACb,gBAAgB,CACd,IAAY,EACZ,SAAkB,EAClB,KAAc,EACd,OAAuC;gBAEvC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YAC9B,CAAC;SACF,CAAC;QAEF,iBAAiB,CAAC,MAAe,EAAE;YACjC,UAAU,EAAE,kBAAkB;YAC9B,aAAa,EAAE,OAAO;YACtB,UAAU,EAAE,KAAK;YACjB,gBAAgB,EAAE,CAAC,OAAO,CAAC;YAC3B,SAAS,EAAE,EAAE;YACb,OAAO,EAAE,GAAG;YACZ,cAAc,EAAE,KAAK;SACtB,CAAC,CAAC;QAEH,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAChD,MAAM,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;QAEjC,MAAM,UAAU,EAAE,CAAC,IAAI,GAAG,CAAC,+BAA+B,CAAC,CAAC,CAAC;QAC7D,MAAM,UAAU,EAAE,CAAC,IAAI,GAAG,CAAC,+BAA+B,CAAC,CAAC,CAAC;QAE7D,MAAM,CAAC,yBAAyB,CAAC,kBAAkB,CAAC,CAAC,qBAAqB,CACxE,CAAC,CACF,CAAC;QACF,MAAM,CACJ,yBAAyB,CAAC,mBAAmB,CAC9C,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;IAC3B,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/__tests__/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

package/dist/__tests__/schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/schema.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/schema.test.js

@@ -0,0 +1,130 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const schemaMockState = vi.hoisted(() => ({
+    getSqlRequestCalls: 0,
+    inputCalls: [],
+    queryCalls: [],
+    queryResults: [],
+}));
+vi.mock("mssql", () => ({
+    default: {
+        NVarChar: "NVarChar",
+        Int: "Int",
+    },
+}));
+vi.mock("../db.js", () => ({
+    getSqlRequest: vi.fn(async () => {
+        schemaMockState.getSqlRequestCalls += 1;
+        return {
+            request: {
+                input(name, type, value) {
+                    schemaMockState.inputCalls.push({ name, type, value });
+                },
+                async query(query) {
+                    schemaMockState.queryCalls.push(query);
+                    return (schemaMockState.queryResults.shift() ?? {
+                        recordset: [],
+                        recordsets: [],
+                    });
+                },
+            },
+        };
+    }),
+}));
+import { describeDatabaseObject } from "../schema.js";
+describe("describeDatabaseObject", () => {
+    beforeEach(() => {
+        schemaMockState.getSqlRequestCalls = 0;
+        schemaMockState.inputCalls.length = 0;
+        schemaMockState.queryCalls.length = 0;
+        schemaMockState.queryResults.length = 0;
+    });
+    it("throws an ambiguity error when multiple schema matches exist", async () => {
+        schemaMockState.queryResults.push({
+            recordset: [
+                {
+                    objectId: 1,
+                    name: "Users",
+                    schemaName: "dbo",
+                    typeCode: "U",
+                    typeDescription: "USER_TABLE",
+                    createdAt: new Date(),
+                    modifiedAt: new Date(),
+                    definition: null,
+                },
+                {
+                    objectId: 2,
+                    name: "Users",
+                    schemaName: "audit",
+                    typeCode: "V",
+                    typeDescription: "VIEW",
+                    createdAt: new Date(),
+                    modifiedAt: new Date(),
+                    definition: null,
+                },
+            ],
+        });
+        await expect(describeDatabaseObject("Users", "AppDb")).rejects.toThrow("Specify schemaName or objectTypes to disambiguate");
+        expect(schemaMockState.getSqlRequestCalls).toBe(1);
+    });
+    it("reuses a single request flow and batches detail queries", async () => {
+        schemaMockState.queryResults.push({
+            recordset: [
+                {
+                    objectId: 7,
+                    name: "Users",
+                    schemaName: "dbo",
+                    typeCode: "U",
+                    typeDescription: "USER_TABLE",
+                    createdAt: new Date("2024-01-01"),
+                    modifiedAt: new Date("2024-01-02"),
+                    definition: null,
+                },
+            ],
+        }, {
+            recordsets: [
+                [
+                    {
+                        name: "id",
+                        dataType: "int",
+                        maxLength: 4,
+                        precision: 10,
+                        scale: 0,
+                        isNullable: false,
+                        isIdentity: true,
+                        defaultValue: null,
+                    },
+                ],
+                [
+                    {
+                        name: "PK_Users",
+                        type: "CLUSTERED",
+                        isUnique: true,
+                        columnName: "id",
+                        keyOrdinal: 1,
+                    },
+                ],
+            ],
+        });
+        const result = await describeDatabaseObject("Users", "AppDb", "dbo");
+        expect(result).toMatchObject({
+            name: "Users",
+            schemaName: "dbo",
+            objectType: "table",
+            columns: [
+                {
+                    name: "id",
+                    dataType: "int",
+                },
+            ],
+            indexes: [
+                {
+                    name: "PK_Users",
+                    columns: ["id"],
+                },
+            ],
+        });
+        expect(schemaMockState.getSqlRequestCalls).toBe(1);
+        expect(schemaMockState.queryCalls).toHaveLength(2);
+    });
+});
+//# sourceMappingURL=schema.test.js.map