create-taserjs 0.1.12 → 0.2.0

package/src/addons/prisma/index.ts

@@ -1,7 +1,6 @@
 import type { AddonDefinition } from "../types.js";
 import type { DbDriver } from "../../core/types.js";
 
-/** Latest Prisma ORM v7 release line — keep all @prisma/* packages on this range. */
 const PRISMA_VERSION = "^7.10.0";
 
 function prismaPackage(name: string): string {
@@ -59,53 +58,50 @@ function driverDevPackages(driver: DbDriver): string[] {
 function dbIndexSource(driver: DbDriver): string {
   switch (driver) {
     case "postgres":
-      return `import { PrismaPg } from '@prisma/adapter-pg'
-
-import { PrismaClient } from './prisma/client.js'
+      return `import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "./prisma/client.js";
 
 export function createDb() {
   const adapter = new PrismaPg({
     connectionString: process.env.DATABASE_URL,
-  })
-  return new PrismaClient({ adapter })
+  });
+  return new PrismaClient({ adapter });
 }
 `;
     case "mysql":
-      return `import { PrismaMariaDb } from '@prisma/adapter-mariadb'
-
-import { PrismaClient } from './prisma/client.js'
+      return `import { PrismaMariaDb } from "@prisma/adapter-mariadb";
+import { PrismaClient } from "./prisma/client.js";
 
 export function createDb() {
-  const adapter = new PrismaMariaDb(process.env.DATABASE_URL ?? 'mariadb://root:@localhost:3306/mydb')
-  return new PrismaClient({ adapter })
+  const adapter = new PrismaMariaDb(process.env.DATABASE_URL ?? "mariadb://root:@localhost:3306/mydb");
+  return new PrismaClient({ adapter });
 }
 `;
     case "sqlite":
     default:
-      return `import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3'
-
-import { PrismaClient } from './prisma/client.js'
+      return `import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
+import { PrismaClient } from "./prisma/client.js";
 
 export function createDb() {
   const adapter = new PrismaBetterSqlite3({
-    url: process.env.DATABASE_URL ?? 'file:./local.db',
-  })
-  return new PrismaClient({ adapter })
+    url: process.env.DATABASE_URL ?? "file:./local.db",
+  });
+  return new PrismaClient({ adapter });
 }
 `;
   }
 }
 
 function prismaConfigSource(): string {
-  return `import 'dotenv/config'
-import { defineConfig, env } from 'prisma/config'
+  return `import "dotenv/config";
+import { defineConfig, env } from "prisma/config";
 
 export default defineConfig({
-  schema: 'prisma/schema.prisma',
+  schema: "prisma/schema.prisma",
   datasource: {
-    url: env('DATABASE_URL'),
+    url: env("DATABASE_URL"),
   },
-})
+});
 `;
 }
 

package/src/addons/registry.ts

@@ -1,86 +1,50 @@
-import { arktypeAddon } from "./arktype/index.js";
 import { drizzleAddon } from "./drizzle/index.js";
 import { kyselyAddon } from "./kysely/index.js";
 import { pinoAddon } from "./pino/index.js";
 import { prismaAddon } from "./prisma/index.js";
-import { valibotAddon } from "./valibot/index.js";
+import type { AddonDefinition, BootBinding } from "./types.js";
+import { ValidatorAddon } from "./validators.js";
 import { winstonAddon } from "./winston/index.js";
