@usequark/quark-create-app 1.23.11

package/src/deploy/discovery.test.js

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { after, test } from "node:test";
+import {
+	discoverQuarkDeployProject,
+	QUARK_DEPLOY_DIAGNOSTIC_CODES,
+	resolveQuarkDeployProject,
+} from "./discovery.js";
+
+const temporaryDirectories = [];
+
+after(async () => {
+	await Promise.all(
+		temporaryDirectories.map((directory) =>
+			fs.rm(directory, { recursive: true, force: true }),
+		),
+	);
+});
+
+async function writeJson(filePath, value) {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, JSON.stringify(value, null, "\t"));
+}
+
+async function createFixture({ hasWeb = true, hasWorker = false } = {}) {
+	const projectDir = await fs.mkdtemp(path.join(os.tmpdir(), "quark-deploy-"));
+	temporaryDirectories.push(projectDir);
+
+	await writeJson(path.join(projectDir, "package.json"), {
+		name: "fixture-quark-project",
+		private: true,
+	});
+
+	if (hasWeb) {
+		await writeJson(path.join(projectDir, "apps", "web", "package.json"), {
+			name: "@fixture/quark-web",
+			private: true,
+			type: "module",
+		});
+	}
+
+	if (hasWorker) {
+		await writeJson(path.join(projectDir, "apps", "worker", "package.json"), {
+			name: "@fixture/quark-worker",
+			private: true,
+			type: "module",
+		});
+	}
+
+	return projectDir;
+}
+
+test("resolveQuarkDeployProject discovers web and worker services in a Quark monorepo", async () => {
+	const projectDir = await createFixture({ hasWeb: true, hasWorker: true });
+	const discovery = await resolveQuarkDeployProject(projectDir);
+
+	assert.equal(discovery.kind, "quark");
+	assert.deepEqual(
+		discovery.services.map((service) => service.kind),
+		["web", "worker"],
+	);
+
+	const [webService, workerService] = discovery.services;
+
+	assert.equal(webService.required, true);
+	assert.equal(webService.packageName, "@fixture/quark-web");
+	assert.equal(webService.relativeRootDir, "apps/web");
+	assert.equal(
+		webService.runtime.relativeEntrypoint,
+		"apps/web/.next/standalone/apps/web/server.js",
+	);
+	assert.equal(webService.runtime.healthcheckPath, "/api/health");
+	assert.equal(
+		webService.runtime.entrypointPath,
+		path.join(
+			projectDir,
+			"apps",
+			"web",
+			".next",
+			"standalone",
+			"apps",
+			"web",
+			"server.js",
+		),
+	);
+
+	assert.equal(workerService.required, false);
+	assert.equal(workerService.packageName, "@fixture/quark-worker");
+	assert.equal(workerService.relativeRootDir, "apps/worker");
+	assert.equal(
+		workerService.runtime.relativeEntrypoint,
+		"apps/worker/src/index.js",
+	);
+});
+
+test("resolveQuarkDeployProject accepts a Quark monorepo without a worker service", async () => {
+	const projectDir = await createFixture({ hasWeb: true, hasWorker: false });
+	const discovery = await resolveQuarkDeployProject(projectDir);
+
+	assert.equal(discovery.diagnostics.length, 0);
+	assert.deepEqual(
+		discovery.services.map((service) => service.kind),
+		["web"],
+	);
+	assert.equal(discovery.services[0].required, true);
+});
+
+test("discoverQuarkDeployProject reports diagnostics and resolveQuarkDeployProject rejects when web is missing", async () => {
+	const projectDir = await createFixture({ hasWeb: false, hasWorker: true });
+	const discovery = await discoverQuarkDeployProject(projectDir);
+
+	assert.deepEqual(
+		discovery.services.map((service) => service.kind),
+		["worker"],
+	);
+	assert.deepEqual(discovery.diagnostics, [
+		{
+			code: QUARK_DEPLOY_DIAGNOSTIC_CODES.MISSING_REQUIRED_SERVICE,
+			serviceKind: "web",
+			required: true,
+			expectedPath: "apps/web/package.json",
+			message: "Missing required Quark web service at apps/web/package.json.",
+		},
+	]);
+
+	await assert.rejects(
+		() => resolveQuarkDeployProject(projectDir),
+		(error) => {
+			assert.equal(error.code, "QUARK_DEPLOY_DISCOVERY_FAILED");
+			assert.equal(error.diagnostics.length, 1);
+			assert.match(error.message, /apps\/web\/package\.json/);
+			assert.deepEqual(
+				error.discovery.services.map((service) => service.kind),
+				["worker"],
+			);
+			return true;
+		},
+	);
+});

package/src/deploy/index.js

