create-taserjs 0.0.1 → 0.0.3

package/src/commands/create.ts

@@ -1,233 +1,258 @@
-import path from 'node:path'
+import path from "node:path";
 
-import * as p from '@clack/prompts'
-import color from 'picocolors'
+import * as p from "@clack/prompts";
+import color from "picocolors";
 
-import { getCapabilitiesCatalog } from '../addons/registry.js'
-import { printCapabilitiesCatalog, printJsonError, printScaffoldResult } from '../core/json-output.js'
+import { getCapabilitiesCatalog } from "../addons/registry.js";
+import {
+  printCapabilitiesCatalog,
+  printJsonError,
+  printScaffoldResult,
+} from "../core/json-output.js";
 import {
   parseDbFlag,
-  parseFrameworkFlag,
   parseLoggerFlag,
+  parseTypeFlag,
+  parseValidatorFlag,
   type ParsedCreateArgs,
   resolveScaffoldDefaults,
-} from '../core/parse-options.js'
-import { scaffoldProject } from '../core/scaffold-engine.js'
-import type { DbDriver, DbOdm, Framework, LoggerId, ScaffoldResult, ValidatorId } from '../core/types.js'
-import { DB_DRIVERS, DB_ODMS, FRAMEWORKS, LOGGERS, VALIDATORS } from '../core/types.js'
-import { validateProjectName } from '../core/validate-project-name.js'
-import { resolveUserAgent, runScript } from '../core/package-manager.js'
-
-function isFramework(value: unknown): value is Framework {
-  return typeof value === 'string' && (FRAMEWORKS as readonly string[]).includes(value)
+} from "../core/parse-options.js";
+import { scaffoldProject } from "../core/scaffold-engine.js";
+import type {
+  DbDriver,
+  DbOdm,
+  LoggerId,
+  ProjectType,
+  ScaffoldResult,
+  ValidatorId,
+} from "../core/types.js";
+import { DB_DRIVERS, DB_ODMS, LOGGERS, PROJECT_TYPES, VALIDATORS } from "../core/types.js";
+import { validateProjectName } from "../core/validate-project-name.js";
+import { resolveUserAgent, runScript } from "../core/package-manager.js";
+
+function isProjectType(value: unknown): value is ProjectType {
+  return typeof value === "string" && (PROJECT_TYPES as readonly string[]).includes(value);
 }
 
 function isDbOdm(value: unknown): value is DbOdm {
-  return typeof value === 'string' && (DB_ODMS as readonly string[]).includes(value)
+  return typeof value === "string" && (DB_ODMS as readonly string[]).includes(value);
 }
 
 function isDbDriver(value: unknown): value is DbDriver {
-  return typeof value === 'string' && (DB_DRIVERS as readonly string[]).includes(value)
+  return typeof value === "string" && (DB_DRIVERS as readonly string[]).includes(value);
 }
 
 function isLoggerId(value: unknown): value is LoggerId {
-  return typeof value === 'string' && (LOGGERS as readonly string[]).includes(value)
+  return typeof value === "string" && (LOGGERS as readonly string[]).includes(value);
 }
 
 function isValidatorId(value: unknown): value is ValidatorId {
-  return typeof value === 'string' && (VALIDATORS as readonly string[]).includes(value)
+  return typeof value === "string" && (VALIDATORS as readonly string[]).includes(value);
 }
 
