create-taserjs 0.0.2 → 0.0.3

package/src/core/parse-options.ts

@@ -2,115 +2,117 @@ import {
   DB_DRIVERS,
   DB_ODMS,
   DEFAULT_DB_DRIVER,
-  FRAMEWORKS,
   LOGGERS,
+  PROJECT_TYPES,
   VALIDATORS,
   type DbDriver,
   type DbOdm,
-  type Framework,
   type LoggerId,
+  type ProjectType,
   type ScaffoldContext,
   type ValidatorId,
-} from './types.js'
+} from "./types.js";
 
 export type ParsedCreateArgs = {
-  projectName?: string
-  framework?: Framework
-  db?: DbOdm
-  driver?: DbDriver
-  logger?: LoggerId
-  validator?: ValidatorId
-  yes: boolean
-  noInstall: boolean
-  json: boolean
-}
-
-function isFramework(value: string): value is Framework {
-  return (FRAMEWORKS as readonly string[]).includes(value)
+  projectName?: string;
+  type?: ProjectType;
+  db?: DbOdm;
+  driver?: DbDriver;
+  logger?: LoggerId;
+  validator?: ValidatorId;
+  yes: boolean;
+  noInstall: boolean;
+  json: boolean;
+};
+
+function isProjectType(value: string): value is ProjectType {
+  return (PROJECT_TYPES as readonly string[]).includes(value);
 }
 
 function isDbOdm(value: string): value is DbOdm {
-  return (DB_ODMS as readonly string[]).includes(value)
+  return (DB_ODMS as readonly string[]).includes(value);
 }
 
 function isDbDriver(value: string): value is DbDriver {
-  return (DB_DRIVERS as readonly string[]).includes(value)
+  return (DB_DRIVERS as readonly string[]).includes(value);
 }
 
 function isLoggerId(value: string): value is LoggerId {
-  return (LOGGERS as readonly string[]).includes(value)
+  return (LOGGERS as readonly string[]).includes(value);
 }
 
 function isValidatorId(value: string): value is ValidatorId {
-  return (VALIDATORS as readonly string[]).includes(value)
+  return (VALIDATORS as readonly string[]).includes(value);
 }
 
