create-taserjs 0.0.5 → 0.1.0

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());
   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.
+  if (ctx.preset !== "node-server") {
+    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(
@@ -128,14 +104,7 @@ export async function scaffoldProject(options: ScaffoldOptions): Promise<Scaffol
   await writeProjectConfig(root, ctx);
 
   if (options.skipInstall) {
-    return {
-      projectName: ctx.projectName,
-      targetDir: root,
-      type: ctx.type,
-      ...(ctx.db ? { db: ctx.db, driver: ctx.driver } : {}),
-      ...(ctx.logger ? { logger: ctx.logger } : {}),
-      ...(ctx.validator ? { validator: ctx.validator } : {}),
-    };
+    return ctx as ScaffoldResult;
   }
 
   const agent = options.agent ?? resolveUserAgent();
@@ -144,12 +113,5 @@ export async function scaffoldProject(options: ScaffoldOptions): Promise<Scaffol
     devDependencies: packages.devDependencies,
   });
 
-  return {
-    projectName: ctx.projectName,
-    targetDir: root,
-    type: ctx.type,
-    ...(ctx.db ? { db: ctx.db, driver: ctx.driver } : {}),
-    ...(ctx.logger ? { logger: ctx.logger } : {}),
-    ...(ctx.validator ? { validator: ctx.validator } : {}),
-  };
+  return ctx as ScaffoldResult;
 }

package/src/core/targets.ts

@@ -0,0 +1,202 @@
+/**
+ * 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> = {
+  "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[]>> = {
+  "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,39 @@
 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 =
+  | "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[] = [
+  "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 +63,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 +83,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[];