@multiplatform.one/cli 7.11.0 → 7.16.0

package/src/commands/adoptApp.spec.ts

@@ -4,7 +4,7 @@ import { dirname, join } from "node:path";
 import spawn from "nano-spawn";
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 import { adoptApp } from "./adoptApp";
-import { cliVersion, readProvenance, writeProvenance } from "./initApp";
+import { cliVersion, readProvenance, writeProvenance } from "./provenance";
 
 const readJson = (path: string) => JSON.parse(readFileSync(path, "utf-8"));
 
@@ -189,6 +189,8 @@ describe("adoptApp", () => {
       cliVersion: "6.6.0",
       name: "flagged",
       mpoVersion: "^6.6.0",
+      apps: [],
+      services: [],
       pieces: ["webext"],
       reconciled: false,
     });
@@ -200,6 +202,8 @@ describe("adoptApp", () => {
       cliVersion: "6.6.0",
       name: "flagged",
       mpoVersion: "^6.6.0",
+      apps: [],
+      services: [],
       pieces: ["webext"],
     });
     expect("reconciled" in readJson(join(dir, ".mpo.json"))).toBe(false);

package/src/commands/adoptApp.ts

@@ -1,9 +1,10 @@
 /**
  * `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
@@ -19,16 +20,18 @@ import inquirer from "inquirer";
 import spawn from "nano-spawn";
 import {
   INIT_APP_PIECES,
-  PROVENANCE_FILE,
   availablePieces,
-  cliVersion,
   normalizePieces,
-  packageJsonName,
   pieceDescription,
+  type InitAppPiece,
+} from "./pieces";
+import {
+  PROVENANCE_FILE,
+  cliVersion,
+  packageJsonName,
   validateName,
   writeProvenance,
-  type InitAppPiece,
-} from "./initApp";
+} from "./provenance";
 
 export interface AdoptAppOptions {
   /** Pieces the project hand-adopted (at least one is required). */
@@ -67,14 +70,14 @@ function isMpoMonorepo(projectDir: string): boolean {
 }
 
 async function resolveAdoptPieces(options: AdoptAppOptions): Promise<InitAppPiece[]> {
-  if (options.pieces?.length) return normalizePieces(options.pieces, "none");
+  if (options.pieces?.length) return normalizePieces(options.pieces);
   if (!options.yes && process.stdout.isTTY) {
     const result = 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,
@@ -83,7 +86,7 @@ async function resolveAdoptPieces(options: AdoptAppOptions): Promise<InitAppPiec
           selection.length > 0 || "Select at least one piece — adopting nothing is meaningless",
       },
     ]);
-    return normalizePieces(result.pieces as string[], "none");
+    return normalizePieces(result.pieces as string[]);
   }
   throw new Error(
     "mpo adopt needs at least one piece " +
@@ -150,6 +153,8 @@ export async function adoptApp(options: AdoptAppOptions = {}): Promise<void> {
     cliVersion: currentVersion,
     name,
     mpoVersion: `^${currentVersion}`,
+    apps: [],
+    services: [],
     pieces,
     reconciled: false,
   });

package/src/commands/doctypeTypes.spec.ts