-export function parseDbFlag(value: string): { db: DbOdm, driver: DbDriver } {
-  const [odm, driver] = value.split(':')
+export function parseDbFlag(value: string): { db: DbOdm; driver: DbDriver } {
+  const [odm, driver] = value.split(":");
   if (!odm || !isDbOdm(odm)) {
-    throw new Error(`Invalid --db value "${value}". Use drizzle, prisma, or kysely (optionally with :postgres, :sqlite, or :mysql).`)
+    throw new Error(
+      `Invalid --db value "${value}". Use drizzle, prisma, or kysely (optionally with :postgres, :sqlite, or :mysql).`,
+    );
   }
 
-  if (driver === undefined || driver === '') {
-    return { db: odm, driver: DEFAULT_DB_DRIVER }
+  if (driver === undefined || driver === "") {
+    return { db: odm, driver: DEFAULT_DB_DRIVER };
   }
 
   if (!isDbDriver(driver)) {
-    throw new Error(`Invalid database driver "${driver}". Use postgres, sqlite, or mysql.`)
+    throw new Error(`Invalid database driver "${driver}". Use postgres, sqlite, or mysql.`);
   }
 
-  return { db: odm, driver }
+  return { db: odm, driver };
 }
 
 export function resolveScaffoldDefaults(args: ParsedCreateArgs): ScaffoldContext {
-  const framework = args.framework ?? 'node'
-  const db = args.db
-  const logger = args.logger
-  const validator = args.validator
+  const type = args.type ?? "node";
+  const db = args.db;
+  const logger = args.logger;
+  const validator = args.validator;
 
   if (!args.projectName) {
-    throw new Error('Project name is required')
+    throw new Error("Project name is required");
   }
 
   const result: ScaffoldContext = {
     projectName: args.projectName.trim(),
-    targetDir: '',
-    framework,
-  }
+    targetDir: "",
+    type,
+  };
 
   if (db) {
-    result.db = db
-    result.driver = args.driver ?? DEFAULT_DB_DRIVER
+    result.db = db;
+    result.driver = args.driver ?? DEFAULT_DB_DRIVER;
   }
 
   if (logger) {
-    result.logger = logger
+    result.logger = logger;
   }
 
   if (validator) {
-    result.validator = validator
+    result.validator = validator;
   }
 
-  return result
+  return result;
 }
 
-export function parseFrameworkFlag(value: string): Framework {
-  if (!isFramework(value)) {
-    throw new Error(`Invalid --framework "${value}". Use node, express, hono, or fastify.`)
+export function parseTypeFlag(value: string): ProjectType {
+  if (!isProjectType(value)) {
+    throw new Error(`Invalid --type "${value}". Use ${PROJECT_TYPES.join(", ")}.`);
   }
-  return value
+  return value;
 }
 
 export function parseLoggerFlag(value: string): LoggerId {
   if (!isLoggerId(value)) {
-    throw new Error(`Invalid --logger "${value}". Use pino or winston.`)
+    throw new Error(`Invalid --logger "${value}". Use pino or winston.`);
   }
-  return value
+  return value;
 }
 
 export function parseValidatorFlag(value: string): ValidatorId {
   if (!isValidatorId(value)) {
-    throw new Error(`Invalid --validator "${value}". Use zod, arktype, or valibot.`)
+    throw new Error(`Invalid --validator "${value}". Use zod, arktype, or valibot.`);
   }
-  return value
+  return value;
 }

package/src/core/project-config.ts

@@ -1,31 +1,27 @@
-import { writeFile } from 'node:fs/promises'
-import path from 'node:path'
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
 
-import type { ScaffoldContext } from './types.js'
+import type { ScaffoldContext } from "./types.js";
 
 export async function writeProjectConfig(root: string, ctx: ScaffoldContext): Promise<void> {
   const config: Record<string, string> = {
-    framework: ctx.framework,
-  }
+    type: ctx.type,
+  };
 
   if (ctx.db) {
-    config.db = ctx.db
+    config.db = ctx.db;
     if (ctx.driver) {
-      config.driver = ctx.driver
+      config.driver = ctx.driver;
     }
   }
 
   if (ctx.logger) {
-    config.logger = ctx.logger
+    config.logger = ctx.logger;
   }
 
   if (ctx.validator) {
-    config.validator = ctx.validator
+    config.validator = ctx.validator;
   }
 
-  await writeFile(
-    path.join(root, '.taser.json'),
-    `${JSON.stringify(config, null, 2)}\n`,
-    'utf8',
-  )
+  await writeFile(path.join(root, ".taser.json"), `${JSON.stringify(config, null, 2)}\n`, "utf8");
 }

package/src/core/resolve-packages.ts

@@ -1,51 +1,88 @@
-import { resolveAddons } from '../addons/registry.js'
-import type { PackageGroups, ScaffoldContext, Framework } from '../core/types.js'
+import { resolveAddons } from "../addons/registry.js";
+import type { PackageGroups, ProjectType, ScaffoldContext } from "../core/types.js";
 
-function frameworkPackages(framework: Framework): PackageGroups {
-  const dependencies = ['@taserjs/router']
+function typePackages(type: ProjectType): PackageGroups {
+  const dependencies = ["@taserjs/router", "dotenv"];
   const devDependencies = [
-    '@taserjs/router-cli',
-    'npm-run-all2',
-    'tsdown',
-    'tsx',
-    'typescript',
-    '@types/node',
-  ]
-  const scripts: Record<string, string> = {}
-
-  switch (framework) {
-    case 'express':
-      dependencies.push('@taserjs/adapter-express', 'express')
-      devDependencies.push('@types/express')
-      break
-    case 'hono':
-      dependencies.push('@hono/node-server', 'hono')
-      break
-    case 'fastify':
-      dependencies.push('@taserjs/adapter-fastify', 'fastify')
-      break
-    case 'node':
+    "@taserjs/router-cli",
+    "npm-run-all2",
+    "tsdown",
+    "tsx",
+    "typescript",
+    "@types/node",
+  ];
+  const scripts: Record<string, string> = {};
+
+  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;
+    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;
+    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":
+    case "node":
     default:
-      dependencies.push('@taserjs/adapter-node')
-      break
+      dependencies.push("@hono/node-server");
+      break;
   }
 
-  return { dependencies, devDependencies, scripts }
+  return { dependencies, devDependencies, scripts };
 }
 
 export function resolvePackages(ctx: ScaffoldContext): PackageGroups {
-  const base = frameworkPackages(ctx.framework)
-  const addons = resolveAddons(ctx)
+  const base = typePackages(ctx.type);
+  const addons = resolveAddons(ctx);
 
-  const dependencies = [...base.dependencies]
-  const devDependencies = [...base.devDependencies]
-  const scripts = { ...base.scripts }
+  const dependencies = [...base.dependencies];
+  const devDependencies = [...base.devDependencies];
+  const scripts = { ...base.scripts };
 
   for (const addon of addons) {
-    dependencies.push(...addon.dependencies(ctx))
-    devDependencies.push(...addon.devDependencies(ctx))
+    dependencies.push(...addon.dependencies(ctx));
+    devDependencies.push(...addon.devDependencies(ctx));
     if (addon.scripts) {
-      Object.assign(scripts, addon.scripts(ctx))
+      Object.assign(scripts, addon.scripts(ctx));
     }
   }
 
@@ -53,11 +90,12 @@ export function resolvePackages(ctx: ScaffoldContext): PackageGroups {
     dependencies: [...new Set(dependencies)],
     devDependencies: [...new Set(devDependencies)],
     scripts,
-  }
+  };
 }
 
-// Backward-compatible export for tests during migration
-export function getPackageGroups(framework: Framework): Omit<PackageGroups, 'scripts'> & { scripts?: Record<string, string> } {
-  const groups = frameworkPackages(framework)
-  return groups
+export function getPackageGroups(
+  type: ProjectType,
+): Omit<PackageGroups, "scripts"> & { scripts?: Record<string, string> } {
+  const groups = typePackages(type);
+  return groups;
 }

package/src/core/scaffold-engine.ts

@@ -1,12 +1,12 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import path from 'node:path'
+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 { 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 { collectBootBindings, resolveAddons } from "../addons/registry.js";
+import { indexTemplate, taserTsTemplate } 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 {
   contextTemplate,
   gitignoreTemplate,
@@ -17,69 +17,139 @@ import {
   starterManifestTemplate,
   tsconfigTemplate,
   tsdownConfigTemplate,
-} from '../templates/base.js'
+} from "../templates/base.js";
 
 async function write(filePath: string, contents: string): Promise<void> {
-  await mkdir(path.dirname(filePath), { recursive: true })
-  await writeFile(filePath, contents, 'utf8')
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, contents, "utf8");
 }
 
 export async function scaffoldProject(options: ScaffoldOptions): Promise<ScaffoldResult> {
-  const root = options.targetDir
+  const root = options.targetDir;
   const ctx = {
     projectName: options.projectName,
     targetDir: root,
-    framework: options.framework,
+    type: options.type,
     ...(options.db ? { db: options.db, driver: options.driver } : {}),
     ...(options.logger ? { logger: options.logger } : {}),
     ...(options.validator ? { validator: options.validator } : {}),
+  };
+
+  const addons = resolveAddons(ctx);
+  const packages = resolvePackages(ctx);
+  const bootBindings = collectBootBindings(ctx);
+
+  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, ".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/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",
+    );
   }
 
-  const addons = resolveAddons(ctx)
-  const packages = resolvePackages(ctx)
-  const bootBindings = collectBootBindings(ctx)
+  if (options.type === "vercel") {
+    await write(
+      path.join(root, "vercel.json"),
+      JSON.stringify(
+        {
+          rewrites: [{ source: "/(.*)", destination: "/src/index.ts" }],
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+  }
 
-  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, '.gitignore'), gitignoreTemplate())
-  await write(path.join(root, 'src/context.ts'), contextTemplate(bootBindings))
-  await write(path.join(root, 'src/taser.ts'), taserTsTemplate(options.framework))
-  await write(path.join(root, 'src/index.ts'), indexTemplate(options.framework))
-  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 === "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(
+    addons.map(async (addon) => {
+      await addon.apply(ctx, (filePath, contents) => write(path.join(root, filePath), contents));
+    }),
+  );
 
-  for (const addon of addons) {
-    await addon.apply(ctx, (filePath, contents) => write(path.join(root, filePath), contents))
+  try {
+    await copyFile(path.join(root, ".env.example"), path.join(root, ".env"));
+  } catch {
+    // .env.example was not created
   }
 
-  await writeProjectConfig(root, ctx)
+  await writeProjectConfig(root, ctx);
 
   if (options.skipInstall) {
     return {
       projectName: ctx.projectName,
       targetDir: root,
-      framework: ctx.framework,
+      type: ctx.type,
       ...(ctx.db ? { db: ctx.db, driver: ctx.driver } : {}),
       ...(ctx.logger ? { logger: ctx.logger } : {}),
       ...(ctx.validator ? { validator: ctx.validator } : {}),
-    }
+    };
   }
 
-  const agent = options.agent ?? resolveUserAgent()
+  const agent = options.agent ?? resolveUserAgent();
   await installPackages(agent, root, {
     dependencies: packages.dependencies,
     devDependencies: packages.devDependencies,
-  })
+  });
 
   return {
     projectName: ctx.projectName,
     targetDir: root,
-    framework: ctx.framework,
+    type: ctx.type,
     ...(ctx.db ? { db: ctx.db, driver: ctx.driver } : {}),
     ...(ctx.logger ? { logger: ctx.logger } : {}),
     ...(ctx.validator ? { validator: ctx.validator } : {}),
-  }
+  };
 }

