@bernierllc/content-storage-adapter 1.2.5 → 1.5.0

package/__tests__/mocks/MockDatabaseAdapter.ts

@@ -1,85 +0,0 @@
-/*
-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 { IDatabaseAdapter, IQueryResult } from '@bernierllc/database-adapter-core';
-
-/**
- * Mock database adapter for testing
- */
-export class MockDatabaseAdapter implements IDatabaseAdapter {
-  private queryResults: Map<string, IQueryResult<Record<string, unknown>>> = new Map();
-  private connected = false;
-
-  async connect(): Promise<void> {
-    this.connected = true;
-  }
-
-  async disconnect(): Promise<void> {
-    this.connected = false;
-  }
-
-  async query<T = Record<string, unknown>>(
-    sql: string,
-    _params?: unknown[]
-  ): Promise<IQueryResult<T>> {
-    if (!this.connected) {
-      throw new Error('Database not connected');
-    }
-
-    // Find matching mock result
-    const key = this.generateKey(sql);
-    const result = this.queryResults.get(key);
-
-    if (!result) {
-      // Return empty result for unregistered queries
-      return {
-        rows: [],
-        rowCount: 0
-      } as IQueryResult<T>;
-    }
-
-    return result as IQueryResult<T>;
-  }
-
-  async beginTransaction(): Promise<void> {
-    // Mock implementation
-  }
-
-  async commit(): Promise<void> {
-    // Mock implementation
-  }
-
-  async rollback(): Promise<void> {
-    // Mock implementation
-  }
-
-  /**
-   * Set mock result for a query pattern
-   */
-  setQueryResult<T = Record<string, unknown>>(
-    sqlPattern: string,
-    result: IQueryResult<T>
-  ): void {
-    const key = this.generateKey(sqlPattern);
-    this.queryResults.set(key, result as IQueryResult<Record<string, unknown>>);
-  }
-
-  /**
-   * Clear all mock results
-   */
-  clearMocks(): void {
-    this.queryResults.clear();
-  }
-
-  /**
-   * Generate key from SQL pattern (normalize whitespace)
-   */
-  private generateKey(sql: string): string {
-    return sql.replace(/\s+/g, ' ').trim().toLowerCase();
-  }
-}

package/jest.config.cjs

@@ -1,30 +0,0 @@
-/*
-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.
-*/
-
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: '<rootDir>/../../../jest-environment-node-fixed.cjs',
-  roots: ['<rootDir>/__tests__'],
-  testMatch: ['**/*.test.ts'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-    '!src/**/index.ts'
-  ],
-  coverageThreshold: {
-    global: {
-      branches: 90,
-      functions: 90,
-      lines: 90,
-      statements: 90
-    }
-  },
-  moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/src/$1'
-  }
-};

package/src/ContentBatchOperations.ts

@@ -1,72 +0,0 @@
-/*
-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 './ContentStorageAdapter';
-import { ContentStatus } from './models/IContent';
-
-/**
- * Batch operations for content management
- */
-export class ContentBatchOperations {
-  constructor(private adapter: ContentStorageAdapter) {}
-
-  /**
-   * Bulk update status for multiple content items
-   */
-  async bulkUpdateStatus(
-    ids: string[],
-    status: ContentStatus
-  ): Promise<number> {
-    let updated = 0;
-
-    for (const id of ids) {
-      try {
-        await this.adapter.update(id, { status });
-        updated++;
-      } catch (error) {
-        // Continue on individual failures
-      }
-    }
-
-    return updated;
-  }
-
-  /**
-   * Bulk soft delete
-   */
-  async bulkDelete(ids: string[]): Promise<number> {
-    const db = (this.adapter as unknown as { db: { query: (sql: string, params: unknown[]) => Promise<{ rowCount: number }> } }).db;
-    const result = await db.query(
-      `
-      UPDATE content
-      SET deleted_at = NOW()
-      WHERE id = ANY($1) AND deleted_at IS NULL
-      `,
-      [ids]
-    );
-
-    return result.rowCount;
-  }
-
-  /**
-   * Bulk restore
-   */
-  async bulkRestore(ids: string[]): Promise<number> {
-    const db = (this.adapter as unknown as { db: { query: (sql: string, params: unknown[]) => Promise<{ rowCount: number }> } }).db;
-    const result = await db.query(
-      `
-      UPDATE content
-      SET deleted_at = NULL
-      WHERE id = ANY($1) AND deleted_at IS NOT NULL
-      `,
-      [ids]
-    );
-
-    return result.rowCount;
-  }
-}

