@xexr/blog-platform 1.0.6 → 1.0.8

package/dist/lib/storage/drizzle.ts

@@ -0,0 +1,400 @@
+import type { InferSelectModel } from "drizzle-orm";
+import { and, desc, eq, sql } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import {
+  sqliteTable,
+  integer,
+  text,
+  uniqueIndex,
+} from "drizzle-orm/sqlite-core";
+import type {
+  PublishedArticle,
+  PublishResult,
+  PublishedAuthor,
+  PublishedSite,
+} from "../../types/contracts";
+import type { BlogPlatformStorage } from "../database";
+
+// Schema definitions for durable storage
+export const bpArticles = sqliteTable(
+  "bp_articles",
+  {
+    id: text("id").primaryKey(),
+    slug: text("slug").notNull(),
+    title: text("title").notNull(),
+    excerpt: text("excerpt").notNull(),
+    content: text("content").notNull(),
+    readingSeconds: integer("reading_seconds").notNull(),
+    wordCount: integer("word_count").notNull(),
+    publishedAt: text("published_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    featuredImage: text("featured_image"),
+    featuredImageAlt: text("featured_image_alt"),
+    // Store complex objects as JSON strings
+    authorJson: text("author_json"),
+    siteJson: text("site_json").notNull(),
+    metaJson: text("meta_json").notNull(),
+    version: integer("version").notNull(),
+  },
+  (table) => ({
+    slugUniqueIdx: uniqueIndex("bp_articles_slug_unique").on(table.slug),
+  }),
+);
+
+export const bpOperations = sqliteTable("bp_operations", {
+  key: text("key").primaryKey(),
+  // JSON-encoded PublishResult
+  resultJson: text("result_json").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+  // Optional TTL field (not currently used by adapter logic)
+  expiresAt: integer("expires_at", { mode: "timestamp_ms" }),
+});
+
+type ArticleRow = InferSelectModel<typeof bpArticles>;
+
+function toRow(article: PublishedArticle): ArticleRow {
+  return {
+    id: article.id,
+    slug: article.slug,
+    title: article.title,
+    excerpt: article.excerpt,
+    content: article.content,
+    readingSeconds: article.readingSeconds,
+    wordCount: article.wordCount,
+    publishedAt: article.publishedAt,
+    updatedAt: article.updatedAt,
+    featuredImage: article.featuredImage ?? null,
+    featuredImageAlt: article.featuredImageAlt ?? null,
+    authorJson: article.author ? JSON.stringify(article.author) : null,
+    siteJson: JSON.stringify(article.site),
+    metaJson: JSON.stringify({
+      ...article.meta,
+      __bloggyTopics: article.topics ?? [],
+    }),
+    version: article.version,
+  };
+}
+
+function fromRow(row: ArticleRow): PublishedArticle {
+  return {
+    id: row.id,
+    slug: row.slug,
+    title: row.title,
+    excerpt: row.excerpt,
+    content: row.content,
+    readingSeconds: row.readingSeconds,
+    wordCount: row.wordCount,
+    publishedAt: row.publishedAt,
+    updatedAt: row.updatedAt,
+    featuredImage: row.featuredImage ?? undefined,
+    featuredImageAlt: row.featuredImageAlt ?? undefined,
+    author: row.authorJson
+      ? (JSON.parse(row.authorJson) as PublishedAuthor)
+      : null,
+    site: JSON.parse(row.siteJson) as PublishedSite,
+    topics: extractTopics(row.metaJson),
+    meta: extractMeta(row.metaJson),
+    version: row.version,
+  };
+}
+
+function extractTopics(metaJson: string): PublishedArticle["topics"] {
+  const parsed = JSON.parse(metaJson) as PublishedArticle["meta"] & {
+    __bloggyTopics?: PublishedArticle["topics"];
+  };
+  return parsed.__bloggyTopics ?? [];
+}
+
+function extractMeta(metaJson: string): PublishedArticle["meta"] {
+  const parsed = JSON.parse(metaJson) as PublishedArticle["meta"] & {
+    __bloggyTopics?: PublishedArticle["topics"];
+  };
+  delete parsed.__bloggyTopics;
+  const meta = parsed;
+  return meta;
+}
+
+export interface DrizzleStorageOptions {
+  // Optional: limit retention for operations table (ms)
+  operationTtlMs?: number;
+}
+
+/**
+ * Drizzle-backed durable storage adapter.
+ * Pass a Drizzle Database instance created with drizzle-orm/libsql.
+ */
+export class DrizzleStorage implements BlogPlatformStorage {
+  private readonly db: LibSQLDatabase;
+  private readonly options: DrizzleStorageOptions;
+
+  constructor(db: LibSQLDatabase, options: DrizzleStorageOptions = {}) {
+    this.db = db;
+    this.options = options;
+  }
+
+  async saveArticle(
+    article: PublishedArticle,
+    idempotencyKey: string,
+  ): Promise<PublishResult> {
+    const existing = await this.checkIdempotency(idempotencyKey);
+
+    // CRITICAL FIX: Allow republish after unpublish
+    // If we found a cached operation result AND it was successful,
+    // check if the article still exists. If it was removed (unpublished),
+    // proceed with the save to allow republishing.
+    if (existing) {
+      if (existing.success) {
+        // Check if article still exists in database
+        const articleExists = await this.db
+          .select({ id: bpArticles.id })
+          .from(bpArticles)
+          .where(eq(bpArticles.id, article.id))
+          .limit(1);
+
+        // If article was removed, allow republish by not returning cached result
+        if (articleExists.length === 0) {
+          // Article was unpublished - proceed with save
+        } else {
+          // Article still exists - this is a true duplicate
+          return existing;
+        }
+      } else {
+        // Failed operations are always returned as-is
+        return existing;
+      }
+    }
+
+    // Enforce slug uniqueness: if slug exists with a different article id → conflict
+    const bySlug = await this.db
+      .select()
+      .from(bpArticles)
+      .where(eq(bpArticles.slug, article.slug))
+      .limit(1);
+
+    const existingRow = bySlug[0];
+    if (existingRow && existingRow.id !== article.id) {
+      const conflict: PublishResult = {
+        success: false,
+        error: {
+          code: "PUB003",
+          message: "This URL is already in use. Please choose another.",
+        },
+        idempotencyKey,
+      };
+      await this.storeOperationResult(idempotencyKey, conflict);
+      return conflict;
+    }
+
+    // Upsert by id; slug is immutable once set for a given id
+    const row = toRow(article);
+
+    if (bySlug.length === 0) {
+      // Insert new
+      await this.db.insert(bpArticles).values(row).run();
+    } else {
+      // Update existing row for same article id
+      await this.db
+        .update(bpArticles)
+        .set({
+          title: row.title,
+          excerpt: row.excerpt,
+          content: row.content,
+          readingSeconds: row.readingSeconds,
+          wordCount: row.wordCount,
+          updatedAt: row.updatedAt,
+          featuredImage: row.featuredImage,
+          featuredImageAlt: row.featuredImageAlt,
+          authorJson: row.authorJson,
+          siteJson: row.siteJson,
+          metaJson: row.metaJson,
+          version: row.version,
+        })
+        .where(and(eq(bpArticles.id, row.id), eq(bpArticles.slug, row.slug)))
+        .run();
+    }
+
+    const success: PublishResult = {
+      success: true,
+      url: `/${article.slug}`,
+      platformPostId: article.id,
+      publishedAt: article.publishedAt,
+      idempotencyKey,
+    };
+
+    await this.storeOperationResult(idempotencyKey, success);
+    return success;
+  }
+
+  async getArticle(slug: string): Promise<PublishedArticle | null> {
+    const rows = await this.db
+      .select()
+      .from(bpArticles)
+      .where(eq(bpArticles.slug, slug))
+      .limit(1);
+    if (!rows[0]) return null;
+    return fromRow(rows[0]);
+  }
+
+  async listArticles(
+    options: {
+      limit?: number;
+      offset?: number;
+      sortBy?: "publishedAt" | "updatedAt";
+      order?: "asc" | "desc";
+    } = {},
+  ): Promise<{ articles: PublishedArticle[]; total: number }> {
+    const {
+      limit = 10,
+      offset = 0,
+      sortBy = "publishedAt",
+      order = "desc",
+    } = options;
+    const orderColumn =
+      sortBy === "publishedAt" ? bpArticles.publishedAt : bpArticles.updatedAt;
+    const orderBy = order === "desc" ? desc(orderColumn) : orderColumn;
+
+    const items = await this.db
+      .select()
+      .from(bpArticles)
+      .orderBy(orderBy)
+      .limit(limit)
+      .offset(offset);
+
+    // Total count (approx via window-free query)
+    const totalRow = await this.db
+      .select({ c: sql<number>`count(*)` })
+      .from(bpArticles);
+    const total = Number(totalRow?.[0]?.c ?? 0);
+
+    return { articles: items.map(fromRow), total };
+  }
+
+  async removeArticle(
+    slug: string,
+    idempotencyKey: string,
+  ): Promise<PublishResult> {
+    const existing = await this.checkIdempotency(idempotencyKey);
+
+    // CRITICAL FIX: Allow re-unpublish after republish
+    // If we found a cached operation result AND it was successful,
+    // check if the article NOW exists. If it was republished,
+    // proceed with the removal to allow re-unpublishing.
+    if (existing) {
+      if (existing.success) {
+        // Check if article exists NOW (might have been republished)
+        const articleExists = await this.db
+          .select({ id: bpArticles.id })
+          .from(bpArticles)
+          .where(eq(bpArticles.slug, slug))
+          .limit(1);
+
+        // If article EXISTS, it was republished - allow re-unpublish
+        if (articleExists.length > 0) {
+          // Article was republished - proceed with removal
+        } else {
+          // Article still removed - this is a true duplicate
+          return existing;
+        }
+      } else {
+        // Failed operations are always returned as-is
+        return existing;
+      }
+    }
+
+    const found = await this.db
+      .select()
+      .from(bpArticles)
+      .where(eq(bpArticles.slug, slug))
+      .limit(1);
+    if (!found[0]) {
+      const notFound: PublishResult = {
+        success: false,
+        error: { code: "PUB007", message: "Article not found" },
+        idempotencyKey,
+      };
+      await this.storeOperationResult(idempotencyKey, notFound);
+      return notFound;
+    }
+
+    await this.db.delete(bpArticles).where(eq(bpArticles.slug, slug)).run();
+
+    const result: PublishResult = { success: true, idempotencyKey };
+    await this.storeOperationResult(idempotencyKey, result);
+    return result;
+  }
+
+  async checkIdempotency(
+    idempotencyKey: string,
+  ): Promise<PublishResult | null> {
+    const rows = await this.db
+      .select()
+      .from(bpOperations)
+      .where(eq(bpOperations.key, idempotencyKey))
+      .limit(1);
+    if (!rows[0]) return null;
+    try {
+      return JSON.parse(rows[0].resultJson) as PublishResult;
+    } catch {
+      return null;
+    }
+  }
+
+  async storeOperationResult(
+    idempotencyKey: string,
+    result: PublishResult,
+  ): Promise<void> {
+    const now = Date.now();
+    const expiresAt = this.options.operationTtlMs
+      ? now + this.options.operationTtlMs
+      : null;
+    // Upsert behavior using ON CONFLICT is not portable via builder; rely on delete+insert
+    await this.db
+      .delete(bpOperations)
+      .where(eq(bpOperations.key, idempotencyKey))
+      .run();
+    await this.db
+      .insert(bpOperations)
+      .values({
+        key: idempotencyKey,
+        resultJson: JSON.stringify(result),
+        createdAt: new Date(now),
+        expiresAt: expiresAt ? new Date(expiresAt) : null,
+      })
+      .run();
+  }
+}
+
+/**
+ * Helper: Return SQL strings for creating required tables.
+ * Consumers can embed these in their migrations.
+ */
+export function getDrizzleAdapterSql(): {
+  createArticles: string;
+  createOperations: string;
+} {
+  return {
+    createArticles: `CREATE TABLE IF NOT EXISTS bp_articles (
+  id TEXT PRIMARY KEY,
+  slug TEXT NOT NULL UNIQUE,
+  title TEXT NOT NULL,
+  excerpt TEXT NOT NULL,
+  content TEXT NOT NULL,
+  reading_seconds INTEGER NOT NULL,
+  word_count INTEGER NOT NULL,
+  published_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  featured_image TEXT,
+  featured_image_alt TEXT,
+  author_json TEXT,
+  site_json TEXT NOT NULL,
+  meta_json TEXT NOT NULL,
+  version INTEGER NOT NULL
+);`,
+    createOperations: `CREATE TABLE IF NOT EXISTS bp_operations (
+  key TEXT PRIMARY KEY,
+  result_json TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  expires_at INTEGER
+);`,
+  };
+}