@@ -0,0 +1,155 @@
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import ts from "typescript";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+  type DoctypeMeta,
+  doctypesToTypeScript,
+  generateDoctypeTypes,
+  generatedHeader,
+  interfaceName,
+  typesDrift,
+} from "./doctypeTypes";
+
+function salesOrder(): DoctypeMeta[] {
+  return [
+    {
+      name: "Sales Order",
+      fields: [
+        { fieldname: "customer", fieldtype: "Link", options: "Customer", reqd: 1 },
+        { fieldname: "status", fieldtype: "Select", options: "\nDraft\nTo Deliver\nCompleted" },
+        { fieldname: "grand_total", fieldtype: "Currency" },
+        { fieldname: "is_return", fieldtype: "Check" },
+        { fieldname: "items", fieldtype: "Table", options: "Sales Order Item", reqd: 1 },
+        { fieldname: "section_break_1", fieldtype: "Section Break" },
+        { fieldname: "notes_html", fieldtype: "HTML" },
+      ],
+    },
+    {
+      name: "Sales Order Item",
+      istable: 1,
+      fields: [
+        { fieldname: "item_code", fieldtype: "Link", options: "Item", reqd: 1 },
+        { fieldname: "qty", fieldtype: "Float" },
+        { fieldname: "idx", fieldtype: "Int" },
+      ],
+    },
+  ];
+}
+
+let docs = salesOrder();
+let lastAuthorization: string | undefined;
+let server: http.Server;
+let baseURL: string;
+
+beforeAll(async () => {
+  server = http.createServer((request, response) => {
+    const url = new URL(request.url ?? "/", "http://stub");
+    lastAuthorization = request.headers.authorization;
+    if (url.pathname !== "/api/method/frappe.desk.form.load.getdoctype") {
+      response.writeHead(404).end();
+      return;
+    }
+    if (url.searchParams.get("doctype") !== "Sales Order") {
+      response.writeHead(403, { "Content-Type": "application/json" }).end("{}");
+      return;
+    }
+    response.writeHead(200, { "Content-Type": "application/json" });
+    response.end(JSON.stringify({ docs }));
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  baseURL = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+
+afterAll(() => new Promise<void>((resolve) => server.close(() => resolve())));
+
+describe("mpo frappe types (MPO-22)", () => {
+  it("emits an interface per doctype from getdoctype, child tables included", async () => {
+    docs = salesOrder();
+    const output = await generateDoctypeTypes(["Sales Order"], {
+      baseURL,
+      apiKey: "key",
+      apiSecret: "secret",
+    });
+    expect(lastAuthorization).toBe("token key:secret");
+    expect(output).toBe(
+      [
+        generatedHeader,
+        "",
+        "export interface SalesOrder {",
+        '  doctype: "Sales Order";',
+        "  name: string;",
+        "  owner?: string;",
+        "  creation?: string;",
+        "  modified?: string;",
+        "  modified_by?: string;",
+        "  docstatus?: 0 | 1 | 2;",
+        "  idx?: number;",
+        "  customer: string;",
+        '  status?: "" | "Draft" | "To Deliver" | "Completed";',
+        "  grand_total?: string;",
+        "  is_return?: 0 | 1;",
+        "  items: SalesOrderItem[];",
+        "}",
+        "",
+        "export interface SalesOrderItem {",
+        '  doctype: "Sales Order Item";',
+        "  name: string;",
+        "  owner?: string;",
+        "  creation?: string;",
+        "  modified?: string;",
+        "  modified_by?: string;",
+        "  docstatus?: 0 | 1 | 2;",
+        "  idx?: number;",
+        "  parent?: string;",
+        "  parentfield?: string;",
+        "  parenttype?: string;",
+        "  item_code: string;",
+        "  qty?: number;",
+        "}",
+        "",
+      ].join("\n"),
+    );
+    const { diagnostics } = ts.transpileModule(output, { reportDiagnostics: true });
+    expect(diagnostics ?? []).toEqual([]);
+  });
+
+  it("a diff against the committed file catches drift on the server", async () => {
+    docs = salesOrder();
+    const committed = await generateDoctypeTypes(["Sales Order"], { baseURL });
+    expect(typesDrift(committed, await generateDoctypeTypes(["Sales Order"], { baseURL }))).toEqual(
+      [],
+    );
+
+    docs = salesOrder();
+    docs[0].fields.splice(1, 1, {
+      fieldname: "status",
+      fieldtype: "Select",
+      options: "\nDraft\nCompleted",
+    });
+    docs[0].fields.push({ fieldname: "delivery_date", fieldtype: "Date" });
+    docs[1].fields = docs[1].fields.filter((field) => field.fieldname !== "qty");
+
+    expect(typesDrift(committed, await generateDoctypeTypes(["Sales Order"], { baseURL }))).toEqual(
+      [
+        '-   status?: "" | "Draft" | "To Deliver" | "Completed";',
+        '+   status?: "" | "Draft" | "Completed";',
+        "+   delivery_date?: string;",
+        "-   qty?: number;",
+      ],
+    );
+  });
+
+  it("fails loudly when the server will not hand over the meta", async () => {
+    await expect(generateDoctypeTypes(["ToDo"], { baseURL })).rejects.toThrow(
+      "getdoctype ToDo: HTTP 403",
+    );
+  });
+
+  it("names interfaces from doctype names", () => {
+    expect(interfaceName("Sales Invoice Item")).toBe("SalesInvoiceItem");
+    expect(interfaceName("ToDo")).toBe("ToDo");
+    expect(interfaceName("2FA Settings")).toBe("DocType2FASettings");
+    expect(doctypesToTypeScript([]).trim()).toBe(generatedHeader);
+  });
+});

package/src/commands/doctypeTypes.ts

@@ -0,0 +1,214 @@
+/**
+ * `mpo frappe types`: TypeScript interfaces for DocTypes, generated from the
+ * server's own meta (`frappe.desk.form.load.getdoctype`), so a TDoc type
+ * parameter is the server schema and not a hand copy of it. `--check`
+ * regenerates and diffs against the committed file, so drift fails loudly.
+ */
+
+export interface DocFieldMeta {
+  fieldname: string;
+  fieldtype: string;
+  label?: string;
+  options?: string;
+  reqd?: 0 | 1 | boolean;
+}
+
+export interface DoctypeMeta {
+  name: string;
+  istable?: 0 | 1 | boolean;
+  fields: DocFieldMeta[];
+}
+
+export interface GetDoctypeOptions {
+  baseURL: string;
+  apiKey?: string;
+  apiSecret?: string;
+  fetch?: typeof fetch;
+}
+
+export 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: Array<[string, string]> = [
+  ["name", "string"],
+  ["owner", "string"],
+  ["creation", "string"],
+  ["modified", "string"],
+  ["modified_by", "string"],
+  ["docstatus", "0 | 1 | 2"],
+  ["idx", "number"],
+];
+
+const childFields: Array<[string, string]> = [
+  ["parent", "string"],
+  ["parentfield", "string"],
+  ["parenttype", "string"],
+];
+
+/** "Sales Invoice Item" → "SalesInvoiceItem". */
+export function interfaceName(doctype: string): string {
+  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: string): string {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(fieldname) ? fieldname : JSON.stringify(fieldname);
+}
+
+function selectType(options?: string): string {
+  if (!options?.trim()) return "string";
+  const choices = [...new Set(options.split("\n").map((choice) => choice.trim()))];
+  return choices
+    .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. */
+export function fieldTsType(field: DocFieldMeta): string | undefined {
+  const { fieldtype, options } = field;
+  if (valuelessFieldtypes.has(fieldtype)) return undefined;
+  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: DoctypeMeta): string {
+  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. */
+export function doctypesToTypeScript(docs: DoctypeMeta[]): string {
+  const byName = new Map(docs.map((meta) => [meta.name, meta]));
+  const sorted = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+  return `${[generatedHeader, ...sorted.map(interfaceFor)].join("\n\n")}\n`;
+}
+
+/** The requested DocType plus its child tables, as getdoctype returns them. */
+export async function fetchDoctypeMeta(
+  doctype: string,
+  options: GetDoctypeOptions,
+): Promise<DoctypeMeta[]> {
+  const url = new URL("/api/method/frappe.desk.form.load.getdoctype", options.baseURL);
+  url.searchParams.set("doctype", doctype);
+  const headers: Record<string, string> = { 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()) as { docs?: DoctypeMeta[] };
+  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;
+}
+
+export async function generateDoctypeTypes(
+  doctypes: string[],
+  options: GetDoctypeOptions,
+): Promise<string> {
+  const docs: DoctypeMeta[] = [];
+  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.
+ */
+export function typesDrift(committed: string, generated: string): string[] {
+  const before = committed.replace(/\r\n/g, "\n").split("\n");
+  const after = generated.split("\n");
+  const lcs: number[][] = 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: string[] = [];
+  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;
+}

package/src/commands/init.spec.ts

@@ -0,0 +1,66 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterAll, describe, expect, it, vi } from "vitest";
+import { init } from "./init";
+
+// init reads THIS checkout at HEAD (resolveSource finds the monorepo around
+// public/cli), so this runs the real scaffold.sh.
+const heavy = 300_000;
+
+describe("mpo init --into", () => {
+  const sandbox = mkdtempSync(join(tmpdir(), "mpo-init-spec-"));
+
+  afterAll(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+  }, heavy);
+
+  it(
+    "leaves an existing repository's files byte for byte and names every one it kept",
+    async () => {
+      const target = join(sandbox, "wealthflow-repo");
+      const existing: Record<string, string> = {
+        "pyproject.toml": '[project]\nname = "wealthflow"\n',
+        "uv.lock": "version = 1\n",
+        Makefile: ".POSIX:\nbuild:\n\tuv build\n",
+        "README.md": "# WealthFlow\n",
+        "src/wealthflow/__init__.py": 'print("hi")\n',
+        "tests/test_x.py": "def test_x():\n    assert True\n",
+        "docs/index.md": "# docs\n",
+      };
+      for (const [file, content] of Object.entries(existing)) {
+        mkdirSync(dirname(join(target, file)), { recursive: true });
+        writeFileSync(join(target, file), content);
+      }
+      const lines: string[] = [];
+      const log = vi.spyOn(console, "log").mockImplementation((...args) => {
+        lines.push(args.join(" "));
+      });
+      try {
+        await init(target, {
+          into: true,
+          apps: ["wealthflow"],
+          services: [],
+          skipInstall: true,
+          skipGit: true,
+          yes: true,
+        });
+      } finally {
+        log.mockRestore();
+      }
+      const output = lines.join("\n");
+
+      for (const [file, content] of Object.entries(existing)) {
+        expect(readFileSync(join(target, file), "utf-8"), file).toBe(content);
+      }
+      expect(existsSync(join(target, "apps/wealthflow/package.json"))).toBe(true);
+      expect(output).toMatch(/Kept \d+ path\(s\) already here, pinned in \.updateignore:/);
+      const updateignore = readFileSync(join(target, ".updateignore"), "utf-8");
+      for (const kept of ["Makefile", "README.md"]) {
+        expect(output).toContain(`  ${kept}`);
+        expect(updateignore).toContain(`${kept}\n`);
+      }
+    },
+    heavy,
+  );
+});