nca-ai-cms-astro-plugin 1.0.0

package/src/services/SchedulerDBAdapter.ts

@@ -0,0 +1,75 @@
+import { db, ScheduledPosts, eq } from 'astro:db';
+import type { ScheduledPostDBRow } from '../domain/entities/ScheduledPost';
+import type { SchedulerDBAdapter } from './SchedulerService';
+
+export class AstroSchedulerDBAdapter implements SchedulerDBAdapter {
+  async listAll(): Promise<ScheduledPostDBRow[]> {
+    return await db.select().from(ScheduledPosts);
+  }
+
+  async getById(id: string): Promise<ScheduledPostDBRow | null> {
+    const row = await db
+      .select()
+      .from(ScheduledPosts)
+      .where(eq(ScheduledPosts.id, id))
+      .get();
+    return row ?? null;
+  }
+
+  async insert(row: ScheduledPostDBRow): Promise<void> {
+    await db.insert(ScheduledPosts).values({
+      id: row.id,
+      input: row.input,
+      inputType: row.inputType,
+      scheduledDate: row.scheduledDate,
+      status: row.status,
+      generatedTitle: row.generatedTitle ?? undefined,
+      generatedDescription: row.generatedDescription ?? undefined,
+      generatedContent: row.generatedContent ?? undefined,
+      generatedTags: row.generatedTags ?? undefined,
+      generatedImageData: row.generatedImageData ?? undefined,
+      generatedImageAlt: row.generatedImageAlt ?? undefined,
+      publishedPath: row.publishedPath ?? undefined,
+      createdAt: row.createdAt,
+    });
+  }
+
+  async update(id: string, data: Partial<ScheduledPostDBRow>): Promise<void> {
+    const updateData: Record<string, unknown> = {};
+    if (data.status !== undefined) updateData.status = data.status;
+    if (data.generatedTitle !== undefined)
+      updateData.generatedTitle = data.generatedTitle;
+    if (data.generatedDescription !== undefined)
+      updateData.generatedDescription = data.generatedDescription;
+    if (data.generatedContent !== undefined)
+      updateData.generatedContent = data.generatedContent;
+    if (data.generatedTags !== undefined)
+      updateData.generatedTags = data.generatedTags;
+    if (data.generatedImageData !== undefined)
+      updateData.generatedImageData = data.generatedImageData;
+    if (data.generatedImageAlt !== undefined)
+      updateData.generatedImageAlt = data.generatedImageAlt;
+    if (data.publishedPath !== undefined)
+      updateData.publishedPath = data.publishedPath;
+
+    await db
+      .update(ScheduledPosts)
+      .set(updateData)
+      .where(eq(ScheduledPosts.id, id));
+  }
+
+  async deleteById(id: string): Promise<void> {
+    await db.delete(ScheduledPosts).where(eq(ScheduledPosts.id, id));
+  }
+
+  async getByDate(date: Date): Promise<ScheduledPostDBRow | null> {
+    // Get all rows and filter by date (astro:db doesn't have date comparison operators)
+    const all = await db.select().from(ScheduledPosts);
+    const dateStr = date.toISOString().split('T')[0];
+    const match = all.find((row: ScheduledPostDBRow) => {
+      const rowDate = new Date(row.scheduledDate).toISOString().split('T')[0];
+      return rowDate === dateStr && row.status !== 'published';
+    });
+    return match ?? null;
+  }
+}

package/src/services/SchedulerService.test.ts

