@django-stack/cli 0.9.0 → 0.10.0

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as dockerRunning, A as projectStack, C as RUN_DOMAIN, D as composeOutput, E as compose, F as DEFAULT_STACK, G as DEV_PORTS, H as pendingChoices, I as NAMED_PRESETS, J as envPorts, K as chooseFreePorts, L as PROMPT_ORDER, M as readLocalRun, N as readProject, O as findProjectDirectory, P as runningServices, Q as dockerNotRunning, R as STACK_OPTIONS, S as generateSecret, T as activeProject, U as resolvePreset, V as encodePreset, W as stackOption, X as runDoctor, Y as portValues, Z as checkTools, _ as validateProjectName, a as LOCAL_S3, b as PACKAGE_NAME, c as lockBackend, d as scaffold, et as isDockerDown, f as setNotificationsApp, g as usesValkey, h as umamiEnv, j as projectUrls, k as parseProfiles, m as toProjectName, n as productionEnv$1, nt as quoteEnvValue, o as cacheEnv, p as timeZones, q as describeMove, r as validateDomain, rt as setEnvValues, s as localS3, t as missingS3, tt as parseEnv, u as relativeDirectory, v as validateTimeZone, w as RUN_ENV, x as generateProjectSecrets, y as CLI_VERSION, z as applies } from "./production-M2SsuuBb.js";
+import { $ as envPorts, A as compose, B as NAMED_PRESETS, C as PACKAGE_NAME, D as RUN_DOMAIN, E as CAPTCHA_APP, F as projectUrls, H as PROMPT_ORDER, I as readLocalRun, J as resolvePreset, K as encodePreset, L as readProject, M as findProjectDirectory, N as parseProfiles, O as RUN_ENV, P as projectStack, Q as describeMove, R as runningServices, S as CLI_VERSION, T as generateSecret, U as STACK_OPTIONS, V as NODE_FRONTENDS, W as applies, X as DEV_PORTS, Y as stackOption, Z as chooseFreePorts, _ as umamiEnv, a as LOCAL_S3, at as isDockerDown, b as validateProjectName, c as localS3, ct as setEnvValues, et as portValues, f as relativeDirectory, g as toProjectName, h as timeZones, it as dockerRunning, j as composeOutput, k as activeProject, l as lockBackend, m as setNotificationsApp, n as productionEnv$1, nt as checkTools, o as cacheEnv, ot as parseEnv, p as scaffold, q as pendingChoices, r as validateDomain, rt as dockerNotRunning, s as frontendPackageManager, st as quoteEnvValue, t as missingS3, tt as runDoctor, u as lockFrontend, v as updateFrontendLock, w as generateProjectSecrets, x as validateTimeZone, y as usesValkey, z as DEFAULT_STACK } from "./production-Ct_qoeXk.js";
 import { createRequire } from "node:module";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, posix, relative, resolve, sep } from "node:path";
