create-taserjs 0.0.6 → 0.1.1

package/src/core/resolve-packages.ts

@@ -1,83 +1,53 @@
 import { resolveAddons } from "../addons/registry.js";
-import type { PackageGroups, ProjectType, ScaffoldContext } from "../core/types.js";
+import { FRAMEWORK_ENTRIES } from "../frameworks/index.js";
+import type { PackageGroups, ScaffoldContext } from "../core/types.js";
+import { resolveDeployEntry } from "./targets.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> = {};
+const BASE_DEPENDENCIES = ["@taserjs/router", "dotenv", "srvx"];
+
+/** Runtime-agnostic build/dev tooling every scaffolded project needs. */
+const BASE_DEV_DEPENDENCIES = ["@taserjs/router-plugin", "typescript@^5.9.3", "vite@^8.1.5"];
 
-  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;
+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, ...frameworkEntry.deps];
+  const nitroDevDeps = ctx.preset === "none" ? [] : ["nitro"];
+  const devDependencies = [
+    ...BASE_DEV_DEPENDENCIES,
+    ...nitroDevDeps,
+    ...runtimeDevDeps(ctx),
+    ...deployEntry.devDeps,
+    ...frameworkEntry.devDeps,
+  ];
 
-  const dependencies = [...base.dependencies];
-  const devDependencies = [...base.devDependencies];
-  const scripts = { ...base.scripts };
+  const scripts: Record<string, string> = {};
+  if (deployEntry.startScript) {
+    if (ctx.preset === "none" && ctx.runtime === "bun") {
+      scripts.start = "bun dist/serve.mjs";
+    } else {
+      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 +62,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;
-}

package/src/core/scaffold-engine.ts

@@ -2,11 +2,13 @@ import { copyFile, mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 import { collectBootBindings, resolveAddons } from "../addons/registry.js";
-import { indexTemplate, taserTsTemplate } from "../frameworks/index.js";
+import { nitroConfigTemplate, taserTsTemplate, viteConfigTemplate } from "../frameworks/index.js";
 import { installPackages, resolveUserAgent } from "./package-manager.js";
 import { writeProjectConfig } from "./project-config.js";
 import { resolvePackages } from "./resolve-packages.js";
-import type { ScaffoldOptions, ScaffoldResult } from "./types.js";
+import { resolveDeployEntry, validateCombination } from "./targets.js";
+import { FRAMEWORK_ENTRIES } from "../frameworks/index.js";
+import type { ScaffoldContext, ScaffoldOptions, ScaffoldResult } from "./types.js";
 import {
   contextTemplate,
   gitignoreTemplate,
@@ -14,9 +16,7 @@ import {
   indexRouteTemplate,
   packageJsonTemplate,
   rootLayoutTemplate,
-  starterManifestTemplate,
   tsconfigTemplate,
-  tsdownConfigTemplate,
 } from "../templates/base.js";
 
 async function write(filePath: string, contents: string): Promise<void> {
@@ -26,10 +26,23 @@ async function write(filePath: string, contents: string): Promise<void> {
 
 export async function scaffoldProject(options: ScaffoldOptions): Promise<ScaffoldResult> {
   const root = options.targetDir;
-  const ctx = {
+  const preset = options.preset ?? "node-server";
+  const framework = options.framework ?? "none";
+
+  // Guards direct/library callers; the CLI path is validated earlier in
+  // resolveScaffoldDefaults. Throws with a precise reason on impossible
+  // runtime × framework × deploy combinations.
+  const combination = validateCombination(options.runtime, framework, preset);
+  if (!combination.ok) {
+    throw new Error(combination.reason);
+  }
+
+  const ctx: ScaffoldContext = {
     projectName: options.projectName,
     targetDir: root,
-    type: options.type,
+    framework,
+    preset,
+    ...(options.runtime !== undefined ? { runtime: options.runtime } : {}),
     ...(options.db ? { db: options.db, driver: options.driver } : {}),
     ...(options.logger ? { logger: options.logger } : {}),
     ...(options.validator ? { validator: options.validator } : {}),
@@ -38,79 +51,42 @@ export async function scaffoldProject(options: ScaffoldOptions): Promise<Scaffol
   const addons = resolveAddons(ctx);
   const packages = resolvePackages(ctx);
   const bootBindings = collectBootBindings(ctx);
+  const frameworkEntry = FRAMEWORK_ENTRIES[framework];
+  const { entry: deployEntry } = resolveDeployEntry(ctx.preset ?? "node-server");
 
   await write(
     path.join(root, "package.json"),
     packageJsonTemplate(options.projectName, packages.scripts),
   );
   await write(path.join(root, "tsconfig.json"), tsconfigTemplate());
-  await write(path.join(root, "tsdown.config.ts"), tsdownConfigTemplate());
+  await write(path.join(root, "vite.config.ts"), viteConfigTemplate(ctx.preset));
   await write(path.join(root, ".gitignore"), gitignoreTemplate());
   await write(path.join(root, "src/context.ts"), contextTemplate(bootBindings));
-  await write(path.join(root, "src/taser.ts"), taserTsTemplate(options.type));
-  await write(path.join(root, "src/index.ts"), indexTemplate(options.type));
+  await write(path.join(root, "src/taser.ts"), taserTsTemplate());
   await write(path.join(root, "src/routes/$.ts"), rootLayoutTemplate());
   await write(path.join(root, "src/routes/index.get.ts"), indexRouteTemplate());
   await write(path.join(root, "src/routes/health.get.ts"), healthRouteTemplate(ctx));
-  await write(path.join(root, "src/routeManifest.gen.ts"), starterManifestTemplate());
-
-  if (options.type === "cloudflare-workers") {
-    await write(
-      path.join(root, "wrangler.jsonc"),
-      JSON.stringify(
-        {
-          $schema: "node_modules/wrangler/config-schema.json",
-          name: options.projectName,
-          main: "src/index.ts",
-          compatibility_date: "2024-11-01",
-        },
-        null,
-        2,
-      ) + "\n",
-    );
-  }
 
-  if (options.type === "vercel") {
-    await write(
-      path.join(root, "vercel.json"),
-      JSON.stringify(
-        {
-          rewrites: [{ source: "/(.*)", destination: "/src/index.ts" }],
-        },
-        null,
-        2,
-      ) + "\n",
-    );
+  // Nitro's default preset is node-server — only emit an explicit config when
+  // the deployment target differs. Do not emit for preset "none".
+  if (ctx.preset !== "node-server" && ctx.preset !== "none") {
+    await write(path.join(root, "nitro.config.ts"), nitroConfigTemplate(deployEntry.id));
   }
 
-  if (options.type === "azure-functions") {
-    await write(
-      path.join(root, "host.json"),
-      JSON.stringify(
-        {
-          version: "2.0",
-          logging: {
-            applicationInsights: {
-              samplingSettings: {
-                isEnabled: true,
-                excludedTypes: "Request",
-              },
-            },
-          },
-          extensionBundle: {
-            id: "Microsoft.Azure.Functions.ExtensionBundle",
-            version: "[4.*, 5.0.0)",
-          },
-          extensions: {
-            http: {
-              routePrefix: "",
-            },
-          },
-        },
-        null,
-        2,
-      ) + "\n",
-    );
+  await Promise.all(
+    deployEntry.files.map((file) =>
+      write(
+        path.join(root, file.name),
+        typeof file.content === "function"
+          ? file.content({ projectName: options.projectName })
+          : file.content,
+      ),
+    ),
+  );
+
+  const serverEntry = frameworkEntry.serverEntry;
+  if (serverEntry) {
+    await write(path.join(root, serverEntry.fileName), serverEntry.content);
   }
 
   await Promise.all(

package/src/core/targets.ts

@@ -0,0 +1,211 @@
+/**
+ * Registry for the three scaffold dimensions — runtime, framework, deploy —
+ * plus the compatibility rules between them.
+ *
+ * Dependency direction: deploy implies the runtime family; the effective
+ * runtime constrains which frameworks can run. `--runtime` is an override
+ * available only where it is meaningful (self-hosted node-family targets).
+ */
+import { DEPLOY_TARGETS, type DeployTarget, type Framework, type Runtime } from "./types.js";
+
+export type PlatformFile = {
+  name: string;
+  content: string | ((ctx: { projectName: string }) => string);
+};
+
+export type DeployEntry = {
+  id: DeployTarget;
+  /** Runtime this target builds for ("workerd" = Cloudflare's V8 runtime). */
+  impliedRuntime: Runtime | "workerd";
+  /** Whether the built output is a long-running server you start locally. */
+  selfHosted: boolean;
+  /** `start` script value; null for platform-deployed targets. */
+  startScript: string | null;
+  /** Runtime/platform tooling devDependencies beyond the base set. */
+  devDeps: string[];
+  files: PlatformFile[];
+};
+
+const NODE_START = "node .output/server/index.mjs";
+
+export const DEPLOY_ENTRIES: Record<DeployTarget, DeployEntry> = {
+  none: {
+    id: "none",
+    impliedRuntime: "node",
+    selfHosted: true,
+    startScript: "node dist/serve.mjs",
+    devDeps: [],
+    files: [],
+  },
+  "node-server": {
+    id: "node-server",
+    impliedRuntime: "node",
+    selfHosted: true,
+    startScript: NODE_START,
+    devDeps: [],
+    files: [],
+  },
+  "node-cluster": {
+    id: "node-cluster",
+    impliedRuntime: "node",
+    selfHosted: true,
+    startScript: NODE_START,
+    devDeps: [],
+    files: [],
+  },
+  bun: {
+    id: "bun",
+    impliedRuntime: "bun",
+    selfHosted: true,
+    startScript: "bun .output/server/index.mjs",
+    devDeps: ["@types/bun"],
+    files: [],
+  },
+  "deno-server": {
+    id: "deno-server",
+    impliedRuntime: "deno",
+    selfHosted: true,
+    startScript: "deno run -A .output/server/index.mjs",
+    devDeps: [],
+    files: [],
+  },
+  "deno-deploy": {
+    id: "deno-deploy",
+    impliedRuntime: "deno",
+    selfHosted: false,
+    startScript: null,
+    devDeps: [],
+    files: [],
+  },
+  "cloudflare-module": {
+    id: "cloudflare-module",
+    impliedRuntime: "workerd",
+    selfHosted: false,
+    startScript: null,
+    devDeps: ["wrangler", "@cloudflare/workers-types"],
+    files: [
+      {
+        name: "wrangler.jsonc",
+        content: ({ projectName }) =>
+          `${JSON.stringify(
+            {
+              $schema: "node_modules/wrangler/config-schema.json",
+              name: projectName,
+              main: ".output/server/index.mjs",
+              compatibility_date: "2024-11-01",
+            },
+            null,
+            2,
+          )}\n`,
+      },
+    ],
+  },
+  vercel: {
+    id: "vercel",
+    impliedRuntime: "node",
+    selfHosted: false,
+    startScript: null,
+    devDeps: ["@vercel/node"],
+    files: [],
+  },
+  "aws-lambda": {
+    id: "aws-lambda",
+    impliedRuntime: "node",
+    selfHosted: false,
+    startScript: null,
+    devDeps: ["@types/aws-lambda"],
+    files: [],
+  },
+  netlify: {
+    id: "netlify",
+    impliedRuntime: "node",
+    selfHosted: false,
+    startScript: null,
+    devDeps: [],
+    files: [],
+  },
+};
+
+/** Runtimes a `--runtime` override may select per self-hosted deploy target. */
+const RUNTIME_OVERRIDES: Partial<Record<DeployTarget, readonly Runtime[]>> = {
+  none: ["node", "bun"],
+  "node-server": ["node", "bun"],
+  "node-cluster": ["node", "bun"],
+};
+
+export const DEFAULT_DEPLOY: DeployTarget = "node-server";
+export const DEFAULT_FRAMEWORK: Framework = "none";
+
+export function isCuratedDeploy(value: string): value is DeployTarget {
+  return (DEPLOY_TARGETS as readonly string[]).includes(value);
+}
+
+/**
+ * Resolves any preset id to its emission entry. Curated ids come from the
+ * registry; unknown strings pass through to Nitro verbatim as non-self-hosted
+ * node-family targets.
+ */
+export function resolveDeployEntry(id: string): { entry: DeployEntry; curated: boolean } {
+  if (isCuratedDeploy(id)) {
+    return { entry: DEPLOY_ENTRIES[id], curated: true };
+  }
+  return {
+    entry: {
+      // Cast: passthrough ids are valid Nitro PresetNameInputs by contract.
+      id: id as DeployTarget,
+      impliedRuntime: "node",
+      selfHosted: false,
+      startScript: null,
+      devDeps: [],
+      files: [],
+    },
+    curated: false,
+  };
+}
+
+/** Runtime overrides permitted for a deploy target; empty = no override. */
+export function allowedRuntimeOverrides(id: DeployTarget): readonly Runtime[] {
+  return RUNTIME_OVERRIDES[id] ?? [];
+}
+
+export type CombinationError = { ok: false; reason: string };
+export type CombinationOk = { ok: true; runtime: Runtime | "workerd" };
+
+/**
+ * Validates a runtime × framework × deploy combination.
+ *
+ * @param runtimeOverride explicit `--runtime` selection, if any
+ * @param deploy preset id (curated or passthrough)
+ */
+export function validateCombination(
+  runtimeOverride: Runtime | undefined,
+  framework: Framework,
+  deploy: string,
+): CombinationOk | CombinationError {
+  const { entry } = resolveDeployEntry(deploy);
+
+  if (runtimeOverride !== undefined) {
+    const allowed = entry.selfHosted ? allowedRuntimeOverrides(entry.id) : [];
+    if (!allowed.includes(runtimeOverride)) {
+      return {
+        ok: false,
+        reason:
+          `Runtime "${runtimeOverride}" is not valid for deploy target "${entry.id}". ` +
+          (allowed.length > 0
+            ? `Allowed overrides: ${allowed.join(", ")}.`
+            : `It implies runtime "${String(entry.impliedRuntime)}".`),
+      };
+    }
+  }
+
+  const effective = runtimeOverride ?? entry.impliedRuntime;
+
+  if ((framework === "express" || framework === "fastify") && effective !== "node") {
+    return {
+      ok: false,
+      reason: `Framework "${framework}" requires the Node runtime, but deploy target "${entry.id}" implies "${String(effective)}".`,
+    };
+  }
+
+  return { ok: true, runtime: effective };
+}

package/src/core/types.ts

@@ -1,32 +1,41 @@
 import type { Agent } from "package-manager-detector";
 
-export type ProjectType =
-  | "node"
-  | "express"
-  | "fastify"
-  | "hono"
+/** Host framework layered on top of pure Taser pass-through dispatch. */
+export type Framework = "none" | "hono" | "express" | "fastify";
+
+export const FRAMEWORKS: readonly Framework[] = ["none", "hono", "express", "fastify"];
+
+export type Runtime = "node" | "bun" | "deno";
+
+export const RUNTIMES: readonly Runtime[] = ["node", "bun", "deno"];
+
+/**
+ * Deployment target. Values are Nitro preset ids (see `nitro/config`
+ * PresetNameInput) so `--preset` passes straight through to Nitro.
+ */
+export type DeployTarget =
+  | "none"
+  | "node-server"
+  | "node-cluster"
   | "bun"
-  | "deno"
-  | "aws-lambda"
-  | "cloudflare-workers"
-  | "netlify"
+  | "deno-server"
+  | "deno-deploy"
+  | "cloudflare-module"
   | "vercel"
-  | "azure-functions"
-  | "google-cloud-run";
-
-export const PROJECT_TYPES: readonly ProjectType[] = [
-  "node",
-  "express",
-  "fastify",
-  "hono",
+  | "aws-lambda"
+  | "netlify";
+
+export const DEPLOY_TARGETS: readonly DeployTarget[] = [
+  "none",
+  "node-server",
+  "node-cluster",
   "bun",
-  "deno",
+  "deno-server",
+  "deno-deploy",
+  "cloudflare-module",
+  "vercel",
   "aws-lambda",
-  "cloudflare-workers",
   "netlify",
-  "vercel",
-  "azure-functions",
-  "google-cloud-run",
 ];
 
 export type DbOdm = "drizzle" | "prisma" | "kysely";
@@ -56,7 +65,12 @@ export type PackageGroups = {
 export type ScaffoldContext = {
   projectName: string;
   targetDir: string;
-  type: ProjectType;
+  /** Host framework; "none" is pure Taser pass-through dispatch. Defaults to "none". */
+  framework?: Framework;
+  /** Deployment target — a Nitro preset id. Defaults to "node-server". */
+  preset?: DeployTarget;
+  /** Set only when explicitly overriding the runtime implied by the preset. */
+  runtime?: Runtime;
   db?: DbOdm;
   driver?: DbDriver;
   logger?: LoggerId;
@@ -71,7 +85,9 @@ export type ScaffoldOptions = ScaffoldContext & {
 export type ScaffoldResult = ScaffoldContext;
 
 export type CapabilitiesCatalog = {
-  types: ProjectType[];
+  frameworks: Framework[];
+  deployTargets: DeployTarget[];
+  runtimes: Runtime[];
   db: {
     odms: DbOdm[];
     drivers: DbDriver[];

package/src/core/validate-project-name.ts

@@ -36,10 +36,6 @@ export function validateProjectName(name: string, cwd = process.cwd()): string |
     return 'Project name cannot contain ".."';
   }
 
-  if (trimmed.includes("/") || trimmed.includes("\\")) {
-    return "Project name cannot contain path separators";
-  }
-
   if (trimmed.startsWith(".") || trimmed.endsWith(".")) {
     return "Project name cannot start or end with a dot";
   }