create-taserjs 0.0.5 → 0.1.0

package/src/addons/validators.ts

@@ -8,26 +8,23 @@ export const IMPORT_LINES: Record<ValidatorId, string> = {
 };
 
 export const VALIDATION_BLOCK_TEMPLATE: Record<ValidatorId, string> = {
-  zod: `, {
-  query: z.object({ name: z.string() }),
-}`,
-  arktype: `, {
-  query: type({ name: 'string' }),
-}`,
-  valibot: `, {
-  query: v.object({ name: v.string() }),
-}`,
+  zod: `
+  .query(z.object({ name: z.string().default('Taser') }))`,
+  arktype: `
+  .query(type({ 'name?': 'string = "Taser"' }))`,
+  valibot: `
+  .query(v.object({ name: v.optional(v.string(), 'Taser') }))`,
 };
 
-const ROUTE_TEMPLATE = (validator: ValidatorId) => `import { reply } from '@taserjs/router'
-import { t } from '#src/taser.js'
+const ROUTE_TEMPLATE = (validator: ValidatorId) => `import { json } from '@taserjs/router/reply'
+import { t } from '#taserjs/router'
 ${IMPORT_LINES[validator]}
 
-const GET = t.get('/'${VALIDATION_BLOCK_TEMPLATE[validator]})
+const GET = t.get('/')${VALIDATION_BLOCK_TEMPLATE[validator]}
 
 export type RouteContext = typeof GET.$Infer.Context
 export const Route = GET.handler((ctx) => {
-  return reply.json({ message: \`Hello, \${ctx.query.name}!\` })
+  return json({ message: \`Hello, \${ctx.query.name}!\` })
 })
 `;
 

package/src/cli.ts

@@ -11,11 +11,12 @@ async function main(): Promise<void> {
   const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
     options: {
-      type: { type: "string", short: "t" },
-      framework: { type: "string" },
+      preset: { type: "string", short: "p" },
       db: { type: "string" },
       logger: { type: "string" },
       validator: { type: "string" },
+      framework: { type: "string" },
+      runtime: { type: "string" },
       y: { type: "boolean", short: "y" },
       noInstall: { type: "boolean" },
       json: { type: "boolean" },
@@ -25,11 +26,12 @@ async function main(): Promise<void> {
 
   const parsed = buildParsedArgsFromCli(
     {
-      ...(values.type !== undefined ? { type: values.type } : {}),
-      ...(values.framework !== undefined ? { framework: values.framework } : {}),
+      ...(values.preset !== undefined ? { preset: values.preset } : {}),
       ...(values.db !== undefined ? { db: values.db } : {}),
       ...(values.logger !== undefined ? { logger: values.logger } : {}),
       ...(values.validator !== undefined ? { validator: values.validator } : {}),
+      ...(values.framework !== undefined ? { framework: values.framework } : {}),
+      ...(values.runtime !== undefined ? { runtime: values.runtime } : {}),
       ...(values.y !== undefined ? { y: values.y } : {}),
       ...(values.noInstall !== undefined ? { noInstall: values.noInstall } : {}),
       ...(values.json !== undefined ? { json: values.json } : {}),

package/src/commands/create.ts

@@ -11,27 +11,30 @@ import {
 } from "../core/json-output.js";
 import {
   parseDbFlag,
+  parseFrameworkFlag,
   parseLoggerFlag,
-  parseTypeFlag,
+  parsePresetFlag,
+  parseRuntimeFlag,
   parseValidatorFlag,
   type ParsedCreateArgs,
   resolveScaffoldDefaults,
 } from "../core/parse-options.js";
 import { scaffoldProject } from "../core/scaffold-engine.js";
+import { allowedRuntimeOverrides } from "../core/targets.js";
 import type {
   DbDriver,
   DbOdm,
+  DeployTarget,
   LoggerId,
-  ProjectType,
   ScaffoldResult,
   ValidatorId,
 } from "../core/types.js";
-import { DB_DRIVERS, DB_ODMS, LOGGERS, PROJECT_TYPES, VALIDATORS } from "../core/types.js";
+import { DB_DRIVERS, DB_ODMS, DEPLOY_TARGETS, LOGGERS, VALIDATORS } from "../core/types.js";
 import { validateProjectName } from "../core/validate-project-name.js";
 import { resolveUserAgent, runScript } from "../core/package-manager.js";
 
-function isProjectType(value: unknown): value is ProjectType {
-  return typeof value === "string" && (PROJECT_TYPES as readonly string[]).includes(value);
+function isDeployTarget(value: unknown): value is DeployTarget {
+  return typeof value === "string" && (DEPLOY_TARGETS as readonly string[]).includes(value);
 }
 
 function isDbOdm(value: unknown): value is DbOdm {
@@ -67,32 +70,71 @@ async function promptInteractiveOptions(args: ParsedCreateArgs): Promise<ParsedC
     process.exit(0);
   }
 
-  const type =
-    args.type ??
+  const framework =
+    args.framework ??
     (await p.select({
-      message: "Project type (runtime / framework)",
+      message: "Host framework",
       options: [
-        { value: "node", label: "Node.js", hint: "default" },
+        { value: "none", label: "Pure Taser", hint: "default" },
+        { value: "hono", label: "Hono" },
         { value: "express", label: "Express" },
         { value: "fastify", label: "Fastify" },
-        { value: "hono", label: "Hono" },
-        { value: "bun", label: "Bun" },
-        { value: "deno", label: "Deno" },
-        { value: "aws-lambda", label: "AWS Lambda" },
-        { value: "cloudflare-workers", label: "Cloudflare Workers" },
-        { value: "netlify", label: "Netlify" },
-        { value: "vercel", label: "Vercel" },
-        { value: "azure-functions", label: "Azure Functions" },
-        { value: "google-cloud-run", label: "Google Cloud Run" },
       ],
-      initialValue: "node",
+      initialValue: "none",
+    }));
+
+  if (p.isCancel(framework)) {
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
+  }
+
+  const DEPLOY_LABELS: Record<DeployTarget, string> = {
+    "node-server": "Node.js server",
+    "node-cluster": "Node.js cluster",
+    bun: "Bun",
+    "deno-server": "Deno",
+    "deno-deploy": "Deno Deploy",
+    "cloudflare-module": "Cloudflare Workers",
+    vercel: "Vercel",
+    "aws-lambda": "AWS Lambda",
+    netlify: "Netlify",
+  };
+
+  const preset =
+    args.preset ??
+    (await p.select({
+      message: "Deployment target",
+      options: DEPLOY_TARGETS.map((id) => ({ value: id, label: DEPLOY_LABELS[id] })),
+      initialValue: "node-server",
     }));
 
-  if (p.isCancel(type) || !isProjectType(type)) {
+  if (p.isCancel(preset) || !isDeployTarget(preset)) {
     p.cancel("Scaffold cancelled.");
     process.exit(0);
   }
 
+  let runtime: import("../core/types.js").Runtime | undefined;
+  const runtimeOverrides = allowedRuntimeOverrides(preset);
+  if (runtimeOverrides.length > 0) {
+    const runtimeChoice =
+      args.runtime ??
+      (await p.select({
+        message: "Runtime",
+        options: [
+          ...runtimeOverrides.map((rt) => ({ value: rt, label: rt })),
+          { value: "default", label: `Preset default`, hint: "no override" },
+        ],
+        initialValue: "default",
+      }));
+
+    if (p.isCancel(runtimeChoice)) {
+      p.cancel("Scaffold cancelled.");
+      process.exit(0);
+    }
+
+    runtime = runtimeChoice === "default" ? undefined : runtimeChoice;
+  }
+
   const dbChoice =
     args.db ??
     (await p.select({
@@ -182,7 +224,9 @@ async function promptInteractiveOptions(args: ParsedCreateArgs): Promise<ParsedC
 
   return {
     projectName: String(projectName).trim(),
-    type,
+    framework,
+    preset,
+    ...(runtime !== undefined ? { runtime } : {}),
     yes: args.yes,
     noInstall: args.noInstall,
     json: args.json,
@@ -207,7 +251,7 @@ export async function runCreateCommand(
     : {
         ...args,
         projectName: args.projectName?.trim(),
-        type: args.type ?? "node",
+        preset: args.preset ?? "node-server",
       };
 
   if (!resolved.projectName) {
@@ -268,8 +312,9 @@ export async function runCreateCommand(
 
 export function buildParsedArgsFromCli(
   values: {
-    type?: string;
+    preset?: string;
     framework?: string;
+    runtime?: string;
     db?: string;
     logger?: string;
     validator?: string;
@@ -289,9 +334,20 @@ export function buildParsedArgsFromCli(
     args.projectName = positionals[0];
   }
 
-  const typeFlag = values.type ?? values.framework;
-  if (typeFlag) {
-    args.type = parseTypeFlag(typeFlag);
+  if (values.preset) {
+    const parsed = parsePresetFlag(values.preset);
+    args.preset = parsed.preset;
+    if (parsed.warning && !args.json) {
+      console.warn(`warning: ${parsed.warning}`);
+    }
+  }
+
+  if (values.framework) {
+    args.framework = parseFrameworkFlag(values.framework);
+  }
+
+  if (values.runtime) {
+    args.runtime = parseRuntimeFlag(values.runtime);
   }
 
   if (values.db) {

package/src/core/parse-options.ts

@@ -2,20 +2,32 @@ import {
   DB_DRIVERS,
   DB_ODMS,
   DEFAULT_DB_DRIVER,
+  FRAMEWORKS,
   LOGGERS,
-  PROJECT_TYPES,
+  RUNTIMES,
   VALIDATORS,
   type DbDriver,
   type DbOdm,
+  type DeployTarget,
+  type Framework,
   type LoggerId,
-  type ProjectType,
+  type Runtime,
   type ScaffoldContext,
   type ValidatorId,
 } from "./types.js";
+import {
+  DEFAULT_DEPLOY,
+  isCuratedDeploy,
+  resolveDeployEntry,
+  validateCombination,
+} from "./targets.js";
 
 export type ParsedCreateArgs = {
   projectName?: string;
-  type?: ProjectType;
+  framework?: Framework;
+  /** Deployment target — a Nitro preset id. */
+  preset?: string;
+  runtime?: Runtime;
   db?: DbOdm;
   driver?: DbDriver;
   logger?: LoggerId;
@@ -25,8 +37,12 @@ export type ParsedCreateArgs = {
   json: boolean;
 };
 
-function isProjectType(value: string): value is ProjectType {
-  return (PROJECT_TYPES as readonly string[]).includes(value);
+function isFramework(value: string): value is Framework {
+  return (FRAMEWORKS as readonly string[]).includes(value);
+}
+
+function isRuntime(value: string): value is Runtime {
+  return (RUNTIMES as readonly string[]).includes(value);
 }
 
 function isDbOdm(value: string): value is DbOdm {
@@ -64,41 +80,33 @@ export function parseDbFlag(value: string): { db: DbOdm; driver: DbDriver } {
   return { db: odm, driver };
 }
 
-export function resolveScaffoldDefaults(args: ParsedCreateArgs): ScaffoldContext {
-  const type = args.type ?? "node";
-  const db = args.db;
-  const logger = args.logger;
-  const validator = args.validator;
-
-  if (!args.projectName) {
-    throw new Error("Project name is required");
-  }
-
-  const result: ScaffoldContext = {
-    projectName: args.projectName.trim(),
-    targetDir: "",
-    type,
-  };
-
-  if (db) {
-    result.db = db;
-    result.driver = args.driver ?? DEFAULT_DB_DRIVER;
-  }
-
-  if (logger) {
-    result.logger = logger;
+export function parseFrameworkFlag(value: string): Framework {
+  if (!isFramework(value)) {
+    throw new Error(`Invalid --framework "${value}". Use ${FRAMEWORKS.join(", ")}.`);
   }
+  return value;
+}
 
-  if (validator) {
-    result.validator = validator;
+/**
+ * Accepts curated deploy targets verbatim; unknown ids pass through to Nitro.
+ * Returns a warning for passthrough ids so callers can surface it.
+ */
+export function parsePresetFlag(value: string): { preset: string; warning?: string } {
+  if (!isCuratedDeploy(value)) {
+    if (!/^[a-z0-9][a-z0-9-_]*$/i.test(value)) {
+      throw new Error(`Invalid --preset "${value}".`);
+    }
+    return {
+      preset: value,
+      warning: `"${value}" is not a curated Taser deploy target; passing it through to Nitro as-is.`,
+    };
   }
-
-  return result;
+  return { preset: value };
 }
 
-export function parseTypeFlag(value: string): ProjectType {
-  if (!isProjectType(value)) {
-    throw new Error(`Invalid --type "${value}". Use ${PROJECT_TYPES.join(", ")}.`);
+export function parseRuntimeFlag(value: string): Runtime {
+  if (!isRuntime(value)) {
+    throw new Error(`Invalid --runtime "${value}". Use node, bun, or deno.`);
   }
   return value;
 }
@@ -116,3 +124,44 @@ export function parseValidatorFlag(value: string): ValidatorId {
   }
   return value;
 }
+
+export function resolveScaffoldDefaults(args: ParsedCreateArgs): ScaffoldContext {
+  const framework: Framework = args.framework ?? "none";
+  const preset = args.preset ?? DEFAULT_DEPLOY;
+
+  if (!args.projectName) {
+    throw new Error("Project name is required");
+  }
+
+  // Throws with a precise reason when runtime × framework × deploy clash.
+  const combination = validateCombination(args.runtime, framework, preset);
+  if (!combination.ok) {
+    throw new Error(combination.reason);
+  }
+
+  const result: ScaffoldContext = {
+    projectName: args.projectName.trim(),
+    targetDir: "",
+    framework,
+    preset: preset as DeployTarget,
+    ...(args.runtime !== undefined ? { runtime: args.runtime } : {}),
+  };
+
+  if (args.db) {
+    result.db = args.db;
+    result.driver = args.driver ?? DEFAULT_DB_DRIVER;
+  }
+
+  if (args.logger) {
+    result.logger = args.logger;
+  }
+
+  if (args.validator) {
+    result.validator = args.validator;
+  }
+
+  return result;
+}
+
+/** Re-exported for CLI layers that need to warn about passthrough presets. */
+export { resolveDeployEntry };

package/src/core/project-config.ts

@@ -5,9 +5,14 @@ import type { ScaffoldContext } from "./types.js";
 
 export async function writeProjectConfig(root: string, ctx: ScaffoldContext): Promise<void> {
   const config: Record<string, string> = {
-    type: ctx.type,
+    framework: ctx.framework ?? "none",
+    preset: ctx.preset ?? "node-server",
   };
 
+  if (ctx.runtime) {
+    config.runtime = ctx.runtime;
+  }
+
   if (ctx.db) {
     config.db = ctx.db;
     if (ctx.driver) {

package/src/core/resolve-packages.ts

@@ -1,83 +1,52 @@
 import { resolveAddons } from "../addons/registry.js";
-import type { PackageGroups, ProjectType, ScaffoldContext } from "../core/types.js";
-
-function typePackages(type: ProjectType): PackageGroups {
-  const dependencies = ["@taserjs/router", "dotenv"];
-  const devDependencies = [
-    "@taserjs/router-cli",
-    "npm-run-all2",
-    "tsdown",
-    "tsx",
-    "typescript@^5.9.3",
-    "@types/node",
-  ];
-  const scripts: Record<string, string> = {};
-
-  switch (type) {
-    case "express":
-      dependencies.push("@taserjs/adapter-express", "express");
-      devDependencies.push("@types/express");
-      break;
-    case "fastify":
-      dependencies.push("@taserjs/adapter-fastify", "fastify");
-      break;
-    case "hono":
-      dependencies.push("@hono/node-server", "hono");
-      break;
+import { FRAMEWORK_ENTRIES } from "../frameworks/index.js";
+import type { PackageGroups, ScaffoldContext } from "../core/types.js";
+import { resolveDeployEntry } from "./targets.js";
+
+const BASE_DEPENDENCIES = ["@taserjs/router", "dotenv"];
+
+/** Runtime-agnostic build/dev tooling every scaffolded project needs. */
+const BASE_DEV_DEPENDENCIES = [
+  "@taserjs/router-plugin",
+  "nitro",
+  "typescript@^5.9.3",
+  "vite@^8.1.5",
+];
+
+function runtimeDevDeps(ctx: ScaffoldContext): string[] {
+  const { entry } = resolveDeployEntry(ctx.preset ?? "node-server");
+  const effective = ctx.runtime ?? entry.impliedRuntime;
+  switch (effective) {
     case "bun":
-      // Bun has native TypeScript and runtime execution
-      devDependencies.push("@types/bun");
-      scripts["dev:server"] = "bun --watch src/index.ts";
-      scripts.start = "bun src/index.ts";
-      scripts.serve = "bun dist/index.mjs";
-      break;
+      return ["@types/bun"];
     case "deno":
-      scripts["dev:server"] = "deno run --watch --allow-net --allow-env --allow-read src/index.ts";
-      scripts.start = "deno run --allow-net --allow-env --allow-read src/index.ts";
-      scripts.serve = "deno run --allow-net --allow-env --allow-read dist/index.mjs";
-      break;
-    case "aws-lambda":
-      dependencies.push("hono");
-      devDependencies.push("@types/aws-lambda");
-      break;
-    case "cloudflare-workers": {
-      // Cloudflare workers uses wrangler
-      const cfDevDeps = devDependencies.filter((d) => d !== "tsx");
-      cfDevDeps.push("wrangler", "@cloudflare/workers-types");
-      devDependencies.length = 0;
-      devDependencies.push(...cfDevDeps);
-      scripts["dev:server"] = "wrangler dev";
-      scripts.deploy = "wrangler deploy";
-      break;
-    }
-    case "netlify":
-      dependencies.push("hono", "@netlify/functions");
-      break;
-    case "vercel":
-      dependencies.push("hono");
-      devDependencies.push("@vercel/node");
-      break;
-    case "azure-functions":
-      dependencies.push("hono", "@azure/functions", "@marplex/hono-azurefunc-adapter");
-      break;
-    case "google-cloud-run":
+      return []; // Deno ships its own tooling and types.
+    case "workerd":
+      return ["@cloudflare/workers-types"];
     case "node":
     default:
-      dependencies.push("@hono/node-server");
-      break;
+      return ["@types/node"];
   }
-
-  return { dependencies, devDependencies, scripts };
 }
 
 export function resolvePackages(ctx: ScaffoldContext): PackageGroups {
-  const base = typePackages(ctx.type);
-  const addons = resolveAddons(ctx);
+  const frameworkEntry = FRAMEWORK_ENTRIES[ctx.framework ?? "none"];
+  const { entry: deployEntry } = resolveDeployEntry(ctx.preset ?? "node-server");
 
-  const dependencies = [...base.dependencies];
-  const devDependencies = [...base.devDependencies];
-  const scripts = { ...base.scripts };
+  const dependencies = [...BASE_DEPENDENCIES, ...frameworkEntry.deps];
+  const devDependencies = [
+    ...BASE_DEV_DEPENDENCIES,
+    ...runtimeDevDeps(ctx),
+    ...deployEntry.devDeps,
+    ...frameworkEntry.devDeps,
+  ];
+
+  const scripts: Record<string, string> = {};
+  if (deployEntry.startScript) {
+    scripts.start = deployEntry.startScript;
+  }
 
+  const addons = resolveAddons(ctx);
   for (const addon of addons) {
     dependencies.push(...addon.dependencies(ctx));
     devDependencies.push(...addon.devDependencies(ctx));
@@ -92,10 +61,3 @@ export function resolvePackages(ctx: ScaffoldContext): PackageGroups {
     scripts,
   };
 }
-
-export function getPackageGroups(
-  type: ProjectType,
-): Omit<PackageGroups, "scripts"> & { scripts?: Record<string, string> } {
-  const groups = typePackages(type);
-  return groups;
-}