create-taserjs 0.0.1 → 0.0.3

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

@@ -1,59 +1,59 @@
-import path from 'node:path'
+import path from "node:path";
 
 const RESERVED_WINDOWS_NAMES = new Set([
-  'CON',
-  'PRN',
-  'AUX',
-  'NVR',
-  'NULL',
-  'COM1',
-  'COM2',
-  'COM3',
-  'COM4',
-  'COM5',
-  'COM6',
-  'COM7',
-  'COM8',
-  'COM9',
-  'LPT1',
-  'LPT2',
-  'LPT3',
-  'LPT4',
-  'LPT5',
-  'LPT6',
-  'LPT7',
-  'LPT8',
-  'LPT9',
-])
+  "CON",
+  "PRN",
+  "AUX",
+  "NVR",
+  "NULL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9",
+]);
 
 export function validateProjectName(name: string, cwd = process.cwd()): string | undefined {
-  const trimmed = name.trim()
+  const trimmed = name.trim();
   if (!trimmed) {
-    return 'Project name is required'
+    return "Project name is required";
   }
 
-  if (trimmed.includes('..')) {
-    return 'Project name cannot contain ".."'
+  if (trimmed.includes("..")) {
+    return 'Project name cannot contain ".."';
   }
 
-  if (trimmed.includes('/') || trimmed.includes('\\')) {
-    return 'Project name cannot contain path separators'
+  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'
+  if (trimmed.startsWith(".") || trimmed.endsWith(".")) {
+    return "Project name cannot start or end with a dot";
   }
 
-  const baseName = trimmed.split('.')[0]?.toUpperCase()
+  const baseName = trimmed.split(".")[0]?.toUpperCase();
   if (baseName && RESERVED_WINDOWS_NAMES.has(baseName)) {
-    return `Project name "${trimmed}" is reserved on Windows`
+    return `Project name "${trimmed}" is reserved on Windows`;
   }
 
-  const targetDir = path.resolve(cwd, trimmed)
-  const relative = path.relative(cwd, targetDir)
-  if (relative.startsWith('..') || path.isAbsolute(relative)) {
-    return 'Project name resolves outside the current directory'
+  const targetDir = path.resolve(cwd, trimmed);
+  const relative = path.relative(cwd, targetDir);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    return "Project name resolves outside the current directory";
   }
 
-  return undefined
+  return undefined;
 }

package/src/frameworks/index.ts

@@ -1,9 +1,11 @@
-import type { Framework } from '../core/types.js'
+import type { ProjectType } from "../core/types.js";
 
-export function indexTemplate(framework: Framework): string {
-  switch (framework) {
-    case 'express':
-      return `import express from 'express'
+export function indexTemplate(type: ProjectType): string {
+  switch (type) {
+    case "express":
+      return `import 'dotenv/config'
+
+import express from 'express'
 import { createExpressHandler } from '@taserjs/adapter-express'
 
 import { routeManifest } from '#src/routeManifest.gen.js'
@@ -13,15 +15,17 @@ const router = t.create(routeManifest)
 
 const taser = createExpressHandler(router)
 const app = express()
-taser.mount('/api{/*splat}', app)
+taser.mount('/{*splat}', app)
 
 const port = Number(process.env.PORT ?? 3000)
 app.listen(port, () => {
   console.log(\`Express listening on http://localhost:\${port}\`)
 })
-`
-    case 'hono':
-      return `import { serve } from '@hono/node-server'
+`;
+    case "hono":
+      return `import 'dotenv/config'
+
+import { serve } from '@hono/node-server'
 import { Hono } from 'hono'
 
 import { routeManifest } from '#src/routeManifest.gen.js'
@@ -30,16 +34,17 @@ import { t } from '#src/taser.js'
 const router = t.create(routeManifest)
 
 const app = new Hono()
-const api = router.base('/api')
-app.all('/api/*', c => api.native(c).fetch(c.req.raw))
+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}\`)
 })
-`
-    case 'fastify':
-      return `import Fastify from 'fastify'
+`;
+    case "fastify":
+      return `import 'dotenv/config'
+
+import Fastify from 'fastify'
 import { createFastifyHandler } from '@taserjs/adapter-fastify'
 
 import { routeManifest } from '#src/routeManifest.gen.js'
@@ -49,36 +54,166 @@ const router = t.create(routeManifest)
 
 const taser = createFastifyHandler(router)
 const app = Fastify()
-taser.mount('/api/*', app)
+taser.mount('/*', app)
 
 const port = Number(process.env.PORT ?? 3000)
 await app.listen({ port })
 console.log(\`Fastify listening on http://localhost:\${port}\`)
-`
-    case 'node':
-    default:
-      return `import { createServer } from 'node:http'
-import { createNodeHandler } from '@taserjs/adapter-node'
+`;
+    case "bun":
+      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 ?? 3000)
+
+export default {
+  port,
+  fetch(request: Request) {
+    return router.fetch(request)
+  },
+}
+`;
+    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)
+  },
+}
+`;
+    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 taser = createNodeHandler(router)
-const app = createServer()
-taser.mount('/api/*', app)
+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'
+
+const router = t.create(routeManifest)
+
+const port = Number(process.env.PORT ?? 8080)
+serve({ fetch: router.fetch, port }, () => {
+  console.log(\`Cloud Run listening on http://localhost:\${port}\`)
+})
+`;
+    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)
 
 const port = Number(process.env.PORT ?? 3000)
-app.listen(port, () => {
+serve({ fetch: router.fetch, port }, () => {
   console.log(\`Node listening on http://localhost:\${port}\`)
 })
-`
+`;
   }
 }
 
-export function taserTsTemplate(framework: Framework = 'node'): string {
-  if (framework === 'hono') {
+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'
 
@@ -95,7 +230,7 @@ export const t = createTaserApp({
 }).context(context)
 
 export type AppContext = InferAppContext<typeof context>
-`
+`;
   }
 
   return `import { createTaserApp, type InferAppContext } from '@taserjs/router'
@@ -107,5 +242,5 @@ export const t = createTaserApp({
 }).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 { Framework, ScaffoldOptions, ScaffoldResult, PackageGroups } from './core/types.js'
+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";

package/src/templates/base.ts

@@ -1,29 +1,32 @@
-import type { BootBinding } from '../addons/types.js'
-import type { ScaffoldContext } from '../core/types.js'
+import type { BootBinding } from "../addons/types.js";
+import type { ScaffoldContext } from "../core/types.js";
 
-export function packageJsonTemplate(projectName: string, scripts: Record<string, string> = {}): string {
+export function packageJsonTemplate(
+  projectName: string,
+  scripts: Record<string, string> = {},
+): string {
   const pkg = {
     name: projectName,
-    version: '1.0.0',
+    version: "1.0.0",
     private: true,
-    type: 'module',
+    type: "module",
     imports: {
-      '#src/*': './src/*',
+      "#src/*": "./src/*",
     },
     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',
-      'typecheck': 'tsc --noEmit -p tsconfig.json',
+      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",
+      typecheck: "tsc --noEmit -p tsconfig.json",
       ...scripts,
     },
-  }
+  };
 
-  return `${JSON.stringify(pkg, null, 2)}\n`
+  return `${JSON.stringify(pkg, null, 2)}\n`;
 }
 
 export function tsdownConfigTemplate(): string {
@@ -36,26 +39,30 @@ export default defineConfig({
   clean: true,
   sourcemap: true,
 })
-`
+`;
 }
 
 export function tsconfigTemplate(): string {
-  return `${JSON.stringify({
-    compilerOptions: {
-      target: 'ES2022',
-      module: 'NodeNext',
-      paths: {
-        '#src/*': ['./src/*'],
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        paths: {
+          "#src/*": ["./src/*"],
+        },
+        strict: true,
+        skipLibCheck: true,
+        verbatimModuleSyntax: true,
+        isolatedModules: true,
+        noEmit: true,
+        types: ["node"],
       },
-      strict: true,
-      skipLibCheck: true,
-      verbatimModuleSyntax: true,
-      isolatedModules: true,
-      noEmit: true,
-      types: ['node'],
+      include: ["src"],
     },
-    include: ['src'],
-  }, null, 2)}\n`
+    null,
+    2,
+  )}\n`;
 }
 
 export function gitignoreTemplate(): string {
@@ -66,23 +73,22 @@ dist
 .env
 local.db
 drizzle
-`
+`;
 }
 
 export function contextTemplate(bindings: BootBinding[]): string {
   const imports = bindings.map(
-    binding => `import { ${binding.factoryName} } from '${binding.importPath}'`,
-  )
+    (binding) => `import { ${binding.factoryName} } from '${binding.importPath}'`,
+  );
 
-  const bootBody = bindings.length > 0
-    ? bindings.map(binding => `    ${binding.key}: ${binding.factoryName}(),`).join('\n')
-    : ''
+  const bootBody =
+    bindings.length > 0
+      ? bindings.map((binding) => `    ${binding.key}: ${binding.factoryName}(),`).join("\n")
+      : "";
 
-  const bootBlock = bindings.length > 0
-    ? `  boot: () => ({\n${bootBody}\n  }),`
-    : ''
+  const bootBlock = bindings.length > 0 ? `  boot: () => ({\n${bootBody}\n  }),` : "";
 
-  const importBlock = imports.length > 0 ? `${imports.join('\n')}\n\n` : ''
+  const importBlock = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
 
   return `${importBlock}import { createContext } from '@taserjs/router'
 
@@ -92,7 +98,7 @@ ${bootBlock}
     requestId: crypto.randomUUID(),
   }),
 })
-`
+`;
 }
 
 export function rootLayoutTemplate(): string {
@@ -104,37 +110,40 @@ import { t } from '#src/taser.js'
 export const Middleware = t.middleware('/$')
   .use(secureHeaders())
   .use(bodyLimit({ maxSize: 1_000_000 }))
-`
+`;
 }
 
 export function indexRouteTemplate(): string {
-  return `import { t } from '#src/taser.js'
+  return `import { reply } from '@taserjs/router'
+import { t } from '#src/taser.js'
 
-export const Route = t.get('/').handler((ctx) => {
-  return ctx.reply.json({ message: 'Welcome to Taser' })
+export const Route = t.get('/').handler(() => {
+  return reply.json({ message: 'Welcome to Taser' })
 })
-`
+`;
 }
 
 export function healthRouteTemplate(ctx: ScaffoldContext): string {
-  const lines: string[] = []
+  const lines: string[] = [];
 
   if (ctx.logger) {
-    lines.push('  ctx.logger.info(\'health check\')')
+    lines.push("  ctx.logger.info('health check')");
   }
 
   if (ctx.db) {
-    lines.push('  // ctx.db is available from context boot')
+    lines.push("  // ctx.db is available from context boot");
   }
 
-  const body = lines.length > 0 ? `${lines.join('\n')}\n` : ''
+  const body = lines.length > 0 ? `${lines.join("\n")}\n` : "";
+  const ctxArg = lines.length > 0 ? "(ctx)" : "()";
 
-  return `import { t } from '#src/taser.js'
+  return `import { reply } from '@taserjs/router'
+import { t } from '#src/taser.js'
 
-export const Route = t.get('/health').handler((ctx) => {
-${body}  return ctx.reply.json({ ok: true })
+export const Route = t.get('/health').handler(${ctxArg} => {
+${body}  return reply.json({ ok: true })
 })
-`
+`;
 }
 
 /** Minimal placeholder until `taser generate` runs. */
@@ -201,5 +210,5 @@ declare module '@taserjs/router' {
     RouteByPathMethod: RouteByPathMethodGen
   }
 }
-`
+`;
 }

package/src/types.ts

@@ -1,9 +1,10 @@
 export type {
-  Framework,
-  DbOdm,
   DbDriver,
+  DbOdm,
   LoggerId,
+  PackageGroups,
+  ProjectType,
   ScaffoldOptions,
   ScaffoldResult,
-  PackageGroups,
-} from './core/types.js'
+  ValidatorId,
+} from "./core/types.js";