@django-stack/cli 0.9.0 → 0.11.0

package/dist/{production-M2SsuuBb.js → production-WThC1aS2.js}

@@ -258,9 +258,10 @@ async function runDoctor(directory) {
 	const services = running ? running.split("\n").filter(Boolean) : [];
 	const backendService = prod ? "backend-prod" : "backend";
 	const frontendService = prod ? "frontend-prod" : "frontend";
+	const frontend = existsSync(join(directory, "frontend", "package.json"));
 	checks.push({
 		name: "Services are running",
-		ok: services.includes(backendService) && services.includes(frontendService),
+		ok: services.includes(backendService) && (!frontend || services.includes(frontendService)),
 		warning: services.length === 0,
 		detail: services.length ? services.join(", ") : `Nothing is running. Start the project with \`docker compose up${prod ? " -d" : ""}\`.`
 	});
@@ -278,11 +279,12 @@ async function runDoctor(directory) {
 		detail: health ? `The ${backendService} container is ${health}` : `See \`docker compose logs ${backendService}\`.`
 	});
 	const site = (env.SITE_URL ?? "http://localhost:3000").replace(/\/$/, "");
-	const frontend = await fetchStatus(site);
+	const status = await fetchStatus(site);
+	const logs = prod ? "proxy" : frontend ? frontendService : backendService;
 	checks.push({
 		name: "The site answers",
-		ok: frontend !== void 0 && frontend < 500,
-		detail: frontend ? `${site} answered ${frontend}` : `No answer on ${site}. See \`docker compose logs ${prod ? "proxy" : frontendService}\`.`
+		ok: status !== void 0 && status < 500,
+		detail: status ? `${site} answered ${status}` : `No answer on ${site}. See \`docker compose logs ${logs}\`.`
 	});
 	const api = await fetchStatus(`${site}/api/content.sitesettings`, { "X-Secret-Key": env.API_READ_KEY ?? "" });
 	checks.push({
@@ -461,13 +463,13 @@ const STACK_OPTIONS = [
 				value: "headless",
 				label: "Headless",
 				hint: "just the API and the admin",
-				generated: false
+				generated: true
 			},
 			{
 				value: "templates",
 				label: "Django templates",
 				hint: "no Node, Django renders the site",
-				generated: false
+				generated: true
 			},
 			{
 				value: "nuxt",
@@ -498,7 +500,7 @@ const STACK_OPTIONS = [
 			value: "latest",
 			label: "Latest",
 			hint: "Postgres 18",
-			generated: false
+			generated: true
 		}]
 	},
 	{
@@ -599,7 +601,7 @@ const STACK_OPTIONS = [
 			value: "on",
 			label: "On",
 			hint: "proof of work, no tracking",
-			generated: false
+			generated: true
 		}, {
 			value: "off",
 			label: "Off",
@@ -634,7 +636,8 @@ const STACK_OPTIONS = [
 			{
 				value: "pnpm",
 				label: "pnpm",
-				generated: false
+				hint: "with a day's delay on new releases",
+				generated: true
 			},
 			{
 				value: "npm",
@@ -644,7 +647,8 @@ const STACK_OPTIONS = [
 			{
 				value: "bun",
 				label: "Bun",
-				generated: false
+				hint: "for installs; the frontend runs on Node.js",
+				generated: true
 			}
 		]
 	},
@@ -682,8 +686,8 @@ const STACK_OPTIONS = [
 			{
 				value: "sentry",
 				label: "Sentry",
-				hint: "or GlitchTip, with SENTRY_DSN",
-				generated: false
+				hint: "sentry.io, with SENTRY_DSN",
+				generated: true
 			},
 			{
 				value: "off",
@@ -724,9 +728,13 @@ const NODE_FRONTENDS = [
 	"nuxt",
 	"sveltekit"
 ];
-/** Whether an option applies to a stack: the package manager only with a Node frontend. */
+/**
+* Whether an option applies to a stack: the package manager only with a Node
+* frontend, page analytics only with a frontend for its tracker.
+*/
 function applies(key, stack) {
 	if (key === "packageManager") return stack.frontend === void 0 || NODE_FRONTENDS.includes(stack.frontend);
+	if (key === "analytics") return stack.frontend !== "headless";
 	return true;
 }
 const DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -914,6 +922,10 @@ function projectName(directory) {
 	} catch {}
 	return basename(directory).toLowerCase();
 }
+/** Whether the project has a frontend: a headless one has no `frontend/`. */
+function hasFrontend(directory) {
+	return existsSync(join(directory, "frontend", "package.json"));
+}
 function fromEnv(directory, name, envFile, localRun) {
 	const env = parseEnv(readFileSync(join(directory, envFile), "utf8"));
 	const profiles = parseProfiles(env.COMPOSE_PROFILES);
@@ -928,7 +940,7 @@ function fromEnv(directory, name, envFile, localRun) {
 		localRun,
 		services: {
 			backend: `backend${suffix}`,
-			frontend: `frontend${suffix}`,
+			...hasFrontend(directory) ? { frontend: `frontend${suffix}` } : {},
 			worker: `worker${suffix}`
 		},
 		composeArgs: localRun ? [
@@ -973,7 +985,8 @@ function projectStack(project) {
 	const fromEnv = {
 		analytics: project.profiles.includes("analytics") ? "umami" : "off",
 		...project.env.CACHE_URL === void 0 ? {} : cacheStack(project.env),
-		...notificationsStack(project)
+		...notificationsStack(project),
+		...captchaStack(project)
 	};
 	const { preset } = projectManifest(project);
 	if (preset) try {
@@ -994,6 +1007,17 @@ function notificationsStack(project) {
 	if (!existsSync(settings)) return {};
 	return { notifications: /^ *["']content_studio\.notifications["'],/m.test(readFileSync(settings, "utf8")) ? "on" : "off" };
 }
+/** The line of DjangoStack's captcha app in the backend's INSTALLED_APPS. */
+const CAPTCHA_APP = /^ *["']django_stack\.contrib\.captcha["'],/m;
+/**
+* The captcha is on when the backend has DjangoStack's captcha app and
+* CAPTCHA is not off. Projects from before the captcha have no app.
+*/
+function captchaStack(project) {
+	const settings = join(project.directory, "backend", "config", "settings.py");
+	if (!existsSync(settings)) return {};
+	return { captcha: CAPTCHA_APP.test(readFileSync(settings, "utf8")) && project.env.CAPTCHA !== "off" ? "on" : "off" };
+}
 const REDIS = /^(redis|rediss|valkey|valkeys):/;
 /**
 * The cache and the tasks a project's `.env` runs. Projects from before 0.7
@@ -1147,6 +1171,73 @@ const PACKAGE_NAME = "@django-stack/cli";
 // src/scaffold.ts
 /** The frontends this version of the CLI generates. */
 const FRONTENDS = stackOption("frontend").values.filter((value) => value.generated).map((value) => value.value);
+/** The Postgres major version of each `--postgres` value. */
+const POSTGRES_VERSIONS = {
+	stable: "17",
+	latest: "18"
+};
+/**
+* The template values of a Postgres version. From 18 the image keeps its data
+* in a versioned directory under /var/lib/postgresql, so the volume is
+* mounted there; before 18 at /var/lib/postgresql/data.
+*/
+function postgresValues(postgres) {
+	const version = POSTGRES_VERSIONS[postgres];
+	return {
+		postgres_version: version,
+		postgres_data: Number(version) >= 18 ? "/var/lib/postgresql" : "/var/lib/postgresql/data"
+	};
+}
+/** The pnpm and Bun versions the frontend image installs with. */
+const PNPM_VERSION = "12.18.0";
+const BUN_VERSION = "1.4.4";
+const LOCKFILES = {
+	pnpm: "pnpm-lock.yaml",
+	npm: "package-lock.json",
+	bun: "bun.lock"
+};
+/** The install command of a package manager: frozen to the lockfile when there is one. */
+function installCommand(manager, flags = "") {
+	const frozen = manager === "npm" ? "npm ci" : `${manager} install --frozen-lockfile`;
+	return `if [ -f ${LOCKFILES[manager]} ]; then ${frozen}${flags}; else ${manager} install${flags}; fi`;
+}
+/**
+* The template values for a package manager: the commands in the README and
+* AGENTS.md, and the install steps of the frontend's Dockerfile. Scripts run
+* with npm in the image whatever installed them; it comes with Node.js.
+*/
+function packageManagerValues(manager) {
+	return {
+		package_manager: manager,
+		pm_run: {
+			pnpm: "pnpm",
+			npm: "npm run",
+			bun: "bun run"
+		}[manager],
+		pm_backend: {
+			pnpm: "pnpm backend",
+			npm: "npm run backend --",
+			bun: "bun run backend"
+		}[manager],
+		pm_setup: {
+			pnpm: `RUN npm install --global pnpm@${PNPM_VERSION}`,
+			npm: "# npm comes with Node.js.",
+			bun: `COPY --from=oven/bun:${BUN_VERSION}-alpine /usr/local/bin/bun /usr/local/bin/bun`
+		}[manager],
+		pm_manifests: {
+			pnpm: "package.json pnpm-lock.yaml* pnpm-workspace.yaml",
+			npm: "package.json package-lock.json*",
+			bun: "package.json bun.lock*"
+		}[manager],
+		pm_install: installCommand(manager),
+		pm_install_no_scripts: installCommand(manager, " --ignore-scripts"),
+		pm_prune: {
+			pnpm: "pnpm prune --prod",
+			npm: "npm prune --omit=dev",
+			bun: "rm -rf node_modules && bun install --production"
+		}[manager]
+	};
+}
 /** Umami's database URL: the project's database, with Umami's tables in the `umami` schema. */
 function umamiDatabaseUrl(databaseUrl) {
 	const url = new URL(databaseUrl);
@@ -1225,7 +1316,7 @@ function localS3(port = 8333) {
 	};
 }
 const LOCAL_S3 = localS3();
-const TEXT_EXTENSIONS = /\.(py|ts|tsx|mjs|js|jsx|json|astro|vue|svelte|css|md|yaml|yml|toml|txt|html|sh|svg)$|Dockerfile$|gitignore$|\.dockerignore$|env\.example$/;
+const TEXT_EXTENSIONS = /\.(py|ts|tsx|mjs|js|jsx|json|astro|vue|svelte|css|md|yaml|yml|toml|txt|html|sh|svg)$|Dockerfile$|Caddyfile$|gitignore$|\.dockerignore$|env\.example$/;
 function defaultTemplatesDir() {
 	return fileURLToPath(new URL("../templates", import.meta.url));
 }
@@ -1259,6 +1350,35 @@ function walk(directory) {
 		return statSync(path).isDirectory() ? walk(path) : [path];
 	});
 }
+const BLOCK_START = /^\s*(?:#|<!--)\s*@if\s+(!?)([a-z]+)\s*(?:-->)?\s*$/;
+const BLOCK_END = /^\s*(?:#|<!--)\s*@end\s*(?:-->)?\s*$/;
+/**
+* Keeps or drops the template's conditional blocks: the lines between a
+* comment line `# @if frontend` (or `<!-- @if !frontend -->`) and `# @end`
+* stay when the flag is on (off with `!`). The marker lines always go.
+*/
+function selectBlocks(text, flags) {
+	if (!/@(if|end)\b/.test(text)) return text;
+	const kept = [];
+	const open = [];
+	for (const line of text.split("\n")) {
+		const start = line.match(BLOCK_START);
+		if (start) {
+			const flag = flags[start[2]];
+			if (flag === void 0) throw new Error(`Unknown template flag ${start[2]}.`);
+			open.push(start[1] ? !flag : flag);
+			continue;
+		}
+		if (BLOCK_END.test(line)) {
+			if (!open.length) throw new Error("@end without @if.");
+			open.pop();
+			continue;
+		}
+		if (open.every(Boolean)) kept.push(line);
+	}
+	if (open.length) throw new Error("@if without @end.");
+	return kept.join("\n");
+}
 function render(text, values) {
 	return text.replace(/\{\{([a-z_]+)\}\}/g, (match, key) => values[key] ?? match);
 }
@@ -1270,6 +1390,16 @@ function validateTimeZone(value) {
 	if (timeZones().includes(value)) return void 0;
 	return `${JSON.stringify(value)} is not a time zone. Use a name such as Europe/Amsterdam or UTC.`;
 }
+/** The root package.json of a headless project: the scripts without the frontend's steps. */
+function headlessScripts(text) {
+	const manifest = JSON.parse(text);
+	const scripts = manifest.scripts;
+	scripts.test = "docker compose exec backend pytest";
+	scripts.lint = "docker compose exec backend ruff check .";
+	scripts["generate:types"] = (scripts["generate:types"] ?? "").split(" && ")[0] ?? "";
+	manifest.description = manifest.description.replace(", Content Studio and Headless,", " and Content Studio,");
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
 function scaffold(options) {
 	const templates = options.templatesDir ?? defaultTemplatesDir();
 	const target = options.directory;
@@ -1280,17 +1410,29 @@ function scaffold(options) {
 		const zoneError = validateTimeZone(options.timeZone);
 		if (zoneError) throw new Error(zoneError);
 	}
+	const headless = options.frontend === "headless";
+	const djangoTemplates = options.frontend === "templates";
+	const jsFrontend = !headless && !djangoTemplates;
 	const frontendTemplate = join(templates, `frontend-${options.frontend}`);
-	if (!existsSync(frontendTemplate)) throw new Error(`This version of the CLI has no ${options.frontend} frontend.`);
+	if (!headless && !existsSync(frontendTemplate)) throw new Error(`This version of the CLI has no ${options.frontend} frontend.`);
 	mkdirSync(target, { recursive: true });
 	cpSync(join(templates, "base"), target, { recursive: true });
 	cpSync(join(templates, "backend"), join(target, "backend"), { recursive: true });
-	cpSync(frontendTemplate, join(target, "frontend"), { recursive: true });
+	const frontendDir = join(target, djangoTemplates ? "backend" : "frontend");
+	if (!headless) cpSync(frontendTemplate, frontendDir, { recursive: true });
 	renameSync(join(target, "gitignore"), join(target, ".gitignore"));
 	makeExecutable(target);
-	const about = join(target, "frontend", "template.json");
-	const frontend = JSON.parse(readFileSync(about, "utf8"));
-	rmSync(about);
+	let frontend = {
+		label: "Headless",
+		url: "",
+		security: ""
+	};
+	if (!headless) {
+		const about = join(frontendDir, "template.json");
+		frontend = JSON.parse(readFileSync(about, "utf8"));
+		rmSync(about);
+	}
+	const packageManager = options.packageManager ?? "pnpm";
 	const values = {
 		project_name: options.name,
 		frontend: options.frontend,
@@ -1300,15 +1442,33 @@ function scaffold(options) {
 		cli_version: CLI_VERSION,
 		preset: options.preset ?? encodePreset(DEFAULT_STACK),
 		site_port: String(options.ports?.SITE_PORT ?? 3e3),
-		mail_port: String(options.ports?.MAIL_PORT ?? 8025)
+		mail_port: String(options.ports?.MAIL_PORT ?? 8025),
+		...packageManagerValues(packageManager),
+		...postgresValues(options.postgres ?? DEFAULT_STACK.postgres)
 	};
 	const files = walk(target);
 	for (const file of files) {
 		if (!TEXT_EXTENSIONS.test(file)) continue;
 		const text = readFileSync(file, "utf8");
-		const rendered = render(text, values);
+		const rendered = render(selectBlocks(text, {
+			frontend: jsFrontend,
+			headless,
+			templates: djangoTemplates,
+			site: !headless
+		}), values);
 		if (rendered !== text) writeFileSync(file, rendered);
 	}
+	if (!jsFrontend) writeFileSync(join(target, "package.json"), headlessScripts(readFileSync(join(target, "package.json"), "utf8")));
+	if (packageManager !== "pnpm") rmSync(join(target, "frontend", "pnpm-workspace.yaml"), { force: true });
+	if (jsFrontend && packageManager !== "npm") {
+		const packageJson = join(target, "frontend", "package.json");
+		const manifest = JSON.parse(readFileSync(packageJson, "utf8"));
+		const version = packageManager === "pnpm" ? PNPM_VERSION : BUN_VERSION;
+		writeFileSync(packageJson, `${JSON.stringify({
+			...manifest,
+			packageManager: `${packageManager}@${version}`
+		}, null, 2)}\n`);
+	}
 	if (options.notifications === false) {
 		const settings = join(target, "backend", "config", "settings.py");
 		writeFileSync(settings, setNotificationsApp(readFileSync(settings, "utf8"), false));
@@ -1322,14 +1482,13 @@ function scaffold(options) {
 	const secrets = generateProjectSecrets();
 	let env = template.replace(/\{\{secret:([a-z_]+)\}\}/g, (match, key) => secrets[key] ?? match);
 	const envExample = template.replace(/\{\{secret:[a-z_]+\}\}/g, "");
-	const profiles = ["dev"];
-	if (options.databaseUrl) env = setEnvValues(env, { DATABASE_URL: normalizeDatabaseUrl(options.databaseUrl) });
-	else profiles.push("db");
+	const profiles = ["dev", "db"];
+	if (options.databaseUrl) env = setEnvValues(env, { PRODUCTION_DATABASE_URL: normalizeDatabaseUrl(options.databaseUrl) });
 	if (options.localS3) {
 		profiles.push("s3");
 		env = setEnvValues(env, LOCAL_S3);
 	}
-	if (options.analytics) {
+	if (options.analytics && !headless) {
 		profiles.push("analytics");
 		env = setEnvValues(env, umamiEnv(parseEnv(env).DATABASE_URL ?? "", secrets));
 	}
@@ -1342,7 +1501,8 @@ function scaffold(options) {
 	env = setEnvValues(env, { COMPOSE_PROFILES: profiles.join(",") });
 	if (options.ports) env = setEnvValues(env, portValues(parseEnv(env), options.ports));
 	if (!options.demoContent) env = setEnvValues(env, { SEED_DEMO_CONTENT: "0" });
-	if (options.errors === "off") env = setEnvValues(env, { ERRORS: "off" });
+	if (options.errors && options.errors !== "email") env = setEnvValues(env, { ERRORS: options.errors });
+	if (options.captcha === false) env = setEnvValues(env, { CAPTCHA: "off" });
 	writeFileSync(join(target, ".env"), env, { mode: 384 });
 	writeFileSync(join(target, ".env.example"), envExample);
 	rmSync(join(target, "env.example"));
@@ -1379,6 +1539,10 @@ function linkPackages(target, monorepo) {
 	const pyproject = join(target, "backend", "pyproject.toml");
 	writeFileSync(pyproject, `${readFileSync(pyproject, "utf8").trimEnd()}\n\n[tool.uv.sources]\ndjango-stack = { path = "vendor/${wheel}" }\n`);
 	const packageJson = join(target, "frontend", "package.json");
+	if (!existsSync(packageJson)) {
+		rmSync(frontendVendor, { recursive: true });
+		return;
+	}
 	const manifest = JSON.parse(readFileSync(packageJson, "utf8"));
 	const packages = Object.keys(manifest.dependencies ?? {}).filter((name) => name.startsWith("@django-stack/"));
 	for (const name of packages) {
@@ -1407,6 +1571,74 @@ function linkPackages(target, monorepo) {
 	writeFileSync(packageJson, `${JSON.stringify(manifest, null, 2)}\n`);
 }
 /** Locks the backend's dependencies with uv, when uv is installed. */
+/** Runs a package manager in the frontend directory: pnpm and Bun through npx, at the image's version. */
+function runPackageManager(directory, manager, args) {
+	const [file, commandArgs] = manager === "npm" ? ["npm", args] : ["npx", [
+		"--yes",
+		`${manager}@${manager === "pnpm" ? PNPM_VERSION : BUN_VERSION}`,
+		...args
+	]];
+	try {
+		execFileSync(file, commandArgs, {
+			cwd: directory,
+			stdio: "ignore",
+			shell: process.platform === "win32"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Writes the frontend's lockfile with the chosen package manager, without installing anything. */
+function lockFrontend(target, manager) {
+	const directory = join(target, "frontend");
+	return runPackageManager(directory, manager, manager === "npm" ? [
+		"install",
+		"--package-lock-only",
+		"--ignore-scripts",
+		"--no-audit",
+		"--no-fund"
+	] : ["install", "--lockfile-only"]) && existsSync(join(directory, LOCKFILES[manager]));
+}
+/** The package manager of a project's frontend, from its lockfile. */
+function frontendPackageManager(directory) {
+	return Object.keys(LOCKFILES).find((manager) => existsSync(join(directory, "frontend", LOCKFILES[manager])));
+}
+/**
+* Updates the frontend's lockfile, without installing: the @django-stack
+* packages, or every package with `all`, within the ranges of package.json.
+* Returns the lockfile, or undefined without one or on failure.
+*/
+function updateFrontendLock(target, all = false) {
+	const manager = frontendPackageManager(target);
+	if (!manager) return void 0;
+	const directory = join(target, "frontend");
+	const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+	const names = Object.keys(manifest.dependencies ?? {}).filter((name) => name.startsWith("@django-stack/"));
+	const packages = all ? [] : names;
+	const args = {
+		pnpm: [
+			"update",
+			...packages,
+			"--lockfile-only"
+		],
+		npm: [
+			"update",
+			...packages,
+			"--package-lock-only",
+			"--ignore-scripts",
+			"--no-audit",
+			"--no-fund"
+		],
+		bun: [
+			"update",
+			...packages,
+			"--lockfile-only"
+		]
+	}[manager];
+	if (!all && !names.length) return LOCKFILES[manager];
+	return runPackageManager(directory, manager, args) ? LOCKFILES[manager] : void 0;
+}
 function lockBackend(target) {
 	try {
 		execFileSync("uv", ["lock", "--quiet"], {
@@ -1462,7 +1694,12 @@ function productionEnv(devEnv, options) {
 		ADMIN_PASSWORD: secrets.admin ?? "",
 		DEFAULT_FROM_EMAIL: `${current.PROJECT_NAME ?? "site"} <noreply@${options.domain.toLowerCase()}>`
 	};
-	if (profiles.includes("db")) {
+	const external = options.bundledDatabase ? "" : current.PRODUCTION_DATABASE_URL ?? "";
+	if (external) {
+		values.DATABASE_URL = external;
+		values.POSTGRES_PASSWORD = "";
+		values.COMPOSE_PROFILES = [...new Set(profiles.filter((profile) => profile !== "db"))].join(",");
+	} else if (profiles.includes("db")) {
 		const user = current.POSTGRES_USER || "app";
 		const name = current.POSTGRES_DB || "app";
 		values.POSTGRES_PASSWORD = secrets.postgres ?? "";
@@ -1499,4 +1736,4 @@ function productionEnv(devEnv, options) {
 		todo
 	};
 }
-export { dockerRunning as $, projectStack as A, decodePreset as B, RUN_DOMAIN as C, composeOutput as D, compose as E, DEFAULT_STACK as F, DEV_PORTS as G, pendingChoices as H, NAMED_PRESETS as I, envPorts as J, chooseFreePorts as K, PROMPT_ORDER as L, readLocalRun as M, readProject as N, findProjectDirectory as O, runningServices as P, dockerNotRunning as Q, STACK_OPTIONS as R, generateSecret as S, activeProject as T, resolvePreset as U, encodePreset as V, stackOption as W, runDoctor as X, portValues as Y, checkTools as Z, validateProjectName as _, LOCAL_S3 as a, PACKAGE_NAME as b, lockBackend as c, scaffold as d, isDockerDown as et, setNotificationsApp as f, usesValkey as g, umamiEnv as h, FRONTENDS as i, projectUrls as j, parseProfiles as k, normalizeDatabaseUrl as l, toProjectName as m, productionEnv as n, quoteEnvValue as nt, cacheEnv as o, timeZones as p, describeMove as q, validateDomain as r, setEnvValues as rt, localS3 as s, missingS3 as t, parseEnv as tt, relativeDirectory as u, validateTimeZone as v, RUN_ENV as w, generateProjectSecrets as x, CLI_VERSION as y, applies as z };
+export { envPorts as $, compose as A, NAMED_PRESETS as B, PACKAGE_NAME as C, RUN_DOMAIN as D, CAPTCHA_APP as E, projectUrls as F, decodePreset as G, PROMPT_ORDER as H, readLocalRun as I, resolvePreset as J, encodePreset as K, readProject as L, findProjectDirectory as M, parseProfiles as N, RUN_ENV as O, projectStack as P, describeMove as Q, runningServices as R, CLI_VERSION as S, generateSecret as T, STACK_OPTIONS as U, NODE_FRONTENDS as V, applies as W, DEV_PORTS as X, stackOption as Y, chooseFreePorts as Z, umamiEnv as _, LOCAL_S3 as a, isDockerDown as at, validateProjectName as b, localS3 as c, setEnvValues as ct, normalizeDatabaseUrl as d, portValues as et, relativeDirectory as f, toProjectName as g, timeZones as h, FRONTENDS as i, dockerRunning as it, composeOutput as j, activeProject as k, lockBackend as l, setNotificationsApp as m, productionEnv as n, checkTools as nt, cacheEnv as o, parseEnv as ot, scaffold as p, pendingChoices as q, validateDomain as r, dockerNotRunning as rt, frontendPackageManager as s, quoteEnvValue as st, missingS3 as t, runDoctor as tt, lockFrontend as u, updateFrontendLock as v, generateProjectSecrets as w, validateTimeZone as x, usesValkey as y, DEFAULT_STACK as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@django-stack/cli",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "The production-ready Django, batteries included stack. Create and manage DjangoStack projects: a Django backend, a frontend, Postgres and Docker Compose in one command.",
   "license": "MIT",
   "author": "Leon van der Grient",

package/templates/backend/Dockerfile

@@ -10,9 +10,14 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     UV_PROJECT_ENVIRONMENT=/venv \
     PATH="/venv/bin:$PATH"
 COPY --from=ghcr.io/astral-sh/uv:0.11 /uv /bin/uv
-# The Postgres client, for the backups (pg_dump and pg_restore).
+# The Postgres client, for the backups (pg_dump and pg_restore), from the
+# PostgreSQL apt repository: its major version must match the server's, as
+# pg_dump refuses a newer server. Change it with the database.
+ARG POSTGRES_VERSION={{postgres_version}}
 RUN apt-get update \
-    && apt-get install --yes --no-install-recommends postgresql-client \
+    && apt-get install --yes --no-install-recommends postgresql-common \
+    && /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y \
+    && apt-get install --yes --no-install-recommends "postgresql-client-${POSTGRES_VERSION}" \
     && rm -rf /var/lib/apt/lists/*
 RUN groupadd --system app && useradd --system --gid app --home-dir /app app
 WORKDIR /app

package/templates/backend/config/settings.py

@@ -40,7 +40,12 @@ INSTALLED_APPS = [
     "content_studio.contrib.password_reset",
     "content_studio.notifications",  # notifications in the admin and by email
     "django_stack",
+    "django_stack.contrib.captcha",  # the captcha of the contact form (CAPTCHA=off turns it off)
     "content",
+    # @if templates
+    "django_stack.contrib.site",  # preview, the page cache, redirects and the template tags of the site
+    "website",  # the site's pages
+    # @end
     # Last: builds the API routes once every model is exposed.
     "headless.rest",
 ]
@@ -55,6 +60,10 @@ MIDDLEWARE = [
     "django.contrib.auth.middleware.AuthenticationMiddleware",
     "django.contrib.messages.middleware.MessageMiddleware",
     "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    # @if templates
+    # The redirects editors manage in the admin, for paths that do not exist.
+    "django_stack.contrib.site.middleware.RedirectMiddleware",
+    # @end
 ]
 
 ROOT_URLCONF = "config.urls"
@@ -71,6 +80,10 @@ TEMPLATES = [
                 "django.template.context_processors.request",
                 "django.contrib.auth.context_processors.auth",
                 "django.contrib.messages.context_processors.messages",
+                # @if templates
+                "django_stack.contrib.site.context_processors.site",  # preview, analytics_website_id
+                "website.context_processors.site",  # site, main_menu, footer_menu
+                # @end
             ],
         },
     },

package/templates/backend/config/urls.py

@@ -6,4 +6,15 @@ urlpatterns = [
     path("api/", include("headless.rest.urls")),
     path("", include("django_stack.urls")),  # /healthz and /readyz
     *media_urlpatterns(),  # uploaded files, in development only
+    # @if headless
+    path("", include("django_stack.start")),  # a start page with links to the admin and the API schema
+    # @end
+    # @if templates
+    path("", include("website.urls")),  # the site's pages, last: they include a catch-all for page paths
+    # @end
 ]
+# @if templates
+
+# The site's 404 page, with its layout (when DJANGO_DEBUG is off).
+handler404 = "website.views.not_found"
+# @end

package/templates/backend/content/admin.py

@@ -7,6 +7,7 @@ from content_studio import register
 from content_studio.admin import ModelStudio
 from content_studio.analytics import Analytics
 from content_studio.form import ActivityLog, Field, FormSet
+from django_stack.analytics import UmamiProvider
 from django_stack.studio import PreviewButton
 
 from .models import Author, Category, FormSubmission, Menu, Page, Post, Redirect, SiteSettings, Tag
@@ -17,9 +18,17 @@ POST_PREVIEW = PreviewButton(component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a02"
 PAGE_ACTIVITY = ActivityLog(component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a03")
 POST_ACTIVITY = ActivityLog(component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a04")
 # The visitors of the page or post, from the analytics (see config/studio.py).
-# Hidden while analytics are off.
-PAGE_ANALYTICS = Analytics(path_field="path", component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a05")
-POST_ANALYTICS = Analytics(path_field="slug", path_prefix="/blog/", component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a06")
+# Only with analytics on: Content Studio refuses them without its
+# AnalyticsExtension.
+ANALYTICS = UmamiProvider.is_configured()
+PAGE_ANALYTICS = (
+    [Analytics(path_field="path", component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a05")] if ANALYTICS else []
+)
+POST_ANALYTICS = (
+    [Analytics(path_field="slug", path_prefix="/blog/", component_id="8d0f6a52-3c51-4a8e-9a2b-6f1f0c8f2a06")]
+    if ANALYTICS
+    else []
+)
 SEO = FormSet(
     title="Search and sharing",
     description="Leave empty to use the title and the site settings.",
@@ -42,7 +51,7 @@ class PageStudio(ModelStudio):
         FormSet(title="Body", fields=["body"]),
         SEO,
     ]
-    edit_sidebar = ["status", "published_at", PAGE_PREVIEW, "order", PAGE_ANALYTICS, PAGE_ACTIVITY]
+    edit_sidebar = ["status", "published_at", PAGE_PREVIEW, "order", *PAGE_ANALYTICS, PAGE_ACTIVITY]
 
 
 @register(Post)
@@ -67,7 +76,7 @@ class PostStudio(ModelStudio):
         "author",
         "categories",
         "tags",
-        POST_ANALYTICS,
+        *POST_ANALYTICS,
         POST_ACTIVITY,
     ]
 

package/templates/backend/content/models.py

@@ -5,8 +5,8 @@ site settings, menus, redirects and form submissions.
 These models are yours: add fields, remove models, create new ones. Every
 model exposed with ``@expose()`` gets routes under /api/ (see
 https://djangoheadless.org/docs/models); register it in ``admin.py`` to edit
-it in Content Studio. After a change, run ``pnpm backend makemigrations``
-and ``pnpm generate:types``.
+it in Content Studio. After a change, run ``{{pm_run}} backend makemigrations``
+and ``{{pm_run}} generate:types``.
 """
 
 from content_studio.blocks import Block, BlockField