create-archlast-forge 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-archlast-forge",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Create an archlast-forge project: a full-stack app or a backend, with the services you choose.",
   "license": "MIT",
   "repository": {

package/src/cli.ts

@@ -66,7 +66,7 @@ export async function gather(flags: Flags, interactive: boolean, io: Io = {}): P
       ? await ask<StackService[]>((o) =>
           p.multiselect<StackService>({
             ...o,
-            message: mode === "backend" ? "Which services should run with it? (space selects, enter confirms)" : "Add services to the stack? (none is fine: SQLite needs nothing)",
+            message: "Which services will production need? (space selects, enter confirms; none keeps SQLite, with no database container)",
             required: false,
             initialValues: DEFAULT_SERVICES[mode],
             options: (Object.keys(SERVICES) as StackService[]).map((s) => ({ value: s, label: SERVICES[s].label, hint: SERVICES[s].hint })),

package/src/options.ts

@@ -22,7 +22,7 @@ export const USAGE = `Usage: bun create archlast-forge [directory] [options]
   -y, --yes                    take the default for everything not given, and ask nothing
   -h, --help
 
-Without options you are asked. Defaults: framework mode with no extra services (SQLite);
+Without options you are asked. Defaults: framework mode with postgres, redis, s3 and caddy;
 backend mode with postgres, redis and s3.`;
 
 export function parseFlags(argv: string[]): Flags {

package/src/stack.ts

@@ -16,8 +16,8 @@ export const SERVICES = {
 } as const;
 export type StackService = keyof typeof SERVICES;
 
-/** Services a mode starts with. A backend is usually shared by several clients, so it gets the whole stack. */
-export const DEFAULT_SERVICES: Record<Mode, StackService[]> = { framework: [], backend: ["postgres", "redis", "s3"] };
+/** Services a mode starts with: what a production deployment needs. An app gets HTTPS too; a backend is usually put behind a proxy of its own. */
+export const DEFAULT_SERVICES: Record<Mode, StackService[]> = { framework: ["postgres", "redis", "s3", "caddy"], backend: ["postgres", "redis", "s3"] };
 
 /** archlast-forge.json */
 export interface ProjectConfig {
@@ -74,9 +74,10 @@ export function renderEnv(services: StackService[], secrets?: Secrets): string {
     "# Opens the dashboard (/_dashboard) and the CLI's data commands.",
     `ADMIN_KEY=${v("ADMIN_KEY")}`,
     "",
-    "# The address people use to reach the app.",
-    has("caddy") ? "BETTER_AUTH_URL=https://${DOMAIN}" : "BETTER_AUTH_URL=http://localhost:3000",
-    ...(has("caddy") ? ["# Your domain; point its DNS (and s3.<domain>) at this machine.", "DOMAIN=localhost"] : ["# Plain http is only for trying things out; remove this once BETTER_AUTH_URL is https.", "ALLOW_INSECURE_HTTP=1", "PORT=3000"]),
+    // DOMAIN comes first: Compose fills ${DOMAIN} only from lines above the one that uses it.
+    ...(has("caddy")
+      ? ["# Your domain; point its DNS (and s3.<domain>) at this machine.", "DOMAIN=localhost", "", "# The address people use to reach the app.", "BETTER_AUTH_URL=https://${DOMAIN}"]
+      : ["# The address people use to reach the app.", "BETTER_AUTH_URL=http://localhost:3000", "# Plain http is only for trying things out; remove this once BETTER_AUTH_URL is https.", "ALLOW_INSECURE_HTTP=1", "PORT=3000"]),
   ];
   if (has("postgres")) lines.push("", "POSTGRES_PASSWORD=" + v("POSTGRES_PASSWORD"));
   if (has("s3")) lines.push("", `S3_ACCESS_KEY=${v("S3_ACCESS_KEY")}`, `S3_SECRET_KEY=${v("S3_SECRET_KEY")}`, "# Where browsers upload to and download from.", has("caddy") ? "S3_PUBLIC_ENDPOINT=https://s3.${DOMAIN}" : "S3_PUBLIC_ENDPOINT=http://localhost:9000");

package/template/backend/README.md

@@ -36,4 +36,4 @@ bun run logs
 bun run down     # stops it; data stays in Docker volumes
 ```
 
-`compose.yaml` is the stack. It is yours to edit. Secrets live in `.env`, which `up` creates and git ignores; `.env.example` lists the keys. To put it on a server, copy the project there and run `bun run up` (or `docker compose up -d --build`).
+`compose.yaml` is the stack. It is yours to edit. Secrets live in `.env`, which `init` created with fresh keys and git ignores (`up` makes one only if it's missing); `.env.example` lists the keys. To put it on a server, copy the project there and run `bun run up` (or `docker compose up -d --build`).

package/template/base/forge/package.json

@@ -4,5 +4,8 @@
   "type": "module",
   "dependencies": {
     "@archlast/forge-runtime": "^__VERSION__"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.3"
   }
 }

package/template/base/forge/tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "target": "ES2023",
     "lib": ["ES2023", "DOM"],
+    "types": ["bun"],
     "module": "ESNext",
     "moduleResolution": "bundler",
     "strict": true,

package/template/framework/README.md

@@ -7,6 +7,8 @@ bun install
 bun run dev      # http://localhost:3000, reloading as you edit
 ```
 
+`dev` starts the services in `archlast-forge.json` (PostgreSQL, Redis, S3 storage) in Docker. `bun run dev -- --no-docker` skips them and uses SQLite.
+
 ## Where things are
 
 ```
@@ -30,4 +32,6 @@ bun run up       # builds the image, starts the stack from compose.yaml, waits u
 bun run down
 ```
 
-`bun run build && bun run start` runs the production bundles on this machine without Docker. `compose.yaml` is yours to edit; secrets are in `.env`, which `up` creates and git ignores.
+`compose.yaml` runs the app with PostgreSQL, Redis, S3 storage (RustFS) and Caddy, which serves HTTPS on ports 80 and 443. Before the first real deploy, open `.env` and set `DOMAIN` to your domain, and point its DNS and `s3.<domain>` at the machine. Caddy then gets the certificates itself.
+
+`bun run build && bun run start` runs the production bundles on this machine without Docker. `compose.yaml` is yours to edit; secrets are in `.env`, which `init` created with fresh keys and git ignores (`up` makes one only if it's missing).