-async function promptInteractiveOptions(
-  args: ParsedCreateArgs,
-): Promise<ParsedCreateArgs> {
-  const projectName = args.projectName
-    ?? await p.text({
-      message: 'Project name',
-      placeholder: 'my-taser-app',
-      defaultValue: 'my-taser-app',
+async function promptInteractiveOptions(args: ParsedCreateArgs): Promise<ParsedCreateArgs> {
+  const projectName =
+    args.projectName ??
+    (await p.text({
+      message: "Project name",
+      placeholder: "my-taser-app",
+      defaultValue: "my-taser-app",
       validate(value) {
-        return validateProjectName(value)
+        return validateProjectName(value);
       },
-    })
+    }));
 
   if (p.isCancel(projectName)) {
-    p.cancel('Scaffold cancelled.')
-    process.exit(0)
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
   }
 
-  const framework = args.framework
-    ?? await p.select({
-      message: 'Framework adapter',
+  const type =
+    args.type ??
+    (await p.select({
+      message: "Project type (runtime / framework)",
       options: [
-        { value: 'node', label: 'Plain Node.js', hint: 'default' },
-        { value: 'express', label: 'Express' },
-        { value: 'hono', label: 'Hono' },
-        { value: 'fastify', label: 'Fastify' },
+        { value: "node", label: "Node.js", hint: "default" },
+        { value: "express", label: "Express" },
+        { value: "fastify", label: "Fastify" },
+        { value: "hono", label: "Hono" },
+        { value: "bun", label: "Bun" },
+        { value: "deno", label: "Deno" },
+        { value: "aws-lambda", label: "AWS Lambda" },
+        { value: "cloudflare-workers", label: "Cloudflare Workers" },
+        { value: "netlify", label: "Netlify" },
+        { value: "vercel", label: "Vercel" },
+        { value: "azure-functions", label: "Azure Functions" },
+        { value: "google-cloud-run", label: "Google Cloud Run" },
       ],
-      initialValue: 'node',
-    })
+      initialValue: "node",
+    }));
 
-  if (p.isCancel(framework) || !isFramework(framework)) {
-    p.cancel('Scaffold cancelled.')
-    process.exit(0)
+  if (p.isCancel(type) || !isProjectType(type)) {
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
   }
 
-  const dbChoice = args.db
-    ?? await p.select({
-      message: 'Database',
+  const dbChoice =
+    args.db ??
+    (await p.select({
+      message: "Database",
       options: [
-        { value: 'none', label: 'None', hint: 'default' },
-        { value: 'drizzle', label: 'Drizzle' },
-        { value: 'prisma', label: 'Prisma' },
-        { value: 'kysely', label: 'Kysely' },
+        { value: "none", label: "None", hint: "default" },
+        { value: "drizzle", label: "Drizzle" },
+        { value: "prisma", label: "Prisma" },
+        { value: "kysely", label: "Kysely" },
       ],
-      initialValue: 'none',
-    })
+      initialValue: "none",
+    }));
 
   if (p.isCancel(dbChoice)) {
-    p.cancel('Scaffold cancelled.')
-    process.exit(0)
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
   }
 
-  let db: DbOdm | undefined
-  let driver: DbDriver | undefined
+  let db: DbOdm | undefined;
+  let driver: DbDriver | undefined;
 
-  if (dbChoice !== 'none' && isDbOdm(dbChoice)) {
-    db = dbChoice
-    const driverChoice = args.driver
-      ?? await p.select({
-        message: 'Database driver',
+  if (dbChoice !== "none" && isDbOdm(dbChoice)) {
+    db = dbChoice;
+    const driverChoice =
+      args.driver ??
+      (await p.select({
+        message: "Database driver",
         options: [
-          { value: 'sqlite', label: 'SQLite', hint: 'default' },
-          { value: 'postgres', label: 'PostgreSQL' },
-          { value: 'mysql', label: 'MySQL' },
+          { value: "sqlite", label: "SQLite", hint: "default" },
+          { value: "postgres", label: "PostgreSQL" },
+          { value: "mysql", label: "MySQL" },
         ],
-        initialValue: 'sqlite',
-      })
+        initialValue: "sqlite",
+      }));
 
     if (p.isCancel(driverChoice) || !isDbDriver(driverChoice)) {
-      p.cancel('Scaffold cancelled.')
-      process.exit(0)
+      p.cancel("Scaffold cancelled.");
+      process.exit(0);
     }
-    driver = driverChoice
+    driver = driverChoice;
   }
 
-  const loggerChoice = args.logger
-    ?? await p.select({
-      message: 'Logger',
+  const loggerChoice =
+    args.logger ??
+    (await p.select({
+      message: "Logger",
       options: [
-        { value: 'none', label: 'None', hint: 'default' },
-        { value: 'pino', label: 'Pino' },
-        { value: 'winston', label: 'Winston' },
+        { value: "none", label: "None", hint: "default" },
+        { value: "pino", label: "Pino" },
+        { value: "winston", label: "Winston" },
       ],
-      initialValue: 'none',
-    })
+      initialValue: "none",
+    }));
 
   if (p.isCancel(loggerChoice)) {
-    p.cancel('Scaffold cancelled.')
-    process.exit(0)
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
   }
 
-  const logger = loggerChoice === 'none' ? undefined : isLoggerId(loggerChoice) ? loggerChoice : undefined
+  const logger =
+    loggerChoice === "none" ? undefined : isLoggerId(loggerChoice) ? loggerChoice : undefined;
 
-  const validatorChoice = args.validator
-    ?? await p.select({
-      message: 'Validator',
+  const validatorChoice =
+    args.validator ??
+    (await p.select({
+      message: "Validator",
       options: [
-        { value: 'none', label: 'None', hint: 'default' },
-        { value: 'zod', label: 'Zod' },
-        { value: 'arktype', label: 'Arktype' },
-        { value: 'valibot', label: 'Valibot' },
+        { value: "none", label: "None", hint: "default" },
+        { value: "zod", label: "Zod" },
+        { value: "arktype", label: "Arktype" },
+        { value: "valibot", label: "Valibot" },
       ],
-      initialValue: 'none',
-    })
+      initialValue: "none",
+    }));
 
   if (p.isCancel(validatorChoice)) {
-    p.cancel('Scaffold cancelled.')
-    process.exit(0)
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
   }
 
-  const validator = validatorChoice === 'none' ? undefined : isValidatorId(validatorChoice) ? validatorChoice : undefined
+  const validator =
+    validatorChoice === "none"
+      ? undefined
+      : isValidatorId(validatorChoice)
+        ? validatorChoice
+        : undefined;
 
   return {
     projectName: String(projectName).trim(),
-    framework,
+    type,
     yes: args.yes,
     noInstall: args.noInstall,
     json: args.json,
     ...(db ? { db, driver: driver! } : {}),
     ...(logger ? { logger } : {}),
     ...(validator ? { validator } : {}),
-  }
+  };
 }
 
-export async function runCreateCommand(args: ParsedCreateArgs): Promise<ScaffoldResult | undefined> {
+export async function runCreateCommand(
+  args: ParsedCreateArgs,
+): Promise<ScaffoldResult | undefined> {
   if (args.json && !args.projectName) {
-    printCapabilitiesCatalog(getCapabilitiesCatalog())
-    return undefined
+    printCapabilitiesCatalog(getCapabilitiesCatalog());
+    return undefined;
   }
 
-  const cwd = process.cwd()
-  const interactive = !args.yes
+  const cwd = process.cwd();
+  const interactive = !args.yes;
   const resolved = interactive
     ? await promptInteractiveOptions(args)
     : {
         ...args,
         projectName: args.projectName?.trim(),
-        framework: args.framework ?? 'node',
-      }
+        type: args.type ?? "node",
+      };
 
   if (!resolved.projectName) {
-    const message = 'Project name is required'
+    const message = "Project name is required";
     if (args.json) {
-      printJsonError(message)
-      process.exit(1)
+      printJsonError(message);
+      process.exit(1);
     }
-    throw new Error(message)
+    throw new Error(message);
   }
 
-  const nameError = validateProjectName(resolved.projectName, cwd)
+  const nameError = validateProjectName(resolved.projectName, cwd);
   if (nameError) {
     if (args.json) {
-      printJsonError(nameError)
-      process.exit(1)
+      printJsonError(nameError);
+      process.exit(1);
     }
-    throw new Error(nameError)
+    throw new Error(nameError);
   }
 
-  const targetDir = path.resolve(cwd, resolved.projectName)
+  const targetDir = path.resolve(cwd, resolved.projectName);
   const scaffoldCtx = resolveScaffoldDefaults({
     ...resolved,
     projectName: resolved.projectName,
-  })
-  scaffoldCtx.targetDir = targetDir
+  });
+  scaffoldCtx.targetDir = targetDir;
 
   if (!args.json) {
-    const spinner = p.spinner()
-    spinner.start('Scaffolding project')
+    const spinner = p.spinner();
+    spinner.start("Scaffolding project");
     try {
       const result = await scaffoldProject({
         ...scaffoldCtx,
         targetDir,
         skipInstall: args.noInstall,
         agent: resolveUserAgent(),
-      })
-      spinner.stop('Project created')
-      const cdPath = path.relative(cwd, targetDir) || '.'
-      p.note(
-        [
-          `cd ${cdPath}`,
-          runScript(resolveUserAgent(), 'dev'),
-        ].join('\n'),
-        'Next steps',
-      )
-      p.outro(color.green('Done.'))
-      return result
-    }
-    catch (error) {
-      spinner.stop('Scaffold failed')
-      throw error
+      });
+      spinner.stop("Project created");
+      const cdPath = path.relative(cwd, targetDir) || ".";
+      p.note([`cd ${cdPath}`, runScript(resolveUserAgent(), "dev")].join("\n"), "Next steps");
+      p.outro(color.green("Done."));
+      return result;
+    } catch (error) {
+      spinner.stop("Scaffold failed");
+      throw error;
     }
   }
 
