nca-ai-cms-astro-plugin 1.0.0

package/src/db/tables.ts

@@ -0,0 +1,39 @@
+import { defineTable, column } from "astro:db";
+
+const SiteSettings = defineTable({
+  columns: {
+    key: column.text({ primaryKey: true }),
+    value: column.text(),
+    updatedAt: column.date({ default: new Date() }),
+  },
+});
+
+const ScheduledPosts = defineTable({
+  columns: {
+    id: column.text({ primaryKey: true }),
+    input: column.text(),
+    inputType: column.text(),
+    scheduledDate: column.date(),
+    status: column.text({ default: "pending" }),
+    generatedTitle: column.text({ optional: true }),
+    generatedDescription: column.text({ optional: true }),
+    generatedContent: column.text({ optional: true }),
+    generatedTags: column.text({ optional: true }),
+    generatedImageData: column.text({ optional: true }),
+    generatedImageAlt: column.text({ optional: true }),
+    publishedPath: column.text({ optional: true }),
+    createdAt: column.date({ default: new Date() }),
+  },
+});
+
+const Prompts = defineTable({
+  columns: {
+    id: column.text({ primaryKey: true }),
+    name: column.text(),
+    category: column.text(),
+    promptText: column.text(),
+    updatedAt: column.date({ default: new Date() }),
+  },
+});
+
+export { SiteSettings, Prompts, ScheduledPosts };

package/src/domain/entities/Article.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect } from 'vitest';
+import { Article } from './Article';
+
+describe('Article', () => {
+  const defaultProps = {
+    title: 'HTML Accessibility Grundlagen',
+    description: 'Lernen Sie die Grundlagen der HTML-Barrierefreiheit',
+    content: '# HTML Accessibility\n\nContent here...',
+    date: new Date('2025-12-07'),
+    tags: ['accessibility', 'html'],
+  };
+
+  it('creates article with valid props', () => {
+    const article = new Article(defaultProps);
+    expect(article.title).toBe('HTML Accessibility Grundlagen');
+    expect(article.tags).toEqual(['accessibility', 'html']);
+  });
+
+  it('generates SEO-compliant slug from title', () => {
+    const article = new Article(defaultProps);
+    expect(article.slug.toString()).toBe('html-accessibility-grundlagen');
+  });
+
+  it('generates correct filename', () => {
+    const article = new Article(defaultProps);
+    expect(article.filename).toBe('html-accessibility-grundlagen.md');
+  });
+
+  it('generates correct folderPath with default contentPath', () => {
+    const article = new Article(defaultProps);
+    expect(article.folderPath).toBe(
+      'nca-ai-cms-content/2025/12/html-accessibility-grundlagen'
+    );
+  });
+
+  it('generates correct filepath with index.md', () => {
+    const article = new Article(defaultProps);
+    expect(article.filepath).toBe(
+      'nca-ai-cms-content/2025/12/html-accessibility-grundlagen/index.md'
+    );
+  });
+
+  it('uses configurable contentPath', () => {
+    const article = new Article({
+      ...defaultProps,
+      contentPath: 'custom-content',
+    });
+    expect(article.folderPath).toBe(
+      'custom-content/2025/12/html-accessibility-grundlagen'
+    );
+    expect(article.filepath).toBe(
+      'custom-content/2025/12/html-accessibility-grundlagen/index.md'
+    );
+  });
+
+  it('defaults contentPath to nca-ai-cms-content when not provided', () => {
+    const article = new Article(defaultProps);
+    expect(article.contentPath).toBe('nca-ai-cms-content');
+  });
+
+  it('stores explicit contentPath', () => {
+    const article = new Article({
+      ...defaultProps,
+      contentPath: 'src/content/articles',
+    });
+    expect(article.contentPath).toBe('src/content/articles');
+  });
+
+  it('extracts year from date', () => {
+    const article = new Article(defaultProps);
+    expect(article.year).toBe(2025);
+  });
+
+  it('extracts zero-padded month from date', () => {
+    const article = new Article({
+      ...defaultProps,
+      date: new Date('2025-01-15'),
+    });
+    expect(article.month).toBe('01');
+  });
+
+  it('generates valid frontmatter object', () => {
+    const article = new Article(defaultProps);
+    const frontmatter = article.toFrontmatter();
+
+    expect(frontmatter.title).toBe('HTML Accessibility Grundlagen');
+    expect(frontmatter.description).toBe(
+      'Lernen Sie die Grundlagen der HTML-Barrierefreiheit'
+    );
+    expect(frontmatter.date).toBe('2025-12-07');
+    expect(frontmatter.tags).toEqual(['accessibility', 'html']);
+  });
+
+  it('generates complete markdown with frontmatter', () => {
+    const article = new Article(defaultProps);
+    const markdown = article.toMarkdown();
+
+    expect(markdown).toContain('---');
+    expect(markdown).toContain('title: "HTML Accessibility Grundlagen"');
+    expect(markdown).toContain('# HTML Accessibility');
+  });
+
+  it('truncates SEO title to 60 chars when title exceeds limit', () => {
+    const longTitle = 'A'.repeat(67);
+    const article = new Article({
+      ...defaultProps,
+      title: longTitle,
+    });
+
+    expect(article.seoMetadata.title.length).toBe(60);
+    expect(article.seoMetadata.title.endsWith('...')).toBe(true);
+    expect(article.title).toBe(longTitle); // Full title preserved
+  });
+
+  it('includes optional image fields with relative path', () => {
+    const article = new Article({
+      ...defaultProps,
+      image: './hero.webp',
+      imageAlt: 'Accessibility illustration',
+    });
+
+    const frontmatter = article.toFrontmatter();
+    expect(frontmatter.image).toBe('./hero.webp');
+    expect(frontmatter.imageAlt).toBe('Accessibility illustration');
+  });
+
+  it('uses relative image path in markdown frontmatter', () => {
+    const article = new Article({
+      ...defaultProps,
+      image: './hero.webp',
+      imageAlt: 'Accessibility illustration',
+    });
+
+    const markdown = article.toMarkdown();
+    expect(markdown).toContain('image: "./hero.webp"');
+    expect(markdown).toContain('imageAlt: "Accessibility illustration"');
+  });
+});