@@ -4070,6 +4070,8 @@ async function init(directoryArgument, options) {
 			analytics: stack.analytics === "umami",
 			cache: stack.cache,
 			notifications: stack.notifications === "on",
+			captcha: stack.captcha === "on",
+			packageManager: stack.packageManager,
 			errors: stack.errors,
 			tasks: stack.tasks,
 			preset: encodePreset(stack),
@@ -4087,6 +4089,16 @@ async function init(directoryArgument, options) {
 		if (lockBackend(target)) spinner.stop(`Locked the backend dependencies in ${pc.bold("backend/uv.lock")}`);
 		else spinner.error("Could not lock the backend dependencies. The image build resolves them instead.");
 	}
+	if (NODE_FRONTENDS.includes(stack.frontend)) {
+		const lockfile = {
+			pnpm: "pnpm-lock.yaml",
+			npm: "package-lock.json",
+			bun: "bun.lock"
+		}[stack.packageManager];
+		spinner.start(`Locking the frontend dependencies with ${stack.packageManager}`);
+		if (lockFrontend(target, stack.packageManager)) spinner.stop(`Locked the frontend dependencies in ${pc.bold(`frontend/${lockfile}`)}`);
+		else spinner.error("Could not lock the frontend dependencies. The image build resolves them instead.");
+	}
 	if (options.git && has("git")) try {
 		execFileSync("git", ["init", "--quiet"], {
 			cwd: target,
@@ -4512,7 +4524,8 @@ const SWITCHABLE = [
 	"media",
 	"cache",
 	"tasks",
-	"notifications"
+	"notifications",
+	"captcha"
 ];
 const EMPTY_S3 = Object.fromEntries(Object.keys(LOCAL_S3).map((key) => [key, key === "S3_CREATE_BUCKET" ? "0" : ""]));
 /**
@@ -4580,6 +4593,10 @@ function applyStack(envText, env, from, to) {
 			}
 		}
 		if (key === "notifications") changes.push(to.notifications === "on" ? "Notifications are on: content_studio.notifications is in INSTALLED_APPS." : "Notifications are off: content_studio.notifications is out of INSTALLED_APPS; its tables stay.");
+		if (key === "captcha") {
+			text = setEnvValues(text, { CAPTCHA: to.captcha });
+			changes.push(to.captcha === "on" ? "The captcha of the contact form is on." : "The captcha is off: public forms need no captcha token.");
+		}
 		if (key === "media") changes.push(to.media === "s3" ? "Uploads in production go to S3; dstack settings asks for the S3 settings." : "Uploads in production stay on the server.");
 	}
 	return {
@@ -4998,6 +5015,11 @@ async function update(options) {
 		}).status !== 0) fail("uv could not update backend/uv.lock.");
 		p.log.success(options.all ? "Updated backend/uv.lock" : "Updated django-stack in backend/uv.lock");
 	} else if (existsSync(lock)) p.log.warn("uv is not installed, so backend/uv.lock stays as it is: https://docs.astral.sh/uv/");
+	if (frontendPackageManager(project.directory)) {
+		const lockfile = updateFrontendLock(project.directory, options.all);
+		if (!lockfile) fail("The package manager could not update the frontend's lockfile.");
+		p.log.success(options.all ? `Updated frontend/${lockfile}` : `Updated the @django-stack packages in frontend/${lockfile}`);
+	}
 	for (const target of targets) {
 		if (compose(target, ["pull", "--ignore-buildable"]) !== 0) fail("Pulling the images failed.");
 		const build = [
@@ -5058,6 +5080,9 @@ async function config(options) {
 		if (!existsSync(compose) || !/^ {2}umami:/m.test(readFileSync(compose, "utf8"))) fail("compose.yaml has no umami service. Add it as the analytics docs describe, then run this again.");
 	}
 	const settingsPath = join(project.directory, "backend", "config", "settings.py");
+	if (next.captcha === "on" && current.captcha !== "on") {
+		if (!existsSync(settingsPath) || !CAPTCHA_APP.test(readFileSync(settingsPath, "utf8"))) fail("The backend has no django_stack.contrib.captcha. Add it and the widget as the captcha docs describe, then run this again.");
+	}
 	let settingsText;
 	if (next.notifications !== current.notifications) {
 		if (!existsSync(settingsPath)) fail("This project has no backend/config/settings.py.");
@@ -5301,7 +5326,7 @@ function createProgram() {
 	program.command("logs").description("Show the logs of the services").argument("[services...]", "Only these services, such as backend").addOption(dirOption()).option("--no-follow", "Print the logs and exit").option("-n, --tail <lines>", "Only the last lines of each service").action(logs);
 	program.command("status").description("Show the containers and whether the database, cache, worker and backups are healthy").addOption(dirOption()).action(status);
 	program.command("check").description("Check the project: setup, Django checks, migrations and linters").addOption(dirOption()).option("--tests", "Run the backend and frontend tests too").action(check);
-	program.command("update").description("Pull and rebuild the images and update the DjangoStack packages").addOption(dirOption()).option("--all", "Update every backend package in uv.lock, not only django-stack").option("--no-cache", "Rebuild the images from scratch").option("--no-restart", "Don't restart what was running").action(update);
+	program.command("update").description("Pull and rebuild the images and update the DjangoStack packages").addOption(dirOption()).option("--all", "Update every package in the lockfiles, not only DjangoStack's").option("--no-cache", "Rebuild the images from scratch").option("--no-restart", "Don't restart what was running").action(update);
 	const configCommand = program.command("config").description("Change the stack options of a project").addOption(dirOption()).option("-y, --yes", "Don't ask; change only what the flags set").action((options, cmd) => config({
 		...options,
 		fromCli: (option) => cmd.getOptionValueSource(option) === "cli"

package/dist/index.d.ts

@@ -174,7 +174,7 @@ export declare const STACK_OPTIONS: readonly [{
     readonly value: "on";
     readonly label: "On";
     readonly hint: "proof of work, no tracking";
-    readonly generated: false;
+    readonly generated: true;
   }, {
     readonly value: "off";
     readonly label: "Off";
@@ -206,7 +206,8 @@ export declare const STACK_OPTIONS: readonly [{
   readonly values: readonly [{
     readonly value: "pnpm";
     readonly label: "pnpm";
-    readonly generated: false;
+    readonly hint: "with a day's delay on new releases";
+    readonly generated: true;
   }, {
     readonly value: "npm";
     readonly label: "npm";
@@ -214,7 +215,8 @@ export declare const STACK_OPTIONS: readonly [{
   }, {
     readonly value: "bun";
     readonly label: "Bun";
-    readonly generated: false;
+    readonly hint: "for installs; the frontend runs on Node.js";
+    readonly generated: true;
   }];
 }, {
   readonly key: "media";
@@ -247,8 +249,8 @@ export declare const STACK_OPTIONS: readonly [{
   }, {
     readonly value: "sentry";
     readonly label: "Sentry";
-    readonly hint: "or GlitchTip, with SENTRY_DSN";
-    readonly generated: false;
+    readonly hint: "sentry.io, with SENTRY_DSN";
+    readonly generated: true;
   }, {
     readonly value: "off";
     readonly label: "Off";
@@ -296,6 +298,10 @@ interface ScaffoldOptions {
   analytics?: boolean;
   /** Content Studio's notifications app; on by default. */
   notifications?: boolean;
+  /** The captcha of the contact form; on by default. */
+  captcha?: boolean;
+  /** The frontend's package manager; pnpm by default. */
+  packageManager?: PackageManager;
   /** How errors are reported in production; by email by default. */
   errors?: Stack["errors"];
   /** The cache backend; the database by default. */
@@ -313,6 +319,8 @@ interface ScaffoldOptions {
   /** Where the templates are; the ones in the package by default. */
   templatesDir?: string;
 }
+/** A package manager of the frontend. */
+type PackageManager = Stack["packageManager"];
 interface ScaffoldResult {
   directory: string;
   adminUsername: string;

package/dist/index.js

@@ -1 +1 @@
-export { F as DEFAULT_STACK, i as FRONTENDS, I as NAMED_PRESETS, R as STACK_OPTIONS, y as VERSION, o as cacheEnv, B as decodePreset, V as encodePreset, x as generateProjectSecrets, S as generateSecret, l as normalizeDatabaseUrl, tt as parseEnv, H as pendingChoices, n as productionEnv, U as resolvePreset, X as runDoctor, d as scaffold, rt as setEnvValues, f as setNotificationsApp, m as toProjectName, g as usesValkey, r as validateDomain, _ as validateProjectName } from "./production-M2SsuuBb.js";
+export { z as DEFAULT_STACK, i as FRONTENDS, B as NAMED_PRESETS, U as STACK_OPTIONS, S as VERSION, o as cacheEnv, G as decodePreset, K as encodePreset, w as generateProjectSecrets, T as generateSecret, d as normalizeDatabaseUrl, ot as parseEnv, q as pendingChoices, n as productionEnv, J as resolvePreset, tt as runDoctor, p as scaffold, ct as setEnvValues, m as setNotificationsApp, g as toProjectName, y as usesValkey, r as validateDomain, b as validateProjectName } from "./production-Ct_qoeXk.js";

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

@@ -599,7 +599,7 @@ const STACK_OPTIONS = [
 			value: "on",
 			label: "On",
 			hint: "proof of work, no tracking",
-			generated: false
+			generated: true
 		}, {
 			value: "off",
 			label: "Off",
@@ -634,7 +634,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 +645,8 @@ const STACK_OPTIONS = [
 			{
 				value: "bun",
 				label: "Bun",
-				generated: false
+				hint: "for installs; the frontend runs on Node.js",
+				generated: true
 			}
 		]
 	},
@@ -682,8 +684,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",
@@ -973,7 +975,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 +997,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 +1161,56 @@ 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 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);
@@ -1291,6 +1355,7 @@ function scaffold(options) {
 	const about = join(target, "frontend", "template.json");
 	const frontend = JSON.parse(readFileSync(about, "utf8"));
 	rmSync(about);
+	const packageManager = options.packageManager ?? "pnpm";
 	const values = {
 		project_name: options.name,
 		frontend: options.frontend,
@@ -1300,7 +1365,8 @@ 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)
 	};
 	const files = walk(target);
 	for (const file of files) {
@@ -1309,6 +1375,16 @@ function scaffold(options) {
 		const rendered = render(text, values);
 		if (rendered !== text) writeFileSync(file, rendered);
 	}
+	if (packageManager !== "pnpm") rmSync(join(target, "frontend", "pnpm-workspace.yaml"), { force: true });
+	if (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));
@@ -1342,7 +1418,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"));
@@ -1407,6 +1484,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"], {
@@ -1499,4 +1644,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.10.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/config/settings.py

@@ -40,6 +40,7 @@ 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",
     # Last: builds the API routes once every model is exposed.
     "headless.rest",

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

package/templates/backend/content/tests/test_api.py

@@ -1,12 +1,13 @@
 """
 Smoke tests of the content API: every exposed model answers the read-only
 key, drafts stay hidden, and the contact form takes submissions.
-Run them with `pnpm test` at the project root.
+Run them with `{{pm_run}} test` at the project root.
 """
 
 import pytest
 from django.apps import apps
 from django.conf import settings
+from django_stack.contrib.captcha.testing import captcha_token
 from rest_framework.test import APIClient
 
 from content.models import FormSubmission, Page, Post
@@ -63,13 +64,24 @@ def test_post_by_slug(reader, seeded):
 def test_contact_form(seeded):
     response = APIClient().post(
         "/api/content.formsubmission",
-        {"name": "Ada", "email": "ada@example.com", "message": "Hello"},
+        {"name": "Ada", "email": "ada@example.com", "message": "Hello", "captcha": captcha_token()},
         format="json",
     )
     assert response.status_code == 201
     assert FormSubmission.objects.filter(email="ada@example.com").exists()
 
 
+@pytest.mark.skipif(not settings.DJANGO_STACK["CAPTCHA"], reason="the captcha is off")
+def test_contact_form_needs_a_captcha(seeded):
+    response = APIClient().post(
+        "/api/content.formsubmission",
+        {"name": "Ada", "email": "ada@example.com", "message": "Hello"},
+        format="json",
+    )
+    assert response.status_code == 400
+    assert "captcha" in response.json()
+
+
 @pytest.mark.skipif(not apps.is_installed("content_studio.notifications"), reason="notifications are off")
 def test_contact_form_notifies_the_editors(seeded, django_capture_on_commit_callbacks):
     from content_studio.notifications.models import Notification
@@ -79,7 +91,7 @@ def test_contact_form_notifies_the_editors(seeded, django_capture_on_commit_call
     with django_capture_on_commit_callbacks(execute=True):
         APIClient().post(
             "/api/content.formsubmission",
-            {"name": "Ada", "email": "ada@example.com", "message": "100% sure"},
+            {"name": "Ada", "email": "ada@example.com", "message": "100% sure", "captcha": captcha_token()},
             format="json",
         )
     notification = Notification.objects.get(recipient=editor, event="site.form_submitted")

package/templates/backend/pyproject.toml

@@ -5,7 +5,7 @@ description = "The Django backend of {{project_name}}."
 requires-python = ">=3.12"
 dependencies = [
     "Django>=6.1,<6.2",
-    "django-stack[server,s3]>=0.9.0",
+    "django-stack[server,s3]>=0.10.0",
     "django-headless[schema]>=1.1.1",
     "django-content-studio[images,huey]>=1.11.0",
 ]

package/templates/base/AGENTS.md

@@ -17,7 +17,7 @@ backend/                 Django project
   content/seed.py        demo content
   content/tests/         pytest tests of the API
 frontend/                the {{frontend_label}} site; frontend/AGENTS.md lists its files
-  src/lib/headless.ts    generated API types; do not edit, run `npm run generate:types`
+  src/lib/headless.ts    generated API types; do not edit, run `{{pm_run}} generate:types`
 compose.yaml             every service; COMPOSE_PROFILES in .env picks dev or prod
 Caddyfile                the prod profile's reverse proxy and HTTPS
 .github/workflows/deploy.yml  optional deploy to a server over SSH
@@ -26,16 +26,16 @@ Caddyfile                the prod profile's reverse proxy and HTTPS
 
 ## Commands
 
-Run them at the project root. They need Docker; Node is only needed for the `npm run` shortcuts.
+Run them at the project root. They need Docker; Node is only needed for the `{{pm_run}}` shortcuts.
 
 | Task | Command |
 |------|---------|
-| Start everything | `docker compose up --build` (or `npm run dev`) |
-| Run a manage.py command | `docker compose exec backend python manage.py <command>` (or `npm run backend -- <command>`) |
+| Start everything | `docker compose up --build` (or `{{pm_run}} dev`) |
+| Run a manage.py command | `docker compose exec backend python manage.py <command>` (or `{{pm_backend}} <command>`) |
 | Make migrations after a model change | `docker compose exec backend python manage.py makemigrations` |
-| Regenerate the API types after a model change | `npm run generate:types` |
-| Run the tests | `npm test` |
-| Lint and type-check | `npm run lint` |
+| Regenerate the API types after a model change | `{{pm_run}} generate:types` |
+| Run the tests | `{{pm_run}} test` |
+| Lint and type-check | `{{pm_run}} lint` |
 | Logs | `docker compose logs --follow backend` |
 | Production settings for a server | `npx @django-stack/cli production --domain example.com` |
 
@@ -54,7 +54,7 @@ in a running container.
    `ModelStudio`.
 3. Run `makemigrations`; the backend migrates on its next start, or run
    `migrate`.
-4. Run `npm run generate:types`, then read it in the frontend as
+4. Run `{{pm_run}} generate:types`, then read it in the frontend as
    `frontend/AGENTS.md` shows.
 5. Add an API smoke test to `backend/content/tests/test_api.py`.
 

package/templates/base/README.md

@@ -38,9 +38,9 @@ the frontend {{frontend_label}}'s, with the source mounted from `backend/` and
 |------|---------|
 | Run a manage.py command | `docker compose exec backend python manage.py <command>` |
 | Make migrations | `docker compose exec backend python manage.py makemigrations` |
-| Regenerate the API types | `npm run generate:types` |
-| Run the tests | `npm test` |
-| Check the setup | `npm run doctor` |
+| Regenerate the API types | `{{pm_run}} generate:types` |
+| Run the tests | `{{pm_run}} test` |
+| Check the setup | `{{pm_run}} doctor` |
 
 With the `dstack` command installed (`npm i -g @django-stack/cli`),
 `dstack dev`, `dstack check`, `dstack manage <command>` and `dstack types` do

package/templates/base/compose.yaml

@@ -45,6 +45,13 @@ x-frontend-env: &frontend-env
   # Page analytics: the tracker loads from /_a/ on the site when set.
   UMAMI_WEBSITE_ID: ${UMAMI_WEBSITE_ID:-}
   UMAMI_URL: ${UMAMI_URL:-}
+  # The captcha widget of the contact form, unless CAPTCHA=off.
+  CAPTCHA: ${CAPTCHA:-on}
+  # Server errors to Sentry with ERRORS=sentry, as the backend's.
+  ERRORS: ${ERRORS:-email}
+  SENTRY_DSN: ${SENTRY_DSN:-}
+  SENTRY_ENVIRONMENT: ${SENTRY_ENVIRONMENT:-production}
+  SENTRY_RELEASE: ${SENTRY_RELEASE:-}
 
 x-backend-depends: &backend-depends
   db:

package/templates/base/env.example

@@ -118,12 +118,24 @@ BACKUP_S3_BUCKET=
 # an Uptime Kuma push monitor, which alerts you when the pings stop.
 BACKUP_PING_URL=
 
+# The captcha of the contact form: a proof of work the visitor's browser
+# solves, served by Django at /api/cap/, with no third party. CAPTCHA=off
+# turns it off for the backend and the frontend.
+CAPTCHA=on
+
 # Error reports (with DJANGO_DEBUG=0): each new error of the backend, the
 # worker or a backup is mailed to ERROR_EMAIL (comma separated) or, when it
 # is empty, to the superusers, and shows in the admin's notifications. The
 # same error is mailed once an hour at most. ERRORS=off turns it off.
 ERRORS=email
 ERROR_EMAIL=
+# ERRORS=sentry sends the errors of the backend, the worker and the
+# frontend's server to Sentry instead: create a Django project on sentry.io
+# and paste its DSN here. SENTRY_TRACES_SAMPLE_RATE (0 to 1) also sends that
+# share of the backend's requests as performance traces.
+SENTRY_DSN=
+SENTRY_ENVIRONMENT=production
+SENTRY_TRACES_SAMPLE_RATE=0
 
 # Logs: one JSON object per line in production, plain text in development
 # (LOG_FORMAT=json or plain). LOG_ACCESS=0 turns off Django's access log.

package/templates/frontend-astro/AGENTS.md

@@ -12,7 +12,7 @@ src/layouts/Base.astro the page shell: head, menus, footer, preview banner
 src/components/        Blocks.astro maps block types to components in components/blocks/
 src/lib/api.ts         getContent(): content helpers with the read-only key, drafts in preview
 src/lib/cache.ts       the in-memory page cache that /revalidate empties
-src/lib/headless.ts    generated API types; do not edit, run `npm run generate:types`
+src/lib/headless.ts    generated API types; do not edit, run `{{pm_run}} generate:types`
 src/middleware.ts      page cache, editor-managed redirects, security headers
 astro.config.mjs       server output, Content-Security-Policy, the dev proxy to Django
 ```
@@ -39,5 +39,5 @@ Run them in the `frontend` container (`docker compose exec frontend <command>`):
 
 | Task | Command |
 |------|---------|
-| Type-check | `npm run check` |
-| Test | `npm test` |
+| Type-check | `{{pm_run}} check` |
+| Test | `{{pm_run}} test` |

package/templates/frontend-astro/Dockerfile

@@ -7,10 +7,13 @@ WORKDIR /app
 ENV ASTRO_TELEMETRY_DISABLED=1
 
 FROM base AS deps
-COPY package.json package-lock.json* ./
+{{pm_setup}}
+COPY {{pm_manifests}} ./
 COPY vendor/ vendor/
 # No BuildKit cache mounts: Railway rejects them, and the layer is cached anyway.
-RUN if [ -f package-lock.json ]; then npm ci; else npm install; fi
+RUN {{pm_install}}
+# The package manager only installs: npm, which comes with Node.js, runs
+# the scripts of package.json below.
 
 FROM deps AS dev
 EXPOSE 3000
@@ -21,7 +24,7 @@ CMD ["sh", "-c", "rm -f .astro/dev.json && exec npm run dev"]
 
 FROM deps AS build
 COPY . .
-RUN npm run build && npm prune --omit=dev
+RUN npm run build && {{pm_prune}}
 
 FROM base AS prod
 ENV NODE_ENV=production HOST=0.0.0.0 PORT=3000