next-blogpanel 1.0.0

package/dist/chunk-6PZ772NQ.js

@@ -0,0 +1,595 @@
+import { MongoClient, ObjectId } from 'mongodb';
+import { randomBytes, createHash } from 'crypto';
+import { z } from 'zod';
+
+// src/lib/db.ts
+
+// src/lib/limits.ts
+var DEFAULT_MAX_IMAGE_SIZE = 2 * 1024 * 1024;
+var DEFAULT_MAX_UPLOAD_SIZE = 10 * 1024 * 1024;
+
+// src/lib/config.ts
+var envSchema = z.object({
+  // Required
+  BLOGPANEL_MONGODB_URI: z.string().min(1, "MongoDB URI is required"),
+  BLOGPANEL_API_KEY: z.string().min(32, "API key must be at least 32 characters"),
+  // Optional — Database name (defaults to the database in your connection URI)
+  BLOGPANEL_MONGODB_DB: z.string().optional(),
+  // Optional — Cloudflare R2 (image storage)
+  BLOGPANEL_R2_ACCOUNT_ID: z.string().optional(),
+  BLOGPANEL_R2_ACCESS_KEY: z.string().optional(),
+  BLOGPANEL_R2_SECRET_KEY: z.string().optional(),
+  BLOGPANEL_R2_BUCKET: z.string().optional(),
+  BLOGPANEL_R2_PUBLIC_URL: z.string().optional(),
+  // Optional — force a storage backend regardless of what is configured.
+  //
+  // Not a z.enum(['gridfs','r2']) any more: a custom provider registered via
+  // registerStorageProvider() is selectable here by its own name, and an enum
+  // could not know those names — they are supplied by application code at
+  // runtime, long after this schema is evaluated.
+  //
+  // The enum did buy loud detection of a typo, and that is not given up, only
+  // moved: getStorageProviderByName() throws StorageProviderNotRegisteredError
+  // and names every resolvable provider. That is a strictly better failure
+  // than the enum's, which rejected the whole environment — taking down
+  // routes that never touch storage — and could only say "expected 'gridfs' |
+  // 'r2'". Left as a plain optional string rather than .min(1) so that an
+  // empty `BLOGPANEL_STORAGE=` line, which reads as "unset" in every .env
+  // file, does not fail config parsing process-wide; getStorageProvider()
+  // treats blank as absent.
+  BLOGPANEL_STORAGE: z.string().optional(),
+  // Optional — Site info (defaults provided)
+  BLOGPANEL_SITE_URL: z.string().optional().default(""),
+  BLOGPANEL_SITE_NAME: z.string().optional().default("Blog")
+});
+var cachedEnv = null;
+function getEnvConfig() {
+  if (cachedEnv) return cachedEnv;
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    const missing = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`);
+    throw new Error(`Next BlogPanel configuration error:
+${missing.join("\n")}`);
+  }
+  cachedEnv = result.data;
+  return cachedEnv;
+}
+function isR2Configured() {
+  const env = getEnvConfig();
+  return !!(env.BLOGPANEL_R2_ACCOUNT_ID && env.BLOGPANEL_R2_ACCESS_KEY && env.BLOGPANEL_R2_SECRET_KEY && env.BLOGPANEL_R2_BUCKET && env.BLOGPANEL_R2_PUBLIC_URL);
+}
+var defaultConfig = {
+  basePath: "/blog",
+  adminPath: "/admin/blog",
+  apiPath: "/api/blog",
+  postsPerPage: 10,
+  excerptLength: 160,
+  codeHighlighter: "shiki",
+  editor: {
+    blocks: [
+      "paragraph",
+      "heading",
+      "image",
+      "codeBlock",
+      "blockquote",
+      "bulletList",
+      "orderedList",
+      "taskList",
+      "table",
+      "embed",
+      "horizontalRule",
+      "callout",
+      "tableOfContents",
+      "faq",
+      "html"
+    ],
+    maxImageSize: DEFAULT_MAX_IMAGE_SIZE,
+    // stored result ceiling — compression target
+    maxUploadSize: DEFAULT_MAX_UPLOAD_SIZE,
+    // raw ingest ceiling — rejection threshold
+    imageFormats: ["jpg", "jpeg", "png", "gif", "webp", "svg"],
+    autosaveInterval: 3e4
+  },
+  seo: {
+    titleTemplate: "%s | %siteName%",
+    generateRSS: true,
+    generateSitemap: true,
+    structuredData: true,
+    minContentLength: 300
+  },
+  auth: {
+    strategy: "api-key"
+  },
+  features: {
+    search: true,
+    relatedPosts: true,
+    readingProgress: true,
+    tableOfContents: true,
+    shareButtons: true,
+    darkMode: true,
+    scheduling: true,
+    revisionHistory: true,
+    imageOptimization: true
+  },
+  theme: {
+    darkMode: true,
+    variables: {
+      "--nbp-primary": "#2563eb",
+      "--nbp-primary-hover": "#1d4ed8",
+      "--nbp-text": "#1f2937",
+      "--nbp-text-muted": "#6b7280",
+      "--nbp-bg": "#ffffff",
+      "--nbp-bg-secondary": "#f9fafb",
+      "--nbp-card-bg": "#ffffff",
+      "--nbp-border": "#e5e7eb",
+      "--nbp-radius": "0.5rem",
+      "--nbp-font-heading": '"Inter", system-ui, sans-serif',
+      "--nbp-font-body": '"Inter", system-ui, sans-serif',
+      "--nbp-font-code": '"JetBrains Mono", "Fira Code", monospace'
+    }
+  },
+  hooks: {}
+};
+function mergeConfig(base, userConfig) {
+  return {
+    ...base,
+    ...userConfig,
+    editor: { ...base.editor, ...userConfig?.editor },
+    seo: { ...base.seo, ...userConfig?.seo },
+    auth: { ...base.auth, ...userConfig?.auth },
+    features: { ...base.features, ...userConfig?.features },
+    theme: {
+      ...base.theme,
+      ...userConfig?.theme,
+      variables: { ...base.theme.variables, ...userConfig?.theme?.variables }
+    },
+    hooks: { ...base.hooks, ...userConfig?.hooks }
+  };
+}
+var CONFIG_SLOT = /* @__PURE__ */ Symbol.for("next-blogpanel.config.v1");
+function slot() {
+  const store = globalThis;
+  let current = store[CONFIG_SLOT];
+  if (!current) {
+    current = { installed: false, config: mergeConfig(defaultConfig) };
+    store[CONFIG_SLOT] = current;
+  }
+  return current;
+}
+var CONFIG_WARNED = /* @__PURE__ */ Symbol.for("next-blogpanel.config.warned");
+function warnApiPathConflict(previous, next) {
+  const store = globalThis;
+  const seen = store[CONFIG_WARNED] || (store[CONFIG_WARNED] = /* @__PURE__ */ new Set());
+  const key = `${previous}=>${next}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  console.warn(
+    `[blogpanel] setConfig() was called again with a different apiPath ('${next}', previously '${previous}'). apiPath is baked into every GridFS media URL already written to the database and into post bodies that embed those images, so this does not retroactively fix or break anything already stored \u2014 but every upload from this point on will use the new value. If that is not what you intended, look for more than one setConfig() call with a hardcoded apiPath (for example, your own call alongside the generated next-blogpanel.setup.ts).`
+  );
+}
+function defineConfig(config) {
+  return config;
+}
+function setConfig(userConfig) {
+  const current = slot();
+  const base = current.installed ? current.config : defaultConfig;
+  if (current.installed && userConfig.apiPath !== void 0 && userConfig.apiPath !== current.config.apiPath) {
+    warnApiPathConflict(current.config.apiPath, userConfig.apiPath);
+  }
+  const merged = mergeConfig(base, userConfig);
+  current.config = merged;
+  current.installed = true;
+  return merged;
+}
+function isConfigInstalled() {
+  return slot().installed;
+}
+function getConfig(userConfig) {
+  if (userConfig) return mergeConfig(defaultConfig, userConfig);
+  return slot().config;
+}
+var ConfigNotInstalledError = class extends Error {
+  constructor(context) {
+    super(
+      `Next BlogPanel: no configuration has been installed in this server runtime, so ${context} cannot be resolved.
+  This value is built from \`apiPath\` and then stored permanently, so falling back to the default ('${defaultConfig.apiPath}') would write a URL that may never resolve.
+  Fix: import the setup module \`next-blogpanel init\` generated next to your app directory (app/next-blogpanel.setup.ts) from the route handler that reaches this code, or call setConfig(config) yourself before serving requests.
+  See docs/configuration.md \u2014 "Getting the config to the server".`
+    );
+    this.name = "ConfigNotInstalledError";
+  }
+};
+function requireApiPath(context) {
+  const current = slot();
+  if (!current.installed) {
+    throw new ConfigNotInstalledError(context);
+  }
+  return current.config.apiPath;
+}
+function getBlogConfig() {
+  const env = getEnvConfig();
+  const config = getConfig();
+  return {
+    ...config,
+    siteUrl: env.BLOGPANEL_SITE_URL,
+    siteName: env.BLOGPANEL_SITE_NAME,
+    metadata: {
+      title: `Blog | ${env.BLOGPANEL_SITE_NAME}`,
+      description: `Latest posts from ${env.BLOGPANEL_SITE_NAME}`,
+      openGraph: {
+        title: `Blog | ${env.BLOGPANEL_SITE_NAME}`,
+        description: `Latest posts from ${env.BLOGPANEL_SITE_NAME}`,
+        url: `${env.BLOGPANEL_SITE_URL}${config.basePath}`,
+        siteName: env.BLOGPANEL_SITE_NAME,
+        type: "website"
+      }
+    }
+  };
+}
+
+// src/lib/slug.ts
+function generateSlug(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function ensureUniqueSlug(slug, collection, excludeId) {
+  let candidate = slug;
+  let counter = 1;
+  while (true) {
+    const query = { slug: candidate };
+    if (excludeId) {
+      query._id = { $ne: excludeId };
+    }
+    const existing = await collection.findOne(query);
+    if (!existing) return candidate;
+    candidate = `${slug}-${counter}`;
+    counter++;
+  }
+}
+
+// src/lib/reading-time.ts
+var WORDS_PER_MINUTE = 200;
+function calculateReadingTime(text) {
+  const words = countWords(text);
+  return Math.max(1, Math.ceil(words / WORDS_PER_MINUTE));
+}
+function countWords(text) {
+  if (!text || !text.trim()) return 0;
+  return text.trim().split(/\s+/).length;
+}
+function extractTextFromHTML(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
+}
+function extractTextFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (typeof n.text === "string") {
+      parts.push(n.text);
+    }
+    if (Array.isArray(n.content)) {
+      for (const child of n.content) {
+        walk(child);
+      }
+    }
+  }
+  for (const block of blocks) {
+    walk(block);
+  }
+  return parts.join(" ");
+}
+
+// src/lib/db.ts
+var client = null;
+var db = null;
+async function getDb() {
+  if (db) return db;
+  const env = getEnvConfig();
+  client = new MongoClient(env.BLOGPANEL_MONGODB_URI);
+  await client.connect();
+  db = client.db(env.BLOGPANEL_MONGODB_DB || void 0);
+  return db;
+}
+async function getCollection(name) {
+  const database = await getDb();
+  return database.collection(name);
+}
+async function ensureIndexes() {
+  const database = await getDb();
+  const posts = database.collection("nbk_posts");
+  await posts.createIndex({ slug: 1 }, { unique: true });
+  await posts.createIndex({ status: 1, publishedAt: -1 });
+  await posts.createIndex({ categories: 1, status: 1 });
+  await posts.createIndex({ tags: 1, status: 1 });
+  await posts.createIndex({ "seo.focusKeyword": 1 });
+  await posts.createIndex({ contentText: "text", title: "text", excerpt: "text" });
+  const categories = database.collection("nbk_categories");
+  await categories.createIndex({ slug: 1 }, { unique: true });
+  await categories.createIndex({ order: 1 });
+  const media = database.collection("nbk_media");
+  await media.createIndex({ createdAt: -1 });
+  await media.createIndex({ storageKey: 1 }, { unique: true });
+  const tokens = database.collection("nbk_api_tokens");
+  await tokens.createIndex({ tokenHash: 1 }, { unique: true });
+  await tokens.createIndex({ createdAt: -1 });
+}
+async function createPost(input, defaultAuthor) {
+  const col = await getCollection("nbk_posts");
+  const slug = await ensureUniqueSlug(
+    input.slug || generateSlug(input.title),
+    col
+  );
+  const contentText = input.contentText || extractTextFromBlocks(input.content || []);
+  const wordCount = countWords(contentText);
+  const readingTime = calculateReadingTime(contentText);
+  const excerpt = input.excerpt || contentText.slice(0, 160).replace(/\s+\S*$/, "") + "...";
+  const now = /* @__PURE__ */ new Date();
+  const doc = {
+    title: input.title,
+    slug,
+    excerpt,
+    content: input.content || [],
+    contentHTML: input.contentHTML || "",
+    contentText,
+    coverImage: input.coverImage,
+    categories: input.categories || [],
+    tags: input.tags || [],
+    author: input.author || defaultAuthor || { name: "Admin" },
+    seo: {
+      ogType: "article",
+      noIndex: false,
+      ...input.seo
+    },
+    status: input.status || "draft",
+    publishedAt: input.status === "published" ? now : input.publishedAt,
+    scheduledAt: input.scheduledAt,
+    readingTime,
+    wordCount,
+    version: 1,
+    revisions: [],
+    createdAt: now,
+    updatedAt: now
+  };
+  const result = await col.insertOne(doc);
+  return { _id: result.insertedId, ...doc };
+}
+async function updatePost(id, input) {
+  const col = await getCollection("nbk_posts");
+  const objectId = new ObjectId(id);
+  const existing = await col.findOne({ _id: objectId });
+  if (!existing) return null;
+  const updates = { ...input, updatedAt: /* @__PURE__ */ new Date() };
+  if (input.slug && input.slug !== existing.slug) {
+    updates.slug = await ensureUniqueSlug(input.slug, col, id);
+  }
+  if (input.content) {
+    const contentText = input.contentText || extractTextFromBlocks(input.content);
+    updates.contentText = contentText;
+    updates.wordCount = countWords(contentText);
+    updates.readingTime = calculateReadingTime(contentText);
+    if (!input.excerpt) {
+      updates.excerpt = contentText.slice(0, 160).replace(/\s+\S*$/, "") + "...";
+    }
+    const revision = {
+      version: existing.version || 1,
+      title: existing.title,
+      content: existing.content,
+      contentHTML: existing.contentHTML,
+      savedAt: /* @__PURE__ */ new Date()
+    };
+    const revisions = [...existing.revisions || [], revision].slice(-10);
+    updates.revisions = revisions;
+    updates.version = (existing.version || 1) + 1;
+  }
+  if (input.status === "published" && existing.status !== "published") {
+    updates.publishedAt = /* @__PURE__ */ new Date();
+  }
+  await col.updateOne({ _id: objectId }, { $set: updates });
+  return await col.findOne({ _id: objectId });
+}
+async function deletePost(id) {
+  const col = await getCollection("nbk_posts");
+  const result = await col.updateOne(
+    { _id: new ObjectId(id) },
+    { $set: { status: "archived", updatedAt: /* @__PURE__ */ new Date() } }
+  );
+  return result.modifiedCount > 0;
+}
+async function hardDeletePost(id) {
+  const col = await getCollection("nbk_posts");
+  const result = await col.deleteOne({ _id: new ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function getPostBySlug(slug) {
+  const col = await getCollection("nbk_posts");
+  return await col.findOne({ slug });
+}
+async function getPostById(id) {
+  const col = await getCollection("nbk_posts");
+  return await col.findOne({ _id: new ObjectId(id) });
+}
+async function listPosts(query = {}) {
+  const col = await getCollection("nbk_posts");
+  const {
+    page = 1,
+    limit = 10,
+    category,
+    tag,
+    status,
+    search,
+    sortBy = "publishedAt",
+    sortOrder = "desc"
+  } = query;
+  const filter = {};
+  if (status) {
+    filter.status = status;
+  } else {
+    filter.status = { $ne: "archived" };
+  }
+  if (category) filter.categories = category;
+  if (tag) filter.tags = tag;
+  if (search) {
+    filter.$text = { $search: search };
+  }
+  const sort = {
+    [sortBy]: sortOrder === "asc" ? 1 : -1
+  };
+  const skip = (page - 1) * limit;
+  const [posts, total] = await Promise.all([
+    col.find(filter).sort(sort).skip(skip).limit(limit).toArray(),
+    col.countDocuments(filter)
+  ]);
+  return {
+    posts,
+    total
+  };
+}
+async function createCategory(input) {
+  const col = await getCollection("nbk_categories");
+  const slug = await ensureUniqueSlug(
+    input.slug || generateSlug(input.name),
+    col
+  );
+  const doc = {
+    name: input.name,
+    slug,
+    description: input.description,
+    seo: input.seo,
+    order: input.order ?? 0,
+    parentId: input.parentId ? new ObjectId(input.parentId) : void 0,
+    postCount: 0
+  };
+  const result = await col.insertOne(doc);
+  return { _id: result.insertedId, ...doc };
+}
+async function updateCategory(id, input) {
+  const col = await getCollection("nbk_categories");
+  const objectId = new ObjectId(id);
+  const updates = { ...input };
+  if (input.slug) {
+    updates.slug = await ensureUniqueSlug(input.slug, col, id);
+  }
+  if (input.parentId) {
+    updates.parentId = new ObjectId(input.parentId);
+  }
+  await col.updateOne({ _id: objectId }, { $set: updates });
+  return await col.findOne({ _id: objectId });
+}
+async function deleteCategory(id) {
+  const col = await getCollection("nbk_categories");
+  const result = await col.deleteOne({ _id: new ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function listCategories() {
+  const col = await getCollection("nbk_categories");
+  return await col.find({}).sort({ order: 1 }).toArray();
+}
+async function getCategoryBySlug(slug) {
+  const col = await getCollection("nbk_categories");
+  return await col.findOne({ slug });
+}
+async function updateCategoryPostCount(categorySlug) {
+  const posts = await getCollection("nbk_posts");
+  const categories = await getCollection("nbk_categories");
+  const count = await posts.countDocuments({
+    categories: categorySlug,
+    status: "published"
+  });
+  await categories.updateOne({ slug: categorySlug }, { $set: { postCount: count } });
+}
+async function createMedia(data) {
+  const col = await getCollection("nbk_media");
+  const result = await col.insertOne(data);
+  return { _id: result.insertedId, ...data };
+}
+async function getMediaById(id) {
+  const col = await getCollection("nbk_media");
+  const media = await col.findOne({ _id: new ObjectId(id) });
+  return media || null;
+}
+async function deleteMedia(id) {
+  const col = await getCollection("nbk_media");
+  const media = await col.findOne({ _id: new ObjectId(id) });
+  if (!media) return null;
+  await col.deleteOne({ _id: new ObjectId(id) });
+  return media;
+}
+async function listMedia(query = {}) {
+  const col = await getCollection("nbk_media");
+  const { page = 1, limit = 20, mimeType } = query;
+  const filter = {};
+  if (mimeType) filter.mimeType = { $regex: mimeType };
+  const skip = (page - 1) * limit;
+  const [media, total] = await Promise.all([
+    col.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).toArray(),
+    col.countDocuments(filter)
+  ]);
+  return { media, total };
+}
+async function getSettings() {
+  const col = await getCollection("nbk_settings");
+  const settings = await col.findOne({ _id: "global" });
+  if (!settings) {
+    const defaults = {
+      _id: "global",
+      postsPerPage: 10,
+      commentSystem: "none"
+    };
+    await col.insertOne(defaults);
+    return defaults;
+  }
+  return settings;
+}
+async function updateSettings(data) {
+  const col = await getCollection("nbk_settings");
+  const { _id, ...updates } = data;
+  await col.updateOne(
+    { _id: "global" },
+    { $set: updates },
+    { upsert: true }
+  );
+  return getSettings();
+}
+function hashToken(plain) {
+  return createHash("sha256").update(plain).digest("hex");
+}
+async function createApiToken(name) {
+  const col = await getCollection("nbk_api_tokens");
+  const plainToken = "nbk_" + randomBytes(24).toString("hex");
+  const tokenHash = hashToken(plainToken);
+  const prefix = plainToken.slice(0, 8);
+  const now = /* @__PURE__ */ new Date();
+  const doc = {
+    name,
+    tokenHash,
+    prefix,
+    createdAt: now
+  };
+  const result = await col.insertOne(doc);
+  const token = { _id: result.insertedId, ...doc };
+  return { token, plainToken };
+}
+async function listApiTokens() {
+  const col = await getCollection("nbk_api_tokens");
+  return await col.find({}, { projection: { tokenHash: 0 } }).sort({ createdAt: -1 }).toArray();
+}
+async function deleteApiToken(id) {
+  const col = await getCollection("nbk_api_tokens");
+  const result = await col.deleteOne({ _id: new ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function verifyApiToken(plainToken) {
+  const col = await getCollection("nbk_api_tokens");
+  const tokenHash = hashToken(plainToken);
+  const token = await col.findOneAndUpdate(
+    { tokenHash },
+    { $set: { lastUsedAt: /* @__PURE__ */ new Date() } },
+    { returnDocument: "after" }
+  );
+  return token;
+}
+
+export { ConfigNotInstalledError, calculateReadingTime, countWords, createApiToken, createCategory, createMedia, createPost, defineConfig, deleteApiToken, deleteCategory, deleteMedia, deletePost, ensureIndexes, ensureUniqueSlug, extractTextFromBlocks, extractTextFromHTML, generateSlug, getBlogConfig, getCategoryBySlug, getCollection, getConfig, getDb, getEnvConfig, getMediaById, getPostById, getPostBySlug, getSettings, hardDeletePost, isConfigInstalled, isR2Configured, listApiTokens, listCategories, listMedia, listPosts, requireApiPath, setConfig, updateCategory, updateCategoryPostCount, updatePost, updateSettings, verifyApiToken };
+//# sourceMappingURL=chunk-6PZ772NQ.js.map
+//# sourceMappingURL=chunk-6PZ772NQ.js.map