@multiplatform.one/cli 7.11.0 → 7.15.0

package/lib/commands/addApp.mjs

@@ -0,0 +1,78 @@
+import { PROVENANCE_FILE, cliVersion, packageJsonName, readProvenance, validateName, writeProvenance } from "./provenance.mjs";
+import { finishMerge, landTree, mergeScaffolds, projectRootOf, requireCleanTree } from "./merge.mjs";
+import { scaffoldToTemp } from "./scaffold.mjs";
+import { rmSync } from "node:fs";
+import { basename, join } from "node:path";
+
+//#region src/commands/addApp.ts
+/**
+* `mpo add-app <name>`: one more product app from apps/one, merged in at the
+* commit the project was scaffolded from.
+*
+*   base   = scaffold(recorded sha, recorded apps)
+*   theirs = scaffold(recorded sha, recorded apps + name)
+*   ours   = HEAD
+*
+* Same commit on both sides, so the diff is exactly the new app and the
+* root wiring that names it; the project's own changes are untouched. The
+* result stays uncommitted like `mpo update`.
+*/
+async function addApp(nameArg, options = {}) {
+	const name = validateName(nameArg);
+	const projectDir = await projectRootOf("mpo add-app");
+	await requireCleanTree(projectDir, "mpo add-app");
+	const provenance = readProvenance(projectDir);
+	if (!provenance) throw new Error(`${PROVENANCE_FILE} not found — mpo add-app needs a project from mpo init`);
+	if (!provenance.source) throw new Error(`mpo add-app needs a project scaffolded from the monorepo (a source commit in ${PROVENANCE_FILE}); adopted and template-era projects run mpo update first`);
+	if (provenance.apps.includes(name)) throw new Error(`apps/${name} is already a product app of this project`);
+	const source = options.source ?? provenance.source.url;
+	if (!source) throw new Error(`${PROVENANCE_FILE} records no source url — pass --source <path or url>`);
+	const { sha } = provenance.source;
+	const common = {
+		source,
+		ref: sha,
+		services: provenance.services,
+		mpoVersion: `^${provenance.cliVersion}`,
+		name: packageJsonName(projectDir) ?? basename(projectDir),
+		verbose: options.verbose
+	};
+	console.log(`\nmpo add-app ${name}: ${provenance.apps.join(", ")} + ${name} @ ${sha.slice(0, 12)}`);
+	const base = await scaffoldToTemp({
+		...common,
+		apps: provenance.apps
+	});
+	const theirs = await scaffoldToTemp({
+		...common,
+		apps: [...provenance.apps, name]
+	}).catch((err) => {
+		base.cleanup();
+		throw err;
+	});
+	try {
+		for (const dir of [base.dir, theirs.dir]) rmSync(join(dir, PROVENANCE_FILE), { force: true });
+		const outcome = await mergeScaffolds({
+			projectDir,
+			baseDir: base.dir,
+			theirsDir: theirs.dir,
+			baseLabel: `mpo scaffold ${sha} (${provenance.apps.join(",")})`,
+			theirsLabel: `mpo scaffold ${sha} (${[...provenance.apps, name].join(",")})`
+		});
+		if (!outcome.changed && !outcome.conflicts.length) {
+			console.log("\n✅ nothing to add (the project already carries this app)");
+			return;
+		}
+		await landTree(projectDir, outcome.mergedTree);
+		writeProvenance(projectDir, {
+			...provenance,
+			cliVersion: cliVersion() ?? provenance.cliVersion,
+			apps: [...provenance.apps, name]
+		});
+		await finishMerge(projectDir, outcome, `feat: add app ${name} (mpo add-app)`, options);
+	} finally {
+		base.cleanup();
+		theirs.cleanup();
+	}
+}
+
+//#endregion
+export { addApp };

package/lib/commands/adoptApp.mjs

@@ -1,6 +1,7 @@
-import { INIT_APP_PIECES, PROVENANCE_FILE, availablePieces, cliVersion, normalizePieces, packageJsonName, pieceDescription, validateName, writeProvenance } from "./initApp.mjs";
-import { join } from "node:path";
+import { PROVENANCE_FILE, cliVersion, packageJsonName, validateName, writeProvenance } from "./provenance.mjs";
+import { INIT_APP_PIECES, availablePieces, normalizePieces, pieceDescription } from "./pieces.mjs";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import spawn from "nano-spawn";
 import inquirer from "inquirer";
 
