@setzkasten-cms/astro-admin 0.6.0

package/src/api-routes/init-add-section.ts

@@ -0,0 +1,511 @@
+import type { APIRoute } from 'astro'
+import type { InferredSection } from '@setzkasten-cms/core/init'
+import { addSectionToConfig } from '@setzkasten-cms/core/init'
+import { resolveStorageConfig, prefixPath } from './_storage-config'
+import { patchTemplateForFields, stripTemplateFallbacks } from '../init/template-patcher-v2'
+import type { RepeatedGroup } from '../init/analyzer-types'
+
+/**
+ * POST /api/setzkasten/init/add-section
+ *
+ * Adds a single section to an already-initialized Setzkasten project.
+ * Updates setzkasten.config.ts, creates the content JSON, and updates the page config.
+ * All changes are committed as a single batch via Git Trees API.
+ *
+ * Body: { owner, repo, branch?, projectRoot, section, pageKey, 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 {
+      owner?: string
+      repo?: string
+      branch?: string
+      projectRoot?: string
+      section: InferredSection & { allFields?: InferredSection['fields']; isPageLevel?: boolean }
+      pageKey: string
+      pagePath?: string
+      contentPath?: string
+    }
+
+    const storage = resolveStorageConfig(body)
+    if (!storage) {
+      return Response.json({ error: 'Could not resolve owner/repo. Set SETZKASTEN_OWNER and SETZKASTEN_REPO env vars.' }, { status: 400 })
+    }
+    const { owner, repo, branch, projectPrefix } = storage
+    const serverConfig = (globalThis as any).__SETZKASTEN_CONFIG__
+    const contentPath = body.contentPath || serverConfig?.storage?.contentPath || 'content'
+    const { section, pageKey } = body
+
+    if (!section || !pageKey) {
+      return Response.json({ error: 'section and pageKey are required' }, { status: 400 })
+    }
+
+    const headers = {
+      Authorization: `Bearer ${githubToken}`,
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      'Content-Type': 'application/json',
+    }
+
+    const filesToCommit: Array<{ path: string; content: string }> = []
+
+    // 1. Read and update setzkasten.config.ts
+    const configPath = prefixPath('setzkasten.config.ts', projectPrefix)
+    const existingConfig = await fetchFileContent(owner, repo, branch, configPath, githubToken)
+
+    if (existingConfig) {
+      const updatedConfig = addSectionToConfig(existingConfig, section.key, section, section.allFields)
+      if (updatedConfig) {
+        filesToCommit.push({ path: configPath, content: updatedConfig })
+      }
+    }
+
+    // 2. Generate content JSON — merge new fields into existing data (if any)
+    const sectionJsonPath = `${contentPath}/_sections/${section.key}.json`
+    const existingSectionJson = await fetchFileContent(owner, repo, branch, sectionJsonPath, githubToken)
+
+    let sectionData: Record<string, unknown> = {}
+    if (existingSectionJson) {
+      try {
+        sectionData = JSON.parse(existingSectionJson)
+      } catch { /* start fresh if invalid */ }
+    }
+
+    // Only add values for fields that don't already exist
+    for (const field of section.fields) {
+      if (!(field.key in sectionData)) {
+        sectionData[field.key] = field.defaultValue ?? getDefaultValue(field.type)
+      }
+    }
+
+    // Reorder JSON keys to match template order (allFields if available, else fields)
+    const orderedKeys = (section.allFields ?? section.fields).map(f => f.key)
+    const orderedData: Record<string, unknown> = {}
+    for (const key of orderedKeys) {
+      if (key in sectionData) {
+        orderedData[key] = sectionData[key]
+      }
+    }
+    // Append any remaining keys not in the ordered list
+    for (const key of Object.keys(sectionData)) {
+      if (!(key in orderedData)) {
+        orderedData[key] = sectionData[key]
+      }
+    }
+
+    filesToCommit.push({
+      path: sectionJsonPath,
+      content: JSON.stringify(orderedData, null, 2),
+    })
+
+    // 3. Update page config (add section to the end)
+    const configKey = '_' + pageKey.replace(/\//g, '_')
+    const pageConfigPath = `${contentPath}/pages/${configKey}.json`
+    const existingPageConfig = await fetchFileContent(owner, repo, branch, pageConfigPath, githubToken)
+
+    let pageConfig: { sections: Array<{ key: string; enabled: boolean }> }
+    if (existingPageConfig) {
+      pageConfig = JSON.parse(existingPageConfig)
+      // Only add if not already present (normalize keys to handle kebab vs camelCase)
+      const normalizeKey = (k: string) => k.replace(/[-_]/g, '').toLowerCase()
+      const normalizedNewKey = normalizeKey(section.key)
+      if (!pageConfig.sections.some((s) => normalizeKey(s.key) === normalizedNewKey)) {
+        pageConfig.sections.push({ key: section.key, enabled: true })
+      }
+    } else {
+      pageConfig = {
+        sections: [{ key: section.key, enabled: true }],
+      }
+    }
+    filesToCommit.push({
+      path: pageConfigPath,
+      content: JSON.stringify(pageConfig, null, 2),
+    })
+
+    // 4. Patch template — replace hardcoded content with CMS variables + data-sk-field
+    if (section.isPageLevel && body.pagePath) {
+      // Page-level: patch the PAGE file directly (not a separate component)
+      // Directory routes: UI sends src/pages/docs.astro but actual file is docs/index.astro.
+      // resolvedPagePath tracks the ACTUAL file found so the sk-preview clone is placed
+      // at the correct path (sk-preview/docs/index.astro, not sk-preview/docs.astro).
+      // This matters for the "../" depth adjustment in buildPreviewClone.
+      let fullPagePath = prefixPath(body.pagePath, projectPrefix)
+      let pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken)
+      let resolvedPagePath = body.pagePath
+      if (!pageSource && body.pagePath.endsWith('.astro')) {
+        const indexPath = body.pagePath.replace(/\.astro$/, '/index.astro')
+        fullPagePath = prefixPath(indexPath, projectPrefix)
+        pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken)
+        if (pageSource) resolvedPagePath = indexPath
+      }
+      if (pageSource) {
+        const repeatedGroups: RepeatedGroup[] = (section as any)._analyzerResult?.repeatedGroups ?? []
+        let patchedSource = await patchTemplateForFields(
+          pageSource, section.key, section.allFields ?? section.fields, repeatedGroups,
+          { mode: 'page' },
+        )
+
+        // Strip ?? 'fallback' expressions from script-patched templates.
+        // Values go into the content JSON (JSON wins if already set).
+        const { source: strippedSource, fallbacks } = stripTemplateFallbacks(patchedSource)
+        if (strippedSource !== patchedSource) {
+          patchedSource = strippedSource
+          // Merge extracted fallback values — only write to JSON where not already set
+          let jsonUpdated = false
+          for (const [key, value] of Object.entries(fallbacks)) {
+            const existing = sectionData[key]
+            // HTML extracted from template wins over a plain-text defaultValue that was
+            // written by buildSectionData. This preserves links (<a href="mailto:">),
+            // inline code etc. that are present in the template fallback but not in the
+            // analyzer's text-only defaultValue.
+            const existingIsPlain = typeof existing === 'string' && !/<[a-z]/.test(existing)
+            const newIsHtml = typeof value === 'string' && /<[a-z]/.test(value as string)
+            if (!(key in sectionData) || existing === '' || existing === null || (existingIsPlain && newIsHtml)) {
+              sectionData[key] = value
+              jsonUpdated = true
+            }
+          }
+          // Update the content JSON entry if we added values
+          if (jsonUpdated) {
+            const jsonIdx = filesToCommit.findIndex(f => f.path === sectionJsonPath)
+            if (jsonIdx !== -1) {
+              filesToCommit[jsonIdx]!.content = JSON.stringify(sectionData, null, 2)
+            }
+          }
+        }
+
+        if (patchedSource !== pageSource) {
+          filesToCommit.push({ path: fullPagePath, content: patchedSource })
+
+          // Create an SSR clone under sk-preview/ so the live preview iframe works.
+          // The patched source already uses getSection() which is draft-aware.
+          // The clone lives one directory deeper (sk-preview/<page> vs <page>),
+          // so all relative imports need one extra "../" level.
+          // Use resolvedPagePath (not body.pagePath) to get correct clone depth for
+          // directory routes (docs/index.astro → sk-preview/docs/index.astro).
+          const previewCopySource = patchedSource
+            .replace(/\bexport\s+const\s+prerender\s*=\s*true\s*;?\s*\n?/, '')
+            .replace(/(from\s+')(\.\.\/)/g, '$1../$2')
+            .replace(/(from\s+")(\.\.\/)/g, '$1../$2')
+          // resolvedPagePath: e.g. "src/pages/docs/index.astro" (for directory routes)
+          const relativePage = resolvedPagePath.replace(/^src\/pages\//, '') // "docs/index.astro"
+          const previewCopyPath = prefixPath(`src/pages/sk-preview/${relativePage}`, projectPrefix)
+          filesToCommit.push({ path: previewCopyPath, content: previewCopySource })
+        }
+
+        // Update content JSON with any _classN fields from patcher
+        const fields = section.allFields ?? section.fields
+        for (const g of repeatedGroups) {
+          const topField = fields.find(f => f.key === g.fieldKey)
+          if (!topField || !Array.isArray(topField.defaultValue)) continue
+          sectionData[g.fieldKey] = topField.defaultValue
+          const jsonIdx = filesToCommit.findIndex(f => f.path === sectionJsonPath)
+          if (jsonIdx !== -1) {
+            filesToCommit[jsonIdx]!.content = JSON.stringify(sectionData, null, 2)
+          }
+        }
+      }
+      // No patchPageFile / SECTION_COMPONENTS for page-level sections
+    } else if (section.componentPath) {
+      const componentSource = await fetchFileContent(owner, repo, branch, section.componentPath, githubToken)
+      if (componentSource) {
+        const repeatedGroups: RepeatedGroup[] = (section as any)._analyzerResult?.repeatedGroups ?? []
+        const patchedSource = await patchTemplateForFields(componentSource, section.key, section.allFields ?? section.fields, repeatedGroups)
+        if (patchedSource !== componentSource) {
+          filesToCommit.push({ path: section.componentPath, content: patchedSource })
+        }
+
+        // Patcher may have added _classN fields to repeatedGroups (dynamic CSS classes).
+        // These were not in the content JSON yet (built before patcher ran).
+        // Re-read the now-mutated fields and update the content JSON entry.
+        const fields = section.allFields ?? section.fields
+        for (const g of repeatedGroups) {
+          const topField = fields.find(f => f.key === g.fieldKey)
+          if (!topField || !Array.isArray(topField.defaultValue)) continue
+          const items = topField.defaultValue as Array<Record<string, unknown>>
+
+          // Update sectionData with the enriched items array
+          sectionData[g.fieldKey] = items
+
+          // Rebuild and replace the content JSON in filesToCommit
+          const jsonIdx = filesToCommit.findIndex(f => f.path === sectionJsonPath)
+          if (jsonIdx !== -1) {
+            filesToCommit[jsonIdx]!.content = JSON.stringify(sectionData, null, 2)
+          }
+        }
+      }
+
+      // 5. Patch page file — add import and registry entry for new section
+      if (body.pagePath && section.componentName) {
+        const fullPagePath = prefixPath(body.pagePath, projectPrefix)
+        const pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken)
+        if (pageSource) {
+          const patched = patchPageFile(pageSource, section.key, section.componentName, section.componentPath, body.pagePath)
+          if (patched && patched !== pageSource) {
+            filesToCommit.push({ path: fullPagePath, content: patched })
+          }
+        }
+
+        // 5b. Also patch the SSR preview route (sk-preview/[...page].astro)
+        const pageDir = body.pagePath.replace(/\/[^/]+$/, '') // e.g. "src/pages"
+        const previewPath = prefixPath(`${pageDir}/sk-preview/[...page].astro`, projectPrefix)
+        const previewSource = await fetchFileContent(owner, repo, branch, previewPath, githubToken)
+        if (previewSource) {
+          const patchedPreview = patchPageFile(previewSource, section.key, section.componentName, section.componentPath, `${pageDir}/sk-preview/[...page].astro`)
+          if (patchedPreview && patchedPreview !== previewSource) {
+            filesToCommit.push({ path: previewPath, content: patchedPreview })
+          }
+        }
+      }
+    }
+
+    if (filesToCommit.length === 0) {
+      return Response.json({ error: 'Nothing to commit' }, { status: 400 })
+    }
+
+    // 6. Batch commit via Git Trees API
+    const commitResult = await batchCommit(
+      owner,
+      repo,
+      branch,
+      filesToCommit,
+      existingSectionJson
+        ? `content: update ${section.key} section — add new fields`
+        : `content: add ${section.key} section to Setzkasten`,
+      headers,
+    )
+
+    if (!commitResult.ok) {
+      return Response.json({ error: commitResult.error }, { status: 500 })
+    }
+
+    return Response.json({
+      success: true,
+      commitSha: commitResult.sha,
+      filesWritten: filesToCommit.map((f) => f.path),
+    })
+  } catch (error) {
+    console.error('[setzkasten] add-section error:', error)
+    return Response.json(
+      { error: error instanceof Error ? error.message : 'Add section failed' },
+      { status: 500 },
+    )
+  }
+}
+
+function getDefaultValue(fieldType: string): unknown {
+  switch (fieldType) {
+    case 'text': return ''
+    case 'number': return 0
+    case 'boolean': return false
+    case 'image': return { path: '', alt: '' }
+    case 'array': return []
+    case 'color': return '#000000'
+    case 'date': return ''
+    case 'icon': return ''
+    default: return ''
+  }
+}
+
+/**
+ * Add import statement and SECTION_COMPONENTS registry entry to a page file.
+ * Returns the patched source, or null if no changes needed.
+ */
+export function patchPageFile(
+  source: string,
+  sectionKey: string,
+  componentName: string,
+  componentPath: string,
+  pagePath: string,
+): string | null {
+  // Normalize for comparison: strip dashes/underscores and lowercase
+  const normalize = (k: string) => k.replace(/[-_]/g, '').toLowerCase()
+
+  // Check if component is already imported
+  if (source.includes(`import ${componentName}`) || source.includes(`'${componentName}'`)) {
+    // Already imported — check if also in registry
+    if (source.includes(normalize(sectionKey))) return null
+  }
+
+  // Calculate relative import path from page to component
+  const pageDir = pagePath.replace(/\/[^/]+$/, '') // e.g. "src/pages"
+  const relPath = calculateRelativePath(pageDir, componentPath)
+
+  let patched = source
+
+  // 1. Add import after last section import (before setzkasten:content import)
+  const lastImportMatch = patched.match(/import\s+\w+\s+from\s+['"][^'"]*Section\.astro['"];?\s*\n/)
+  if (lastImportMatch) {
+    // Find the LAST such import
+    let lastIdx = 0
+    const importRegex = /import\s+\w+\s+from\s+['"][^'"]*Section\.astro['"];?\s*\n/g
+    let m: RegExpExecArray | null
+    while ((m = importRegex.exec(patched)) !== null) {
+      lastIdx = m.index + m[0].length
+    }
+    const importLine = `import ${componentName} from '${relPath}';\n`
+    if (!patched.includes(`import ${componentName}`)) {
+      patched = patched.slice(0, lastIdx) + importLine + patched.slice(lastIdx)
+    }
+  }
+
+  // 2. Add to SECTION_COMPONENTS registry
+  const registryPattern = /SECTION_COMPONENTS[^{]*\{([^}]*)\}/s
+  const registryMatch = patched.match(registryPattern)
+  if (registryMatch) {
+    const registryContent = registryMatch[1]!
+    // Check if key (normalized) is already in registry
+    if (!registryContent.includes(normalize(sectionKey))) {
+      // Find the last entry and add after it
+      const lastEntryMatch = registryContent.match(/.*\w+Section,?\s*$/m)
+      if (lastEntryMatch && lastEntryMatch.index !== undefined) {
+        const insertPos = registryMatch.index! + registryMatch[0].indexOf(registryContent) + lastEntryMatch.index + lastEntryMatch[0].length
+        const newEntry = `\n  [normalize('${sectionKey}')]: ${componentName},`
+        patched = patched.slice(0, insertPos) + newEntry + patched.slice(insertPos)
+      }
+    }
+  }
+
+  // 3. Remove hardcoded <ComponentName /> from template (now rendered via loop)
+  const hardcodedPattern = new RegExp(`\\s*<${componentName}\\s*/?>\\s*\\n?`, 'g')
+  patched = patched.replace(hardcodedPattern, '\n')
+
+  return patched !== source ? patched : null
+}
+
+/**
+ * Calculate a relative import path from a page directory to a component file.
+ */
+export function calculateRelativePath(fromDir: string, toPath: string): string {
+  const fromParts = fromDir.split('/')
+  const toParts = toPath.split('/')
+
+  // Find common prefix length
+  let common = 0
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++
+  }
+
+  const ups = fromParts.length - common
+  const remaining = toParts.slice(common).join('/')
+
+  if (ups === 0) return './' + remaining
+  return '../'.repeat(ups) + remaining
+}
+
+async function fetchFileContent(
+  owner: string,
+  repo: string,
+  branch: string,
+  path: string,
+  token: string,
+): Promise<string | null> {
+  try {
+    const response = 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 (!response.ok) return null
+    const data = await response.json() as { content: string; encoding: string }
+    return data.encoding === 'base64'
+      ? Buffer.from(data.content, 'base64').toString('utf-8')
+      : data.content
+  } catch {
+    return null
+  }
+}
+
+async function batchCommit(
+  owner: string,
+  repo: string,
+  branch: string,
+  files: Array<{ path: string; content: string }>,
+  message: string,
+  headers: Record<string, string>,
+): Promise<{ ok: true; sha: string } | { ok: false; error: string }> {
+  try {
+    // 1. Get HEAD ref
+    const refRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`,
+      { headers },
+    )
+    if (!refRes.ok) return { ok: false, error: `Failed to get HEAD: ${refRes.status}` }
+    const refData = await refRes.json() as { object: { sha: string } }
+    const headSha = refData.object.sha
+
+    // 2. Get base tree
+    const commitRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/commits/${headSha}`,
+      { headers },
+    )
+    if (!commitRes.ok) return { ok: false, error: `Failed to get commit: ${commitRes.status}` }
+    const commitData = await commitRes.json() as { tree: { sha: string } }
+
+    // 3. Create new tree
+    const treeRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees`,
+      {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          base_tree: commitData.tree.sha,
+          tree: files.map((f) => ({
+            path: f.path,
+            mode: '100644',
+            type: 'blob',
+            content: f.content,
+          })),
+        }),
+      },
+    )
+    if (!treeRes.ok) return { ok: false, error: `Failed to create tree: ${treeRes.status}` }
+    const treeData = await treeRes.json() as { sha: string }
+
+    // 4. Create commit
+    const newCommitRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/commits`,
+      {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          tree: treeData.sha,
+          parents: [headSha],
+          message,
+        }),
+      },
+    )
+    if (!newCommitRes.ok) return { ok: false, error: `Failed to create commit: ${newCommitRes.status}` }
+    const newCommitData = await newCommitRes.json() as { sha: string }
+
+    // 5. Update ref
+    const updateRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`,
+      {
+        method: 'PATCH',
+        headers,
+        body: JSON.stringify({ sha: newCommitData.sha }),
+      },
+    )
+    if (!updateRes.ok) return { ok: false, error: `Failed to update ref: ${updateRes.status}` }
+
+    return { ok: true, sha: newCommitData.sha }
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : 'Commit failed' }
+  }
+}