@@ -236,42 +261,52 @@ export async function runCreateCommand(args: ParsedCreateArgs): Promise<Scaffold
     targetDir,
     skipInstall: args.noInstall,
     agent: resolveUserAgent(),
-  })
-  printScaffoldResult(result)
-  return result
+  });
+  printScaffoldResult(result);
+  return result;
 }
 
-export function buildParsedArgsFromCli(values: {
-  framework?: string
-  db?: string
-  logger?: string
-  y?: boolean
-  noInstall?: boolean
-  json?: boolean
-}, positionals: string[]): ParsedCreateArgs {
+export function buildParsedArgsFromCli(
+  values: {
+    type?: string;
+    framework?: string;
+    db?: string;
+    logger?: string;
+    validator?: string;
+    y?: boolean;
+    noInstall?: boolean;
+    json?: boolean;
+  },
+  positionals: string[],
+): ParsedCreateArgs {
   const args: ParsedCreateArgs = {
     yes: values.y ?? false,
     noInstall: values.noInstall ?? false,
     json: values.json ?? false,
-  }
+  };
 
   if (positionals[0]) {
-    args.projectName = positionals[0]
+    args.projectName = positionals[0];
   }
 
-  if (values.framework) {
-    args.framework = parseFrameworkFlag(values.framework)
+  const typeFlag = values.type ?? values.framework;
+  if (typeFlag) {
+    args.type = parseTypeFlag(typeFlag);
   }
 
   if (values.db) {
-    const parsed = parseDbFlag(values.db)
-    args.db = parsed.db
-    args.driver = parsed.driver
+    const parsed = parseDbFlag(values.db);
+    args.db = parsed.db;
+    args.driver = parsed.driver;
   }
 
   if (values.logger) {
-    args.logger = parseLoggerFlag(values.logger)
+    args.logger = parseLoggerFlag(values.logger);
+  }
+
+  if (values.validator) {
+    args.validator = parseValidatorFlag(values.validator);
   }
 
-  return args
+  return args;
 }

package/src/core/json-output.ts

@@ -1,13 +1,13 @@
-import type { CapabilitiesCatalog, ScaffoldResult } from './types.js'
+import type { CapabilitiesCatalog, ScaffoldResult } from "./types.js";
 
 export function printCapabilitiesCatalog(catalog: CapabilitiesCatalog): void {
-  console.log(JSON.stringify(catalog, null, 2))
+  console.log(JSON.stringify(catalog, null, 2));
 }
 
 export function printScaffoldResult(result: ScaffoldResult): void {
-  console.log(JSON.stringify(result, null, 2))
+  console.log(JSON.stringify(result, null, 2));
 }
 
 export function printJsonError(message: string): void {
-  console.error(JSON.stringify({ error: message }))
+  console.error(JSON.stringify({ error: message }));
 }

package/src/core/package-manager.ts

@@ -1,68 +1,72 @@
-import { spawn } from 'node:child_process'
+import { spawn } from "node:child_process";
 
-import type { Agent, ResolvedCommand } from 'package-manager-detector'
-import { resolveCommand } from 'package-manager-detector/commands'
-import { getUserAgent } from 'package-manager-detector/detect'
+import type { Agent, ResolvedCommand } from "package-manager-detector";
+import { resolveCommand } from "package-manager-detector/commands";
+import { getUserAgent } from "package-manager-detector/detect";
 
 export function resolveUserAgent(): Agent {
-  return getUserAgent() || 'npm'
+  return getUserAgent() || "npm";
 }
 
 function runCommand(command: string, args: string[], cwd: string): Promise<void> {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
-      stdio: 'inherit',
+      stdio: "inherit",
       shell: false,
       env: process.env,
-    })
-    child.on('error', reject)
-    child.on('close', (code) => {
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
       if (code === 0) {
-        resolve()
-        return
+        resolve();
+        return;
       }
-      reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`))
-    })
-  })
+      reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
 }
 
-const fallback = {
-  agent: 'npm',
-  install: (packages: string[], dev: boolean) => {
-    return ['install', ...packages, dev ? '-D' : '']
-  },
-}
-
-function resolveInstallCommand(agent: Agent, packages: string[], dev: boolean): ResolvedCommand {
-  const command = resolveCommand(agent, 'install', packages)
-  if (command) return command
+export function resolveInstallCommand(
+  agent: Agent,
+  packages: string[],
+  dev: boolean,
+): ResolvedCommand {
+  const args = dev ? ["-D", ...packages] : packages;
+  const command = resolveCommand(agent, "add", args);
+  if (command) return command;
 
-  return { command: fallback.agent, args: fallback.install(packages, dev) }
+  return {
+    command: "npm",
+    args: ["install", ...args],
+  };
 }
 
 export async function installPackages(
   agent: Agent,
   cwd: string,
-  { dependencies, devDependencies }: {
-    dependencies: string[]
-    devDependencies: string[]
+  {
+    dependencies,
+    devDependencies,
+  }: {
+    dependencies: string[];
+    devDependencies: string[];
   },
 ): Promise<void> {
   if (dependencies.length > 0) {
-    const { command, args } = resolveInstallCommand(agent, dependencies, false)
-    await runCommand(command, args, cwd)
+    const { command, args } = resolveInstallCommand(agent, dependencies, false);
+    await runCommand(command, args, cwd);
   }
   if (devDependencies.length > 0) {
-    const { command, args } = resolveInstallCommand(agent, devDependencies, true)
-    await runCommand(command, args, cwd)
+    const { command, args } = resolveInstallCommand(agent, devDependencies, true);
+    await runCommand(command, args, cwd);
   }
 }
 
 export function runScript(agent: Agent, script: string): string {
-  const resolved = resolveCommand(agent, 'run', [script])
+  const resolved = resolveCommand(agent, "run", [script]);
   if (!resolved) {
-    throw new Error(`Unable to resolve run command for ${agent}`)
+    throw new Error(`Unable to resolve run command for ${agent}`);
   }
-  return `${resolved.command} ${resolved.args.join(' ')}`
+  return `${resolved.command} ${resolved.args.join(" ")}`;
 }