package/src/domain/entities/Article.ts

@@ -0,0 +1,90 @@
+import { Slug } from '../value-objects/Slug';
+import { SEOMetadata } from '../value-objects/SEOMetadata';
+
+export type ArticleProps = {
+  title: string;
+  description: string;
+  content: string;
+  date: Date;
+  tags: string[];
+  image?: string;
+  imageAlt?: string;
+  contentPath?: string;
+};
+
+export class Article {
+  readonly title: string;
+  readonly description: string;
+  readonly content: string;
+  readonly date: Date;
+  readonly tags: string[];
+  readonly slug: Slug;
+  readonly seoMetadata: SEOMetadata;
+  readonly image?: string;
+  readonly imageAlt?: string;
+  readonly contentPath: string;
+
+  constructor(props: ArticleProps) {
+    this.title = props.title;
+    this.description = props.description;
+    this.date = props.date;
+    this.tags = props.tags;
+    this.slug = new Slug(props.title);
+    this.seoMetadata = new SEOMetadata(props.title, props.description);
+    this.contentPath = props.contentPath ?? 'nca-ai-cms-content';
+
+    this.content = props.content;
+
+    if (props.image !== undefined) {
+      this.image = props.image;
+    }
+    if (props.imageAlt !== undefined) {
+      this.imageAlt = props.imageAlt;
+    }
+  }
+
+  get filename(): string {
+    return `${this.slug.toString()}.md`;
+  }
+
+  get year(): number {
+    return this.date.getFullYear();
+  }
+
+  get month(): string {
+    return String(this.date.getMonth() + 1).padStart(2, '0');
+  }
+
+  get folderPath(): string {
+    return `${this.contentPath}/${this.year}/${this.month}/${this.slug.toString()}`;
+  }
+
+  get filepath(): string {
+    return `${this.folderPath}/index.md`;
+  }
+
+  toFrontmatter(): Record<string, unknown> {
+    return {
+      title: this.title,
+      description: this.description,
+      date: this.date.toISOString().split('T')[0],
+      createdAt: this.date.toISOString(),
+      tags: this.tags,
+      ...(this.image && { image: this.image }),
+      ...(this.imageAlt && { imageAlt: this.imageAlt }),
+    };
+  }
+
+  toMarkdown(): string {
+    const frontmatter = Object.entries(this.toFrontmatter())
+      .map(([key, value]) => {
+        if (Array.isArray(value)) {
+          return `${key}: ${JSON.stringify(value)}`;
+        }
+        return `${key}: "${value}"`;
+      })
+      .join('\n');
+
+    return `---\n${frontmatter}\n---\n\n${this.content}`;
+  }
+}

