create-taserjs 0.1.12 → 0.2.1

package/src/addons/drizzle/index.ts

@@ -4,29 +4,29 @@ import type { DbDriver } from "../../core/types.js";
 function schemaSource(driver: DbDriver): string {
   switch (driver) {
     case "postgres":
-      return `import { pgTable, serial, text } from 'drizzle-orm/pg-core'
+      return `import { pgTable, serial, text } from "drizzle-orm/pg-core";
 
-export const users = pgTable('users', {
-  id: serial('id').primaryKey(),
-  email: text('email').notNull(),
-})
+export const users = pgTable("users", {
+  id: serial("id").primaryKey(),
+  email: text("email").notNull(),
+});
 `;
     case "mysql":
-      return `import { mysqlTable, serial, varchar } from 'drizzle-orm/mysql-core'
+      return `import { mysqlTable, serial, varchar } from "drizzle-orm/mysql-core";
 
-export const users = mysqlTable('users', {
-  id: serial('id').primaryKey(),
-  email: varchar('email', { length: 255 }).notNull(),
-})
+export const users = mysqlTable("users", {
+  id: serial("id").primaryKey(),
+  email: varchar("email", { length: 255 }).notNull(),
+});
 `;
     case "sqlite":
     default:
-      return `import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
+      return `import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
 
-export const users = sqliteTable('users', {
-  id: integer('id').primaryKey({ autoIncrement: true }),
-  email: text('email').notNull(),
-})
+export const users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  email: text("email").notNull(),
+});
 `;
   }
 }
@@ -34,40 +34,37 @@ export const users = sqliteTable('users', {
 function dbIndexSource(driver: DbDriver): string {
   switch (driver) {
     case "postgres":
-      return `import { drizzle } from 'drizzle-orm/node-postgres'
-import pg from 'pg'
-
-import * as schema from './schema.js'
+      return `import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import * as schema from "./schema.js";
 
 export function createDb() {
   const pool = new pg.Pool({
     connectionString: process.env.DATABASE_URL,
-  })
-  return drizzle(pool, { schema })
+  });
+  return drizzle(pool, { schema });
 }
 `;
     case "mysql":
-      return `import { drizzle } from 'drizzle-orm/mysql2'
-import mysql from 'mysql2/promise'
-
-import * as schema from './schema.js'
+      return `import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import * as schema from "./schema.js";
 
 export function createDb() {
-  const pool = mysql.createPool(process.env.DATABASE_URL ?? '')
-  return drizzle(pool, { schema, mode: 'default' })
+  const pool = mysql.createPool(process.env.DATABASE_URL ?? "");
+  return drizzle(pool, { schema, mode: "default" });
 }
 `;
     case "sqlite":
     default:
-      return `import Database from 'better-sqlite3'
-import { drizzle } from 'drizzle-orm/better-sqlite3'
-
-import * as schema from './schema.js'
+      return `import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema.js";
 
 export function createDb() {
-  const filePath = (process.env.DATABASE_URL ?? 'file:./local.db').replace(/^file:/, '')
-  const client = new Database(filePath)
-  return drizzle(client, { schema })
+  const filePath = (process.env.DATABASE_URL ?? "file:./local.db").replace(/^file:/, "");
+  const client = new Database(filePath);
+  return drizzle(client, { schema });
 }
 `;
   }
@@ -75,16 +72,16 @@ export function createDb() {
 
 function drizzleConfigSource(driver: DbDriver): string {
   const dialect = driver === "postgres" ? "postgresql" : driver === "mysql" ? "mysql" : "sqlite";
-  return `import { defineConfig } from 'drizzle-kit'
+  return `import { defineConfig } from "drizzle-kit";
 
 export default defineConfig({
-  schema: './src/db/schema.ts',
-  out: './drizzle',
-  dialect: '${dialect}',
+  schema: "./src/db/schema.ts",
+  out: "./drizzle",
+  dialect: "${dialect}",
   dbCredentials: {
-    url: process.env.DATABASE_URL ?? '',
+    url: process.env.DATABASE_URL ?? "",
   },
-})
+});
 `;
 }
 

package/src/addons/kysely/index.ts

@@ -3,12 +3,12 @@ import type { DbDriver } from "../../core/types.js";
 
 function schemaTypesSource(): string {
   return `export interface UserTable {
-  id: number
-  email: string
+  id: number;
+  email: string;
 }
 
 export interface DB {
-  users: UserTable
+  users: UserTable;
 }
 `;
 }
@@ -16,46 +16,43 @@ export interface DB {
 function dbIndexSource(driver: DbDriver): string {
   switch (driver) {
     case "postgres":
-      return `import { Kysely, PostgresDialect } from 'kysely'
-import pg from 'pg'
-
-import type { DB } from './schema.js'
+      return `import { Kysely, PostgresDialect } from "kysely";
+import pg from "pg";
+import type { DB } from "./schema.js";
 
 export function createDb() {
   const pool = new pg.Pool({
     connectionString: process.env.DATABASE_URL,
-  })
+  });
   return new Kysely<DB>({
     dialect: new PostgresDialect({ pool }),
-  })
+  });
 }
 `;
     case "mysql":
-      return `import { Kysely, MysqlDialect } from 'kysely'
-import { createPool } from 'mysql2'
-
-import type { DB } from './schema.js'
+      return `import { Kysely, MysqlDialect } from "kysely";
+import { createPool } from "mysql2";
+import type { DB } from "./schema.js";
 
 export function createDb() {
-  const pool = createPool(process.env.DATABASE_URL ?? '')
+  const pool = createPool(process.env.DATABASE_URL ?? "");
   return new Kysely<DB>({
     dialect: new MysqlDialect({ pool }),
-  })
+  });
 }
 `;
     case "sqlite":
     default:
-      return `import Database from 'better-sqlite3'
-import { Kysely, SqliteDialect } from 'kysely'
-
-import type { DB } from './schema.js'
+      return `import Database from "better-sqlite3";
+import { Kysely, SqliteDialect } from "kysely";
+import type { DB } from "./schema.js";
 
 export function createDb() {
-  const filePath = (process.env.DATABASE_URL ?? 'file:./local.db').replace(/^file:/, '')
-  const database = new Database(filePath)
+  const filePath = (process.env.DATABASE_URL ?? "file:./local.db").replace(/^file:/, "");
+  const database = new Database(filePath);
   return new Kysely<DB>({
     dialect: new SqliteDialect({ database }),
-  })
+  });
 }
 `;
   }

package/src/addons/pino/index.ts

@@ -19,10 +19,10 @@ export const pinoAddon: AddonDefinition = {
   async apply(_ctx, write) {
     await write(
       "src/logger.ts",
-      `import pino from 'pino'
+      `import pino from "pino";
 
 export function createLogger() {
-  return pino({ level: process.env.LOG_LEVEL ?? 'info' })
+  return pino({ level: process.env.LOG_LEVEL ?? "info" });
 }
 `,
     );

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()],
-  })
+  });
 }
 `,
     );