create-taserjs 0.0.5 → 0.1.0

package/src/frameworks/index.ts

@@ -1,246 +1,110 @@
-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.native(c).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'
-
-import Fastify from 'fastify'
-import { createFastifyHandler } from '@taserjs/adapter-fastify'
+      return {
+        fileName: "src/server.node.ts",
+        content: `import Fastify from '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.native(c).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.native(c).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.native(c).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.native(c).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 {
-  if (
-    type === "hono" ||
-    type === "aws-lambda" ||
-    type === "netlify" ||
-    type === "vercel" ||
-    type === "azure-functions"
-  ) {
-    return `import type { Context } from 'hono'
-import { createTaserApp, type InferAppContext } from '@taserjs/router'
-
-import { context } from '#src/context.js'
-
-declare module '@taserjs/router' {
-  interface RouterRegister {
-    NativeContext: Context
-  }
 }
 
-export const t = createTaserApp({
-  response: { validate: true },
-}).context(context)
-
-export type AppContext = InferAppContext<typeof context>
-`;
-  }
+export function taserTsTemplate(): string {
+  return `import { createTaserApp } from '@taserjs/router'
 
-  return `import { createTaserApp, type InferAppContext } from '@taserjs/router'
-
-import { context } from '#src/context.js'
+import { context } from './context.js'
 
 export const t = createTaserApp({
   response: { validate: true },
 }).context(context)
-
-export type AppContext = InferAppContext<typeof context>
 `;
 }

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";

package/src/templates/base.ts

@@ -11,16 +11,11 @@ export function packageJsonTemplate(
     private: true,
     type: "module",
     imports: {
-      "#src/*": "./src/*",
+      "#taserjs/router": "./src/taser.ts",
     },
     scripts: {
-      dev: "run-p dev:server dev:taser",
-      "dev:server": "tsx watch src/index.ts",
-      "dev:taser": "taser watch",
-      start: "tsx src/index.ts",
-      generate: "taser generate",
-      build: "taser generate && tsdown",
-      serve: "node dist/index.mjs",
+      dev: "vite",
+      build: "vite build",
       typecheck: "tsc --noEmit -p tsconfig.json",
       ...scripts,
     },
@@ -29,19 +24,6 @@ export function packageJsonTemplate(
   return `${JSON.stringify(pkg, null, 2)}\n`;
 }
 
-export function tsdownConfigTemplate(): string {
-  return `import { defineConfig } from 'tsdown'
-
-export default defineConfig({
-  entry: ['./src/index.ts'],
-  platform: 'node',
-  outDir: 'dist',
-  clean: true,
-  sourcemap: true,
-})
-`;
-}
-
 export function tsconfigTemplate(): string {
   return `${JSON.stringify(
     {
@@ -49,16 +31,15 @@ export function tsconfigTemplate(): string {
         target: "ES2022",
         module: "NodeNext",
         paths: {
-          "#src/*": ["./src/*"],
+          "#taserjs/router": ["./src/taser.ts"],
         },
         strict: true,
         skipLibCheck: true,
         verbatimModuleSyntax: true,
         isolatedModules: true,
         noEmit: true,
-        types: ["node"],
       },
-      include: ["src"],
+      include: ["src", ".taser/types/**/*.d.ts"],
     },
     null,
     2,
@@ -68,6 +49,8 @@ export function tsconfigTemplate(): string {
 export function gitignoreTemplate(): string {
   return `node_modules
 dist
+.output
+.taser
 .DS_Store
 *.log
 .env
@@ -104,7 +87,7 @@ ${bootBlock}
 export function rootLayoutTemplate(): string {
   return `import { cors } from '@taserjs/router/cors'
 
-import { t } from '#src/taser.js'
+import { t } from '#taserjs/router'
 
 export const Middleware = t.middleware('/$')
   .use(cors())
@@ -112,14 +95,14 @@ export const Middleware = t.middleware('/$')
 }
 
 export function indexRouteTemplate(): string {
-  return `import { reply } from '@taserjs/router'
-import { t } from '#src/taser.js'
+  return `import { json } from '@taserjs/router/reply'
+import { t } from '#taserjs/router'
 
 const GET = t.get('/')
 
 export type RouteContext = typeof GET.$Infer.Context
 export const Route = GET.handler((_ctx) => {
-  return reply.json({ message: 'Welcome to Taser' })
+  return json({ message: 'Welcome to Taser' })
 })
 `;
 }
@@ -138,81 +121,14 @@ export function healthRouteTemplate(ctx: ScaffoldContext): string {
   const body = lines.length > 0 ? `${lines.join("\n")}\n` : "";
   const ctxArg = lines.length > 0 ? "(ctx)" : "(_ctx)";
 
-  return `import { reply } from '@taserjs/router'
-import { t } from '#src/taser.js'
+  return `import { json } from '@taserjs/router/reply'
+import { t } from '#taserjs/router'
 
 const GET = t.get('/health')
 
 export type RouteContext = typeof GET.$Infer.Context
 export const Route = GET.handler(${ctxArg} => {
-${body}  return reply.json({ ok: true })
+${body}  return json({ ok: true })
 })
 `;
 }
-
-/** Minimal placeholder until `taser generate` runs. */
-export function starterManifestTemplate(): string {
-  return `/* eslint-disable */
-// Run \`pnpm generate\` (taser generate) to replace this file.
-import { Middleware as RootSplatLayoutImport } from './routes/$.js'
-import { Route as RootIndexGetRouteImport } from './routes/index.get.js'
-import { Route as HealthGetRouteImport } from './routes/health.get.js'
-
-export const routeManifest = {
-  layouts: {
-    '/$': {
-      middlewares: RootSplatLayoutImport,
-    },
-  },
-  routes: {
-    '/': {
-      GET: {
-        layoutChain: ['/$'],
-        route: RootIndexGetRouteImport,
-      },
-    },
-    '/health': {
-      GET: {
-        layoutChain: ['/$'],
-        route: HealthGetRouteImport,
-      },
-    },
-  },
-} as const
-
-export type RoutePathGen = '/' | '/health'
-export type LayoutIdGen = '/$'
-export type LayoutTreeGen = {
-  '/$': {
-    parent: null
-    middlewares: typeof RootSplatLayoutImport
-  }
-}
-export type RouteByPathMethodGen = {
-  '/': {
-    GET: {
-      parent: '/$'
-      layoutChain: ['/$']
-      route: typeof RootIndexGetRouteImport
-    }
-  }
-  '/health': {
-    GET: {
-      parent: '/$'
-      layoutChain: ['/$']
-      route: typeof HealthGetRouteImport
-    }
-  }
-}
-export type RouteManifest = typeof routeManifest
-
-declare module '@taserjs/router' {
-  interface RouterRegister {
-    RoutePath: RoutePathGen
-    LayoutId: LayoutIdGen
-    LayoutTree: LayoutTreeGen
-    RouteByPathMethod: RouteByPathMethodGen
-  }
-}
-`;
-}

package/src/types.ts

@@ -1,9 +1,11 @@
 export type {
   DbDriver,
   DbOdm,
+  DeployTarget,
+  Framework,
   LoggerId,
   PackageGroups,
-  ProjectType,
+  Runtime,
   ScaffoldOptions,
   ScaffoldResult,
   ValidatorId,