@conduction/nextcloud-vue 2.2.0-vue3.13 → 2.2.0-vue3.14

package/scripts/update-fleet-manifest-fixtures.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//
+// update-fleet-manifest-fixtures.js — refresh the vendored fleet-manifest
+// corpus used by tests/schemas/fleet-manifest-regression.spec.js.
+//
+// Why (2026-07-06 manifest fleet audit, item 15): a schema change in this
+// library can silently invalidate a manifest already deployed in a fleet app
+// — the exact drift the audit chased (installed schema generations spanned
+// beta.30..beta.155). The regression spec validates every deployed manifest
+// against the CURRENT candidate schema on every PR, so a breaking schema
+// change fails HERE, before release, instead of surfacing as install drift.
+//
+// The corpus is a vendored snapshot (CI has no fleet checkout). This script
+// refreshes it from the sibling app checkouts. Run it after a deliberate,
+// reviewed manifest change lands in a fleet app — never to make a failing
+// regression test pass (that would defeat the guard).
+//
+// Usage:
+//   node scripts/update-fleet-manifest-fixtures.js [fleet-root]
+//     fleet-root — dir whose children are the app checkouts
+//                  (default: the parent of this library's checkout).
+//
+// Output: writes tests/fixtures/fleet-manifests/<app>.json for every app
+// that ships src/manifest.json, plus an index.json manifest (app -> bytes,
+// $schema, sha256) so the spec can report drift precisely.
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const { execFileSync } = require('child_process')
+
+const REPO_ROOT = path.resolve(__dirname, '..')
+const FLEET_ROOT = process.argv[2]
+	? path.resolve(process.argv[2])
+	: path.resolve(REPO_ROOT, '..')
+const OUT_DIR = path.join(REPO_ROOT, 'tests', 'fixtures', 'fleet-manifests')
+
+// Non-app sibling dirs that may carry a src/manifest.json but are not fleet
+// apps we want to gate on (this library's own examples, etc.).
+const SKIP = new Set(['nextcloud-vue'])
+
+function sha256(buf) {
+	return crypto.createHash('sha256').update(buf).digest('hex')
+}
+
+function main() {
+	if (fs.existsSync(OUT_DIR) === false) {
+		fs.mkdirSync(OUT_DIR, { recursive: true })
+	}
+
+	const index = {}
+	let written = 0
+
+	for (const app of fs.readdirSync(FLEET_ROOT).sort()) {
+		if (SKIP.has(app)) {
+			continue
+		}
+		const appDir = path.join(FLEET_ROOT, app)
+		const manifestPath = path.join(appDir, 'src', 'manifest.json')
+		if (fs.existsSync(manifestPath) === false) {
+			continue
+		}
+
+		// The corpus must reflect the DEPLOYED manifest — what is merged to the
+		// app's integration branch — not whatever a local checkout happens to
+		// have on a feature branch. Prefer the committed origin/development (or
+		// origin/main) blob; fall back to the working tree only if git can't
+		// resolve one (e.g. a shallow CI checkout).
+		let raw = null
+		for (const ref of ['origin/development', 'origin/main']) {
+			try {
+				raw = execFileSync('git', ['-C', appDir, 'show', `${ref}:src/manifest.json`], { maxBuffer: 32 * 1024 * 1024 })
+				break
+			} catch (_) { /* try next ref */ }
+		}
+		if (raw === null) {
+			try {
+				raw = fs.readFileSync(manifestPath)
+				console.error(`  (note: ${app} — no origin/development|main blob, snapshotting working tree)`)
+			} catch (_) {
+				continue
+			}
+		}
+
+		// Validate it is parseable JSON before vendoring — never snapshot
+		// a corrupt file into the corpus.
+		let parsed
+		try {
+			parsed = JSON.parse(raw)
+		} catch (e) {
+			console.error(`SKIP ${app}: manifest.json is not valid JSON (${e.message})`)
+			continue
+		}
+
+		const pretty = JSON.stringify(parsed, null, '\t') + '\n'
+		fs.writeFileSync(path.join(OUT_DIR, `${app}.json`), pretty)
+		index[app] = {
+			bytes: Buffer.byteLength(pretty),
+			$schema: typeof parsed.$schema === 'string' ? parsed.$schema : null,
+			sha256: sha256(pretty),
+		}
+		written += 1
+		console.log(`  ${app} (${index[app].bytes} bytes)`)
+	}
+
+	fs.writeFileSync(
+		path.join(OUT_DIR, 'index.json'),
+		JSON.stringify(index, null, '\t') + '\n',
+	)
+	console.log(`\nWrote ${written} fleet manifests + index.json to ${path.relative(REPO_ROOT, OUT_DIR)}`)
+}
+
+main()

