@beforesemicolon/site-builder 0.35.0 → 0.36.0

package/scaffolds/admin/repository-manager.js

@@ -0,0 +1,329 @@
+/**
+ * Get file content from repository via Netlify Function
+ * @param {string} filePath - Path to file in repository
+ * @returns {Promise<{content: string, sha: string}>} File content and SHA
+ */
+export async function getFileContent(filePath) {
+    try {
+        const response = await fetch('/api/github', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                action: 'getFile',
+                data: { filePath },
+            }),
+        })
+
+        if (!response.ok) {
+            const error = await response.json()
+            throw new Error(
+                error.error || `Failed to fetch file: ${response.status}`
+            )
+        }
+
+        const result = await response.json()
+        return result
+    } catch (error) {
+        console.error('Error fetching file content:', error)
+        throw error
+    }
+}
+
+/**
+ * Parse widget file and extract inputs section
+ * @param {string} fileContent - Widget file content
+ * @returns {{inputs: string, beforeInputs: string, afterInputs: string}}
+ */
+export function parseWidgetFile(fileContent) {
+    // Find the inputs array in the widget file
+    const inputsMatch = fileContent.match(/inputs:\s*\[([\s\S]*?)\],\s*render/)
+
+    if (!inputsMatch) {
+        throw new Error('Could not find inputs section in widget file')
+    }
+
+    const inputsContent = inputsMatch[1]
+    const inputsStartIndex = inputsMatch.index
+    const inputsEndIndex =
+        inputsStartIndex + inputsMatch[0].length - ', render'.length
+
+    return {
+        inputs: inputsContent,
+        beforeInputs: fileContent.substring(
+            0,
+            inputsStartIndex + 'inputs: ['.length
+        ),
+        afterInputs: fileContent.substring(inputsEndIndex),
+    }
+}
+
+/**
+ * Convert widget inputs object to JavaScript code string
+ * @param {Array} inputs - Widget inputs array
+ * @returns {string} JavaScript code representation
+ */
+export function serializeInputs(inputs) {
+    const serializeValue = (value) => {
+        if (typeof value === 'string') {
+            // Escape special characters and preserve newlines
+            return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value)
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map(serializeValue).join(', ')}]`
+        }
+        if (typeof value === 'object' && value !== null) {
+            const entries = Object.entries(value).map(
+                ([k, v]) => `${k}: ${serializeValue(v)}`
+            )
+            return `{${entries.join(', ')}}`
+        }
+        return 'null'
+    }
+
+    const serializeInput = (input, indent = '    ') => {
+        const parts = []
+
+        // Add type
+        parts.push(`type: "${input.type}"`)
+
+        // Add name
+        parts.push(`name: "${input.name}"`)
+
+        // Add value
+        parts.push(`value: ${serializeValue(input.value)}`)
+
+        // Add definitions if present (for list/group types)
+        if (input.definitions) {
+            const defIndent = indent + '  '
+            const defsStr = input.definitions
+                .map((def) => `\n${defIndent}${serializeInput(def, defIndent)}`)
+                .join(',')
+            parts.push(`definitions: [${defsStr}\n${indent}]`)
+        }
+
+        return `{ ${parts.join(', ')} }`
+    }
+
+    return inputs.map((input) => `\n    ${serializeInput(input)}`).join(',')
+}
+
+/**
+ * Update widget file with new inputs
+ * @param {string} widgetId - Widget identifier
+ * @param {Array} newInputs - New inputs array
+ * @returns {Promise<{content: string, sha: string, filePath: string}>} Updated file content
+ */
+export async function updateWidgetFile(widgetId, newInputs) {
+    const filePath = `widgets/${widgetId}.js`
+
+    // Fetch current file content
+    const { content, sha } = await getFileContent(filePath)
+
+    // Parse the file to extract inputs section
+    const { beforeInputs, afterInputs } = parseWidgetFile(content)
+
+    // Serialize new inputs
+    const serializedInputs = serializeInputs(newInputs)
+
+    // Reconstruct the file (add comma before render function)
+    const updatedContent = `${beforeInputs}${serializedInputs}\n  ],${afterInputs}`
+
+    return {
+        content: updatedContent,
+        sha,
+        filePath,
+    }
+}
+
+/**
+ * Convert ArrayBuffer to base64 string for GitHub API
+ * @param {ArrayBuffer} buffer - File data as ArrayBuffer
+ * @returns {string} Base64 encoded string
+ */
+function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer)
+    let binary = ''
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i])
+    }
+    return btoa(binary)
+}
+
+/**
+ * Commit changes to repository via Netlify Function
+ * @param {string} message - Commit message
+ * @param {Array<{filePath: string, content: string, sha: string}>} changedFiles - Files to commit
+ * @param {Array<{filePath: string, fileData: Object}>} uploadedFiles - Files to upload (optional)
+ * @returns {Promise<Object>} Commit response
+ */
+export async function commitChanges(
+    message,
+    changedFiles,
+    uploadedFiles = [],
+    widgets = []
+) {
+    const commitData = { message }
+    const hasWidgets = Array.isArray(widgets) && widgets.length > 0
+    const hasFiles = Array.isArray(changedFiles) && changedFiles.length > 0
+
+    if (hasWidgets) {
+        commitData.widgets = widgets
+    }
+
+    if (hasFiles) {
+        commitData.files = changedFiles
+    }
+
+    if (uploadedFiles && uploadedFiles.length > 0) {
+        commitData.uploadedFiles = uploadedFiles.map((file) => ({
+            filePath: file.filePath,
+            content: arrayBufferToBase64(file.fileData.data), // Convert ArrayBuffer to base64
+            encoding: 'base64', // GitHub API expects base64 for binary files
+        }))
+    }
+
+    const hasUploadedFiles =
+        Array.isArray(commitData.uploadedFiles) &&
+        commitData.uploadedFiles.length > 0
+
+    if (!hasWidgets && !hasFiles && !hasUploadedFiles) {
+        return
+    }
+
+    const response = await fetch('/api/github', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            action: 'commitChanges',
+            data: commitData,
+        }),
+    })
+
+    if (!response.ok) {
+        const error = await response.json()
+        console.error('[cms:commitChanges] Commit failed', {
+            status: response.status,
+            error,
+        })
+        throw new Error(
+            error.error || `Failed to commit changes: ${response.status}`
+        )
+    }
+
+    return await response.json()
+}
+
+/**
+ * Trigger a Netlify build/deploy
+ * @returns {Promise<{buildId: string}>}
+ */
+/**
+ * Wait for auto-build to start after commit
+ * Polls for a new build that was created after the commit time
+ * @param {string} commitTime - ISO timestamp of when commit was made
+ * @returns {Promise<{buildId: string}>} Build ID
+ */
+export async function waitForBuild(commitTime) {
+    const maxAttempts = 12 // 1 minute max (5 second intervals)
+    let attempts = 0
+
+    while (attempts < maxAttempts) {
+        const response = await fetch('/api/build', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                action: 'getLatestBuild',
+            }),
+        })
+
+        if (!response.ok) {
+            const error = await response.json()
+            throw new Error(
+                error.error || `Failed to get latest build: ${response.status}`
+            )
+        }
+
+        const { buildId, createdAt } = await response.json()
+
+        // Check if this build was created after our commit
+        if (new Date(createdAt) >= new Date(commitTime)) {
+            return { buildId }
+        }
+
+        // Wait 5 seconds before next check
+        await new Promise((resolve) => setTimeout(resolve, 5000))
+        attempts++
+    }
+
+    throw new Error(
+        'Timeout waiting for build to start - check Netlify dashboard'
+    )
+}
+
+/**
+ * Check build status via Netlify Function
+ * @param {string} buildId - Build ID to check
+ * @returns {Promise<{status: string, done: boolean}>} Build status
+ */
+export async function checkBuildStatus(buildId) {
+    const response = await fetch('/api/build', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            action: 'checkBuildStatus',
+            data: { buildId },
+        }),
+    })
+
+    if (!response.ok) {
+        const error = await response.json()
+        throw new Error(
+            error.error || `Failed to check build status: ${response.status}`
+        )
+    }
+
+    return await response.json()
+}
+
+/**
+ * Poll build status until complete
+ * @param {string} buildId - Build ID to poll
+ * @param {Function} onProgress - Progress callback
+ * @returns {Promise<void>}
+ */
+export async function pollBuildStatus(buildId) {
+    const maxAttempts = 60 // 5 minutes max (5 second intervals)
+    let attempts = 0
+
+    while (attempts < maxAttempts) {
+        const { done, status, error } = await checkBuildStatus(buildId)
+
+        if (done) {
+            // Check if build failed
+            if (status === 'error') {
+                throw new Error(
+                    error ||
+                        'Build failed - check Netlify dashboard for details'
+                )
+            }
+            return
+        }
+
+        // Wait 5 seconds before next check
+        await new Promise((resolve) => setTimeout(resolve, 5000))
+        attempts++
+    }
+
+    throw new Error('Build timeout - please check Netlify dashboard')
+}