@@ -8,9 +9,10 @@ import inquirer from "inquirer";
 /**
 * `mpo adopt` — bring an EXISTING, never-scaffolded project under `mpo
 * update` management. Projects like this hand-copied one or more delivery
-* targets (webext, gnome, …) from the mpo templates and consume
+* targets (webext, gnome, …) from templates/pieces and consume
 * @multiplatform.one/* from npm, but have no .mpo.json provenance, so
-* `mpo update` refuses to run.
+* `mpo update` refuses to run. A project that wants the whole monorepo
+* scaffold instead runs `mpo init --into`.
 *
 * Adoption writes provenance ONLY (template "none" + the chosen pieces +
 * the current CLI version) and seeds .updateignore — it never rewrites a
@@ -41,18 +43,18 @@ function isMpoMonorepo(projectDir) {
 	}
 }
 async function resolveAdoptPieces(options) {
-	if (options.pieces?.length) return normalizePieces(options.pieces, "none");
+	if (options.pieces?.length) return normalizePieces(options.pieces);
 	if (!options.yes && process.stdout.isTTY) return normalizePieces((await inquirer.prompt([{
 		message: "Which pieces did this project adopt? (space to toggle, enter to confirm)",
 		name: "pieces",
 		type: "checkbox",
-		choices: availablePieces("none").map((piece) => ({
+		choices: availablePieces().map((piece) => ({
 			name: `${piece} — ${pieceDescription(piece)}`,
 			value: piece,
 			checked: false
 		})),
 		validate: (selection) => selection.length > 0 || "Select at least one piece — adopting nothing is meaningless"
-	}])).pieces, "none");
+	}])).pieces);
 	throw new Error(`mpo adopt needs at least one piece (${INIT_APP_PIECES.map((piece) => `--${piece}`).join(", ")}) — adopting nothing is meaningless`);
 }
 async function adoptApp(options = {}) {
@@ -89,6 +91,8 @@ async function adoptApp(options = {}) {
 		cliVersion: currentVersion,
 		name,
 		mpoVersion: `^${currentVersion}`,
+		apps: [],
+		services: [],
 		pieces,
 		reconciled: false
 	});

package/lib/commands/doctypeTypes.mjs

@@ -0,0 +1,148 @@
+//#region src/commands/doctypeTypes.ts
+const generatedHeader = "// Generated by `mpo frappe types` from frappe.desk.form.load.getdoctype. Do not edit.";
+const stringFieldtypes = new Set([
+	"Attach",
+	"Attach Image",
+	"Autocomplete",
+	"Barcode",
+	"Code",
+	"Color",
+	"Currency",
+	"Data",
+	"Date",
+	"Datetime",
+	"Dynamic Link",
+	"Geolocation",
+	"HTML Editor",
+	"Icon",
+	"JSON",
+	"Link",
+	"Long Text",
+	"Markdown Editor",
+	"Password",
+	"Phone",
+	"Read Only",
+	"Signature",
+	"Small Text",
+	"Text",
+	"Text Editor",
+	"Time"
+]);
+const numberFieldtypes = new Set([
+	"Duration",
+	"Float",
+	"Int",
+	"Percent",
+	"Rating"
+]);
+const valuelessFieldtypes = new Set([
+	"Button",
+	"Column Break",
+	"Fold",
+	"HTML",
+	"Heading",
+	"Image",
+	"Section Break",
+	"Tab Break"
+]);
+const standardFields = [
+	["name", "string"],
+	["owner", "string"],
+	["creation", "string"],
+	["modified", "string"],
+	["modified_by", "string"],
+	["docstatus", "0 | 1 | 2"],
+	["idx", "number"]
+];
+const childFields = [
+	["parent", "string"],
+	["parentfield", "string"],
+	["parenttype", "string"]
+];
+/** "Sales Invoice Item" → "SalesInvoiceItem". */
+function interfaceName(doctype) {
+	const name = doctype.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+	return /^[0-9]/.test(name) ? `DocType${name}` : name || "DocType";
+}
+function propertyKey(fieldname) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(fieldname) ? fieldname : JSON.stringify(fieldname);
+}
+function selectType(options) {
+	if (!options?.trim()) return "string";
+	return [...new Set(options.split("\n").map((choice) => choice.trim()))].filter((choice, index) => choice !== "" || index === 0).map((choice) => JSON.stringify(choice)).join(" | ");
+}
+/** The TypeScript type a field's value takes, or undefined for layout/display fields. */
+function fieldTsType(field) {
+	const { fieldtype, options } = field;
+	if (valuelessFieldtypes.has(fieldtype)) return void 0;
+	if (stringFieldtypes.has(fieldtype)) return "string";
+	if (numberFieldtypes.has(fieldtype)) return "number";
+	if (fieldtype === "Check") return "0 | 1";
+	if (fieldtype === "Select") return selectType(options);
+	if (fieldtype === "Table" || fieldtype === "Table MultiSelect") return options ? `${interfaceName(options)}[]` : "Record<string, unknown>[]";
+	return "unknown";
+}
+function interfaceFor(meta) {
+	const lines = [`export interface ${interfaceName(meta.name)} {`];
+	lines.push(`  doctype: ${JSON.stringify(meta.name)};`);
+	const base = meta.istable ? [...standardFields, ...childFields] : standardFields;
+	const taken = new Set(["doctype", ...base.map(([key]) => key)]);
+	for (const [key, type] of base) lines.push(`  ${key}${key === "name" ? "" : "?"}: ${type};`);
+	for (const field of meta.fields) {
+		if (!field.fieldname || taken.has(field.fieldname)) continue;
+		const type = fieldTsType(field);
+		if (!type) continue;
+		taken.add(field.fieldname);
+		lines.push(`  ${propertyKey(field.fieldname)}${field.reqd ? "" : "?"}: ${type};`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+/** One module with an interface per DocType, sorted by name so output is stable. */
+function doctypesToTypeScript(docs) {
+	return `${[generatedHeader, ...[...new Map(docs.map((meta) => [meta.name, meta])).values()].sort((a, b) => a.name.localeCompare(b.name)).map(interfaceFor)].join("\n\n")}\n`;
+}
+/** The requested DocType plus its child tables, as getdoctype returns them. */
+async function fetchDoctypeMeta(doctype, options) {
+	const url = new URL("/api/method/frappe.desk.form.load.getdoctype", options.baseURL);
+	url.searchParams.set("doctype", doctype);
+	const headers = { Accept: "application/json" };
+	if (options.apiKey && options.apiSecret) headers.Authorization = `token ${options.apiKey}:${options.apiSecret}`;
+	const response = await (options.fetch ?? fetch)(url, { headers });
+	if (!response.ok) throw new Error(`getdoctype ${doctype}: HTTP ${response.status}`);
+	const body = await response.json();
+	if (!Array.isArray(body.docs) || !body.docs.some((meta) => meta?.name === doctype)) throw new Error(`getdoctype ${doctype}: the response carried no meta for it`);
+	return body.docs;
+}
+async function generateDoctypeTypes(doctypes, options) {
+	const docs = [];
+	for (const doctype of doctypes) docs.push(...await fetchDoctypeMeta(doctype, options));
+	return doctypesToTypeScript(docs);
+}
+/**
+* Line diff of the committed file against a fresh generation: `-` lines the
+* server no longer has, `+` lines it now has. Empty means no drift.
+*/
+function typesDrift(committed, generated) {
+	const before = committed.replace(/\r\n/g, "\n").split("\n");
+	const after = generated.split("\n");
+	const lcs = Array.from({ length: before.length + 1 }, () => Array.from({ length: after.length + 1 }, () => 0));
+	for (let i = before.length - 1; i >= 0; i -= 1) for (let j = after.length - 1; j >= 0; j -= 1) lcs[i][j] = before[i] === after[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const drift = [];
+	let i = 0;
+	let j = 0;
+	while (i < before.length || j < after.length) if (i < before.length && j < after.length && before[i] === after[j]) {
+		i += 1;
+		j += 1;
+	} else if (i < before.length && (j >= after.length || lcs[i + 1][j] >= lcs[i][j + 1])) {
+		drift.push(`- ${before[i]}`);
+		i += 1;
+	} else {
+		drift.push(`+ ${after[j]}`);
+		j += 1;
+	}
+	return drift;
+}
+
+//#endregion
+export { doctypesToTypeScript, fetchDoctypeMeta, fieldTsType, generateDoctypeTypes, generatedHeader, interfaceName, typesDrift };

package/lib/commands/e2e.mjs

@@ -1,10 +1,10 @@
-import fs from "node:fs/promises";
 import path from "node:path";
+import fs from "node:fs/promises";
 import spawn from "nano-spawn";
 import YAML from "yaml";
 import yoctoSpinner from "yocto-spinner";
-import crypto from "node:crypto";
 import os from "node:os";
+import crypto from "node:crypto";
 
 //#region src/commands/e2e.ts
 function sessionFileName(portOffset) {