package/scripts/vue3-compile-sweep.cjs

@@ -0,0 +1,77 @@
+/**
+ * Vue 3 compile-readiness sweep (ADR-066, openspec vue-3-migration).
+ *
+ * Compiles every SFC template + script under src/ with @vue/compiler-sfc in
+ * @vue/compat MODE 2, and reports which components fail to COMPILE on Vue 3.
+ * This is the fastest signal for the migration: compile failures are hard
+ * blockers, and this needs no bundle/install of the runtime deps.
+ *
+ * Requires the Vue 3 toolchain (`npm i -D @vue/compiler-sfc@^3.5`). Run:
+ *   node scripts/vue3-compile-sweep.cjs        (or: npm run check:vue3-compile)
+ *
+ * Exit code is the number of failing components (0 = all clean).
+ *
+ * NOTE: a clean sweep does NOT mean runtime-correct. Plain Vue 3 silently
+ * mis-compiles `.sync` and `{{x|f}}` (see BUILD-VUE3.md); compat MODE 2 keeps
+ * them correct here, but every such site must still be rewritten (tasks 2.2/2.6)
+ * before the compat flags come off.
+ */
+const fs = require('fs')
+const path = require('path')
+
+let sfc
+try {
+	sfc = require('@vue/compiler-sfc')
+} catch (e) {
+	console.error('[vue3-compile-sweep] @vue/compiler-sfc not found — install the Vue 3 toolchain first (npm i -D @vue/compiler-sfc@^3.5).')
+	process.exit(2)
+}
+
+const root = path.resolve(__dirname, '..', 'src')
+const compat = { compatConfig: { MODE: 2, COMPILER_FILTERS: true } }
+
+function walk(dir, out = []) {
+	for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+		const p = path.join(dir, e.name)
+		if (e.isDirectory()) walk(p, out)
+		else if (e.name.endsWith('.vue')) out.push(p)
+	}
+	return out
+}
+
+const files = walk(root)
+let clean = 0
+const failed = []
+
+for (const f of files) {
+	const src = fs.readFileSync(f, 'utf8')
+	const errs = []
+	try {
+		const { descriptor, errors } = sfc.parse(src, { filename: f })
+		errs.push(...(errors || []).map((e) => 'parse: ' + (e.message || e)))
+		if (descriptor.template) {
+			const t = sfc.compileTemplate({ source: descriptor.template.content, filename: f, id: 'x', compilerOptions: compat })
+			errs.push(...(t.errors || []).map((e) => 'tmpl: ' + (e.message || String(e)).slice(0, 100)))
+		}
+		if (descriptor.script || descriptor.scriptSetup) {
+			try {
+				sfc.compileScript(descriptor, { id: 'x', templateOptions: { compilerOptions: compat } })
+			} catch (e) {
+				errs.push('script: ' + (e.message || String(e)).slice(0, 100))
+			}
+		}
+	} catch (e) {
+		errs.push('fatal: ' + (e.message || String(e)).slice(0, 100))
+	}
+	if (errs.length === 0) clean++
+	else failed.push({ f: path.relative(root, f), errs })
+}
+
+console.log(`Vue 3 compile sweep (compat MODE 2) — ${files.length} components`)
+console.log(`  clean : ${clean}`)
+console.log(`  failed: ${failed.length}`)
+if (failed.length) {
+	console.log('')
+	for (const x of failed) console.log(`  ✗ ${x.f}\n      ${x.errs[0]}`)
+}
+process.exit(failed.length)