@@ -0,0 +1,286 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SchedulerService } from './SchedulerService';
+import type { ScheduledPostDBRow } from '../domain/entities/ScheduledPost';
+
+// Mock DB adapter interface
+interface MockDB {
+  listAll(): Promise<ScheduledPostDBRow[]>;
+  getById(id: string): Promise<ScheduledPostDBRow | null>;
+  insert(row: ScheduledPostDBRow): Promise<void>;
+  update(id: string, data: Partial<ScheduledPostDBRow>): Promise<void>;
+  deleteById(id: string): Promise<void>;
+  getByDate(date: Date): Promise<ScheduledPostDBRow | null>;
+}
+
+function createMockDB(rows: ScheduledPostDBRow[] = []): MockDB {
+  const store = new Map<string, ScheduledPostDBRow>();
+  rows.forEach((r) => store.set(r.id, r));
+
+  return {
+    listAll: vi.fn(async () => [...store.values()]),
+    getById: vi.fn(async (id: string) => store.get(id) || null),
+    insert: vi.fn(async (row: ScheduledPostDBRow) => {
+      store.set(row.id, row);
+    }),
+    update: vi.fn(async (id: string, data: Partial<ScheduledPostDBRow>) => {
+      const existing = store.get(id);
+      if (existing) store.set(id, { ...existing, ...data });
+    }),
+    deleteById: vi.fn(async (id: string) => {
+      store.delete(id);
+    }),
+    getByDate: vi.fn(async (date: Date) => {
+      const dateStr = date.toISOString().split('T')[0];
+      for (const row of store.values()) {
+        const rowDate = new Date(row.scheduledDate).toISOString().split('T')[0];
+        if (rowDate === dateStr && row.status !== 'published') return row;
+      }
+      return null;
+    }),
+  };
+}
+
+describe('SchedulerService', () => {
+  let db: MockDB;
+  let service: SchedulerService;
+
+  beforeEach(() => {
+    db = createMockDB();
+    service = new SchedulerService(db);
+  });
+
+  describe('create', () => {
+    it('creates a new scheduled post', async () => {
+      const result = await service.create({
+        input: 'ARIA Landmarks',
+        scheduledDate: new Date('2026-04-01'),
+      });
+
+      expect(result.id).toMatch(/^sp_/);
+      expect(result.status).toBe('pending');
+      expect(result.inputType).toBe('keywords');
+      expect(db.insert).toHaveBeenCalled();
+    });
+
+    it('detects URL input type', async () => {
+      const result = await service.create({
+        input: 'https://example.com/article',
+        scheduledDate: new Date('2026-04-01'),
+      });
+
+      expect(result.inputType).toBe('url');
+    });
+
+    it('rejects duplicate dates', async () => {
+      const date = new Date('2026-04-01');
+      db = createMockDB([
+        {
+          id: 'sp_existing',
+          input: 'existing',
+          inputType: 'keywords',
+          scheduledDate: date,
+          status: 'pending',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      await expect(
+        service.create({ input: 'new entry', scheduledDate: date })
+      ).rejects.toThrow('already scheduled');
+    });
+  });
+
+  describe('list', () => {
+    it('returns all posts sorted by date', async () => {
+      const rows: ScheduledPostDBRow[] = [
+        {
+          id: 'sp_2',
+          input: 'b',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-02'),
+          status: 'pending',
+          createdAt: new Date(),
+        },
+        {
+          id: 'sp_1',
+          input: 'a',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-01'),
+          status: 'pending',
+          createdAt: new Date(),
+        },
+      ];
+      db = createMockDB(rows);
+      service = new SchedulerService(db);
+
+      const result = await service.list();
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('delete', () => {
+    it('deletes a non-published post', async () => {
+      db = createMockDB([
+        {
+          id: 'sp_1',
+          input: 'test',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-01'),
+          status: 'pending',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      await service.delete('sp_1');
+      expect(db.deleteById).toHaveBeenCalledWith('sp_1');
+    });
+
+    it('refuses to delete a published post', async () => {
+      db = createMockDB([
+        {
+          id: 'sp_1',
+          input: 'test',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-01'),
+          status: 'published',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      await expect(service.delete('sp_1')).rejects.toThrow('Cannot delete');
+    });
+
+    it('throws if post not found', async () => {
+      await expect(service.delete('sp_nonexistent')).rejects.toThrow(
+        'not found'
+      );
+    });
+  });
+
+  describe('getDuePosts', () => {
+    it('returns generated posts whose date has passed', async () => {
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+
+      db = createMockDB([
+        {
+          id: 'sp_due',
+          input: 'due',
+          inputType: 'keywords',
+          scheduledDate: yesterday,
+          status: 'generated',
+          generatedTitle: 'Title',
+          generatedContent: '# Content',
+          createdAt: new Date(),
+        },
+        {
+          id: 'sp_future',
+          input: 'future',
+          inputType: 'keywords',
+          scheduledDate: tomorrow,
+          status: 'generated',
+          createdAt: new Date(),
+        },
+        {
+          id: 'sp_pending',
+          input: 'pending',
+          inputType: 'keywords',
+          scheduledDate: yesterday,
+          status: 'pending',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      const due = await service.getDuePosts();
+      expect(due).toHaveLength(1);
+      expect(due[0]!.id).toBe('sp_due');
+    });
+  });
+
+  describe('markGenerated', () => {
+    it('updates post with generated content', async () => {
+      db = createMockDB([
+        {
+          id: 'sp_1',
+          input: 'test',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-01'),
+          status: 'pending',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      await service.markGenerated('sp_1', {
+        title: 'Generated Title',
+        description: 'Generated description',
+        content: '# Content',
+        tags: ['tag1', 'tag2'],
+      });
+
+      expect(db.update).toHaveBeenCalledWith(
+        'sp_1',
+        expect.objectContaining({
+          status: 'generated',
+          generatedTitle: 'Generated Title',
+        })
+      );
+    });
+
+    it('rejects generation for published posts', async () => {
+      db = createMockDB([
+        {
+          id: 'sp_1',
+          input: 'test',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-01'),
+          status: 'published',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      await expect(
+        service.markGenerated('sp_1', {
+          title: 'Title',
+          description: 'Desc',
+          content: '# C',
+          tags: [],
+        })
+      ).rejects.toThrow('Cannot generate');
+    });
+  });
+
+  describe('markPublished', () => {
+    it('updates post status to published with path', async () => {
+      db = createMockDB([
+        {
+          id: 'sp_1',
+          input: 'test',
+          inputType: 'keywords',
+          scheduledDate: new Date('2026-04-01'),
+          status: 'generated',
+          createdAt: new Date(),
+        },
+      ]);
+      service = new SchedulerService(db);
+
+      await service.markPublished('sp_1', 'nca-ai-cms-content/2026/04/test');
+
+      expect(db.update).toHaveBeenCalledWith(
+        'sp_1',
+        expect.objectContaining({
+          status: 'published',
+          publishedPath: 'nca-ai-cms-content/2026/04/test',
+        })
+      );
+    });
+  });
+});

package/src/services/SchedulerService.ts

@@ -0,0 +1,149 @@
+import {
+  ScheduledPost,
+  type ScheduledPostDBRow,
+  type ScheduledPostStatus,
+} from '../domain/entities/ScheduledPost';
+
+export interface SchedulerDBAdapter {
+  listAll(): Promise<ScheduledPostDBRow[]>;
+  getById(id: string): Promise<ScheduledPostDBRow | null>;
+  insert(row: ScheduledPostDBRow): Promise<void>;
+  update(id: string, data: Partial<ScheduledPostDBRow>): Promise<void>;
+  deleteById(id: string): Promise<void>;
+  getByDate(date: Date): Promise<ScheduledPostDBRow | null>;
+}
+
+export interface CreateScheduledPostInput {
+  input: string;
+  scheduledDate: Date;
+}
+
+export class SchedulerService {
+  constructor(private readonly db: SchedulerDBAdapter) {}
+
+  private async requireGeneratable(id: string, action: string): Promise<void> {
+    const post = await this.getById(id);
+    if (!post.canGenerate()) {
+      throw new Error(`Cannot ${action}: post is in status "${post.status}"`);
+    }
+  }
+
+  async create(data: CreateScheduledPostInput): Promise<ScheduledPost> {
+    // Check for duplicate date
+    const existing = await this.db.getByDate(data.scheduledDate);
+    if (existing) {
+      const dateStr = data.scheduledDate.toISOString().split('T')[0];
+      throw new Error(`Date ${dateStr} is already scheduled for another post`);
+    }
+
+    const inputType = ScheduledPost.detectInputType(data.input);
+    const post = ScheduledPost.create({
+      input: data.input,
+      inputType,
+      scheduledDate: data.scheduledDate,
+    });
+
+    await this.db.insert({
+      id: post.id,
+      input: post.input,
+      inputType: post.inputType,
+      scheduledDate: post.scheduledDate,
+      status: post.status,
+      createdAt: post.createdAt,
+    });
+
+    return post;
+  }
+
+  async list(): Promise<ScheduledPost[]> {
+    const rows = await this.db.listAll();
+    return rows
+      .map((row) => ScheduledPost.fromDB(row))
+      .sort((a, b) => a.scheduledDate.getTime() - b.scheduledDate.getTime());
+  }
+
+  async getById(id: string): Promise<ScheduledPost> {
+    const row = await this.db.getById(id);
+    if (!row) {
+      throw new Error(`Scheduled post not found: ${id}`);
+    }
+    return ScheduledPost.fromDB(row);
+  }
+
+  async delete(id: string): Promise<void> {
+    const post = await this.getById(id);
+    if (!post.canDelete()) {
+      throw new Error('Cannot delete a published post');
+    }
+    await this.db.deleteById(id);
+  }
+
+  async markGenerated(
+    id: string,
+    data: {
+      title: string;
+      description: string;
+      content: string;
+      tags: string[];
+      imageData?: string | undefined;
+      imageAlt?: string | undefined;
+    }
+  ): Promise<void> {
+    await this.requireGeneratable(id, 'generate');
+
+    await this.db.update(id, {
+      status: 'generated' as ScheduledPostStatus,
+      generatedTitle: data.title,
+      generatedDescription: data.description,
+      generatedContent: data.content,
+      generatedTags: JSON.stringify(data.tags),
+      generatedImageData: data.imageData || null,
+      generatedImageAlt: data.imageAlt || null,
+    });
+  }
+
+  async updateText(
+    id: string,
+    data: {
+      title: string;
+      description: string;
+      content: string;
+      tags: string[];
+    }
+  ): Promise<void> {
+    await this.requireGeneratable(id, 'regenerate');
+
+    await this.db.update(id, {
+      status: 'generated' as ScheduledPostStatus,
+      generatedTitle: data.title,
+      generatedDescription: data.description,
+      generatedContent: data.content,
+      generatedTags: JSON.stringify(data.tags),
+    });
+  }
+
+  async updateImage(
+    id: string,
+    data: { imageData: string; imageAlt: string }
+  ): Promise<void> {
+    await this.requireGeneratable(id, 'regenerate');
+
+    await this.db.update(id, {
+      status: 'generated' as ScheduledPostStatus,
+      generatedImageData: data.imageData,
+      generatedImageAlt: data.imageAlt,
+    });
+  }
+
+  async markPublished(id: string, publishedPath: string): Promise<void> {
+    await this.db.update(id, {
+      status: 'published' as ScheduledPostStatus,
+      publishedPath,
+    });
+  }
+
+  async getDuePosts(): Promise<ScheduledPost[]> {
+    const all = await this.list();
+    return all.filter((post) => post.isDue());
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,27 @@
+export { ContentFetcher, type FetchedContent } from './ContentFetcher';
+export {
+  ContentGenerator,
+  type GeneratedContent,
+  type ContentGeneratorConfig,
+  type IPromptService,
+} from './ContentGenerator';
+export { FileWriter, type WriteResult } from './FileWriter';
+export {
+  ArticleService,
+  type ArticleData,
+  ArticleNotFoundError,
+  type UpdateContentOptions,
+} from './ArticleService';
+export {
+  ImageGenerator,
+  type GeneratedImage,
+  type ImageGeneratorConfig,
+} from './ImageGenerator';
+export { convertToWebP } from './ImageConverter';
+export {
+  SchedulerService,
+  type SchedulerDBAdapter,
+  type CreateScheduledPostInput,
+} from './SchedulerService';
+export { PromptService, type CTAConfig } from './PromptService';
+export { startAutoPublisher, stopAutoPublisher } from './AutoPublisher';

package/src/utils/authUtils.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { isPublicPath, isProtectedPath, isAuthenticated } from './authUtils.js';
+
+describe('isPublicPath', () => {
+  it('allows auth endpoints and login page', () => {
+    expect(isPublicPath('/api/auth/login')).toBe(true);
+    expect(isPublicPath('/api/auth/logout')).toBe(true);
+    expect(isPublicPath('/login')).toBe(true);
+  });
+
+  it('rejects other paths', () => {
+    expect(isPublicPath('/api/generate-content')).toBe(false);
+    expect(isPublicPath('/editor')).toBe(false);
+    expect(isPublicPath('/')).toBe(false);
+  });
+});
+
+describe('isProtectedPath', () => {
+  it('protects API routes and editor', () => {
+    expect(isProtectedPath('/api/generate-content')).toBe(true);
+    expect(isProtectedPath('/api/prompts')).toBe(true);
+    expect(isProtectedPath('/editor')).toBe(true);
+  });
+
+  it('does not protect other paths', () => {
+    expect(isProtectedPath('/')).toBe(false);
+    expect(isProtectedPath('/about')).toBe(false);
+    expect(isProtectedPath('/login')).toBe(false);
+  });
+});
+
+describe('isAuthenticated', () => {
+  beforeEach(() => {
+    process.env.EDITOR_ADMIN = 'admin';
+    process.env.EDITOR_PASSWORD = 'secret';
+  });
+
+  afterEach(() => {
+    delete process.env.EDITOR_ADMIN;
+    delete process.env.EDITOR_PASSWORD;
+  });
+
+  it('returns true for valid base64 credentials', () => {
+    const token = btoa('admin:secret');
+    expect(isAuthenticated(token)).toBe(true);
+  });
+
+  it('returns false for wrong credentials', () => {
+    const token = btoa('admin:wrong');
+    expect(isAuthenticated(token)).toBe(false);
+  });
+
+  it('returns false for undefined', () => {
+    expect(isAuthenticated(undefined)).toBe(false);
+  });
+
+  it('returns false for invalid base64', () => {
+    expect(isAuthenticated('%%%not-base64')).toBe(false);
+  });
+});

package/src/utils/authUtils.ts

@@ -0,0 +1,25 @@
+import { getEnvVariable } from './envUtils.js';
+
+const PUBLIC_PATHS = ['/api/auth/login', '/api/auth/logout', '/login'];
+
+export function isPublicPath(pathname: string): boolean {
+  return PUBLIC_PATHS.includes(pathname);
+}
+
+export function isProtectedPath(pathname: string): boolean {
+  return pathname.startsWith('/api/') || pathname === '/editor';
+}
+
+export function isAuthenticated(cookieValue: string | undefined): boolean {
+  if (!cookieValue) return false;
+
+  try {
+    const decoded = atob(cookieValue);
+    const [username, password] = decoded.split(':');
+    const expectedUsername = getEnvVariable('EDITOR_ADMIN');
+    const expectedPassword = getEnvVariable('EDITOR_PASSWORD');
+    return username === expectedUsername && password === expectedPassword;
+  } catch {
+    return false;
+  }
+}

package/src/utils/envUtils.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { getEnvVariable } from "./envUtils.js";
+
+describe("getEnvVariable", () => {
+  const TEST_VAR = "TEST_ENV_VARIABLE_FOR_UTILS";
+
+  afterEach(() => {
+    delete process.env[TEST_VAR];
+  });
+
+  it("returns the value when the environment variable is set", () => {
+    process.env[TEST_VAR] = "hello";
+    expect(getEnvVariable(TEST_VAR)).toBe("hello");
+  });
+
+  it("returns the default value when the variable is not set", () => {
+    expect(getEnvVariable(TEST_VAR, "fallback")).toBe("fallback");
+  });
+
+  it("returns the default value when the variable is an empty string", () => {
+    process.env[TEST_VAR] = "";
+    expect(getEnvVariable(TEST_VAR, "fallback")).toBe("fallback");
+  });
+
+  it("throws when a required variable is missing and no default is provided", () => {
+    expect(() => getEnvVariable(TEST_VAR)).toThrow(
+      `Required environment variable "${TEST_VAR}" is not set.`,
+    );
+  });
+
+  it("prefers the actual env value over the default", () => {
+    process.env[TEST_VAR] = "actual";
+    expect(getEnvVariable(TEST_VAR, "default")).toBe("actual");
+  });
+
+  it("returns the default when the variable is undefined in process.env", () => {
+    delete process.env[TEST_VAR];
+    expect(getEnvVariable(TEST_VAR, "")).toBe("");
+  });
+});

package/src/utils/envUtils.ts

@@ -0,0 +1,26 @@
+/**
+ * Reads an environment variable from `process.env`.
+ *
+ * @param variable     - The name of the environment variable.
+ * @param defaultValue - Optional fallback when the variable is not set.
+ * @returns The value of the environment variable, or the default.
+ * @throws {Error} When the variable is not set and no default is provided.
+ */
+export function getEnvVariable(
+  variable: string,
+  defaultValue?: string,
+): string {
+  const value = process.env[variable];
+
+  if (value !== undefined && value !== "") {
+    return value;
+  }
+
+  if (defaultValue !== undefined) {
+    return defaultValue;
+  }
+
+  throw new Error(
+    `Required environment variable "${variable}" is not set.`,
+  );
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export { renderMarkdown } from "./markdown.js";
+export {
+  sanitizeMarkdownHtml,
+  escapeJsonLd,
+  escapeHtml,
+} from "./sanitize.js";
+export { getEnvVariable } from "./envUtils.js";