@cyberxon/xon 0.3.0 → 0.4.0

package/dist/cli.js

@@ -10,8 +10,9 @@ import { cancelDeploy, COVERAGE_FORMATTERS, previewDeploy, quickDeploy, reportDe
 import { previewRetrieve, resumeRetrieve, startRetrieve } from "./retrieve.js";
 import { collectSourceFiles, writeSourceFiles } from "./source.js";
 import { displayOrg, loginAccessToken, loginCredentials, loginJwt, loginSfdxUrl, loginWeb, logoutOrg, openInBrowser, openOrg } from "./org.js";
-import { clearOrgs, listOrgs } from "./org-store.js";
+import { clearOrgs, listOrgs, tryGetOrg } from "./org-store.js";
 import { applyFlagsDir } from "./flags-dir.js";
+import { formatMetadataFilter, parseMetadataFilter } from "./metadata-registry.js";
 const cliVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 const program = new Command();
 function output(value) {
@@ -30,7 +31,12 @@ async function apiClient(options) {
     if (!baseUrl) {
         throw new Error("An API base URL is required. Set XON_BASE_URL, pass --base-url, or run 'xon org login' inside a project to save one.");
     }
-    return new ApiClient({ baseUrl, token: options.token ?? process.env.XON_TOKEN });
+    let token = options.token ?? process.env.XON_TOKEN;
+    if (!token) {
+        const org = await tryGetOrg(options.targetOrg ?? project?.defaultOrg);
+        token = org?.token;
+    }
+    return new ApiClient({ baseUrl, token });
 }
 async function requireProjectRoot() {
     try {
@@ -47,6 +53,20 @@ async function resolveTargetOrg(explicit) {
     const project = await tryReadProject(".");
     return project?.defaultOrg;
 }
+async function resolveSourceDirs(explicit) {
+    if (explicit.length > 0) {
+        return explicit;
+    }
+    const project = await tryReadProject(".");
+    return [project?.sourceDir ?? "src"];
+}
+async function resolveSourceDir(explicit) {
+    if (explicit) {
+        return explicit;
+    }
+    const project = await tryReadProject(".");
+    return project?.sourceDir ?? "src";
+}
 async function saveProjectLoginDefaults(baseUrl, orgAlias) {
     const project = await tryReadProject(".");
     if (!project) {
@@ -70,6 +90,7 @@ const parseWait = (value) => {
 };
 const DEFAULT_DEPLOY_WAIT_SECONDS = 33 * 60;
 const collect = (value, previous) => previous.concat([value]);
+const collectMetadata = (value, previous) => previous.concat([formatMetadataFilter(parseMetadataFilter(value))]);
 function parseEnum(name, allowed) {
     return (value) => {
         if (!allowed.includes(value)) {
@@ -114,7 +135,7 @@ function addDeployStartFlags(cmd) {
         .option("--json", "Format output as JSON", false)
         .option("--junit", "Output JUnit test results", false)
         .option("-x, --manifest <path>", "Full file path for manifest (package.xml) of components to deploy")
-        .option("-m, --metadata <name>", "Metadata component names to deploy (repeatable)", collect, [])
+        .option("-m, --metadata <name>", "Metadata component names to deploy, e.g. ApexClass or ApexClass:MyClass (repeatable)", collectMetadata, [])
         .option("--metadata-dir <path>", "Root of directory of metadata formatted files to deploy")
         .option("--post-destructive-changes <path>", "File path for a manifest of components to delete after the deploy")
         .option("--pre-destructive-changes <path>", "File path for a manifest of components to delete before the deploy")
@@ -140,8 +161,9 @@ project
     .command("create <name>")
     .description("Create a new Xon project")
     .option("-d, --directory <path>", "Directory to create the project in", ".")
+    .option("-f, --full", "Scaffold the full force-app/main/default layout instead of a plain src/ folder", false)
     .action(async (name, options) => {
-    const root = await createProject(options.directory, name);
+    const root = await createProject(options.directory, name, { full: options.full });
     console.log(`Created project ${name} in ${root}`);
 });
 const projectDeploy = project.command("deploy").description("Deploy metadata between your project and an org");
@@ -155,7 +177,7 @@ addDeployStartFlags(projectDeploy.command("start").description("Deploy metadata
         options = command.opts();
     }
     const client = await apiClient(options);
-    const sourceDirs = (options.sourceDir.length > 0 ? options.sourceDir : ["src"]).map((dir) => path.resolve(dir));
+    const sourceDirs = (await resolveSourceDirs(options.sourceDir)).map((dir) => path.resolve(dir));
     const status = await startDeploy(client, sourceDirs, {
         targetOrg: await resolveTargetOrg(options.targetOrg),
         checkOnly: options.dryRun,
@@ -188,7 +210,7 @@ addDeployStartFlags(projectDeploy.command("validate").description("Validate a me
         options = command.opts();
     }
     const client = await apiClient(options);
-    const sourceDirs = (options.sourceDir.length > 0 ? options.sourceDir : ["src"]).map((dir) => path.resolve(dir));
+    const sourceDirs = (await resolveSourceDirs(options.sourceDir)).map((dir) => path.resolve(dir));
     const status = await startDeploy(client, sourceDirs, {
         targetOrg: await resolveTargetOrg(options.targetOrg),
         checkOnly: true,
@@ -255,10 +277,11 @@ projectDeploy
 projectDeploy
     .command("preview")
     .description("Preview deployment details for the local project source")
-    .option("-d, --source-dir <dir>", "Directory of source to preview", "src")
+    .option("-d, --source-dir <dir>", "Directory of source to preview")
     .action(async (options) => {
     await requireProjectRoot();
-    const files = await collectSourceFiles(path.resolve(options.sourceDir));
+    const sourceDir = await resolveSourceDir(options.sourceDir);
+    const files = await collectSourceFiles(path.resolve(sourceDir));
     console.table(previewDeploy(files));
 });
 const projectRetrieve = project.command("retrieve").description("Retrieve metadata from an org into your project");
@@ -270,8 +293,8 @@ projectRetrieve
     .option("-c, --ignore-conflicts", "Ignore conflicts and save files, even if they overwrite local changes", false)
     .option("--json", "Format output as JSON", false)
     .option("-x, --manifest <path>", "File path for the manifest (package.xml) that specifies the components to retrieve")
-    .option("-m, --metadata <name>", "Metadata component names to retrieve (repeatable)", collect, [])
-    .option("-r, --output-dir <path>", "Directory root for the retrieved source files", "src")
+    .option("-m, --metadata <name>", "Metadata component names to retrieve, e.g. ApexClass or ApexClass:MyClass (repeatable)", collectMetadata, [])
+    .option("-r, --output-dir <path>", "Directory root for the retrieved source files")
     .option("-n, --package-name <name>", "Package names to retrieve (repeatable)", collect, [])
     .option("--single-package", "Indicates that the zip file points to a directory structure for a single package", false)
     .option("-d, --source-dir <path>", "File paths for source to retrieve from the org (repeatable)", collect, [])
@@ -304,8 +327,9 @@ projectRetrieve
         result = await resumeRetrieve(client, result.id, options.wait);
     }
     if (result.success && result.files && (options.unzip || !options.targetMetadataDir)) {
-        await writeSourceFiles(path.resolve(options.outputDir), result.files);
-        console.log(`Retrieved ${result.files.length} file(s) into ${options.outputDir}`);
+        const outputDir = await resolveSourceDir(options.outputDir);
+        await writeSourceFiles(path.resolve(outputDir), result.files);
+        console.log(`Retrieved ${result.files.length} file(s) into ${outputDir}`);
     }
     if (result.success && result.metadataZip && options.targetMetadataDir) {
         const zipDir = path.resolve(options.targetMetadataDir);

package/dist/deploy.js

@@ -1,4 +1,6 @@
 import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { findTypeBySuffix } from "./metadata-registry.js";
 import { pollJob } from "./polling.js";
 import { collectSourceFiles } from "./source.js";
 export const TEST_LEVELS = ["NoTestRun", "RunSpecifiedTests", "RunLocalTests", "RunAllTestsInOrg", "RunRelevantTests"];
@@ -54,6 +56,19 @@ export async function cancelDeploy(client, id) {
 export async function quickDeploy(client, id) {
     return client.post(`/deployRequests/${encodeURIComponent(id)}/quickDeploy`, undefined);
 }
+function inferSuffix(filePath) {
+    const base = path.basename(filePath);
+    const metaMatch = base.match(/\.([A-Za-z0-9]+)-meta\.xml$/);
+    if (metaMatch) {
+        return metaMatch[1];
+    }
+    const dotIndex = base.lastIndexOf(".");
+    return dotIndex === -1 ? undefined : base.slice(dotIndex + 1);
+}
 export function previewDeploy(files) {
-    return files.map((file) => ({ path: file.path, action: "Add" }));
+    return files.map((file) => {
+        const suffix = inferSuffix(file.path);
+        const type = suffix ? findTypeBySuffix(suffix)?.name : undefined;
+        return { path: file.path, type: type ?? "Unknown", action: "Add" };
+    });
 }

package/dist/metadata-registry.js

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function packageRoot() {
+    const dist = path.dirname(fileURLToPath(import.meta.url));
+    return path.dirname(dist);
+}
+let cached;
+function load() {
+    if (cached) {
+        return cached;
+    }
+    const registryPath = path.join(packageRoot(), "registry", "metadataRegistry.json");
+    const raw = JSON.parse(readFileSync(registryPath, "utf8"));
+    const byName = new Map();
+    const byId = new Map();
+    for (const def of Object.values(raw.types)) {
+        byName.set(def.name.toLowerCase(), def);
+        byId.set(def.id, def);
+        if (def.children?.types) {
+            for (const childDef of Object.values(def.children.types)) {
+                const child = { ...childDef, parentId: def.id };
+                byName.set(child.name.toLowerCase(), child);
+                byId.set(child.id, child);
+            }
+        }
+    }
+    cached = { raw, byName, byId };
+    return cached;
+}
+export function findTypeByName(name) {
+    return load().byName.get(name.trim().toLowerCase());
+}
+export function findTypeBySuffix(suffix) {
+    const { raw, byId } = load();
+    const typeId = raw.suffixes[suffix] ?? raw.suffixes[suffix.toLowerCase()];
+    return typeId ? byId.get(typeId) : undefined;
+}
+export function parseMetadataFilter(raw) {
+    const separatorIndex = raw.indexOf(":");
+    const typePart = (separatorIndex === -1 ? raw : raw.slice(0, separatorIndex)).trim();
+    const namePart = separatorIndex === -1 ? undefined : raw.slice(separatorIndex + 1).trim();
+    const def = findTypeByName(typePart);
+    if (!def) {
+        throw new Error(`Unknown metadata type '${typePart}'. Check the Metadata API name (e.g. ApexClass, CustomObject, Flow).`);
+    }
+    if (namePart !== undefined && namePart.length === 0) {
+        throw new Error(`Invalid --metadata value '${raw}': expected '${def.name}' or '${def.name}:<name>'.`);
+    }
+    return { type: def.name, name: namePart };
+}
+export function formatMetadataFilter(filter) {
+    return filter.name ? `${filter.type}:${filter.name}` : filter.type;
+}

package/dist/org-store.js

@@ -13,8 +13,8 @@ async function readStore() {
     }
 }
 async function writeStore(data) {
-    await mkdir(storeDir, { recursive: true });
-    await writeFile(storePath, `${JSON.stringify(data, null, 2)}\n`);
+    await mkdir(storeDir, { recursive: true, mode: 0o700 });
+    await writeFile(storePath, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
 }
 export async function saveOrg(record, setDefault) {
     const data = await readStore();
@@ -54,3 +54,11 @@ export async function listOrgs() {
     const data = await readStore();
     return { orgs: Object.values(data.orgs), defaultOrg: data.defaultOrg };
 }
+export async function tryGetOrg(alias) {
+    try {
+        return await getOrg(alias);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/org.js

@@ -9,13 +9,14 @@ export function openInBrowser(url) {
             : `xdg-open "${url}"`;
     exec(command);
 }
-async function finishLogin(response, alias, setDefault) {
+async function finishLogin(response, alias, setDefault, tokenOverride) {
     const record = {
         alias: alias ?? response.username,
         orgId: response.orgId,
         username: response.username,
         instanceUrl: response.instanceUrl,
         connectedAt: new Date().toISOString(),
+        token: tokenOverride ?? response.token,
     };
     await saveOrg(record, setDefault);
     return record;
@@ -56,7 +57,7 @@ export async function loginAccessToken(client, options) {
         instanceUrl: options.instanceUrl,
         accessToken: options.accessToken,
     });
-    return finishLogin(response, options.alias, options.setDefault);
+    return finishLogin(response, options.alias, options.setDefault, options.accessToken);
 }
 export async function loginCredentials(client, options) {
     const { token } = await client.post("/auth/login", {

package/dist/project.js

@@ -1,15 +1,38 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 const projectFile = ".xon/project.json";
-export async function createProject(directory, name) {
+const DEFAULT_SOURCE_DIR = "src";
+const FULL_SOURCE_DIR = "force-app/main/default";
+const FULL_METADATA_DIRS = [
+    "applications",
+    "aura",
+    "classes",
+    "contentassets",
+    "flexipages",
+    "layouts",
+    "lwc",
+    "objects",
+    "permissionsets",
+    "staticresources",
+    "tabs",
+    "triggers",
+];
+export async function createProject(directory, name, options = {}) {
     const root = path.resolve(directory, name);
+    const sourceDir = options.full ? FULL_SOURCE_DIR : DEFAULT_SOURCE_DIR;
     const config = {
         name,
         apiVersion: "v1",
         createdAt: new Date().toISOString(),
+        sourceDir,
     };
     await mkdir(path.join(root, ".xon"), { recursive: true });
-    await mkdir(path.join(root, "src"), { recursive: true });
+    if (options.full) {
+        await Promise.all(FULL_METADATA_DIRS.map((dir) => mkdir(path.join(root, sourceDir, dir), { recursive: true })));
+    }
+    else {
+        await mkdir(path.join(root, sourceDir), { recursive: true });
+    }
     await writeFile(path.join(root, projectFile), `${JSON.stringify(config, null, 2)}\n`, { flag: "wx" });
     return root;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyberxon/xon",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A CLI for Xon projects and deployments",
   "type": "module",
   "license": "UNLICENSED",
@@ -16,7 +16,8 @@
     "node": ">=18"
   },
   "files": [
-    "dist"
+    "dist",
+    "registry"
   ],
   "bin": {
     "xon": "dist/cli.js"