package/src/domain/entities/ScheduledPost.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect } from 'vitest';
+import { ScheduledPost } from './ScheduledPost';
+import type { ScheduledPostInputType } from './ScheduledPost';
+
+describe('ScheduledPost', () => {
+  const defaultProps = {
+    input: 'ARIA Landmarks barrierefreie Navigation',
+    inputType: 'keywords' as ScheduledPostInputType,
+    scheduledDate: new Date('2026-03-15'),
+  };
+
+  it('creates a scheduled post with pending status', () => {
+    const post = ScheduledPost.create(defaultProps);
+    expect(post.status).toBe('pending');
+    expect(post.input).toBe(defaultProps.input);
+    expect(post.inputType).toBe('keywords');
+  });
+
+  it('generates a unique id starting with sp_', () => {
+    const post = ScheduledPost.create(defaultProps);
+    expect(post.id).toMatch(/^sp_/);
+  });
+
+  it('sets createdAt to current date', () => {
+    const before = new Date();
+    const post = ScheduledPost.create(defaultProps);
+    const after = new Date();
+    expect(post.createdAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
+    expect(post.createdAt.getTime()).toBeLessThanOrEqual(after.getTime());
+  });
+
+  it('detects URL input type', () => {
+    expect(ScheduledPost.detectInputType('https://example.com')).toBe('url');
+    expect(ScheduledPost.detectInputType('http://example.com')).toBe('url');
+  });
+
+  it('detects keywords input type', () => {
+    expect(ScheduledPost.detectInputType('ARIA Landmarks')).toBe('keywords');
+    expect(ScheduledPost.detectInputType('barrierefreie Navigation')).toBe(
+      'keywords'
+    );
+  });
+
+  it('can transition from pending to generated', () => {
+    const post = ScheduledPost.create(defaultProps);
+    expect(post.canGenerate()).toBe(true);
+    expect(post.canPublish()).toBe(false);
+  });
+
+  it('can regenerate when already generated', () => {
+    const post = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      status: 'generated',
+      createdAt: new Date(),
+    });
+    expect(post.canGenerate()).toBe(true);
+    expect(post.canPublish()).toBe(true);
+  });
+
+  it('cannot generate or publish when already published', () => {
+    const post = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      status: 'published',
+      createdAt: new Date(),
+    });
+    expect(post.canGenerate()).toBe(false);
+    expect(post.canPublish()).toBe(false);
+  });
+
+  it('can delete when not published', () => {
+    const pending = ScheduledPost.create(defaultProps);
+    expect(pending.canDelete()).toBe(true);
+
+    const generated = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      status: 'generated',
+      createdAt: new Date(),
+    });
+    expect(generated.canDelete()).toBe(true);
+
+    const published = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      status: 'published',
+      createdAt: new Date(),
+    });
+    expect(published.canDelete()).toBe(false);
+  });
+
+  it('determines if a post is due for auto-publish', () => {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+
+    const post = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      scheduledDate: yesterday,
+      status: 'generated',
+      createdAt: new Date(),
+    });
+    expect(post.isDue()).toBe(true);
+  });
+
+  it('is not due if date is in the future', () => {
+    const nextWeek = new Date();
+    nextWeek.setDate(nextWeek.getDate() + 7);
+
+    const post = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      scheduledDate: nextWeek,
+      status: 'generated',
+      createdAt: new Date(),
+    });
+    expect(post.isDue()).toBe(false);
+  });
+
+  it('is not due if status is pending', () => {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+
+    const post = ScheduledPost.fromDB({
+      ...defaultProps,
+      id: 'sp_1',
+      scheduledDate: yesterday,
+      status: 'pending',
+      createdAt: new Date(),
+    });
+    expect(post.isDue()).toBe(false);
+  });
+
+  it('computes year and month from scheduledDate', () => {
+    const post = ScheduledPost.create({
+      ...defaultProps,
+      scheduledDate: new Date('2026-03-15'),
+    });
+    expect(post.scheduledYear).toBe(2026);
+    expect(post.scheduledMonth).toBe('03');
+  });
+
+  it('reconstructs from DB row', () => {
+    const post = ScheduledPost.fromDB({
+      id: 'sp_123',
+      input: 'test keywords',
+      inputType: 'keywords',
+      scheduledDate: new Date('2026-04-01'),
+      status: 'generated',
+      generatedTitle: 'Test Title',
+      generatedDescription: 'Test desc',
+      generatedContent: '# Test',
+      generatedTags: '["tag1","tag2"]',
+      generatedImageData: 'base64data',
+      generatedImageAlt: 'alt text',
+      publishedPath: null,
+      createdAt: new Date('2026-01-01'),
+    });
+
+    expect(post.id).toBe('sp_123');
+    expect(post.status).toBe('generated');
+    expect(post.generatedTitle).toBe('Test Title');
+    expect(post.parsedTags).toEqual(['tag1', 'tag2']);
+  });
+
+  it('returns empty array for null tags', () => {
+    const post = ScheduledPost.create(defaultProps);
+    expect(post.parsedTags).toEqual([]);
+  });
+
+  describe('isDue() timezone safety', () => {
+    it('is due when scheduled for today (UTC)', () => {
+      const today = new Date();
+      const post = ScheduledPost.fromDB({
+        ...defaultProps,
+        id: 'sp_tz1',
+        scheduledDate: today,
+        status: 'generated',
+        createdAt: new Date(),
+      });
+      expect(post.isDue()).toBe(true);
+    });
+
+    it('is due when scheduled date is an ISO string parsed as UTC', () => {
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      const isoDate = yesterday.toISOString().slice(0, 10);
+
+      const post = ScheduledPost.fromDB({
+        ...defaultProps,
+        id: 'sp_tz2',
+        scheduledDate: new Date(isoDate),
+        status: 'generated',
+        createdAt: new Date(),
+      });
+      expect(post.isDue()).toBe(true);
+    });
+
+    it('is not due when scheduled for tomorrow', () => {
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+
+      const post = ScheduledPost.fromDB({
+        ...defaultProps,
+        id: 'sp_tz3',
+        scheduledDate: tomorrow,
+        status: 'generated',
+        createdAt: new Date(),
+      });
+      expect(post.isDue()).toBe(false);
+    });
+
+    it('is not due when status is published', () => {
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+
+      const post = ScheduledPost.fromDB({
+        ...defaultProps,
+        id: 'sp_tz4',
+        scheduledDate: yesterday,
+        status: 'published',
+        createdAt: new Date(),
+      });
+      expect(post.isDue()).toBe(false);
+    });
+  });
+});