package/src/core/types.ts

@@ -1,57 +1,82 @@
-import type { Agent } from 'package-manager-detector'
+import type { Agent } from "package-manager-detector";
 
-export type Framework = 'node' | 'express' | 'hono' | 'fastify'
+export type ProjectType =
+  | "node"
+  | "express"
+  | "fastify"
+  | "hono"
+  | "bun"
+  | "deno"
+  | "aws-lambda"
+  | "cloudflare-workers"
+  | "netlify"
+  | "vercel"
+  | "azure-functions"
+  | "google-cloud-run";
 
-export const FRAMEWORKS: readonly Framework[] = ['node', 'express', 'hono', 'fastify']
+export const PROJECT_TYPES: readonly ProjectType[] = [
+  "node",
+  "express",
+  "fastify",
+  "hono",
+  "bun",
+  "deno",
+  "aws-lambda",
+  "cloudflare-workers",
+  "netlify",
+  "vercel",
+  "azure-functions",
+  "google-cloud-run",
+];
 
-export type DbOdm = 'drizzle' | 'prisma' | 'kysely'
+export type DbOdm = "drizzle" | "prisma" | "kysely";
 
-export const DB_ODMS: readonly DbOdm[] = ['drizzle', 'prisma', 'kysely']
+export const DB_ODMS: readonly DbOdm[] = ["drizzle", "prisma", "kysely"];
 
