@pauldvlp/vp-react-ts-nestjs 0.1.0 → 0.2.0

package/README.md

@@ -16,8 +16,7 @@ The api rides Vite+'s native **Oxc** transform, which emits `emitDecoratorMetada
 the production build is a Vite SSR bundle (`dist/main.js`), and a single `vp check` / `vp test` /
 `vp run -r build` covers the whole workspace.
 
-It's a [Bingo](https://create.bingo) template, so options can be passed on the `vp create` command line
-(anything after `--`).
+Options can be passed on the `vp create` command line (anything after `--`) or answered interactively.
 
 ## Usage
 
@@ -32,9 +31,8 @@ vp create @pauldvlp:vp-react-ts-nestjs -- \
   --name my-app --scope @acme --apiPort 3000 --webPort 5173
 ```
 
-> Only **string** options parse reliably as `vp create -- --flag value`. **Boolean** options
-> (`--swagger`, `--serveWeb`, `--docker`, `--install`) are best left to the interactive prompt — Bingo's
-> CLI does not accept `--no-x` / `--x=false` cleanly. Omit them and answer the prompt.
+> **Boolean** options (`--swagger`, `--serveWeb`, `--docker`, `--install`) accept both forms: pass
+> `--swagger` to enable or `--no-swagger` to disable. Omit any option to answer it at the interactive prompt.
 
 ## Options
 

package/dist/index.js

@@ -1,15 +1,10 @@
 #!/usr/bin/env node
 
-// bin/index.ts
-import { runTemplateCLI } from "bingo";
-
-// src/template.ts
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
-
 // ../template-kit/src/index.ts
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import * as prompts from "@clack/prompts";
 var RENAME = {
   _gitignore: ".gitignore",
   _dockerignore: ".dockerignore",
@@ -19,6 +14,10 @@ function toScope(name) {
   const n = name.trim();
   return n.startsWith("@") ? n : `@${n}`;
 }
+function dirName(directory) {
+  const base = path.basename(directory || "");
+  return base && base !== "." ? base : "my-app";
+}
 function readTree(dir, transform, base = dir) {
   const out = {};
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -43,15 +42,178 @@ function patchJson(tree, relPath, mutate) {
   node[key] = `${JSON.stringify(json, null, 2)}
 `;
 }
+function defineTemplate(config) {
+  return config;
+}
+function writeTree(node, dir) {
+  for (const [name, value] of Object.entries(node)) {
+    const p = path.join(dir, name);
+    if (typeof value === "string") {
+      fs.mkdirSync(path.dirname(p), { recursive: true });
+      fs.writeFileSync(p, value);
+    } else {
+      fs.mkdirSync(p, { recursive: true });
+      writeTree(value, p);
+    }
+  }
+}
+function parseArgv(argv, descriptors) {
+  const booleanKeys = new Set(descriptors.filter((d) => d.type === "boolean").map((d) => d.key));
+  const values = {};
+  let directory;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    let body = arg.slice(2);
+    if (body.startsWith("no-") && booleanKeys.has(body.slice(3))) {
+      values[body.slice(3)] = false;
+      continue;
+    }
+    let inline;
+    const eq = body.indexOf("=");
+    if (eq !== -1) {
+      inline = body.slice(eq + 1);
+      body = body.slice(0, eq);
+    }
+    if (body === "directory") {
+      directory = inline ?? argv[++i];
+      continue;
+    }
+    if (booleanKeys.has(body)) {
+      values[body] = inline === void 0 ? true : inline !== "false";
+      continue;
+    }
+    values[body] = inline ?? argv[++i] ?? "";
+  }
+  return { values, directory };
+}
+function resolveDefault(d, options, directory) {
+  return typeof d.default === "function" ? d.default({ options, directory }) : d.default;
+}
+async function promptForOption(d, def) {
+  if (d.type === "boolean") {
+    return prompts.confirm({ message: d.message, initialValue: def === void 0 ? false : Boolean(def) });
+  }
+  if (d.type === "select") {
+    return prompts.select({
+      message: d.message,
+      options: (d.choices ?? []).map((c) => ({ value: c, label: c })),
+      initialValue: def
+    });
+  }
+  const fallback = def === void 0 ? void 0 : String(def);
+  return prompts.text({
+    message: d.message,
+    placeholder: fallback,
+    defaultValue: fallback,
+    // When a default exists, an empty submit means "use the default" — don't run validation on it,
+    // otherwise a rule like the port check would reject pressing Enter to accept 3000.
+    validate: d.validate ? (value) => !value && fallback !== void 0 ? void 0 : d.validate(value ?? "") : void 0
+  });
+}
+function printHelp(template) {
+  const lines = [];
+  if (template.about?.name) lines.push(template.about.name);
+  if (template.about?.description) lines.push(template.about.description);
+  lines.push("", "Options:", "  --directory <dir>      Where to scaffold");
+  for (const d of template.options) {
+    const hint = d.type === "select" && d.choices ? ` <${d.choices.join("|")}>` : d.type === "boolean" ? ` / --no-${d.key}` : " <value>";
+    lines.push(`  --${d.key}${hint}      ${d.message}`);
+  }
+  console.log(lines.join("\n"));
+}
+function initGit(dir) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir, stdio: "ignore" });
+    return;
+  } catch {
+  }
+  try {
+    execFileSync("git", ["init"], { cwd: dir, stdio: "ignore" });
+    execFileSync("git", ["add", "-A"], { cwd: dir, stdio: "ignore" });
+    let identity = [];
+    try {
+      execFileSync("git", ["config", "user.email"], { cwd: dir, stdio: "ignore" });
+    } catch {
+      identity = ["-c", "user.name=create", "-c", "user.email=create@users.noreply.github.com"];
+    }
+    execFileSync("git", [...identity, "commit", "-m", "feat: initialize project", "--no-gpg-sign"], { cwd: dir, stdio: "ignore" });
+  } catch {
+  }
+}
+async function runTemplateCLI(template) {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printHelp(template);
+    return 0;
+  }
+  const interactive = Boolean(process.stdout.isTTY) && !argv.includes("--no-interactive");
+  const { values, directory: dirArg } = parseArgv(argv, template.options);
+  prompts.intro(template.about?.name ?? "create");
+  let directory = dirArg;
+  if (!directory) {
+    if (interactive) {
+      const answer = await prompts.text({ message: "Where should we create your project?", placeholder: "my-app", defaultValue: "my-app" });
+      if (prompts.isCancel(answer)) {
+        prompts.cancel("Cancelled.");
+        return 2;
+      }
+      directory = answer || "my-app";
+    } else {
+      directory = "my-app";
+    }
+  }
+  const options = {};
+  for (const d of template.options) {
+    const def = resolveDefault(d, options, directory);
+    if (d.key in values) {
+      const value = values[d.key];
+      if (d.validate && typeof value === "string") {
+        const error = d.validate(value);
+        if (error) {
+          prompts.cancel(`Invalid --${d.key}: ${error}`);
+          return 1;
+        }
+      }
+      options[d.key] = value;
+      continue;
+    }
+    if (interactive) {
+      const answer = await promptForOption(d, def);
+      if (prompts.isCancel(answer)) {
+        prompts.cancel("Cancelled.");
+        return 2;
+      }
+      options[d.key] = answer === "" && def !== void 0 ? def : answer;
+    } else {
+      options[d.key] = def;
+    }
+  }
+  const creation = await template.produce({ options });
+  writeTree(creation.files, directory);
+  if (creation.scripts?.length) {
+    for (const step of [...creation.scripts].sort((a, b) => a.phase - b.phase)) {
+      for (const command of step.commands) {
+        execFileSync(command, { cwd: directory, stdio: "inherit", shell: true });
+      }
+    }
+  }
+  if (template.git !== false) initGit(directory);
+  if (creation.suggestions?.length) {
+    prompts.note(creation.suggestions.join("\n"), "Next steps");
+  }
+  prompts.outro("Done!");
+  return 0;
+}
 
 // src/template.ts
-import { createTemplate } from "bingo";
-import { z } from "zod";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
 
 // package.json
 var package_default = {
   name: "@pauldvlp/vp-react-ts-nestjs",
-  version: "0.1.0",
+  version: "0.2.0",
   description: "Vite+ monorepo template: a React web app + a NestJS api (conformed to the Vite+ toolchain) sharing Zod contracts.",
   author: "pauldvlp (https://github.com/pauldvlp/vp-templates)",
   license: "MIT",
@@ -81,8 +243,7 @@ var package_default = {
     prepack: "pnpm run build"
   },
   dependencies: {
-    bingo: "^0.9.3",
-    zod: "^3.25.76"
+    "@clack/prompts": "^1.6.0"
   },
   devDependencies: {
     "@pauldvlp/template-kit": "workspace:*",
@@ -96,6 +257,9 @@ var package_default = {
 };
 
 // src/template.ts
+function validatePort(value) {
+  return /^\d+$/.test(value) && Number(value) > 0 && Number(value) < 65536 ? void 0 : "must be a number between 1 and 65535";
+}
 var TEMPLATE_DIR = path2.join(path2.dirname(fileURLToPath(import.meta.url)), "..", "template");
 var MAIN_TS = path2.join("apps", "api", "src", "main.ts");
 var SWAGGER_IMPORT = "import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger'";
@@ -108,34 +272,28 @@ var SERVEWEB_MODULE = [
   "      exclude: ['/api/*path']",
   "    }),"
 ].join("\n");
-function applyDocBlock(text, tag, keep) {
-  return keep ? text.replace(new RegExp(`^<!-- ${tag}:(START|END) -->\\n`, "gm"), "") : text.replace(new RegExp(`<!-- ${tag}:START -->\\n[\\s\\S]*?<!-- ${tag}:END -->\\n`, "g"), "");
+function applyDocBlock(text2, tag, keep) {
+  return keep ? text2.replace(new RegExp(`^<!-- ${tag}:(START|END) -->\\n`, "gm"), "") : text2.replace(new RegExp(`<!-- ${tag}:START -->\\n[\\s\\S]*?<!-- ${tag}:END -->\\n`, "g"), "");
 }
-var template_default = createTemplate({
+var template_default = defineTemplate({
   about: {
     name: package_default.name,
     description: package_default.description
   },
-  options: {
-    name: z.string().describe("Root project / package name").default("my-app"),
-    scope: z.string().describe("npm scope for workspace packages, e.g. @acme (defaults to @<name>)"),
-    // Ports are strings, not z.number(): Bingo's clack prompt renders an option's default as a text
-    // placeholder and calls `.slice` on it, which throws for non-string defaults. They're only ever
-    // substituted into config files as text anyway.
-    apiPort: z.string().describe("Port the NestJS api listens on").default("3000"),
-    webPort: z.string().describe("Port the web dev server listens on").default("5173"),
-    swagger: z.boolean().describe("Expose Swagger UI at /docs on the api").default(false),
-    serveWeb: z.boolean().describe("Have the api serve the built web app (single deployable)").default(false),
-    docker: z.boolean().describe("Add a multi-stage Dockerfile for the api").default(false),
-    install: z.boolean().describe("Install deps after scaffolding").default(true)
-  },
-  // Lazily default the package scope to `@<name>` (prefixing `@` unless the name already has one),
-  // so it tracks the project name instead of a fixed value. Falls back to `@app` when no name is set.
-  prepare({ options }) {
-    return {
-      scope: () => options.name ? toScope(options.name) : "@app"
-    };
-  },
+  options: [
+    // Default the name to the target directory the user chose, so they don't retype it.
+    { key: "name", type: "string", message: "Root project / package name", default: ({ directory }) => dirName(directory) },
+    // Lazily default the package scope to `@<name>` (prefixing `@` unless the name already has one),
+    // so it tracks the project name instead of a fixed value. Falls back to `@app` when no name is set.
+    { key: "scope", type: "string", message: "npm scope for workspace packages, e.g. @acme (defaults to @<name>)", default: ({ options }) => options.name ? toScope(options.name) : "@app" },
+    // Ports stay strings (validated as integers): they're only ever substituted into config files as text.
+    { key: "apiPort", type: "string", message: "Port the NestJS api listens on", default: "3000", validate: validatePort },
+    { key: "webPort", type: "string", message: "Port the web dev server listens on", default: "5173", validate: validatePort },
+    { key: "swagger", type: "boolean", message: "Expose Swagger UI at /docs on the api", default: false },
+    { key: "serveWeb", type: "boolean", message: "Have the api serve the built web app (single deployable)", default: false },
+    { key: "docker", type: "boolean", message: "Add a multi-stage Dockerfile for the api", default: false },
+    { key: "install", type: "boolean", message: "Install deps after scaffolding", default: true }
+  ],
   async produce({ options }) {
     const scope = toScope(options.scope || options.name || "app");
     const swaggerSetup = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pauldvlp/vp-react-ts-nestjs",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Vite+ monorepo template: a React web app + a NestJS api (conformed to the Vite+ toolchain) sharing Zod contracts.",
   "author": "pauldvlp (https://github.com/pauldvlp/vp-templates)",
   "license": "MIT",
@@ -24,8 +24,7 @@
     "template"
   ],
   "dependencies": {
-    "bingo": "^0.9.3",
-    "zod": "^3.25.76"
+    "@clack/prompts": "^1.6.0"
   },
   "devDependencies": {
     "@types/node": "^24",

package/template/apps/api/package.json

@@ -19,7 +19,7 @@
     "pino-http": "^10",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "zod": "^3.25.76"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@nestjs/testing": "^11",

package/template/apps/api/src/common/zod-validation.pipe.ts

@@ -1,16 +1,16 @@
 import { BadRequestException, type PipeTransform } from '@nestjs/common'
-import type { ZodSchema } from 'zod'
+import { flattenError, type ZodMiniType } from 'zod/v4-mini'
 
 /**
  * Minimal, zero-dependency bridge between Zod and Nest's pipe system. Use it per-route against a
  * schema from `@app/contracts`, e.g. `@Body(new ZodValidationPipe(createItemSchema)) body: CreateItem`.
  */
 export class ZodValidationPipe<T> implements PipeTransform {
-  constructor(private readonly schema: ZodSchema<T>) {}
+  constructor(private readonly schema: ZodMiniType<T>) {}
 
   transform(value: unknown): T {
     const result = this.schema.safeParse(value)
-    if (!result.success) throw new BadRequestException(result.error.flatten())
+    if (!result.success) throw new BadRequestException(flattenError(result.error))
     return result.data
   }
 }

package/template/apps/api/src/config/env.ts

@@ -1,9 +1,9 @@
-import { z } from 'zod'
+import * as z from 'zod/v4-mini'
 
 /** Validate `process.env` at boot — the app fails fast with a clear error if something is missing. */
 export const envSchema = z.object({
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
-  PORT: z.coerce.number().default(__API_PORT__)
+  NODE_ENV: z._default(z.enum(['development', 'production', 'test']), 'development'),
+  PORT: z._default(z.coerce.number(), __API_PORT__)
 })
 
 export type Env = z.infer<typeof envSchema>

package/template/packages/contracts/package.json

@@ -13,7 +13,7 @@
     "check": "vp check"
   },
   "dependencies": {
-    "zod": "^3.25.76"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "catalog:",

package/template/packages/contracts/src/index.ts

@@ -1,18 +1,19 @@
-import { z } from 'zod'
+import * as z from 'zod/v4-mini'
 
 /**
  * Shared API contracts. Both ends import from here so there is a single source of truth:
  * the api validates request bodies against these schemas (via the ZodValidationPipe) and the
- * web app uses the inferred types to type its `fetch` responses.
+ * web app uses the inferred types to type its `fetch` responses. Zod Mini keeps the bundle small
+ * for the shared package — its functional API (`z.pick`, `.check(...)`) replaces the chained methods.
  */
 
 export const itemSchema = z.object({
   id: z.string(),
-  name: z.string().min(1),
+  name: z.string().check(z.minLength(1)),
   createdAt: z.string()
 })
 
-export const createItemSchema = itemSchema.pick({ name: true })
+export const createItemSchema = z.pick(itemSchema, { name: true })
 
 export type Item = z.infer<typeof itemSchema>
 export type CreateItem = z.infer<typeof createItemSchema>