140 lines
5.7 KiB
JavaScript
140 lines
5.7 KiB
JavaScript
#!/usr/bin/env node
|
|
// mosaic business validate <business>
|
|
// mosaic business resolve <business> <instance> [--project <id>]
|
|
//
|
|
// validate loads the business file, every role definition it uses, the
|
|
// project files that exist under its declared roots, and stat-checks every
|
|
// credential reference. resolve prints one role instance's resolved record.
|
|
// Both print JSON on stdout and problems on stderr.
|
|
//
|
|
// Exit codes: 0 ok; 2 invalid (business, role, project file or a credential
|
|
// reference); 3 system config problem; 4 usage, or a required file missing.
|
|
|
|
import { spawnSync } from "node:child_process";
|
|
import { existsSync } from "node:fs";
|
|
import { dirname, join, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { BusinessError } from "./errors.mjs";
|
|
import { loadBusiness } from "./business.mjs";
|
|
import { loadProject, projectFilePath } from "./project.mjs";
|
|
import { checkCredentialRef } from "./credentials.mjs";
|
|
import { systemVars, resolveInstance } from "./resolve.mjs";
|
|
|
|
const REPO = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
|
|
const USAGE = "usage: mosaic business validate <business> | resolve <business> <instance> [--project <id>]";
|
|
|
|
function fail(code, message) {
|
|
process.stderr.write(`mosaic business: ${message}\n`);
|
|
process.exit(code);
|
|
}
|
|
|
|
function loadSystem() {
|
|
const proc = spawnSync(process.execPath, [join(REPO, "scripts", "mosaic-config.mjs"), "validate"], {
|
|
encoding: "utf8",
|
|
maxBuffer: 1024 * 1024,
|
|
});
|
|
if (proc.status !== 0) fail(3, `system config problem (mosaic-config exit ${proc.status}): ${proc.stderr.trim()}`);
|
|
try {
|
|
return JSON.parse(proc.stdout);
|
|
} catch {
|
|
fail(3, "system config: mosaic-config printed something that isn't JSON");
|
|
}
|
|
}
|
|
|
|
function rolesDir() {
|
|
return resolve(process.env.MOSAIC_ROLES_DIR || join(REPO, "roles"));
|
|
}
|
|
|
|
// Check credential references; print warnings; return the problem list.
|
|
function checkRefs(refs, forbiddenRoots) {
|
|
const problems = [];
|
|
const warnings = [];
|
|
for (const ref of refs) {
|
|
const result = checkCredentialRef(ref, { forbiddenRoots });
|
|
problems.push(...result.problems);
|
|
warnings.push(...result.warnings);
|
|
}
|
|
return { problems, warnings };
|
|
}
|
|
|
|
function forbiddenRoots(config, business) {
|
|
return [REPO, config.dataRoot, ...Object.values(business.projects).filter(p => p.kind !== 'library').map((p) => p.root)];
|
|
}
|
|
|
|
function validate(args) {
|
|
if (args.length !== 1) fail(4, USAGE);
|
|
const config = loadSystem();
|
|
const system = systemVars(config);
|
|
const business = loadBusiness(args[0], { rolesDir: rolesDir() });
|
|
const projects = {};
|
|
const warnings = [];
|
|
for (const [id, entry] of Object.entries(business.projects)) {
|
|
if (entry.kind === 'library') { projects[id] = 'library'; continue; }
|
|
const file = projectFilePath(entry.root);
|
|
if (!existsSync(file)) {
|
|
projects[id] = "absent";
|
|
warnings.push(`project ${id}: no project file at ${file}; it has no project variables`);
|
|
continue;
|
|
}
|
|
const project = loadProject(entry.root);
|
|
if (project.id !== id) fail(2, `project file ${file} has id ${project.id}, but business ${business.id} declares it as ${id}`);
|
|
for (const instance of Object.keys(business.roles)) resolveInstance({ system, business, project, instance });
|
|
projects[id] = "valid";
|
|
}
|
|
const refs = [
|
|
...Object.values(business.tracker?.sync?.credentials ?? {}),
|
|
...Object.values(business.roles).flatMap((r) => Object.values(r.credentials)),
|
|
];
|
|
const checked = checkRefs(refs, forbiddenRoots(config, business));
|
|
warnings.push(...checked.warnings);
|
|
const instances = {};
|
|
for (const instance of Object.keys(business.roles)) {
|
|
instances[instance] = resolveInstance({ system, business, instance }).digest;
|
|
}
|
|
for (const w of warnings) process.stderr.write(`mosaic business: warning: ${w}\n`);
|
|
if (checked.problems.length > 0) {
|
|
for (const p of checked.problems) process.stderr.write(`mosaic business: ${p}\n`);
|
|
fail(2, `business ${business.id}: ${checked.problems.length} credential reference problem(s)`);
|
|
}
|
|
process.stdout.write(`${JSON.stringify({ business: business.id, file: business.file, projects, instances }, null, 2)}\n`);
|
|
}
|
|
|
|
function resolveCommand(args) {
|
|
let project = null;
|
|
const rest = [];
|
|
for (let i = 0; i < args.length; i++) {
|
|
if (args[i] === "--project") {
|
|
if (!args[i + 1] || project !== null) fail(4, USAGE);
|
|
project = args[++i];
|
|
} else rest.push(args[i]);
|
|
}
|
|
if (rest.length !== 2) fail(4, USAGE);
|
|
const [businessId, instance] = rest;
|
|
const config = loadSystem();
|
|
const business = loadBusiness(businessId, { rolesDir: rolesDir() });
|
|
let loaded = null;
|
|
if (project !== null) {
|
|
const entry = Object.hasOwn(business.projects, project) ? business.projects[project] : null;
|
|
if (!entry) fail(2, `business ${business.id} declares no project ${JSON.stringify(project)}`);
|
|
if (entry.kind !== 'library') loaded = loadProject(entry.root);
|
|
}
|
|
const resolved = resolveInstance({ system: systemVars(config), business, project: loaded, instance });
|
|
const checked = checkRefs(Object.values(resolved.credentials), forbiddenRoots(config, business));
|
|
for (const w of checked.warnings) process.stderr.write(`mosaic business: warning: ${w}\n`);
|
|
if (checked.problems.length > 0) {
|
|
for (const p of checked.problems) process.stderr.write(`mosaic business: ${p}\n`);
|
|
fail(2, `${business.id} ${instance}: ${checked.problems.length} credential reference problem(s)`);
|
|
}
|
|
process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
|
|
}
|
|
|
|
const [verb, ...args] = process.argv.slice(2);
|
|
try {
|
|
if (verb === "validate") validate(args);
|
|
else if (verb === "resolve") resolveCommand(args);
|
|
else fail(4, USAGE);
|
|
} catch (error) {
|
|
if (error instanceof BusinessError) fail(error.exitCode, error.message);
|
|
throw error;
|
|
}
|