@bernierllc/content-storage-adapter 1.0.0

package/__tests__/ContentStorageAdapter.test.ts

@@ -0,0 +1,604 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { ContentStorageAdapter } from '../src/ContentStorageAdapter';
+import { ContentType, ContentFormat, ContentStatus } from '../src/models/IContent';
+import { ContentNotFoundError } from '../src/errors/ContentNotFoundError';
+import { OptimisticLockError } from '../src/errors/OptimisticLockError';
+import { MockDatabaseAdapter } from './mocks/MockDatabaseAdapter';
+import { IDatabaseAdapter } from '@bernierllc/database-adapter-core';
+
+describe('ContentStorageAdapter', () => {
+  let adapter: ContentStorageAdapter;
+  let dbAdapter: MockDatabaseAdapter;
+
+  beforeEach(async () => {
+    dbAdapter = new MockDatabaseAdapter();
+    await dbAdapter.connect();
+    adapter = new ContentStorageAdapter(dbAdapter as unknown as IDatabaseAdapter);
+  });
+
+  afterEach(async () => {
+    await dbAdapter.disconnect();
+    dbAdapter.clearMocks();
+  });
+
+  describe('create', () => {
+    it('should create content with auto-generated slug', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        excerpt: 'Test excerpt',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      };
+
+      // Mock slug existence check (doesn't exist)
+      dbAdapter.setQueryResult(
+        'SELECT EXISTS(SELECT 1 FROM content WHERE slug = $1 AND deleted_at IS NULL) as exists',
+        { rows: [{ exists: false }], rowCount: 1 }
+      );
+
+      // Mock insert
+      dbAdapter.setQueryResult(
+        'INSERT INTO content',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.create({
+        userId: 'user1',
+        title: 'Test Title',
+        body: 'Test body',
+        excerpt: 'Test excerpt'
+      });
+
+      expect(result.id).toBe('123');
+      expect(result.title).toBe('Test Title');
+      expect(result.slug).toBe('test-title');
+    });
+
+    it('should ensure unique slugs', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title-1',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      };
+
+      // First slug check returns true (exists)
+      dbAdapter.setQueryResult(
+        'SELECT EXISTS(SELECT 1 FROM content WHERE slug = $1 AND deleted_at IS NULL) as exists',
+        { rows: [{ exists: true }], rowCount: 1 }
+      );
+
+      // Mock insert
+      dbAdapter.setQueryResult(
+        'INSERT INTO content',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.create({
+        userId: 'user1',
+        title: 'Test Title',
+        body: 'Test body'
+      });
+
+      expect(result.slug).toMatch(/test-title-\d+/);
+    });
+
+    it('should set default values for type/format/status', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      };
+
+      dbAdapter.setQueryResult(
+        'SELECT EXISTS(SELECT 1 FROM content WHERE slug = $1 AND deleted_at IS NULL) as exists',
+        { rows: [{ exists: false }], rowCount: 1 }
+      );
+
+      dbAdapter.setQueryResult(
+        'INSERT INTO content',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.create({
+        userId: 'user1',
+        title: 'Test Title',
+        body: 'Test body'
+      });
+
+      expect(result.type).toBe(ContentType.BLOG);
+      expect(result.format).toBe(ContentFormat.MARKDOWN);
+      expect(result.status).toBe(ContentStatus.DRAFT);
+    });
+  });
+
+  describe('getById', () => {
+    it('should get content by ID', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date(),
+        deleted_at: null
+      };
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE id = $1 AND deleted_at IS NULL',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.getById('123');
+
+      expect(result).not.toBeNull();
+      expect(result?.id).toBe('123');
+    });
+
+    it('should exclude soft-deleted content by default', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE id = $1 AND deleted_at IS NULL',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.getById('123');
+
+      expect(result).toBeNull();
+    });
+
+    it('should include deleted content when requested', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date(),
+        deleted_at: new Date()
+      };
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE id = $1',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.getById('123', { includeDeleted: true });
+
+      expect(result).not.toBeNull();
+      expect(result?.deletedAt).toBeDefined();
+    });
+  });
+
+  describe('getBySlug', () => {
+    it('should get content by slug', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      };
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE slug = $1 AND deleted_at IS NULL',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.getBySlug('test-title');
+
+      expect(result).not.toBeNull();
+      expect(result?.slug).toBe('test-title');
+    });
+  });
+
+  describe('update', () => {
+    it('should update content fields', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Updated Title',
+        slug: 'test-title',
+        body: 'Updated body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.IN_REVIEW,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date()
+      };
+
+      dbAdapter.setQueryResult(
+        'UPDATE content',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.update('123', {
+        title: 'Updated Title',
+        body: 'Updated body',
+        status: ContentStatus.IN_REVIEW
+      });
+
+      expect(result.title).toBe('Updated Title');
+      expect(result.status).toBe(ContentStatus.IN_REVIEW);
+    });
+
+    it('should update timestamps automatically', async () => {
+      const now = new Date();
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(now.getTime() - 10000),
+        updated_at: now
+      };
+
+      dbAdapter.setQueryResult(
+        'UPDATE content',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.update('123', { title: 'Updated' });
+
+      expect(result.updatedAt).toBeDefined();
+    });
+
+    it('should enforce optimistic locking', async () => {
+      dbAdapter.setQueryResult(
+        'UPDATE content',
+        { rows: [], rowCount: 0 }
+      );
+
+      const expectedUpdatedAt = new Date();
+
+      await expect(
+        adapter.update('123', { title: 'Updated' }, expectedUpdatedAt)
+      ).rejects.toThrow(OptimisticLockError);
+    });
+
+    it('should throw error on version conflict', async () => {
+      dbAdapter.setQueryResult(
+        'UPDATE content',
+        { rows: [], rowCount: 0 }
+      );
+
+      await expect(
+        adapter.update('123', { title: 'Updated' }, new Date())
+      ).rejects.toThrow(OptimisticLockError);
+    });
+
+    it('should throw error when no fields to update', async () => {
+      await expect(
+        adapter.update('123', {})
+      ).rejects.toThrow('No fields to update');
+    });
+  });
+
+  describe('delete', () => {
+    it('should soft delete content', async () => {
+      dbAdapter.setQueryResult(
+        'UPDATE content SET deleted_at = NOW() WHERE id = $1 AND deleted_at IS NULL',
+        { rows: [], rowCount: 1 }
+      );
+
+      await expect(adapter.delete('123')).resolves.not.toThrow();
+    });
+
+    it('should not return deleted content in queries', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE id = $1 AND deleted_at IS NULL',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.getById('123');
+      expect(result).toBeNull();
+    });
+
+    it('should throw error when content not found', async () => {
+      dbAdapter.setQueryResult(
+        'UPDATE content SET deleted_at = NOW() WHERE id = $1 AND deleted_at IS NULL',
+        { rows: [], rowCount: 0 }
+      );
+
+      await expect(adapter.delete('999')).rejects.toThrow(ContentNotFoundError);
+    });
+  });
+
+  describe('restore', () => {
+    it('should restore deleted content', async () => {
+      const mockContent = {
+        id: '123',
+        user_id: 'user1',
+        title: 'Test Title',
+        slug: 'test-title',
+        body: 'Test body',
+        type: ContentType.BLOG,
+        format: ContentFormat.MARKDOWN,
+        status: ContentStatus.DRAFT,
+        ai_reviewed: false,
+        view_count: 0,
+        share_count: 0,
+        generated_from_commit: false,
+        created_at: new Date(),
+        updated_at: new Date(),
+        deleted_at: null
+      };
+
+      dbAdapter.setQueryResult(
+        'UPDATE content SET deleted_at = NULL WHERE id = $1 AND deleted_at IS NOT NULL RETURNING *',
+        { rows: [mockContent], rowCount: 1 }
+      );
+
+      const result = await adapter.restore('123');
+
+      expect(result.id).toBe('123');
+      expect(result.deletedAt).toBeUndefined();
+    });
+  });
+
+  describe('hardDelete', () => {
+    it('should permanently delete content', async () => {
+      dbAdapter.setQueryResult(
+        'DELETE FROM content WHERE id = $1',
+        { rows: [], rowCount: 1 }
+      );
+
+      await expect(adapter.hardDelete('123')).resolves.not.toThrow();
+    });
+  });
+
+  describe('list', () => {
+    it('should filter by user ID', async () => {
+      const mockContents = [
+        {
+          id: '123',
+          user_id: 'user1',
+          title: 'Test 1',
+          slug: 'test-1',
+          body: 'Body 1',
+          type: ContentType.BLOG,
+          format: ContentFormat.MARKDOWN,
+          status: ContentStatus.DRAFT,
+          ai_reviewed: false,
+          view_count: 0,
+          share_count: 0,
+          generated_from_commit: false,
+          created_at: new Date(),
+          updated_at: new Date()
+        }
+      ];
+
+      dbAdapter.setQueryResult(
+        'SELECT COUNT(*) as count FROM content WHERE deleted_at IS NULL AND user_id = $1',
+        { rows: [{ count: '1' }], rowCount: 1 }
+      );
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE deleted_at IS NULL AND user_id = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3',
+        { rows: mockContents, rowCount: 1 }
+      );
+
+      const result = await adapter.list({ userId: 'user1' });
+
+      expect(result.data.length).toBe(1);
+      expect(result.total).toBe(1);
+    });
+
+    it('should filter by status', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT COUNT(*) as count FROM content WHERE deleted_at IS NULL AND status = $1',
+        { rows: [{ count: '0' }], rowCount: 1 }
+      );
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE deleted_at IS NULL AND status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.list({ status: ContentStatus.PUBLISHED });
+
+      expect(result.data.length).toBe(0);
+    });
+
+    it('should support pagination', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT COUNT(*) as count FROM content WHERE deleted_at IS NULL',
+        { rows: [{ count: '100' }], rowCount: 1 }
+      );
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE deleted_at IS NULL ORDER BY created_at DESC LIMIT $1 OFFSET $2',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.list({ limit: 10, offset: 20 });
+
+      expect(result.limit).toBe(10);
+      expect(result.offset).toBe(20);
+      expect(result.hasMore).toBe(true);
+    });
+
+    it('should order by specified field', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT COUNT(*) as count FROM content WHERE deleted_at IS NULL',
+        { rows: [{ count: '0' }], rowCount: 1 }
+      );
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE deleted_at IS NULL ORDER BY title ASC LIMIT $1 OFFSET $2',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.list({
+        orderBy: 'title',
+        orderDirection: 'ASC'
+      });
+
+      expect(result.data).toEqual([]);
+    });
+
+    it('should search content text', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT COUNT(*) as count FROM content WHERE deleted_at IS NULL',
+        { rows: [{ count: '0' }], rowCount: 1 }
+      );
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content WHERE deleted_at IS NULL',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.list({ searchQuery: 'test' });
+
+      expect(result.data).toEqual([]);
+    });
+  });
+
+  describe('getVersions', () => {
+    it('should retrieve all versions', async () => {
+      const mockVersions = [
+        {
+          id: 'v1',
+          content_id: '123',
+          version_number: 2,
+          title: 'Version 2',
+          body: 'Body v2',
+          is_autosave: false,
+          created_at: new Date(),
+          created_by: 'user1'
+        },
+        {
+          id: 'v2',
+          content_id: '123',
+          version_number: 1,
+          title: 'Version 1',
+          body: 'Body v1',
+          is_autosave: false,
+          created_at: new Date(),
+          created_by: 'user1'
+        }
+      ];
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content_versions WHERE content_id = $1 ORDER BY version_number DESC',
+        { rows: mockVersions, rowCount: 2 }
+      );
+
+      const result = await adapter.getVersions('123');
+
+      expect(result.length).toBe(2);
+      expect(result[0].versionNumber).toBe(2);
+    });
+
+    it('should order versions by number descending', async () => {
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content_versions WHERE content_id = $1 ORDER BY version_number DESC',
+        { rows: [], rowCount: 0 }
+      );
+
+      const result = await adapter.getVersions('123');
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getVersion', () => {
+    it('should retrieve specific version', async () => {
+      const mockVersion = {
+        id: 'v1',
+        content_id: '123',
+        version_number: 1,
+        title: 'Version 1',
+        body: 'Body v1',
+        is_autosave: false,
+        created_at: new Date(),
+        created_by: 'user1'
+      };
+
+      dbAdapter.setQueryResult(
+        'SELECT * FROM content_versions WHERE content_id = $1 AND version_number = $2',
+        { rows: [mockVersion], rowCount: 1 }
+      );
+
+      const result = await adapter.getVersion('123', 1);
+
+      expect(result).not.toBeNull();
+      expect(result?.versionNumber).toBe(1);
+    });
+  });
+});