-import { zodAddon } from "./zod/index.js";
-import type { AddonDefinition } from "./types.js";
-import type { CapabilitiesCatalog, ScaffoldContext } from "../core/types.js";
-import {
-  DB_DRIVERS,
-  DB_ODMS,
-  DEFAULT_DB_DRIVER,
-  DEPLOY_TARGETS,
-  FRAMEWORKS,
-  LOGGERS,
-  RUNTIMES,
-  VALIDATORS,
-} from "../core/types.js";
-
-const ALL_ADDONS: AddonDefinition[] = [
-  drizzleAddon,
-  prismaAddon,
-  kyselyAddon,
-  pinoAddon,
-  winstonAddon,
-  zodAddon,
-  arktypeAddon,
-  valibotAddon,
-];
-
-const DB_ADDONS = ALL_ADDONS.filter((addon) => addon.category === "database");
-const LOGGER_ADDONS = ALL_ADDONS.filter((addon) => addon.category === "logger");
-const VALIDATOR_ADDONS = ALL_ADDONS.filter((addon) => addon.category === "validator");
-
-export function getCapabilitiesCatalog(): CapabilitiesCatalog {
-  return {
-    frameworks: [...FRAMEWORKS],
-    deployTargets: [...DEPLOY_TARGETS],
-    runtimes: [...RUNTIMES],
-    db: {
-      odms: [...DB_ODMS],
-      drivers: [...DB_DRIVERS],
-      defaultDriver: DEFAULT_DB_DRIVER,
-    },
-    loggers: [...LOGGERS],
-    validators: [...VALIDATORS],
-  };
-}
+import type { ScaffoldContext } from "../core/types.js";
+
+export const ADDONS: Record<string, AddonDefinition> = {
+  drizzle: drizzleAddon,
+  prisma: prismaAddon,
+  kysely: kyselyAddon,
+  pino: pinoAddon,
+  winston: winstonAddon,
+  zod: ValidatorAddon("zod"),
+  arktype: ValidatorAddon("arktype"),
+  valibot: ValidatorAddon("valibot"),
+};
 
 export function resolveAddons(ctx: ScaffoldContext): AddonDefinition[] {
-  const selected: AddonDefinition[] = [];
-
-  if (ctx.db) {
-    const dbAddon = DB_ADDONS.find((addon) => addon.id === ctx.db);
-    if (!dbAddon) {
-      throw new Error(`Unknown database addon "${ctx.db}"`);
-    }
-    selected.push(dbAddon);
+  const result: AddonDefinition[] = [];
+  if (ctx.db && ADDONS[ctx.db]) {
+    const addon = ADDONS[ctx.db];
+    if (addon) result.push(addon);
   }
-
-  if (ctx.logger) {
-    const loggerAddon = LOGGER_ADDONS.find((addon) => addon.id === ctx.logger);
-    if (!loggerAddon) {
-      throw new Error(`Unknown logger addon "${ctx.logger}"`);
-    }
-    selected.push(loggerAddon);
+  if (ctx.logger && ADDONS[ctx.logger]) {
+    const addon = ADDONS[ctx.logger];
+    if (addon) result.push(addon);
   }
-
-  if (ctx.validator) {
-    const validatorAddon = VALIDATOR_ADDONS.find((addon) => addon.id === ctx.validator);
-    if (!validatorAddon) {
-      throw new Error(`Unknown validator addon "${ctx.validator}"`);
-    }
-    selected.push(validatorAddon);
+  if (ctx.validator && ADDONS[ctx.validator]) {
+    const addon = ADDONS[ctx.validator];
+    if (addon) result.push(addon);
   }
-
-  return selected;
+  return result;
 }
 
-export function collectBootBindings(ctx: ScaffoldContext) {
-  return resolveAddons(ctx)
-    .map((addon) => addon.bootBinding?.(ctx))
-    .filter((v): v is NonNullable<typeof v> => Boolean(v));
+export function collectBootBindings(ctx: ScaffoldContext): BootBinding[] {
+  const addons = resolveAddons(ctx);
+  const bindings: BootBinding[] = [];
+  for (const addon of addons) {
+    if (addon.bootBinding) {
+      const binding = addon.bootBinding(ctx);
+      if (binding) {
+        bindings.push(binding);
+      }
+    }
+  }
+  return bindings;
 }

package/src/addons/types.ts

@@ -1,19 +1,18 @@
-import type { ScaffoldContext } from "../core/types.js";
-
-export type BootBinding = {
+export interface BootBinding {
   key: string;
   importPath: string;
   factoryName: string;
-};
-
-export type FileWriter = (filePath: string, contents: string) => Promise<void>;
+}
 
-export type AddonDefinition = {
+export interface AddonDefinition {
   id: string;
   category: "database" | "logger" | "validator";
-  dependencies: (ctx: ScaffoldContext) => string[];
-  devDependencies: (ctx: ScaffoldContext) => string[];
-  scripts?: (ctx: ScaffoldContext) => Record<string, string>;
-  bootBinding?: (ctx: ScaffoldContext) => BootBinding;
-  apply: (ctx: ScaffoldContext, write: FileWriter) => Promise<void>;
-};
+  dependencies(ctx: import("../core/types.js").ScaffoldContext): string[];
+  devDependencies(ctx: import("../core/types.js").ScaffoldContext): string[];
+  scripts?(ctx: import("../core/types.js").ScaffoldContext): Record<string, string>;
+  bootBinding?(ctx: import("../core/types.js").ScaffoldContext): BootBinding | undefined;
+  apply(
+    ctx: import("../core/types.js").ScaffoldContext,
+    write: (path: string, content: string) => Promise<void> | void,
+  ): Promise<void>;
+}

package/src/addons/validators.ts

@@ -1,37 +1,36 @@
-import type { ValidatorId } from "../core/types";
-import type { AddonDefinition } from "./types";
+import type { ValidatorId } from "../core/types.js";
+import type { AddonDefinition } from "./types.js";
 
 export const IMPORT_LINES: Record<ValidatorId, string> = {
-  zod: `import { z } from 'zod'`,
-  arktype: `import { type } from 'arktype'`,
-  valibot: `import * as v from 'valibot'`,
+  zod: `import { z } from "zod";`,
+  arktype: `import { type } from "arktype";`,
+  valibot: `import * as v from "valibot";`,
 };
 
-export const VALIDATION_BLOCK_TEMPLATE: Record<ValidatorId, string> = {
-  zod: `
-  .query(z.object({ name: z.string().default('Taser.js') }))`,
-  arktype: `
-  .query(type({ 'name?': 'string = "Taser.js"' }))`,
-  valibot: `
-  .query(v.object({ name: v.optional(v.string(), 'Taser.js') }))`,
+export const QUERY_SCHEMA_EXPR: Record<ValidatorId, string> = {
+  zod: `z.object({ name: z.string().default("Taser.js") })`,
+  arktype: `type({ "name?": 'string = "Taser.js"' })`,
+  valibot: `v.object({ name: v.optional(v.string(), "Taser.js") })`,
 };
 
-const ROUTE_TEMPLATE = (validator: ValidatorId) => `import { t } from '@taserjs/router'
-import { json } from '@taserjs/router/reply'
-${IMPORT_LINES[validator]}
-
-export default t.get('/')${VALIDATION_BLOCK_TEMPLATE[validator]}
-  .handler((ctx) => {
-    return json({ message: \`Hello, \${ctx.query.name}!\` })
-  })
-`;
-
 export const ValidatorAddon = (validator: ValidatorId): AddonDefinition => {
   return {
     id: validator,
     category: "validator",
     dependencies: () => [validator],
     devDependencies: () => [],
-    apply: (ctx, write) => write("src/routes/index.get.ts", ROUTE_TEMPLATE(validator)),
+    apply: async (_ctx, write) => {
+      const content = `import { t } from "@taserjs/router";
+${IMPORT_LINES[validator]}
+
+export default t
+  .get("/")
+  .query(${QUERY_SCHEMA_EXPR[validator]})
+  .handler(({ req }) => {
+    return Response.json({ message: \`Hello, \${req.query.name}!\` });
+  });
+`;
+      await write("src/routes/index.get.ts", content);
+    },
   };
 };

package/src/addons/winston/index.ts

@@ -19,14 +19,14 @@ export const winstonAddon: AddonDefinition = {
   async apply(_ctx, write) {
     await write(
       "src/logger.ts",
-      `import winston from 'winston'
+      `import winston from "winston";
 
 export function createLogger() {
   return winston.createLogger({
-    level: process.env.LOG_LEVEL ?? 'info',
+    level: process.env.LOG_LEVEL ?? "info",
     format: winston.format.json(),
     transports: [new winston.transports.Console()],
-  })
+  });
 }
 `,
     );

package/src/cli.ts

@@ -1,62 +1,102 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { runCreateCommand, type RunCreateCommandOptions } from "./commands/create.js";
+import type {
+  DbDriver,
+  DbOdm,
+  DeployTarget,
+  LoggerId,
+  Runtime,
+  ValidatorId,
+} from "./core/types.js";
 
-import * as p from "@clack/prompts";
-import color from "picocolors";
+export async function run(argv: string[] = hideBin(process.argv)): Promise<void> {
+  const parser = yargs(argv)
+    .scriptName("create-taserjs")
+    .usage("$0 [dir] [options]")
+    .command(
+      "$0 [dir]",
+      "Scaffold a new Taser.js application",
+      (y: any) =>
+        y
+          .positional("dir", {
+            type: "string",
+            description: "Directory or project name",
+          })
+          .option("preset", {
+            alias: "p",
+            type: "string",
+            description: "Deployment preset",
+          })
+          .option("runtime", {
+            type: "string",
+            description: "Runtime override (node, bun, deno)",
+          })
+          .option("validator", {
+            alias: "v",
+            type: "string",
+            choices: ["zod", "valibot", "arktype", "none"],
+            description: "Standard Schema validator",
+          })
+          .option("db", {
+            type: "string",
+            choices: ["drizzle", "prisma", "kysely", "none"],
+            description: "Database ORM / Query builder",
+          })
+          .option("driver", {
+            type: "string",
+            choices: ["sqlite", "postgres", "mysql"],
+            description: "Database driver",
+          })
+          .option("logger", {
+            alias: "l",
+            type: "string",
+            choices: ["pino", "winston", "none"],
+            description: "Logger addon",
+          })
+          .option("skip-install", {
+            type: "boolean",
+            description: "Skip dependency installation",
+            default: false,
+          })
+          .option("yes", {
+            alias: "y",
+            type: "boolean",
+            description: "Skip prompts and use defaults",
+            default: false,
+          }),
+      async (args: any) => {
+        const createOpts: RunCreateCommandOptions = {
+          targetDir: args.dir as string | undefined,
+          projectName: args.dir as string | undefined,
+          preset: args.preset as DeployTarget | undefined,
+          runtime: args.runtime as Runtime | undefined,
+          validator: (args.validator === "none" ? undefined : args.validator) as
+            | ValidatorId
+            | undefined,
+          db: (args.db === "none" ? undefined : args.db) as DbOdm | undefined,
+          driver: args.driver as DbDriver | undefined,
+          logger: (args.logger === "none" ? undefined : args.logger) as LoggerId | undefined,
+          skipInstall: Boolean(args.skipInstall),
+          interactive: !args.yes,
+        };
+        await runCreateCommand(createOpts);
+      },
+    )
+    .help()
+    .alias("help", "h")
+    .version()
+    .alias("version", "V")
+    .strict()
+    .exitProcess(false);
 
-import { buildParsedArgsFromCli, runCreateCommand } from "./commands/create.js";
-import { printJsonError } from "./core/json-output.js";
+  await parser.parse();
+}
 
-async function main(): Promise<void> {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(2),
-    options: {
-      preset: { type: "string", short: "p" },
-      db: { type: "string" },
-      logger: { type: "string" },
-      validator: { type: "string" },
-      framework: { type: "string" },
-      runtime: { type: "string" },
-      y: { type: "boolean", short: "y" },
-      noInstall: { type: "boolean" },
-      json: { type: "boolean" },
-    },
-    allowPositionals: true,
+if (process.argv[1] && process.argv[1].endsWith("cli.js")) {
+  run().catch((err: unknown) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
   });
-
-  const parsed = buildParsedArgsFromCli(
-    {
-      ...(values.preset !== undefined ? { preset: values.preset } : {}),
-      ...(values.db !== undefined ? { db: values.db } : {}),
-      ...(values.logger !== undefined ? { logger: values.logger } : {}),
-      ...(values.validator !== undefined ? { validator: values.validator } : {}),
-      ...(values.framework !== undefined ? { framework: values.framework } : {}),
-      ...(values.runtime !== undefined ? { runtime: values.runtime } : {}),
-      ...(values.y !== undefined ? { y: values.y } : {}),
-      ...(values.noInstall !== undefined ? { noInstall: values.noInstall } : {}),
-      ...(values.json !== undefined ? { json: values.json } : {}),
-    },
-    positionals,
-  );
-
-  if (!parsed.json) {
-    console.clear();
-    p.intro(color.bgCyan(color.black(" create-taserjs ")));
-  }
-
-  try {
-    await runCreateCommand(parsed);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (parsed.json) {
-      printJsonError(message);
-      process.exit(1);
-    }
-    throw error;
-  }
 }
-
-main().catch((error: unknown) => {
-  console.error(error);
-  process.exit(1);
-});