-export type DbDriver = 'postgres' | 'sqlite' | 'mysql'
+export type DbDriver = "postgres" | "sqlite" | "mysql";
 
-export const DB_DRIVERS: readonly DbDriver[] = ['postgres', 'sqlite', 'mysql']
+export const DB_DRIVERS: readonly DbDriver[] = ["postgres", "sqlite", "mysql"];
 
-export const DEFAULT_DB_DRIVER: DbDriver = 'sqlite'
+export const DEFAULT_DB_DRIVER: DbDriver = "sqlite";
 
-export type LoggerId = 'pino' | 'winston'
+export type LoggerId = "pino" | "winston";
 
-export const LOGGERS: readonly LoggerId[] = ['pino', 'winston']
+export const LOGGERS: readonly LoggerId[] = ["pino", "winston"];
 
-export type ValidatorId = 'zod' | 'arktype' | 'valibot'
+export type ValidatorId = "zod" | "arktype" | "valibot";
 
-export const VALIDATORS: readonly ValidatorId[] = ['zod', 'arktype', 'valibot']
+export const VALIDATORS: readonly ValidatorId[] = ["zod", "arktype", "valibot"];
 
 export type PackageGroups = {
-  dependencies: string[]
-  devDependencies: string[]
-  scripts: Record<string, string>
-}
+  dependencies: string[];
+  devDependencies: string[];
+  scripts: Record<string, string>;
+};
 
 export type ScaffoldContext = {
-  projectName: string
-  targetDir: string
-  framework: Framework
-  db?: DbOdm
-  driver?: DbDriver
-  logger?: LoggerId
-  validator?: ValidatorId
-}
+  projectName: string;
+  targetDir: string;
+  type: ProjectType;
+  db?: DbOdm;
+  driver?: DbDriver;
+  logger?: LoggerId;
+  validator?: ValidatorId;
+};
 
 export type ScaffoldOptions = ScaffoldContext & {
-  skipInstall?: boolean
-  agent?: Agent
-}
+  skipInstall?: boolean;
+  agent?: Agent;
+};
 
-export type ScaffoldResult = ScaffoldContext
+export type ScaffoldResult = ScaffoldContext;
 
 export type CapabilitiesCatalog = {
-  frameworks: Framework[]
+  types: ProjectType[];
   db: {
-    odms: DbOdm[]
-    drivers: DbDriver[]
-    defaultDriver: DbDriver
-  }
-  loggers: LoggerId[]
-  validators: ValidatorId[]
-}
+    odms: DbOdm[];
+    drivers: DbDriver[];
+    defaultDriver: DbDriver;
+  };
+  loggers: LoggerId[];
+  validators: ValidatorId[];
+};