package/src/domain/entities/ScheduledPost.ts

@@ -0,0 +1,152 @@
+export type ScheduledPostStatus = 'pending' | 'generated' | 'published';
+export type ScheduledPostInputType = 'url' | 'keywords';
+
+export interface ScheduledPostProps {
+  input: string;
+  inputType: ScheduledPostInputType;
+  scheduledDate: Date;
+}
+
+export interface ScheduledPostDBRow {
+  id: string;
+  input: string;
+  inputType: string;
+  scheduledDate: Date;
+  status: string;
+  generatedTitle?: string | null;
+  generatedDescription?: string | null;
+  generatedContent?: string | null;
+  generatedTags?: string | null;
+  generatedImageData?: string | null;
+  generatedImageAlt?: string | null;
+  publishedPath?: string | null;
+  createdAt: Date;
+}
+
+export class ScheduledPost {
+  readonly id: string;
+  readonly input: string;
+  readonly inputType: ScheduledPostInputType;
+  readonly scheduledDate: Date;
+  readonly status: ScheduledPostStatus;
+  readonly generatedTitle: string | null | undefined;
+  readonly generatedDescription: string | null | undefined;
+  readonly generatedContent: string | null | undefined;
+  readonly generatedTags: string | null | undefined;
+  readonly generatedImageData: string | null | undefined;
+  readonly generatedImageAlt: string | null | undefined;
+  readonly publishedPath: string | null | undefined;
+  readonly createdAt: Date;
+
+  private constructor(
+    id: string,
+    input: string,
+    inputType: ScheduledPostInputType,
+    scheduledDate: Date,
+    status: ScheduledPostStatus,
+    createdAt: Date,
+    generatedTitle: string | null | undefined,
+    generatedDescription: string | null | undefined,
+    generatedContent: string | null | undefined,
+    generatedTags: string | null | undefined,
+    generatedImageData: string | null | undefined,
+    generatedImageAlt: string | null | undefined,
+    publishedPath: string | null | undefined
+  ) {
+    this.id = id;
+    this.input = input;
+    this.inputType = inputType;
+    this.scheduledDate = scheduledDate;
+    this.status = status;
+    this.createdAt = createdAt;
+    this.generatedTitle = generatedTitle;
+    this.generatedDescription = generatedDescription;
+    this.generatedContent = generatedContent;
+    this.generatedTags = generatedTags;
+    this.generatedImageData = generatedImageData;
+    this.generatedImageAlt = generatedImageAlt;
+    this.publishedPath = publishedPath;
+  }
+
+  static create(props: ScheduledPostProps): ScheduledPost {
+    const id = `sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    return new ScheduledPost(
+      id,
+      props.input,
+      props.inputType,
+      props.scheduledDate,
+      'pending',
+      new Date(),
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined
+    );
+  }
+
+  static fromDB(row: ScheduledPostDBRow): ScheduledPost {
+    return new ScheduledPost(
+      row.id,
+      row.input,
+      row.inputType as ScheduledPostInputType,
+      row.scheduledDate,
+      row.status as ScheduledPostStatus,
+      row.createdAt,
+      row.generatedTitle,
+      row.generatedDescription,
+      row.generatedContent,
+      row.generatedTags,
+      row.generatedImageData,
+      row.generatedImageAlt,
+      row.publishedPath
+    );
+  }
+
+  static detectInputType(input: string): ScheduledPostInputType {
+    try {
+      new URL(input);
+      return 'url';
+    } catch {
+      return 'keywords';
+    }
+  }
+
+  canGenerate(): boolean {
+    return this.status === 'pending' || this.status === 'generated';
+  }
+
+  canPublish(): boolean {
+    return this.status === 'generated';
+  }
+
+  canDelete(): boolean {
+    return this.status !== 'published';
+  }
+
+  isDue(): boolean {
+    if (this.status !== 'generated') return false;
+    const nowDate = new Date().toISOString().slice(0, 10);
+    const scheduledDate = new Date(this.scheduledDate).toISOString().slice(0, 10);
+    return scheduledDate <= nowDate;
+  }
+
+  get scheduledYear(): number {
+    return this.scheduledDate.getFullYear();
+  }
+
+  get scheduledMonth(): string {
+    return String(this.scheduledDate.getMonth() + 1).padStart(2, '0');
+  }
+
+  get parsedTags(): string[] {
+    if (!this.generatedTags) return [];
+    try {
+      return JSON.parse(this.generatedTags);
+    } catch {
+      return [];
+    }
+  }
+}

package/src/domain/entities/Source.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { Source } from './Source';
+
+describe('Source', () => {
+  it('creates source from valid HTTPS URL', () => {
+    const source = new Source(
+      'https://developer.mozilla.org/en-US/docs/Web/HTML'
+    );
+    expect(source.url).toBe(
+      'https://developer.mozilla.org/en-US/docs/Web/HTML'
+    );
+  });
+
+  it('extracts domain from URL', () => {
+    const source = new Source(
+      'https://developer.mozilla.org/en-US/docs/Web/HTML'
+    );
+    expect(source.domain).toBe('developer.mozilla.org');
+  });
+
+  it('throws error for HTTP URL', () => {
+    expect(() => new Source('http://example.com')).toThrow(
+      'Only HTTPS URLs are allowed'
+    );
+  });
+
+  it('throws error for invalid URL', () => {
+    expect(() => new Source('not-a-url')).toThrow('Invalid URL');
+  });
+
+  it('identifies MDN URLs', () => {
+    const source = new Source(
+      'https://developer.mozilla.org/en-US/docs/Web/HTML'
+    );
+    expect(source.isMDN()).toBe(true);
+  });
+
+  it('identifies W3C URLs', () => {
+    const source = new Source('https://www.w3.org/WAI/WCAG21/quickref/');
+    expect(source.isW3C()).toBe(true);
+  });
+
+  it('returns false for non-MDN URL', () => {
+    const source = new Source('https://example.com');
+    expect(source.isMDN()).toBe(false);
+  });
+
+  it('returns false for non-W3C URL', () => {
+    const source = new Source('https://example.com');
+    expect(source.isW3C()).toBe(false);
+  });
+
+  it('converts to string', () => {
+    const source = new Source('https://developer.mozilla.org');
+    expect(source.toString()).toBe('https://developer.mozilla.org');
+  });
+});