package/__tests__/mocks/MockDatabaseAdapter.test.ts

@@ -0,0 +1,97 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { MockDatabaseAdapter } from './MockDatabaseAdapter';
+
+describe('MockDatabaseAdapter validation', () => {
+  let adapter: MockDatabaseAdapter;
+
+  beforeEach(() => {
+    adapter = new MockDatabaseAdapter();
+  });
+
+  afterEach(() => {
+    adapter.clearMocks();
+  });
+
+  it('should implement IDatabaseAdapter interface', () => {
+    expect(adapter.connect).toBeDefined();
+    expect(adapter.disconnect).toBeDefined();
+    expect(adapter.query).toBeDefined();
+    expect(adapter.beginTransaction).toBeDefined();
+    expect(adapter.commit).toBeDefined();
+    expect(adapter.rollback).toBeDefined();
+  });
+
+  it('should track connection state', async () => {
+    await adapter.connect();
+    // Connection is established, queries should work
+    const result = await adapter.query('SELECT 1');
+    expect(result).toBeDefined();
+
+    await adapter.disconnect();
+    // After disconnect, should throw error
+    await expect(adapter.query('SELECT 1')).rejects.toThrow('Database not connected');
+  });
+
+  it('should return mocked query results', async () => {
+    await adapter.connect();
+
+    adapter.setQueryResult('SELECT * FROM test', {
+      rows: [{ id: 1, name: 'test' }],
+      rowCount: 1
+    });
+
+    const result = await adapter.query('SELECT * FROM test');
+    expect(result.rows).toEqual([{ id: 1, name: 'test' }]);
+    expect(result.rowCount).toBe(1);
+  });
+
+  it('should normalize SQL whitespace for matching', async () => {
+    await adapter.connect();
+
+    adapter.setQueryResult('SELECT   *   FROM   test', {
+      rows: [{ id: 1 }],
+      rowCount: 1
+    });
+
+    const result = await adapter.query('SELECT * FROM test');
+    expect(result.rows).toEqual([{ id: 1 }]);
+  });
+
+  it('should clear mocks when requested', async () => {
+    await adapter.connect();
+
+    adapter.setQueryResult('SELECT * FROM test', {
+      rows: [{ id: 1 }],
+      rowCount: 1
+    });
+
+    adapter.clearMocks();
+
+    const result = await adapter.query('SELECT * FROM test');
+    expect(result.rows).toEqual([]);
+    expect(result.rowCount).toBe(0);
+  });
+
+  it('should return empty result for unregistered queries', async () => {
+    await adapter.connect();
+
+    const result = await adapter.query('SELECT * FROM unknown');
+    expect(result.rows).toEqual([]);
+    expect(result.rowCount).toBe(0);
+  });
+
+  it('should handle transaction methods', async () => {
+    await adapter.connect();
+
+    await expect(adapter.beginTransaction()).resolves.not.toThrow();
+    await expect(adapter.commit()).resolves.not.toThrow();
+    await expect(adapter.rollback()).resolves.not.toThrow();
+  });
+});