@setzkasten-cms/astro-admin 0.6.0

package/src/api-routes/section-management.ts

@@ -0,0 +1,95 @@
+/**
+ * Pure helper functions for section delete and duplicate operations.
+ * No GitHub API — callers handle storage.
+ */
+
+interface SectionEntry {
+  key: string
+  type?: string
+  enabled?: boolean
+  order?: number
+  [key: string]: unknown
+}
+
+interface PageConfig {
+  sections: SectionEntry[]
+  [key: string]: unknown
+}
+
+/**
+ * Removes a section from the page config and re-numbers order.
+ */
+export function removeFromPageConfig(config: PageConfig, sectionKey: string): PageConfig {
+  const sections = config.sections
+    .filter(s => s.key !== sectionKey)
+    .map((s, i) => ({ ...s, order: i }))
+  return { ...config, sections }
+}
+
+/**
+ * Generates a unique duplicate key for a section.
+ * 'hero' → 'hero--copy', then 'hero--copy2', 'hero--copy3', ...
+ */
+export function generateDuplicateKey(existingKeys: string[], originalKey: string): string {
+  const base = `${originalKey}--copy`
+  if (!existingKeys.includes(base)) return base
+  let n = 2
+  while (existingKeys.includes(`${base}${n}`)) n++
+  return `${base}${n}`
+}
+
+/**
+ * Generates a unique key for a new section of a given type.
+ * 'hero' → 'hero' (if free), then 'hero--2', 'hero--3', ...
+ */
+export function generateAddKey(existingKeys: string[], type: string): string {
+  if (!existingKeys.includes(type)) return type
+  let n = 2
+  while (existingKeys.includes(`${type}--${n}`)) n++
+  return `${type}--${n}`
+}
+
+/**
+ * Appends a new section entry at the end of the page config.
+ * Sets `type` only when key differs from type (multi-instance case).
+ */
+export function addToPageConfig(
+  config: PageConfig,
+  key: string,
+  type: string,
+): PageConfig {
+  const entry: SectionEntry = {
+    key,
+    enabled: true,
+    order: config.sections.length,
+    ...(key !== type ? { type } : {}),
+  }
+  return { ...config, sections: [...config.sections, entry] }
+}
+
+/**
+ * Inserts a duplicate entry immediately after the original in the page config.
+ * The copy is always enabled. Order is re-numbered.
+ */
+export function duplicateInPageConfig(
+  config: PageConfig,
+  originalKey: string,
+  newKey: string,
+): PageConfig {
+  const original = config.sections.find(s => s.key === originalKey)
+  if (!original) return config
+
+  // Always set type explicitly: copy key differs from type (e.g. 'testPricing--copy'),
+  // so getSectionDef / resolveSectionType can find the original type, not the copy key.
+  const resolvedType = original.type ?? originalKey
+  const copy: SectionEntry = { ...original, key: newKey, enabled: true, type: resolvedType }
+
+  const insertAfter = config.sections.indexOf(original)
+  const sections = [
+    ...config.sections.slice(0, insertAfter + 1),
+    copy,
+    ...config.sections.slice(insertAfter + 1),
+  ].map((s, i) => ({ ...s, order: i }))
+
+  return { ...config, sections }
+}

package/src/api-routes/section-prepare-copy.ts

