create-taserjs 0.0.6 → 0.1.0

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[];

package/src/frameworks/index.ts

@@ -1,215 +1,107 @@
-import type { ProjectType } from "../core/types.js";
+import type { Framework } from "../core/types.js";
 
-export function indexTemplate(type: ProjectType): string {
-  switch (type) {
-    case "express":
-      return `import 'dotenv/config'
+export function serverEntryTemplate(
+  framework: Framework,
+): { fileName: string; content: string } | null {
+  switch (framework) {
+    case "hono":
+      return {
+        fileName: "src/server.ts",
+        content: `import { Hono } from 'hono'
 
-import express from 'express'
-import { createExpressHandler } from '@taserjs/adapter-express'
+const app = new Hono()
 
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
+app.get('/host', (c) => {
+  return c.text('Hello from Hono host!')
+})
 
-const router = t.create(routeManifest)
+export default app
+`,
+      };
+    case "express":
+      return {
+        fileName: "src/server.node.ts",
+        content: `import express from 'express'
 
-const taser = createExpressHandler(router)
 const app = express()
-taser.mount('/{*splat}', app)
 
-const port = Number(process.env.PORT ?? 3000)
-app.listen(port, () => {
-  console.log(\`Express listening on http://localhost:\${port}\`)
+app.get('/host', (_req, res) => {
+  res.json({ message: 'Hello from Express host!' })
 })
-`;
-    case "hono":
-      return `import 'dotenv/config'
-
-import { serve } from '@hono/node-server'
-import { Hono } from 'hono'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
 
-const router = t.create(routeManifest)
-
-const app = new Hono()
-app.all('/*', c => router.fetch(c.req.raw))
-
-const port = Number(process.env.PORT ?? 3000)
-serve({ fetch: app.fetch, port }, () => {
-  console.log(\`Hono listening on http://localhost:\${port}\`)
-})
-`;
+export default app
+`,
+      };
     case "fastify":
-      return `import 'dotenv/config'
+      return {
+        fileName: "src/server.node.ts",
+        content: `import Fastify from 'fastify'
 
-import Fastify from 'fastify'
-import { createFastifyHandler } from '@taserjs/adapter-fastify'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
-
-const taser = createFastifyHandler(router)
 const app = Fastify()
-taser.mount('/*', app)
 
-const port = Number(process.env.PORT ?? 3000)
-await app.listen({ port })
-console.log(\`Fastify listening on http://localhost:\${port}\`)
-`;
-    case "bun":
-      return `import 'dotenv/config'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
+app.get('/host', async () => {
+  return { message: 'Hello from Fastify host!' }
+})
 
-const port = Number(process.env.PORT ?? 3000)
+await app.ready()
 
-export default {
-  port,
-  fetch(request: Request) {
-    return router.fetch(request)
-  },
+export default app.routing
+`,
+      };
+    default:
+      return null;
+  }
 }
-`;
-    case "deno":
-      return `import 'dotenv/config'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
 
-const port = Number(process.env.PORT ?? 8000)
-Deno.serve({ port }, (request: Request) => router.fetch(request))
-`;
-    case "aws-lambda":
-      return `import 'dotenv/config'
-
-import { Hono } from 'hono'
-import { handle } from 'hono/aws-lambda'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
-
-const app = new Hono()
-app.all('/*', c => router.fetch(c.req.raw))
-
-export const handler = handle(app)
-`;
-    case "cloudflare-workers":
-      return `import 'dotenv/config'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
-
-export default {
-  fetch(request: Request, env: unknown, ctx: unknown) {
-    return router.fetch(request, env, ctx)
+export type FrameworkEntry = {
+  id: Framework;
+  serverEntry: { fileName: string; content: string } | null;
+  deps: string[];
+  devDeps: string[];
+};
+
+export const FRAMEWORK_ENTRIES: Record<Framework, FrameworkEntry> = {
+  none: { id: "none", serverEntry: null, deps: [], devDeps: [] },
+  hono: { id: "hono", serverEntry: serverEntryTemplate("hono"), deps: ["hono"], devDeps: [] },
+  express: {
+    id: "express",
+    serverEntry: serverEntryTemplate("express"),
+    deps: ["express", "srvx"],
+    devDeps: ["@types/express"],
   },
-}
-`;
-    case "netlify":
-      return `import 'dotenv/config'
-
-import { Hono } from 'hono'
-import { handle } from 'hono/netlify'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
-
-const app = new Hono()
-app.all('/*', c => router.fetch(c.req.raw))
-
-export default handle(app)
-`;
-    case "vercel":
-      return `import 'dotenv/config'
-
-import { Hono } from 'hono'
-import { handle } from 'hono/vercel'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
-
-const app = new Hono()
-app.all('/*', c => router.fetch(c.req.raw))
-
-export default handle(app)
-`;
-    case "azure-functions":
-      return `import 'dotenv/config'
-
-import { app } from '@azure/functions'
-import { Hono } from 'hono'
-import { azureHonoHandler } from '@marplex/hono-azurefunc-adapter'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
-
-const router = t.create(routeManifest)
-
-const honoApp = new Hono()
-honoApp.all('/*', c => router.fetch(c.req.raw))
-
-app.http('httpTrigger', {
-  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
-  authLevel: 'anonymous',
-  route: '{*proxy}',
-  handler: azureHonoHandler(honoApp.fetch),
-})
-`;
-    case "google-cloud-run":
-      return `import 'dotenv/config'
-
-import { serve } from '@hono/node-server'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
+  fastify: {
+    id: "fastify",
+    // srvx bridges the Fastify Node handler to fetch (see compose codegen).
+    serverEntry: serverEntryTemplate("fastify"),
+    deps: ["fastify", "srvx"],
+    devDeps: [],
+  },
+};
 
-const router = t.create(routeManifest)
+export function nitroConfigTemplate(nitroPreset: string): string {
+  return `import { defineConfig } from 'nitro/config'
 
-const port = Number(process.env.PORT ?? 8080)
-serve({ fetch: router.fetch, port }, () => {
-  console.log(\`Cloud Run listening on http://localhost:\${port}\`)
+export default defineConfig({
+  preset: '${nitroPreset}',
 })
 `;
-    case "node":
-    default:
-      return `import 'dotenv/config'
-
-import { serve } from '@hono/node-server'
-
-import { routeManifest } from '#src/routeManifest.gen.js'
-import { t } from '#src/taser.js'
+}
 
-const router = t.create(routeManifest)
+export function viteConfigTemplate(): string {
+  return `import { defineConfig } from 'vite'
+import { nitro } from 'nitro/vite'
+import { taser } from '@taserjs/router-plugin/vite'
 
-const port = Number(process.env.PORT ?? 3000)
-serve({ fetch: router.fetch, port }, () => {
-  console.log(\`Node listening on http://localhost:\${port}\`)
+export default defineConfig({
+  plugins: [taser(), nitro()],
 })
 `;
-  }
 }
 
-export function taserTsTemplate(_type: ProjectType = "node"): string {
+export function taserTsTemplate(): string {
   return `import { createTaserApp } from '@taserjs/router'
 
-import { context } from '#src/context.js'
+import { context } from './context.js'
 
 export const t = createTaserApp({
   response: { validate: true },

package/src/scaffold.ts

@@ -1,3 +1,3 @@
 export { scaffoldProject } from "./core/scaffold-engine.js";
-export { getPackageGroups, resolvePackages } from "./core/resolve-packages.js";
-export type { PackageGroups, ProjectType, ScaffoldOptions, ScaffoldResult } from "./core/types.js";
+export { resolvePackages } from "./core/resolve-packages.js";
+export type { PackageGroups, ScaffoldOptions, ScaffoldResult } from "./core/types.js";