@jgardner04/ghost-mcp-server 1.13.2 → 1.13.4

package/src/services/__tests__/ghostServiceImproved.pages.test.js

@@ -1,41 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with pages support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -64,6 +33,7 @@ import {
   validators,
 } from '../ghostServiceImproved.js';
 import { createPageSchema, updatePageSchema } from '../../schemas/pageSchemas.js';
+import { GhostAPIError, NotFoundError, ValidationError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Pages', () => {
   beforeEach(() => {
@@ -236,13 +206,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle Ghost API validation errors (422)', async () => {
-      const error422 = new Error('Validation failed');
+      const error422 = new GhostAPIError('pages.add', 'Validation failed', 422);
       error422.response = { status: 422 };
       api.pages.add.mockRejectedValue(error422);
 
-      await expect(createPage({ title: 'Test', html: '<p>Content</p>' })).rejects.toThrow(
-        'Page creation failed due to validation errors'
-      );
+      const rejection = createPage({ title: 'Test', html: '<p>Content</p>' });
+      await expect(rejection).rejects.toBeInstanceOf(ValidationError);
+      await expect(rejection).rejects.toThrow('Page creation failed due to validation errors');
     });
 
     it('should NOT include tags in page creation (pages do not support tags)', async () => {
@@ -292,8 +262,8 @@ describe('ghostServiceImproved - Pages', () => {
       expect(api.pages.read).toHaveBeenCalledWith({}, { id: pageId });
       // Should send ONLY updateData + updated_at, NOT the full existing page
       expect(api.pages.edit).toHaveBeenCalledWith(
-        { title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: pageId }
+        { id: pageId, title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.pages.edit.mock.calls[0][0];
@@ -303,13 +273,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle page not found (404)', async () => {
-      const error404 = new Error('Page not found');
+      const error404 = new GhostAPIError('pages.read', 'Page not found', 404);
       error404.response = { status: 404 };
       api.pages.read.mockRejectedValue(error404);
 
-      await expect(updatePage('nonexistent-id', { title: 'Updated' })).rejects.toThrow(
-        'Page not found'
-      );
+      const rejection = updatePage('nonexistent-id', { title: 'Updated' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Page not found');
     });
 
     it('should preserve updated_at timestamp for conflict resolution', async () => {
@@ -341,6 +311,61 @@ describe('ghostServiceImproved - Pages', () => {
         'Page validation failed'
       );
     });
+
+    it('should reject past published_at when existing page is scheduled (no status in update)', async () => {
+      const pageId = 'page-123';
+      const existingPage = {
+        id: pageId,
+        title: 'Scheduled Page',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+
+      api.pages.read.mockResolvedValue(existingPage);
+
+      await expect(updatePage(pageId, { published_at: pastDate })).rejects.toThrow(
+        'Page validation failed'
+      );
+    });
+
+    it('should allow future published_at when existing page is scheduled (no status in update)', async () => {
+      const pageId = 'page-123';
+      const futureDate = new Date(Date.now() + 172800000).toISOString();
+      const existingPage = {
+        id: pageId,
+        title: 'Scheduled Page',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.pages.read.mockResolvedValue(existingPage);
+      api.pages.edit.mockResolvedValue({ ...existingPage, published_at: futureDate });
+
+      const result = await updatePage(pageId, { published_at: futureDate });
+
+      expect(result).toBeDefined();
+    });
+
+    it('should allow published_at change when existing page is not scheduled', async () => {
+      const pageId = 'page-123';
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+      const existingPage = {
+        id: pageId,
+        title: 'Draft Page',
+        status: 'draft',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.pages.read.mockResolvedValue(existingPage);
+      api.pages.edit.mockResolvedValue({ ...existingPage, published_at: pastDate });
+
+      const result = await updatePage(pageId, { published_at: pastDate });
+
+      expect(result).toBeDefined();
+    });
   });
 
   describe('deletePage', () => {
@@ -361,11 +386,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle page not found (404)', async () => {
-      const error404 = new Error('Page not found');
+      const error404 = new GhostAPIError('pages.delete', 'Page not found', 404);
       error404.response = { status: 404 };
       api.pages.delete.mockRejectedValue(error404);
 
-      await expect(deletePage('nonexistent-id')).rejects.toThrow('Page not found');
+      const rejection = deletePage('nonexistent-id');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Page not found');
     });
   });
 
@@ -409,11 +436,13 @@ describe('ghostServiceImproved - Pages', () => {
     });
 
     it('should handle page not found (404)', async () => {
-      const error404 = new Error('Page not found');
+      const error404 = new GhostAPIError('pages.read', 'Page not found', 404);
       error404.response = { status: 404 };
       api.pages.read.mockRejectedValue(error404);
 
-      await expect(getPage('nonexistent-id')).rejects.toThrow('Page not found');
+      const rejection = getPage('nonexistent-id');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Page not found');
     });
   });
 

package/src/services/__tests__/ghostServiceImproved.posts.test.js

@@ -1,48 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with posts support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -62,6 +24,7 @@ vi.mock('fs/promises', () => ({
 // Import after setting up mocks
 import { updatePost, api, validators } from '../ghostServiceImproved.js';
 import { updatePostSchema } from '../../schemas/postSchemas.js';
+import { GhostAPIError, NotFoundError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Posts (updatePost)', () => {
   beforeEach(() => {
@@ -95,8 +58,8 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
       expect(result).toEqual(expectedResult);
       // Should send ONLY updateData + updated_at, NOT the full existing post
       expect(api.posts.edit).toHaveBeenCalledWith(
-        { title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
-        { id: postId }
+        { id: postId, title: 'Updated Title', updated_at: '2024-01-01T00:00:00.000Z' },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.posts.edit.mock.calls[0][0];
@@ -124,22 +87,18 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
     });
 
     it('should throw error when post ID is missing', async () => {
-      await expect(updatePost(null, { title: 'Updated' })).rejects.toThrow(
-        'Post ID is required for update'
-      );
-      await expect(updatePost('', { title: 'Updated' })).rejects.toThrow(
-        'Post ID is required for update'
-      );
+      await expect(updatePost(null, { title: 'Updated' })).rejects.toThrow('Post ID is required');
+      await expect(updatePost('', { title: 'Updated' })).rejects.toThrow('Post ID is required');
     });
 
     it('should handle post not found (404)', async () => {
-      const error404 = new Error('Post not found');
+      const error404 = new GhostAPIError('posts.read', 'Post not found', 404);
       error404.response = { status: 404 };
       api.posts.read.mockRejectedValue(error404);
 
-      await expect(updatePost('nonexistent-id', { title: 'Updated' })).rejects.toThrow(
-        'Post not found'
-      );
+      const rejection = updatePost('nonexistent-id', { title: 'Updated' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Post not found');
     });
 
     it('should throw ValidationError when updating to scheduled without published_at', async () => {
@@ -173,10 +132,65 @@ describe('ghostServiceImproved - Posts (updatePost)', () => {
 
       expect(result).toBeDefined();
       expect(api.posts.edit).toHaveBeenCalledWith(
-        { ...updateData, updated_at: existingPost.updated_at },
-        { id: postId }
+        { id: postId, ...updateData, updated_at: existingPost.updated_at },
+        {}
       );
     });
+
+    it('should reject past published_at when existing post is scheduled (no status in update)', async () => {
+      const postId = 'post-123';
+      const existingPost = {
+        id: postId,
+        title: 'Scheduled Post',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+
+      api.posts.read.mockResolvedValue(existingPost);
+
+      await expect(updatePost(postId, { published_at: pastDate })).rejects.toThrow(
+        'Post validation failed'
+      );
+    });
+
+    it('should allow future published_at when existing post is scheduled (no status in update)', async () => {
+      const postId = 'post-123';
+      const futureDate = new Date(Date.now() + 172800000).toISOString();
+      const existingPost = {
+        id: postId,
+        title: 'Scheduled Post',
+        status: 'scheduled',
+        published_at: new Date(Date.now() + 86400000).toISOString(),
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.posts.read.mockResolvedValue(existingPost);
+      api.posts.edit.mockResolvedValue({ ...existingPost, published_at: futureDate });
+
+      const result = await updatePost(postId, { published_at: futureDate });
+
+      expect(result).toBeDefined();
+    });
+
+    it('should allow published_at change when existing post is not scheduled', async () => {
+      const postId = 'post-123';
+      const pastDate = new Date(Date.now() - 86400000).toISOString();
+      const existingPost = {
+        id: postId,
+        title: 'Draft Post',
+        status: 'draft',
+        updated_at: '2024-01-01T00:00:00.000Z',
+      };
+
+      api.posts.read.mockResolvedValue(existingPost);
+      api.posts.edit.mockResolvedValue({ ...existingPost, published_at: pastDate });
+
+      const result = await updatePost(postId, { published_at: pastDate });
+
+      expect(result).toBeDefined();
+    });
   });
 
   describe('validators.validateScheduledStatus', () => {

package/src/services/__tests__/ghostServiceImproved.tags.test.js

@@ -1,48 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with tags support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -69,6 +31,7 @@ import {
   api,
   ghostCircuitBreaker,
 } from '../ghostServiceImproved.js';
+import { GhostAPIError, NotFoundError } from '../../errors/index.js';
 
 describe('ghostServiceImproved - Tags', () => {
   beforeEach(() => {
@@ -288,12 +251,13 @@ describe('ghostServiceImproved - Tags', () => {
     });
 
     it('should throw not found error when tag does not exist', async () => {
-      api.tags.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Tag not found',
-      });
+      const error404 = new GhostAPIError('tags.read', 'Tag not found', 404);
+      error404.response = { status: 404 };
+      api.tags.read.mockRejectedValue(error404);
 
-      await expect(getTag('non-existent')).rejects.toThrow();
+      const rejection = getTag('non-existent');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Tag not found');
     });
   });
 
@@ -381,10 +345,9 @@ describe('ghostServiceImproved - Tags', () => {
       };
 
       // First call fails with duplicate error
-      api.tags.add.mockRejectedValue({
-        response: { status: 422 },
-        message: 'Tag already exists',
-      });
+      const error422 = new GhostAPIError('tags.add', 'Tag already exists', 422);
+      error422.response = { status: 422, data: { errors: [{ message: 'Tag already exists' }] } };
+      api.tags.add.mockRejectedValue(error422);
 
       // getTags returns existing tag when called with name filter
       api.tags.browse.mockResolvedValue([{ id: 'tag-1', name: 'JavaScript', slug: 'javascript' }]);
@@ -431,8 +394,8 @@ describe('ghostServiceImproved - Tags', () => {
       expect(api.tags.read).toHaveBeenCalled();
       // Should send ONLY updateData, NOT the full existing tag
       expect(api.tags.edit).toHaveBeenCalledWith(
-        { name: 'Updated JavaScript', description: 'Updated description' },
-        { id: tagId }
+        { id: tagId, name: 'Updated JavaScript', description: 'Updated description' },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.tags.edit.mock.calls[0][0];
@@ -443,18 +406,17 @@ describe('ghostServiceImproved - Tags', () => {
     });
 
     it('should throw validation error for missing tag ID', async () => {
-      await expect(updateTag(null, { name: 'Test' })).rejects.toThrow(
-        'Tag ID is required for update'
-      );
+      await expect(updateTag(null, { name: 'Test' })).rejects.toThrow('Tag ID is required');
     });
 
     it('should throw not found error if tag does not exist', async () => {
-      api.tags.read.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Tag not found',
-      });
+      const error404 = new GhostAPIError('tags.read', 'Tag not found', 404);
+      error404.response = { status: 404 };
+      api.tags.read.mockRejectedValue(error404);
 
-      await expect(updateTag('non-existent', { name: 'Test' })).rejects.toThrow();
+      const rejection = updateTag('non-existent', { name: 'Test' });
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Tag not found');
     });
   });
 
@@ -471,16 +433,17 @@ describe('ghostServiceImproved - Tags', () => {
     });
 
     it('should throw validation error for missing tag ID', async () => {
-      await expect(deleteTag(null)).rejects.toThrow('Tag ID is required for deletion');
+      await expect(deleteTag(null)).rejects.toThrow('Tag ID is required');
     });
 
     it('should throw not found error if tag does not exist', async () => {
-      api.tags.delete.mockRejectedValue({
-        response: { status: 404 },
-        message: 'Tag not found',
-      });
+      const error404 = new GhostAPIError('tags.delete', 'Tag not found', 404);
+      error404.response = { status: 404 };
+      api.tags.delete.mockRejectedValue(error404);
 
-      await expect(deleteTag('non-existent')).rejects.toThrow();
+      const rejection = deleteTag('non-existent');
+      await expect(rejection).rejects.toBeInstanceOf(NotFoundError);
+      await expect(rejection).rejects.toThrow('Tag not found');
     });
   });
 });

package/src/services/__tests__/ghostServiceImproved.tiers.test.js

@@ -1,55 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 
-// Mock the Ghost Admin API with tiers support
-vi.mock('@tryghost/admin-api', () => ({
-  default: vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      pages: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      members: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      tiers: {
-        add: vi.fn(),
-        browse: vi.fn(),
-        read: vi.fn(),
-        edit: vi.fn(),
-        delete: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  }),
-}));
+// Mock the Ghost Admin API using shared mock factory
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
 vi.mock('dotenv', () => mockDotenv());
@@ -270,14 +225,7 @@ describe('ghostServiceImproved - Tiers', () => {
 
       const result = await getTier('tier-1');
 
-      expect(api.tiers.read).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: 'tier-1',
-        }),
-        expect.objectContaining({
-          id: 'tier-1',
-        })
-      );
+      expect(api.tiers.read).toHaveBeenCalledWith({}, { id: 'tier-1' });
       expect(result).toEqual(mockTier);
     });
 
@@ -327,14 +275,16 @@ describe('ghostServiceImproved - Tiers', () => {
 
       const result = await updateTier('tier-1', updateData);
 
-      expect(api.tiers.read).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'tier-1' }),
-        expect.objectContaining({ id: 'tier-1' })
-      );
+      expect(api.tiers.read).toHaveBeenCalledWith({}, { id: 'tier-1' });
       // Should send ONLY updateData + updated_at, NOT the full existing tier
       expect(api.tiers.edit).toHaveBeenCalledWith(
-        { name: 'Premium Plus', monthly_price: 1299, updated_at: '2024-01-01T00:00:00.000Z' },
-        expect.objectContaining({ id: 'tier-1' })
+        {
+          id: 'tier-1',
+          name: 'Premium Plus',
+          monthly_price: 1299,
+          updated_at: '2024-01-01T00:00:00.000Z',
+        },
+        {}
       );
       // Verify read-only fields are NOT sent
       const editCallData = api.tiers.edit.mock.calls[0][0];

package/src/services/__tests__/memberService.test.js

@@ -6,7 +6,6 @@ import {
   validateMemberLookup,
   validateSearchQuery,
   validateSearchOptions,
-  sanitizeNqlValue,
 } from '../memberService.js';
 
 describe('memberService - Validation', () => {
@@ -447,31 +446,4 @@ describe('memberService - Validation', () => {
       );
     });
   });
-
-  describe('sanitizeNqlValue', () => {
-    it('should escape backslashes', () => {
-      expect(sanitizeNqlValue('test\\value')).toBe('test\\\\value');
-    });
-
-    it('should escape single quotes', () => {
-      expect(sanitizeNqlValue("test'value")).toBe("test\\'value");
-    });
-
-    it('should escape double quotes', () => {
-      expect(sanitizeNqlValue('test"value')).toBe('test\\"value');
-    });
-
-    it('should handle multiple special characters', () => {
-      expect(sanitizeNqlValue('test\'value"with\\chars')).toBe('test\\\'value\\"with\\\\chars');
-    });
-
-    it('should not modify strings without special characters', () => {
-      expect(sanitizeNqlValue('normalvalue')).toBe('normalvalue');
-      expect(sanitizeNqlValue('test@example.com')).toBe('test@example.com');
-    });
-
-    it('should handle empty string', () => {
-      expect(sanitizeNqlValue('')).toBe('');
-    });
-  });
 });

package/src/services/__tests__/tierService.test.js

@@ -3,7 +3,6 @@ import {
   validateTierData,
   validateTierUpdateData,
   validateTierQueryOptions,
-  sanitizeNqlValue,
 } from '../tierService.js';
 import { ValidationError } from '../../errors/index.js';
 
@@ -342,31 +341,4 @@ describe('tierService - Validation', () => {
       ).not.toThrow();
     });
   });
-
-  describe('sanitizeNqlValue', () => {
-    it('should return value if undefined or null', () => {
-      expect(sanitizeNqlValue(null)).toBe(null);
-      expect(sanitizeNqlValue(undefined)).toBe(undefined);
-    });
-
-    it('should escape backslashes', () => {
-      expect(sanitizeNqlValue('test\\value')).toBe('test\\\\value');
-    });
-
-    it('should escape single quotes', () => {
-      expect(sanitizeNqlValue("test'value")).toBe("test\\'value");
-    });
-
-    it('should escape double quotes', () => {
-      expect(sanitizeNqlValue('test"value')).toBe('test\\"value');
-    });
-
-    it('should escape multiple special characters', () => {
-      expect(sanitizeNqlValue('test\\value"with\'quotes')).toBe('test\\\\value\\"with\\\'quotes');
-    });
-
-    it('should handle strings without special characters', () => {
-      expect(sanitizeNqlValue('simple-value')).toBe('simple-value');
-    });
-  });
 });