@@ -0,0 +1,93 @@
+import type { APIRoute } from 'astro'
+import { resolveStorageConfig } from './_storage-config'
+import { generateDuplicateKey, duplicateInPageConfig } from './section-management'
+
+/**
+ * POST /api/setzkasten/sections/prepare-copy
+ *
+ * Prepares a deferred duplicate of an existing section:
+ * - Reads the original section content from GitHub
+ * - Generates a unique copy key (hero → hero--copy → hero--copy2 …)
+ * - Returns { key, type, content, updatedPageConfig } WITHOUT committing
+ *
+ * The client uses this to update local state + preview draft immediately.
+ * Only committed to GitHub when the user presses "Live setzen".
+ *
+ * Body: { pageKey, sectionKey, owner?, repo?, branch?, contentPath? }
+ */
+export const POST: APIRoute = async ({ request, cookies }) => {
+  const session = cookies.get('setzkasten_session')?.value
+  if (!session) return new Response('Unauthorized', { status: 401 })
+
+  const githubToken = import.meta.env.GITHUB_TOKEN ?? process.env.GITHUB_TOKEN
+  if (!githubToken) return new Response('GitHub token not configured', { status: 500 })
+
+  try {
+    const body = await request.json() as {
+      pageKey: string
+      sectionKey: string
+      owner?: string
+      repo?: string
+      branch?: string
+      contentPath?: string
+    }
+
+    const storage = resolveStorageConfig(body)
+    if (!storage) return Response.json({ error: 'Could not resolve owner/repo' }, { status: 400 })
+    const { owner, repo, branch } = storage
+
+    const serverConfig = (globalThis as any).__SETZKASTEN_CONFIG__
+    const contentPath = body.contentPath || serverConfig?.storage?.contentPath || 'content'
+    const { pageKey, sectionKey } = body
+
+    if (!pageKey || !sectionKey) {
+      return Response.json({ error: 'pageKey and sectionKey are required' }, { status: 400 })
+    }
+
+    // 1. Read current page config
+    const configKey = '_' + pageKey.replace(/\//g, '_')
+    const pageConfigPath = `${contentPath}/pages/${configKey}.json`
+    const pageConfigRaw = await fetchFileContent(owner, repo, branch, pageConfigPath, githubToken)
+    if (!pageConfigRaw) return Response.json({ error: 'Page config not found' }, { status: 404 })
+
+    const pageConfig = JSON.parse(pageConfigRaw)
+    const existingKeys: string[] = (pageConfig.sections ?? []).map((s: { key: string }) => s.key)
+
+    // 2. Generate unique copy key
+    const newKey = generateDuplicateKey(existingKeys, sectionKey)
+
+    // 3. Read original section content (null-safe: fall back to empty object)
+    const originalJsonPath = `${contentPath}/_sections/${sectionKey}.json`
+    const originalRaw = await fetchFileContent(owner, repo, branch, originalJsonPath, githubToken)
+    const content: Record<string, unknown> = originalRaw ? JSON.parse(originalRaw) : {}
+
+    // 4. Determine section type (for multi-instance support)
+    const originalEntry = (pageConfig.sections ?? []).find((s: any) => s.key === sectionKey)
+    const type: string = originalEntry?.type ?? sectionKey
+
+    // 5. Build updated page config (for client-side optimistic update)
+    const updatedPageConfig = duplicateInPageConfig(pageConfig, sectionKey, newKey)
+
+    return Response.json({ key: newKey, type, content, updatedPageConfig })
+  } catch (error) {
+    console.error('[setzkasten] section-prepare-copy error:', error)
+    return Response.json(
+      { error: error instanceof Error ? error.message : 'Prepare copy failed' },
+      { status: 500 },
+    )
+  }
+}
+
+async function fetchFileContent(
+  owner: string, repo: string, branch: string, path: string, token: string,
+): Promise<string | null> {
+  try {
+    const res = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      { headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28' } },
+    )
+    if (!res.ok) return null
+    const data = await res.json() as { content: string; encoding: string }
+    return data.encoding === 'base64' ? Buffer.from(data.content, 'base64').toString('utf-8') : data.content
+  } catch { return null }
+}

package/src/api-routes/section-prepare.ts

@@ -0,0 +1,121 @@
+import type { APIRoute } from 'astro'
+import { resolveStorageConfig, prefixPath } from './_storage-config'
+import { generateAddKey } from './section-management'
+
+/**
+ * POST /api/setzkasten/sections/prepare
+ *
+ * Prepares a new section for optimistic/deferred addition:
+ * - Generates a unique key for the given sectionType
+ * - Builds default content from schema (NO GitHub commit)
+ * - Returns { key, type, defaultContent, updatedPageConfig }
+ *
+ * The client uses this to update local state + preview draft immediately,
+ * and only commits to GitHub when the user explicitly saves ("Seite speichern").
+ *
+ * Body: { pageKey, sectionType, owner?, repo?, branch?, contentPath? }
+ */
+export const POST: APIRoute = async ({ request, cookies }) => {
+  const session = cookies.get('setzkasten_session')?.value
+  if (!session) return new Response('Unauthorized', { status: 401 })
+
+  const githubToken = import.meta.env.GITHUB_TOKEN ?? process.env.GITHUB_TOKEN
+  if (!githubToken) return new Response('GitHub token not configured', { status: 500 })
+
+  try {
+    const body = await request.json() as {
+      pageKey: string
+      sectionType: string
+      owner?: string
+      repo?: string
+      branch?: string
+      contentPath?: string
+    }
+
+    const storage = resolveStorageConfig(body)
+    if (!storage) return Response.json({ error: 'Could not resolve owner/repo' }, { status: 400 })
+    const { owner, repo, branch } = storage
+
+    const serverConfig = (globalThis as any).__SETZKASTEN_CONFIG__
+    const fullConfig = (globalThis as any).__SETZKASTEN_FULL_CONFIG__
+    const contentPath = body.contentPath || serverConfig?.storage?.contentPath || 'content'
+    const { pageKey, sectionType } = body
+
+    if (!pageKey || !sectionType) {
+      return Response.json({ error: 'pageKey and sectionType are required' }, { status: 400 })
+    }
+
+    // 1. Read current page config from GitHub to determine existing keys
+    const configKey = '_' + pageKey.replace(/\//g, '_')
+    const pageConfigPath = `${contentPath}/pages/${configKey}.json`
+    const pageConfigRaw = await fetchFileContent(owner, repo, branch, pageConfigPath, githubToken)
+    if (!pageConfigRaw) return Response.json({ error: 'Page config not found' }, { status: 404 })
+
+    const pageConfig = JSON.parse(pageConfigRaw)
+    const existingKeys: string[] = (pageConfig.sections ?? []).map((s: { key: string }) => s.key)
+
+    // 2. Generate unique key
+    const newKey = generateAddKey(existingKeys, sectionType)
+
+    // 3. Build default content from schema (no GitHub write)
+    const sectionDef = findSectionDef(fullConfig, sectionType)
+    const defaultContent = sectionDef ? buildDefaultContent(sectionDef.fields ?? {}) : {}
+
+    // 4. Build updated page config (for client-side optimistic update)
+    const newEntry: Record<string, unknown> = {
+      key: newKey,
+      enabled: true,
+      order: pageConfig.sections.length,
+      ...(newKey !== sectionType ? { type: sectionType } : {}),
+    }
+    const updatedPageConfig = {
+      ...pageConfig,
+      sections: [...(pageConfig.sections ?? []), newEntry],
+    }
+
+    return Response.json({
+      key: newKey,
+      type: sectionType,
+      defaultContent,
+      updatedPageConfig,
+    })
+  } catch (error) {
+    console.error('[setzkasten] section-prepare error:', error)
+    return Response.json(
+      { error: error instanceof Error ? error.message : 'Prepare failed' },
+      { status: 500 },
+    )
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers (same as section-add.ts)
+// ---------------------------------------------------------------------------
+
+function findSectionDef(fullConfig: any, sectionType: string): any {
+  if (!fullConfig?.products) return null
+  for (const product of Object.values(fullConfig.products) as any[]) {
+    if (product?.sections?.[sectionType]) return product.sections[sectionType]
+  }
+  return null
+}
+
+function buildDefaultContent(fields: Record<string, any>): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.defaultValue !== undefined) result[key] = field.defaultValue
+  }
+  return result
+}
+
+async function fetchFileContent(owner: string, repo: string, branch: string, path: string, token: string): Promise<string | null> {
+  try {
+    const res = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      { headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28' } },
+    )
+    if (!res.ok) return null
+    const data = await res.json() as { content: string; encoding: string }
+    return data.encoding === 'base64' ? Buffer.from(data.content, 'base64').toString('utf-8') : data.content
+  } catch { return null }
+}

package/src/env.d.ts

@@ -0,0 +1,7 @@
+interface ImportMeta {
+  readonly env: Record<string, string | undefined> & {
+    readonly PROD: boolean
+    readonly DEV: boolean
+    readonly MODE: string
+  }
+}