@@ -0,0 +1,38 @@
+export {
+	applyIacConfig,
+	checkRailwayCLI,
+	checkRailwayLogin,
+	deleteService,
+	deployService,
+	ensurePlugin,
+	ensureRailwayProject,
+	ensureService,
+	escapeTsString,
+	generateIacFile,
+	getDeploymentStatus,
+	getExistingVariable,
+	getServiceUrl,
+	installRailwaySdk,
+	isProjectLinked,
+	listProjects,
+	RAILWAY,
+	RAILWAY_DIAGNOSTIC_CODES,
+	RailwayError,
+	removeServiceDomain,
+	setProjectVariables,
+	tryLinkProject,
+} from "./adapters/index.js";
+export {
+	QUARK_DEPLOY_PROJECT_KIND,
+	QUARK_SERVICE_CONTRACTS,
+	QUARK_SERVICE_KINDS,
+	SUPPORTED_QUARK_SERVICE_KINDS,
+} from "./contract.js";
+export { deployToRailway } from "./deploy.js";
+export {
+	discoverQuarkDeployProject,
+	formatQuarkDeployDiagnostics,
+	QUARK_DEPLOY_DIAGNOSTIC_CODES,
+	resolveQuarkDeployProject,
+} from "./discovery.js";
+export { inspectProject } from "./inspect.js";

package/src/deploy/inspect.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import chalk from "chalk";
+import { execa } from "execa";
+import fs from "fs-extra";
+import {
+	checkRailwayCLI,
+	checkRailwayLogin,
+	getProjectDomains,
+	isProjectLinked,
+	RAILWAY,
+} from "./adapters/index.js";
+import { discoverQuarkDeployProject } from "./discovery.js";
+
+function formatBool(value) {
+	return value ? chalk.green("✔ yes") : chalk.red("✖ no");
+}
+
+export async function inspectProject(options = {}) {
+	const { cwd = process.cwd(), output = console.log } = options;
+
+	output(chalk.blue.bold("\n🔍 Quark Deploy Inspection\n"));
+
+	// --- Service discovery ---
+	output(chalk.cyan("  Project Services\n"));
+
+	const discovery = await discoverQuarkDeployProject(cwd);
+
+	if (discovery.services.length === 0) {
+		output(chalk.yellow("  No Quark services discovered."));
+	} else {
+		for (const service of discovery.services) {
+			output(`  ${chalk.bold(service.name)}`);
+			output(`    Package:    ${service.packageName ?? chalk.dim("unknown")}`);
+			output(`    Root:       ${service.relativeRootDir}`);
+			output(`    Entrypoint: ${service.runtime.relativeEntrypoint}`);
+			if (service.runtime.healthcheckPath) {
+				output(`    Health:     ${service.runtime.healthcheckPath}`);
+			}
+			output(
+				`    Required:   ${service.required ? chalk.green("yes") : chalk.dim("no")}`,
+			);
+			output();
+		}
+	}
+
+	// --- Diagnostics ---
+	if (discovery.diagnostics.length > 0) {
+		output(chalk.yellow("  Diagnostics\n"));
+		for (const diagnostic of discovery.diagnostics) {
+			output(`  ${chalk.yellow("⚠")} ${diagnostic.message}`);
+		}
+		output();
+	}
+
+	// --- Railway readiness ---
+	output(chalk.cyan("  Railway Readiness\n"));
+
+	const railCLIVersion = await checkRailwayCLI();
+	output(`  CLI installed:  ${formatBool(!!railCLIVersion)}`);
+	if (railCLIVersion) {
+		output(`    Version:       ${railCLIVersion}`);
+	}
+
+	const railUser = await checkRailwayLogin();
+	output(`  Logged in:      ${formatBool(!!railUser)}`);
+	if (railUser) {
+		output(`    User:          ${railUser}`);
+	}
+
+	const linked = await isProjectLinked(cwd);
+	output(`  Project linked: ${formatBool(linked)}`);
+
+	if (linked) {
+		const domains = await getProjectDomains({ cwd });
+		if (domains.length > 0) {
+			output(chalk.green("\n  Deployed Services\n"));
+			for (const domain of domains) {
+				output(
+					`    ${domain.service ?? chalk.dim("unknown")}: ${domain.domain ?? chalk.dim("no domain")}`,
+				);
+			}
+		}
+	}
+
+	// --- Service Status ---
+	if (linked) {
+		output(chalk.cyan("  Service Status\n"));
+
+		try {
+			const configPath = path.join(cwd, ".railway", "config.json");
+			const config = fs.readJsonSync(configPath);
+			const projectId = config.project;
+
+			const { stdout } = await execa(RAILWAY, ["service", "list", "--json"], {
+				cwd,
+				timeout: 15_000,
+			});
+			const services = JSON.parse(stdout);
+
+			for (const service of services) {
+				const shortId = service.id.slice(0, 8);
+				const status = service.status ?? "unknown";
+				let coloredStatus;
+				if (status === "deployed") {
+					coloredStatus = chalk.green(status);
+				} else if (status === "deploying") {
+					coloredStatus = chalk.yellow(status);
+				} else if (
+					status === "crashing" ||
+					status === "crashed" ||
+					status === "failed"
+				) {
+					coloredStatus = chalk.red(status);
+				} else {
+					coloredStatus = chalk.dim(status);
+				}
+				const url = `https://railway.com/project/${projectId}/service/${service.id}`;
+				output(
+					`  ${chalk.bold(service.name)} : ${coloredStatus} (${shortId}) → ${chalk.dim(url)}`,
+				);
+			}
+		} catch (err) {
+			output(
+				`  ${chalk.red("✖")} ${chalk.dim(`Failed to fetch service status: ${err.message}`)}`,
+			);
+		}
+	}
+
+	output();
+}