package/src/ContentStorageAdapter.ts

@@ -1,476 +0,0 @@
-/*
-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 { IDatabaseAdapter } from '@bernierllc/database-adapter-core';
-import { generateSlug } from '@bernierllc/slug-generator';
-import {
-  IContent,
-  IContentCreateData,
-  IContentUpdateData,
-  ContentType,
-  ContentFormat,
-  ContentStatus
-} from './models/IContent';
-import { IContentVersion } from './models/IContentVersion';
-import { IContentFilters, IPaginatedResult } from './models/IContentFilters';
-import { ContentNotFoundError } from './errors/ContentNotFoundError';
-import { OptimisticLockError } from './errors/OptimisticLockError';
-
-/**
- * Content storage adapter
- * Provides type-safe CRUD operations for content management
- */
-export class ContentStorageAdapter {
-  constructor(private db: IDatabaseAdapter) {}
-
-  /**
-   * Create new content with automatic slug generation
-   */
-  async create(data: IContentCreateData): Promise<IContent> {
-    // Generate unique slug from title
-    const baseSlug = generateSlug(data.title);
-    const slug = await this.ensureUniqueSlug(baseSlug);
-
-    const result = await this.db.query<Record<string, unknown>>(
-      `
-      INSERT INTO content (
-        user_id, title, slug, body, excerpt, type, format, status,
-        meta_title, meta_description, keywords,
-        ai_reviewed, view_count, share_count, generated_from_commit
-      ) VALUES (
-        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15
-      )
-      RETURNING *
-      `,
-      [
-        data.userId,
-        data.title,
-        slug,
-        data.body,
-        data.excerpt || null,
-        data.type || ContentType.BLOG,
-        data.format || ContentFormat.MARKDOWN,
-        data.status || ContentStatus.DRAFT,
-        data.metaTitle || null,
-        data.metaDescription || null,
-        data.keywords || [],
-        false, // ai_reviewed
-        0, // view_count
-        0, // share_count
-        false // generated_from_commit
-      ]
-    );
-
-    return this.mapRowToContent(result.rows[0]);
-  }
-
-  /**
-   * Get content by ID (with soft-delete check)
-   */
-  async getById(
-    id: string,
-    options: { includeDeleted?: boolean } = {}
-  ): Promise<IContent | null> {
-    const whereClause = options.includeDeleted
-      ? 'id = $1'
-      : 'id = $1 AND deleted_at IS NULL';
-
-    const result = await this.db.query<Record<string, unknown>>(
-      `SELECT * FROM content WHERE ${whereClause}`,
-      [id]
-    );
-
-    return result.rows.length > 0
-      ? this.mapRowToContent(result.rows[0])
-      : null;
-  }
-
-  /**
-   * Get content by slug
-   */
-  async getBySlug(slug: string): Promise<IContent | null> {
-    const result = await this.db.query<Record<string, unknown>>(
-      'SELECT * FROM content WHERE slug = $1 AND deleted_at IS NULL',
-      [slug]
-    );
-
-    return result.rows.length > 0
-      ? this.mapRowToContent(result.rows[0])
-      : null;
-  }
-
-  /**
-   * Update content with optimistic locking
-   */
-  async update(
-    id: string,
-    data: IContentUpdateData,
-    expectedUpdatedAt?: Date
-  ): Promise<IContent> {
-    // Build dynamic UPDATE query
-    const updates: string[] = [];
-    const params: unknown[] = [];
-    let paramIndex = 1;
-
-    if (data.title !== undefined) {
-      updates.push(`title = $${paramIndex++}`);
-      params.push(data.title);
-    }
-    if (data.body !== undefined) {
-      updates.push(`body = $${paramIndex++}`);
-      params.push(data.body);
-    }
-    if (data.excerpt !== undefined) {
-      updates.push(`excerpt = $${paramIndex++}`);
-      params.push(data.excerpt);
-    }
-    if (data.status !== undefined) {
-      updates.push(`status = $${paramIndex++}`);
-      params.push(data.status);
-    }
-    if (data.workflowStage !== undefined) {
-      updates.push(`workflow_stage = $${paramIndex++}`);
-      params.push(data.workflowStage);
-    }
-    if (data.assignedTo !== undefined) {
-      updates.push(`assigned_to = $${paramIndex++}`);
-      params.push(data.assignedTo);
-    }
-    if (data.publishedAt !== undefined) {
-      updates.push(`published_at = $${paramIndex++}`);
-      params.push(data.publishedAt);
-    }
-    if (data.scheduledFor !== undefined) {
-      updates.push(`scheduled_for = $${paramIndex++}`);
-      params.push(data.scheduledFor);
-    }
-    if (data.metaTitle !== undefined) {
-      updates.push(`meta_title = $${paramIndex++}`);
-      params.push(data.metaTitle);
-    }
-    if (data.metaDescription !== undefined) {
-      updates.push(`meta_description = $${paramIndex++}`);
-      params.push(data.metaDescription);
-    }
-    if (data.keywords !== undefined) {
-      updates.push(`keywords = $${paramIndex++}`);
-      params.push(data.keywords);
-    }
-
-    if (updates.length === 0) {
-      throw new Error('No fields to update');
-    }
-
-    // Add optimistic locking check
-    params.push(id);
-    const idParam = paramIndex++;
-
-    let whereClause = `id = $${idParam} AND deleted_at IS NULL`;
-    if (expectedUpdatedAt) {
-      params.push(expectedUpdatedAt);
-      whereClause += ` AND updated_at = $${paramIndex++}`;
-    }
-
-    const sql = `
-      UPDATE content
-      SET ${updates.join(', ')}, updated_at = NOW()
-      WHERE ${whereClause}
-      RETURNING *
-    `;
-
-    const result = await this.db.query<Record<string, unknown>>(sql, params);
-
-    if (result.rows.length === 0) {
-      if (expectedUpdatedAt) {
-        throw new OptimisticLockError(id);
-      }
-      throw new ContentNotFoundError(id);
-    }
-
-    return this.mapRowToContent(result.rows[0]);
-  }
-
-  /**
-   * Soft delete content
-   */
-  async delete(id: string): Promise<void> {
-    const result = await this.db.query(
-      `
-      UPDATE content
-      SET deleted_at = NOW()
-      WHERE id = $1 AND deleted_at IS NULL
-      `,
-      [id]
-    );
-
-    if (result.rowCount === 0) {
-      throw new ContentNotFoundError(id);
-    }
-  }
-
-  /**
-   * Permanently delete content (use sparingly)
-   */
-  async hardDelete(id: string): Promise<void> {
-    await this.db.query('DELETE FROM content WHERE id = $1', [id]);
-  }
-
-  /**
-   * Restore soft-deleted content
-   */
-  async restore(id: string): Promise<IContent> {
-    const result = await this.db.query<Record<string, unknown>>(
-      `
-      UPDATE content
-      SET deleted_at = NULL
-      WHERE id = $1 AND deleted_at IS NOT NULL
-      RETURNING *
-      `,
-      [id]
-    );
-
-    if (result.rows.length === 0) {
-      throw new Error('Content not found or not deleted');
-    }
-
-    return this.mapRowToContent(result.rows[0]);
-  }
-
-  /**
-   * List content with filters and pagination
-   */
-  async list(
-    filters: IContentFilters = {}
-  ): Promise<IPaginatedResult<IContent>> {
-    // Build WHERE clause
-    const conditions: string[] = [];
-    const params: unknown[] = [];
-    let paramIndex = 1;
-
-    if (!filters.includeDeleted) {
-      conditions.push('deleted_at IS NULL');
-    }
-
-    if (filters.userId) {
-      conditions.push(`user_id = $${paramIndex++}`);
-      params.push(filters.userId);
-    }
-
-    if (filters.status) {
-      if (Array.isArray(filters.status)) {
-        conditions.push(`status = ANY($${paramIndex++})`);
-        params.push(filters.status);
-      } else {
-        conditions.push(`status = $${paramIndex++}`);
-        params.push(filters.status);
-      }
-    }
-
-    if (filters.type) {
-      if (Array.isArray(filters.type)) {
-        conditions.push(`type = ANY($${paramIndex++})`);
-        params.push(filters.type);
-      } else {
-        conditions.push(`type = $${paramIndex++}`);
-        params.push(filters.type);
-      }
-    }
-
-    if (filters.workflowStage) {
-      conditions.push(`workflow_stage = $${paramIndex++}`);
-      params.push(filters.workflowStage);
-    }
-
-    if (filters.publishedAfter) {
-      conditions.push(`published_at >= $${paramIndex++}`);
-      params.push(filters.publishedAfter);
-    }
-
-    if (filters.publishedBefore) {
-      conditions.push(`published_at <= $${paramIndex++}`);
-      params.push(filters.publishedBefore);
-    }
-
-    if (filters.searchQuery) {
-      conditions.push(`(
-        title ILIKE $${paramIndex} OR
-        body ILIKE $${paramIndex} OR
-        excerpt ILIKE $${paramIndex}
-      )`);
-      params.push(`%${filters.searchQuery}%`);
-      paramIndex++;
-    }
-
-    const whereClause = conditions.length > 0
-      ? `WHERE ${conditions.join(' AND ')}`
-      : '';
-
-    // Build ORDER BY
-    const orderBy = filters.orderBy || 'createdAt';
-    const orderDirection = filters.orderDirection || 'DESC';
-    const orderClause = `ORDER BY ${this.mapOrderField(orderBy)} ${orderDirection}`;
-
-    // Pagination
-    const limit = filters.limit || 20;
-    const offset = filters.offset || 0;
-
-    // Get total count
-    const countResult = await this.db.query<{ count: string }>(
-      `SELECT COUNT(*) as count FROM content ${whereClause}`,
-      params
-    );
-    const total = parseInt(countResult.rows[0].count);
-
-    // Get data
-    params.push(limit, offset);
-    const dataResult = await this.db.query<Record<string, unknown>>(
-      `
-      SELECT * FROM content
-      ${whereClause}
-      ${orderClause}
-      LIMIT $${paramIndex++} OFFSET $${paramIndex++}
-      `,
-      params
-    );
-
-    return {
-      data: dataResult.rows.map(row => this.mapRowToContent(row)),
-      total,
-      limit,
-      offset,
-      hasMore: offset + limit < total
-    };
-  }
-
-  /**
-   * Get content versions
-   */
-  async getVersions(contentId: string): Promise<IContentVersion[]> {
-    const result = await this.db.query<Record<string, unknown>>(
-      `
-      SELECT * FROM content_versions
-      WHERE content_id = $1
-      ORDER BY version_number DESC
-      `,
-      [contentId]
-    );
-
-    return result.rows.map(row => this.mapRowToVersion(row));
-  }
-
-  /**
-   * Get specific version
-   */
-  async getVersion(
-    contentId: string,
-    versionNumber: number
-  ): Promise<IContentVersion | null> {
-    const result = await this.db.query<Record<string, unknown>>(
-      `
-      SELECT * FROM content_versions
-      WHERE content_id = $1 AND version_number = $2
-      `,
-      [contentId, versionNumber]
-    );
-
-    return result.rows.length > 0
-      ? this.mapRowToVersion(result.rows[0])
-      : null;
-  }
-
-  /**
-   * Ensure slug is unique by appending number if needed
-   */
-  private async ensureUniqueSlug(baseSlug: string): Promise<string> {
-    let slug = baseSlug;
-    let counter = 1;
-
-    while (await this.slugExists(slug)) {
-      slug = `${baseSlug}-${counter}`;
-      counter++;
-    }
-
-    return slug;
-  }
-
-  /**
-   * Check if slug exists
-   */
-  private async slugExists(slug: string): Promise<boolean> {
-    const result = await this.db.query<{ exists: boolean }>(
-      'SELECT EXISTS(SELECT 1 FROM content WHERE slug = $1 AND deleted_at IS NULL) as exists',
-      [slug]
-    );
-    return result.rows[0].exists;
-  }
-
-  /**
-   * Map database row to content model
-   */
-  private mapRowToContent(row: Record<string, unknown>): IContent {
-    return {
-      id: row.id as string,
-      userId: row.user_id as string,
-      title: row.title as string,
-      slug: row.slug as string,
-      body: row.body as string,
-      excerpt: row.excerpt as string | undefined,
-      type: row.type as ContentType,
-      format: row.format as ContentFormat,
-      status: row.status as ContentStatus,
-      workflowStage: row.workflow_stage as string | undefined,
-      assignedTo: row.assigned_to as string | undefined,
-      aiReviewed: row.ai_reviewed as boolean,
-      aiReviewScore: row.ai_review_score as number | undefined,
-      aiProvider: row.ai_provider as string | undefined,
-      publishedAt: row.published_at as Date | undefined,
-      scheduledFor: row.scheduled_for as Date | undefined,
-      deletedAt: row.deleted_at as Date | undefined,
-      metaTitle: row.meta_title as string | undefined,
-      metaDescription: row.meta_description as string | undefined,
-      keywords: row.keywords as string[] | undefined,
-      viewCount: row.view_count as number,
-      shareCount: row.share_count as number,
-      generatedFromCommit: row.generated_from_commit as boolean,
-      sourceCommitSha: row.source_commit_sha as string | undefined,
-      sourceRepository: row.source_repository as string | undefined,
-      createdAt: row.created_at as Date,
-      updatedAt: row.updated_at as Date
-    };
-  }
-
-  /**
-   * Map database row to version model
-   */
-  private mapRowToVersion(row: Record<string, unknown>): IContentVersion {
-    return {
-      id: row.id as string,
-      contentId: row.content_id as string,
-      versionNumber: row.version_number as number,
-      title: row.title as string,
-      body: row.body as string,
-      changeSummary: row.change_summary as string | undefined,
-      isAutosave: row.is_autosave as boolean,
-      createdAt: row.created_at as Date,
-      createdBy: row.created_by as string
-    };
-  }
-
-  /**
-   * Map order field to database column
-   */
-  private mapOrderField(field: string): string {
-    const fieldMap: Record<string, string> = {
-      createdAt: 'created_at',
-      updatedAt: 'updated_at',
-      publishedAt: 'published_at',
-      title: 'title'
-    };
-    return fieldMap[field] || 'created_at';
-  }
-}

package/src/errors/ContentNotFoundError.ts

@@ -1,17 +0,0 @@
-/*
-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.
-*/
-
-/**
- * Error thrown when content is not found
- */
-export class ContentNotFoundError extends Error {
-  constructor(id: string) {
-    super(`Content not found or already deleted: ${id}`);
-    this.name = 'ContentNotFoundError';
-  }
-}

package/src/errors/DuplicateSlugError.ts

@@ -1,17 +0,0 @@
-/*
-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.
-*/
-
-/**
- * Error thrown when slug already exists
- */
-export class DuplicateSlugError extends Error {
-  constructor(slug: string) {
-    super(`Slug already exists: ${slug}`);
-    this.name = 'DuplicateSlugError';
-  }
-}