Tom Boullay
553 lines
17 KiB
TypeScript
553 lines
17 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server'
|
|
import { Octokit } from '@octokit/rest'
|
|
import { extname, basename, join } from 'path'
|
|
import { mkdir, writeFile, readFile, unlink, rm } from 'fs/promises'
|
|
import { existsSync } from 'fs'
|
|
import { execFile } from 'child_process'
|
|
import { promisify } from 'util'
|
|
import { createHash } from 'crypto'
|
|
|
|
const execFileAsync = promisify(execFile)
|
|
|
|
export const runtime = 'nodejs'
|
|
export const dynamic = 'force-dynamic'
|
|
|
|
const MODEL_EXTENSIONS = new Set(['.glb', '.gltf'])
|
|
const TEXTURE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp'])
|
|
const ALL_ALLOWED_EXTENSIONS = new Set([...MODEL_EXTENSIONS, ...TEXTURE_EXTENSIONS])
|
|
const REQUIRED_TEXTURES = ['roughness', 'normal', 'metalness', 'color', 'displace']
|
|
const VALID_DESTINATIONS = new Set(['farm', 'map', 'powergrid', 'workshop', 'general', 'environment'])
|
|
|
|
const TMP_DIR = join('/tmp', 'assets')
|
|
|
|
function sanitizeFilename(name: string): string {
|
|
return basename(name)
|
|
.replace(/[^a-zA-Z0-9._-]/g, '_')
|
|
.replace(/_{2,}/g, '_')
|
|
.toLowerCase()
|
|
}
|
|
|
|
function getOctokit(): Octokit {
|
|
const token = process.env.GITHUB_TOKEN
|
|
if (!token) throw new Error('GITHUB_TOKEN non configure')
|
|
return new Octokit({ auth: token })
|
|
}
|
|
|
|
function parseRepoUrl(): { owner: string; repo: string } {
|
|
const url = process.env.GIT_REPO_URL
|
|
if (!url) throw new Error('GIT_REPO_URL non configure')
|
|
|
|
const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)/)
|
|
const sshMatch = url.match(/github\.com:([^/]+)\/([^/.]+)/)
|
|
const shortMatch = url.match(/^([^/]+)\/([^/]+)$/)
|
|
|
|
const match = httpsMatch || sshMatch || shortMatch
|
|
if (!match) throw new Error(`Format GIT_REPO_URL invalide: "${url}"`)
|
|
|
|
return { owner: match[1], repo: match[2] }
|
|
}
|
|
|
|
/** Compute the SHA that Git would assign to a blob with this content */
|
|
function computeGitBlobSha(content: Buffer): string {
|
|
const header = `blob ${content.length}\0`
|
|
const store = Buffer.concat([Buffer.from(header), content])
|
|
return createHash('sha1').update(store).digest('hex')
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Blender Draco compression
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function compressWithBlender(
|
|
inputPath: string,
|
|
outputPath: string
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const blenderPath = process.env.BLENDER_PATH || 'blender'
|
|
const scriptPath = join(process.cwd(), 'scripts', 'compress.py')
|
|
|
|
if (!existsSync(scriptPath)) {
|
|
return { success: false, error: 'scripts/compress.py introuvable' }
|
|
}
|
|
|
|
try {
|
|
await execFileAsync(blenderPath, [
|
|
'--background',
|
|
'--python', scriptPath,
|
|
'--',
|
|
'-i', inputPath,
|
|
'-o', outputPath,
|
|
'--draco-level', '7',
|
|
'--texture-size', '512',
|
|
'-q',
|
|
], { timeout: 120_000 })
|
|
|
|
if (!existsSync(outputPath)) {
|
|
return { success: false, error: 'Blender n\'a pas produit de fichier compresse' }
|
|
}
|
|
|
|
return { success: true }
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
return { success: false, error: `Compression Blender echouee: ${message}` }
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Build commit message with checklist
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function buildCommitMessage(
|
|
folderName: string,
|
|
destination: string,
|
|
modelFilename: string,
|
|
textureNames: string[],
|
|
compressed: boolean,
|
|
isReplace: boolean,
|
|
fileChanges: Map<string, 'new' | 'changed' | 'unchanged'>,
|
|
deletedFileNames: string[],
|
|
): string {
|
|
const title = isReplace
|
|
? `update: upload-gltf update -> ${destination}/${folderName}`
|
|
: `update: upload-gltf add a new model -> ${destination}/${folderName}`
|
|
|
|
const lines: string[] = [title, '']
|
|
|
|
// Model section — only show if changed or new
|
|
const modelChange = fileChanges.get(modelFilename.toLowerCase())
|
|
if (modelChange === 'new') {
|
|
lines.push('📦 Model')
|
|
lines.push(` ✅ ${modelFilename}${compressed ? ' (compressed)' : ''}`)
|
|
} else if (modelChange === 'changed') {
|
|
lines.push('📦 Model')
|
|
lines.push(` 🔄 ${modelFilename}${compressed ? ' (compressed)' : ''}`)
|
|
}
|
|
// unchanged → don't show model section at all
|
|
|
|
// Textures section — only show lines that have changes
|
|
const foundTextures = new Set(
|
|
textureNames.map(t => t.toLowerCase().replace(/\.[^.]+$/, ''))
|
|
)
|
|
|
|
const textureLines: string[] = []
|
|
|
|
// Changed or new textures
|
|
for (const tex of REQUIRED_TEXTURES) {
|
|
if (foundTextures.has(tex)) {
|
|
const actual = textureNames.find(t => t.toLowerCase().replace(/\.[^.]+$/, '') === tex)!
|
|
const change = fileChanges.get(actual.toLowerCase())
|
|
if (change === 'new') {
|
|
textureLines.push(` ✅ ${actual}`)
|
|
} else if (change === 'changed') {
|
|
textureLines.push(` 🔄 ${actual}`)
|
|
}
|
|
// unchanged → skip
|
|
} else if (!isReplace) {
|
|
// Only show missing textures for new uploads
|
|
textureLines.push(` ❌ ${tex} (manquant)`)
|
|
}
|
|
}
|
|
|
|
// Deleted files (orphans removed from remote)
|
|
for (const name of deletedFileNames) {
|
|
textureLines.push(` ❌ ${name} (supprime)`)
|
|
}
|
|
|
|
if (textureLines.length > 0) {
|
|
lines.push('🎨 Textures')
|
|
lines.push(...textureLines)
|
|
}
|
|
|
|
return lines.join('\n')
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Parse all files from a multi-file FormData
|
|
// ---------------------------------------------------------------------------
|
|
|
|
interface ParsedFile {
|
|
filename: string
|
|
buffer: Buffer
|
|
isModel: boolean
|
|
textureName?: string
|
|
}
|
|
|
|
async function parseMultiUpload(req: NextRequest): Promise<{
|
|
folderName: string
|
|
destination: string
|
|
files: ParsedFile[]
|
|
}> {
|
|
const formData = await req.formData()
|
|
const folderName = (formData.get('folderName') as string | null)?.trim() || 'assets'
|
|
const safeFolderName = sanitizeFilename(folderName).replace(/[^a-zA-Z0-9-_]/g, '-')
|
|
|
|
const rawDestination = (formData.get('destination') as string | null)?.trim() || 'general'
|
|
if (!VALID_DESTINATIONS.has(rawDestination)) {
|
|
throw new Error(`Destination invalide: "${rawDestination}"`)
|
|
}
|
|
const destination = rawDestination
|
|
|
|
const fileEntries = formData.getAll('files') as File[]
|
|
const fileTypes = formData.getAll('fileTypes') as string[]
|
|
const textureNames = formData.getAll('textureNames') as string[]
|
|
|
|
if (fileEntries.length === 0) {
|
|
throw new Error('Aucun fichier recu')
|
|
}
|
|
|
|
const parsed: ParsedFile[] = []
|
|
|
|
for (let i = 0; i < fileEntries.length; i++) {
|
|
const file = fileEntries[i]
|
|
if (!file || file.size === 0) continue
|
|
|
|
const fileType = fileTypes[i] || 'model'
|
|
const texName = textureNames[i] || ''
|
|
|
|
const originalSafe = sanitizeFilename(file.name)
|
|
const ext = extname(originalSafe).toLowerCase()
|
|
|
|
if (!ALL_ALLOWED_EXTENSIONS.has(ext)) {
|
|
throw new Error(`Extension non autorisee: "${ext}"`)
|
|
}
|
|
|
|
let filename: string
|
|
if (fileType === 'texture' && texName) {
|
|
filename = sanitizeFilename(texName)
|
|
} else {
|
|
filename = originalSafe
|
|
}
|
|
|
|
const isModel = MODEL_EXTENSIONS.has(ext)
|
|
const buffer = Buffer.from(await file.arrayBuffer())
|
|
|
|
parsed.push({ filename, buffer, isModel, textureName: texName || undefined })
|
|
}
|
|
|
|
return { folderName: safeFolderName, destination, files: parsed }
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Push all files in a single commit
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function pushAllToGitHub(
|
|
folderName: string,
|
|
files: { path: string; contentBase64: string }[],
|
|
deletePaths: string[],
|
|
commitMessage: string
|
|
): Promise<{ commitUrl: string }> {
|
|
const octokit = getOctokit()
|
|
const { owner, repo } = parseRepoUrl()
|
|
const branch = process.env.GIT_BRANCH ?? 'main'
|
|
|
|
// 1. Get latest commit on branch
|
|
const { data: ref } = await octokit.git.getRef({
|
|
owner,
|
|
repo,
|
|
ref: `heads/${branch}`,
|
|
})
|
|
const latestCommitSha = ref.object.sha
|
|
|
|
// 2. Get that commit's tree
|
|
const { data: commit } = await octokit.git.getCommit({
|
|
owner,
|
|
repo,
|
|
commit_sha: latestCommitSha,
|
|
})
|
|
|
|
// 3. Create all blobs in parallel
|
|
const blobResults = await Promise.all(
|
|
files.map(f =>
|
|
octokit.git.createBlob({
|
|
owner,
|
|
repo,
|
|
content: f.contentBase64,
|
|
encoding: 'base64',
|
|
})
|
|
)
|
|
)
|
|
|
|
// 4. Create a single tree with all files (add new + delete orphans)
|
|
const newFilePaths = new Set(files.map(f => f.path))
|
|
const deleteEntries = deletePaths
|
|
.filter(p => !newFilePaths.has(p))
|
|
.map(p => ({
|
|
path: p,
|
|
mode: '100644' as const,
|
|
type: 'blob' as const,
|
|
sha: null,
|
|
}))
|
|
|
|
const { data: newTree } = await octokit.git.createTree({
|
|
owner,
|
|
repo,
|
|
base_tree: commit.tree.sha,
|
|
tree: [
|
|
...files.map((f, i) => ({
|
|
path: f.path,
|
|
mode: '100644' as const,
|
|
type: 'blob' as const,
|
|
sha: blobResults[i].data.sha,
|
|
})),
|
|
...deleteEntries,
|
|
],
|
|
})
|
|
|
|
// 5. Create a single commit
|
|
const { data: newCommit } = await octokit.git.createCommit({
|
|
owner,
|
|
repo,
|
|
message: commitMessage,
|
|
tree: newTree.sha,
|
|
parents: [latestCommitSha],
|
|
})
|
|
|
|
// 6. Update branch ref
|
|
await octokit.git.updateRef({
|
|
owner,
|
|
repo,
|
|
ref: `heads/${branch}`,
|
|
sha: newCommit.sha,
|
|
})
|
|
|
|
return { commitUrl: newCommit.html_url }
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET handler — check if folder already exists on remote
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export async function GET(req: NextRequest) {
|
|
const { searchParams } = new URL(req.url)
|
|
const destination = searchParams.get('destination')?.trim()
|
|
const folderName = searchParams.get('folderName')?.trim()
|
|
const secret = req.headers.get('x-upload-secret')
|
|
const expectedSecret = process.env.UPLOAD_SECRET_KEY
|
|
|
|
if (!expectedSecret || !secret || secret !== expectedSecret) {
|
|
return NextResponse.json({ success: false, error: 'Non autorise' }, { status: 401 })
|
|
}
|
|
|
|
if (!destination || !folderName) {
|
|
return NextResponse.json({ success: false, error: 'Parametres manquants' }, { status: 400 })
|
|
}
|
|
|
|
if (!VALID_DESTINATIONS.has(destination)) {
|
|
return NextResponse.json({ success: false, error: 'Destination invalide' }, { status: 400 })
|
|
}
|
|
|
|
const safeFolderName = sanitizeFilename(folderName).replace(/[^a-zA-Z0-9-_]/g, '-')
|
|
const folderPath = `public/models/${destination}/${safeFolderName}`
|
|
|
|
try {
|
|
const octokit = getOctokit()
|
|
const { owner, repo } = parseRepoUrl()
|
|
const branch = process.env.GIT_BRANCH ?? 'main'
|
|
|
|
const { data } = await octokit.repos.getContent({
|
|
owner,
|
|
repo,
|
|
path: folderPath,
|
|
ref: branch,
|
|
})
|
|
|
|
if (Array.isArray(data)) {
|
|
const existingFiles = data.map(f => ({ name: f.name, sha: f.sha }))
|
|
return NextResponse.json({
|
|
success: true,
|
|
exists: true,
|
|
path: folderPath,
|
|
files: existingFiles,
|
|
})
|
|
}
|
|
|
|
return NextResponse.json({ success: true, exists: false })
|
|
} catch (err: unknown) {
|
|
const status = (err as { status?: number })?.status
|
|
if (status === 404) {
|
|
return NextResponse.json({ success: true, exists: false })
|
|
}
|
|
const message = err instanceof Error ? err.message : 'Erreur inconnue'
|
|
return NextResponse.json({ success: false, error: message }, { status: 500 })
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// POST handler
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export async function POST(req: NextRequest) {
|
|
// --- Auth ---
|
|
const secret = req.headers.get('x-upload-secret')
|
|
const expectedSecret = process.env.UPLOAD_SECRET_KEY
|
|
|
|
if (!expectedSecret) {
|
|
return NextResponse.json(
|
|
{ success: false, error: 'Configuration serveur incomplete (UPLOAD_SECRET_KEY manquant)' },
|
|
{ status: 500 }
|
|
)
|
|
}
|
|
|
|
if (!secret || secret !== expectedSecret) {
|
|
return NextResponse.json(
|
|
{ success: false, error: "Cle d'authentification invalide" },
|
|
{ status: 401 }
|
|
)
|
|
}
|
|
|
|
// --- Parse all files ---
|
|
let folderName: string
|
|
let destination: string
|
|
let parsedFiles: ParsedFile[]
|
|
|
|
try {
|
|
;({ folderName, destination, files: parsedFiles } = await parseMultiUpload(req))
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : 'Erreur inconnue'
|
|
return NextResponse.json({ success: false, error: message }, { status: 400 })
|
|
}
|
|
|
|
// --- Process files (compress model if possible) ---
|
|
const filesToPush: { path: string; contentBase64: string }[] = []
|
|
let modelFilename = ''
|
|
let compressed = false
|
|
let compressionError: string | undefined
|
|
const textureNames: string[] = []
|
|
|
|
for (const pf of parsedFiles) {
|
|
let content = pf.buffer
|
|
|
|
if (pf.isModel) {
|
|
modelFilename = pf.filename
|
|
|
|
// Write to /tmp for Blender compression
|
|
const tmpFolder = join(TMP_DIR, folderName)
|
|
await mkdir(tmpFolder, { recursive: true })
|
|
const tmpFilePath = join(tmpFolder, pf.filename)
|
|
await writeFile(tmpFilePath, pf.buffer)
|
|
|
|
const stem = pf.filename.replace(/\.[^.]+$/, '')
|
|
const compressedPath = join(tmpFolder, `${stem}_compressed.glb`)
|
|
|
|
const result = await compressWithBlender(tmpFilePath, compressedPath)
|
|
|
|
if (result.success && existsSync(compressedPath)) {
|
|
content = await readFile(compressedPath)
|
|
compressed = true
|
|
await unlink(compressedPath).catch(() => {})
|
|
} else {
|
|
compressionError = result.error
|
|
}
|
|
|
|
await unlink(tmpFilePath).catch(() => {})
|
|
await rm(tmpFolder, { recursive: true, force: true }).catch(() => {})
|
|
} else {
|
|
textureNames.push(pf.filename)
|
|
}
|
|
|
|
filesToPush.push({
|
|
path: `public/models/${destination}/${folderName}/${pf.filename}`,
|
|
contentBase64: content.toString('base64'),
|
|
})
|
|
}
|
|
|
|
// --- Detect existing files and compare SHA to classify changes ---
|
|
const folderPath = `public/models/${destination}/${folderName}`
|
|
const remoteFileMap = new Map<string, string>() // name -> sha
|
|
|
|
try {
|
|
const octokit = getOctokit()
|
|
const { owner, repo } = parseRepoUrl()
|
|
const branch = process.env.GIT_BRANCH ?? 'main'
|
|
|
|
const { data } = await octokit.repos.getContent({
|
|
owner,
|
|
repo,
|
|
path: folderPath,
|
|
ref: branch,
|
|
})
|
|
|
|
if (Array.isArray(data)) {
|
|
for (const f of data) {
|
|
remoteFileMap.set(f.name.toLowerCase(), f.sha)
|
|
}
|
|
}
|
|
} catch {
|
|
// 404 = folder doesn't exist yet
|
|
}
|
|
|
|
const isReplace = remoteFileMap.size > 0
|
|
|
|
// Classify each file: changed, new, or unchanged
|
|
type FileChange = 'new' | 'changed' | 'unchanged'
|
|
const fileChanges = new Map<string, FileChange>()
|
|
const changedFilesToPush: { path: string; contentBase64: string }[] = []
|
|
|
|
for (const f of filesToPush) {
|
|
const filename = f.path.split('/').pop()!
|
|
const localSha = computeGitBlobSha(Buffer.from(f.contentBase64, 'base64'))
|
|
const remoteSha = remoteFileMap.get(filename.toLowerCase())
|
|
|
|
if (!remoteSha) {
|
|
fileChanges.set(filename.toLowerCase(), 'new')
|
|
changedFilesToPush.push(f)
|
|
} else if (remoteSha !== localSha) {
|
|
fileChanges.set(filename.toLowerCase(), 'changed')
|
|
changedFilesToPush.push(f)
|
|
} else {
|
|
fileChanges.set(filename.toLowerCase(), 'unchanged')
|
|
// skip — don't push unchanged files
|
|
}
|
|
}
|
|
|
|
// Files on remote that are not in the new upload → will be deleted (orphans)
|
|
const newFileNames = new Set(filesToPush.map(f => f.path.split('/').pop()!.toLowerCase()))
|
|
const deletedFileNames: string[] = []
|
|
const deletePaths: string[] = []
|
|
for (const [name] of remoteFileMap) {
|
|
if (!newFileNames.has(name)) {
|
|
deletedFileNames.push(name)
|
|
deletePaths.push(`${folderPath}/${name}`)
|
|
}
|
|
}
|
|
|
|
// If nothing changed at all, don't create an empty commit
|
|
if (changedFilesToPush.length === 0 && deletePaths.length === 0) {
|
|
return NextResponse.json({
|
|
success: true,
|
|
folderName,
|
|
filesCount: 0,
|
|
compressed,
|
|
compressionError: compressionError || undefined,
|
|
message: 'Aucun fichier modifie — rien a envoyer.',
|
|
})
|
|
}
|
|
|
|
// --- Build commit message ---
|
|
const commitMessage = buildCommitMessage(
|
|
folderName, destination, modelFilename, textureNames,
|
|
compressed, isReplace, fileChanges, deletedFileNames,
|
|
)
|
|
|
|
// --- Push all in one commit ---
|
|
try {
|
|
const { commitUrl } = await pushAllToGitHub(folderName, changedFilesToPush, deletePaths, commitMessage)
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
folderName,
|
|
filesCount: changedFilesToPush.length,
|
|
compressed,
|
|
compressionError: compressionError || undefined,
|
|
message: `${changedFilesToPush.length} fichier(s) modifie(s) envoye(s) sur GitHub en un seul commit.`,
|
|
commitUrl,
|
|
})
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : 'Erreur GitHub inconnue'
|
|
return NextResponse.json(
|
|
{ success: false, error: `Push GitHub echoue: ${message}` },
|
|
{ status: 500 }
|
|
)
|
|
}
|
|
}
|