@businessdash/sdk 0.9.60 → 0.9.80

package/src/cli.ts

@@ -67,6 +67,11 @@ import {
 	isReservedPagePath,
 	reservedPagePathErrorMessage,
 } from "./reserved-paths.js";
+import {
+	callPackageApi,
+	runSeed,
+	type SeedDefinition,
+} from "./seed-core/index.js";
 
 const COMMANDS = [
 	"sync-schema",
@@ -80,10 +85,23 @@ const COMMANDS = [
 	"export-graphql-schema",
 	"sync-data-model",
 	"sync-records",
+	// Whole-seed: schema, records, collections, products, posts and coupons in
+	// one dependency-ordered run. Same functions the programmatic API exposes.
+	"seed",
 	"wipe-collections",
 	"wipe-database",
 	"help",
 ] as const;
+
+/** Candidates for a whole-seed file, newest naming first. */
+const SEED_CONFIG_CANDIDATES = [
+	"businessdash.seed.ts",
+	"businessdash.seed.mjs",
+	"businessdash.seed.js",
+	"biab.seed.ts",
+	"biab.seed.mjs",
+	"biab.seed.js",
+];
 type Command = (typeof COMMANDS)[number];
 
 /** Config candidates per flow. The marketing and data-model configs are
@@ -453,6 +471,14 @@ function resolveApiTarget(env: Record<string, string>): ApiTarget {
 	return { baseUrl: normalizeBaseUrl(rawBase), apiKey, siteId };
 }
 
+/**
+ * One data-model request.
+ *
+ * The transport, the auth header and the error shaping live in
+ * `seed-core/callPackageApi`, which the programmatic seeding API also uses.
+ * Two copies would drift, and the one that drifted would be whichever of the
+ * CLI or a consumer's build step nobody happened to be testing that week.
+ */
 async function callDataModelApi(input: {
 	target: ApiTarget;
 	path: string;
@@ -460,35 +486,14 @@ async function callDataModelApi(input: {
 	body?: unknown;
 }): Promise<Record<string, unknown>> {
 	const { target, path, method, body } = input;
-	const url = `${target.baseUrl}/sites/${encodeURIComponent(target.siteId)}/data-model/${path}`;
-	const res = await fetch(url, {
-		method,
-		headers: {
-			"content-type": "application/json",
-			authorization: `Bearer ${target.apiKey}`,
+	return callPackageApi(
+		{ apiKey: target.apiKey, siteId: target.siteId, baseUrl: target.baseUrl },
+		{
+			path: `sites/${encodeURIComponent(target.siteId)}/data-model/${path}`,
+			method,
+			...(body !== undefined ? { body } : {}),
 		},
-		...(body !== undefined ? { body: JSON.stringify(body) } : {}),
-	});
-	const text = await res.text();
-	let parsed: Record<string, unknown> | null = null;
-	try {
-		parsed = JSON.parse(text) as Record<string, unknown>;
-	} catch {
-		parsed = null;
-	}
-	if (!res.ok) {
-		const message =
-			typeof parsed?.["message"] === "string"
-				? parsed["message"]
-				: `HTTP ${res.status} ${res.statusText} — ${text.slice(0, 240)}`;
-		throw new Error(message);
-	}
-	if (!parsed) {
-		throw new Error(
-			`Server replied ${res.status} but the body wasn't JSON — first 240 chars: ${text.slice(0, 240)}`,
-		);
-	}
-	return parsed;
+	);
 }
 
 type PlanChange = {
@@ -1241,6 +1246,134 @@ type WipeCollectionsResult = {
  * no `--all` and no `--yes`: a human must name the targets, review live counts,
  * answer once, and then type a state-bound phrase exactly.
  */
+/**
+ * Run a whole seed file: schema, records, static collections, products, blog
+ * posts and coupons, in that order.
+ *
+ * This is the same `runSeed` the programmatic API exposes, not a second
+ * implementation — a consumer running `businessdash seed` in CI and a consumer
+ * calling `runSeed` from a Nuxt module get identical behaviour, including the
+ * refusal on a destructive plan.
+ */
+async function cmdSeed(opts: {
+	env: Record<string, string>;
+	cwd: string;
+	configPath?: string | undefined;
+	dryRun: boolean;
+	force: boolean;
+}) {
+	const seedPath = findConfigPath(
+		opts.cwd,
+		opts.configPath,
+		SEED_CONFIG_CANDIDATES,
+		"Create one with `defineSeed({...})` exported as default.",
+	);
+
+	const url = pathToFileURL(seedPath).href;
+	let mod: { default?: unknown; seed?: unknown };
+	try {
+		mod = (await import(url)) as typeof mod;
+	} catch (err) {
+		if (seedPath.endsWith(".ts")) {
+			throw new Error(
+				`Could not load TypeScript seed at ${seedPath}. Run the CLI under tsx, e.g.: ` +
+					`\`npx tsx node_modules/@businessdash/sdk/dist/cli.js seed\`.\nUnderlying: ${
+						err instanceof Error ? err.message : String(err)
+					}`,
+			);
+		}
+		throw err;
+	}
+
+	const seed = (mod.default ?? mod.seed) as SeedDefinition | undefined;
+	if (!seed || typeof seed !== "object") {
+		throw new Error(
+			`${seedPath} did not export a seed. Default-export \`defineSeed({...})\`.`,
+		);
+	}
+
+	const counts = [
+		seed.dataModel && "schema",
+		seed.records && `${Object.keys(seed.records).length} record set(s)`,
+		seed.collections?.length && `${seed.collections.length} collection(s)`,
+		seed.products?.length && `${seed.products.length} product(s)`,
+		seed.posts?.length && `${seed.posts.length} post(s)`,
+		seed.coupons?.length && `${seed.coupons.length} coupon(s)`,
+	].filter(Boolean) as string[];
+
+	logStep(
+		counts.length > 0
+			? `Seeding ${counts.join(", ")} from ${fg.bold(seedPath)}.`
+			: `${seedPath} is empty — nothing to seed.`,
+	);
+	if (counts.length === 0) return;
+
+	if (opts.dryRun) {
+		// The schema step still runs, because its own dry run is plan-only and
+		// the plan is the single most useful thing to see before a real seed.
+		// Everything else is skipped rather than faked.
+		logStep("--dry-run: planning the schema, uploading nothing else.");
+		if (seed.dataModel) {
+			await runSeed(
+				resolveSeedTarget(opts.env),
+				{ dataModel: seed.dataModel, dataModelOptions: { dryRun: true } },
+				{ onProgress: (m) => console.log(`  ${fg.dim("→")} ${m}`) },
+			);
+		}
+		for (const line of counts.filter((c) => c !== "schema")) {
+			console.log(`  ${fg.dim("→")} would seed ${line}`);
+		}
+		return;
+	}
+
+	const result = await runSeed(resolveSeedTarget(opts.env), seed, {
+		onProgress: (message) => console.log(`  ${fg.dim("→")} ${message}`),
+		// --force is the deliberate decision the refusal asks for.
+		failOnDangerousPlan: !opts.force,
+	});
+
+	// Conflicts are REPORTED rather than thrown, so a duplicate slug halfway
+	// through does not hide the seven that worked. Surface them here or they
+	// are invisible.
+	const skipped = [
+		...(result.posts ?? [])
+			.filter((p) => !p.created)
+			.map((p) => `post "${p.slug}" already existed`),
+		...(result.coupons ?? [])
+			.filter((c) => !c.created)
+			.map((c) => `coupon "${c.code}" already existed`),
+	];
+	for (const line of skipped) {
+		console.log(`  ${fg.amber("⚠")} ${fg.dim(line)}`);
+	}
+
+	console.log("");
+	logStep(fg.green("✓ Seed complete."));
+	if (
+		result.dataModel &&
+		!result.dataModel.noop &&
+		!result.dataModel.planOnly
+	) {
+		console.log(
+			`  ${fg.dim("The schema landed as a DRAFT. Promote it in Site Builder → Site Data → Database to apply it.")}`,
+		);
+	}
+	if (result.products?.length) {
+		console.log(
+			`  ${fg.dim("Products were created unpublished and are NOT in Stripe yet — publish them, then sync the catalogue.")}`,
+		);
+	}
+}
+
+/** The seed target, from the same env the rest of the CLI reads. */
+function resolveSeedTarget(env: Record<string, string>): {
+	baseUrl: string;
+	apiKey: string;
+	siteId: string;
+} {
+	return resolveApiTarget(env);
+}
+
 async function cmdWipeCollections(opts: {
 	env: Record<string, string>;
 	collections: string[];
@@ -2162,10 +2295,17 @@ CUSTOM DATABASE (biab.data-model.config.ts)
   npx biab-dev export-graphql-schema [--out path] [--include-standard]
   npx biab-dev sync-data-model  [--config path] [--dry-run] [--prune] [--forms [slugs]] [--no-forms] [--note "..."]
   npx biab-dev sync-records     [--records-dir path] [--dry-run]
+  npx biab-dev seed             [--config path] [--dry-run] [--yes]
   npx biab-dev wipe-collections --collections name-a,name-b [--dry-run]
   npx biab-dev wipe-database     --collections name-a,name-b [--config path] [--dry-run] [--yes]
   npx biab-dev wipe-database     --all [--config path] [--dry-run] [--yes]
 
+  seed    run businessdash.seed.ts — schema, records, static collections,
+          products, blog posts and coupons, in dependency order. Products and
+          posts are created UNPUBLISHED, and the schema lands as a DRAFT you
+          promote in the dashboard. A destructive schema plan refuses unless
+          you pass --yes. Same code path as runSeed() from @businessdash/sdk/seed.
+
   view    what's LIVE in BIAB right now (the dashboard can change it too, so
           this is not just "what I last pushed")
   print   what your local config resolves to — no network
@@ -2489,6 +2629,22 @@ async function main(): Promise<void> {
 		return;
 	}
 
+	// Above the marketing-config resolution below: a seed file is its own
+	// config, and a project that seeds a store without a marketing site should
+	// not be told its businessdash.config.ts is missing.
+	if (command === "seed") {
+		await cmdSeed({
+			env,
+			cwd,
+			configPath: configOverride,
+			dryRun,
+			// A destructive plan refuses by default; --yes is the deliberate
+			// decision, matching how the wipe commands read.
+			force: yes,
+		});
+		return;
+	}
+
 	const configPath = findConfigPath(cwd, configOverride);
 	if (command === "print-schema") {
 		await cmdPrintSchema({ configPath });