create-taserjs 0.0.1 → 0.0.3

package/src/addons/prisma/index.ts

@@ -1,81 +1,154 @@
-import type { AddonDefinition } from '../types.js'
-import type { DbDriver } from '../../core/types.js'
+import type { AddonDefinition } from "../types.js";
+import type { DbDriver } from "../../core/types.js";
 
 function prismaProvider(driver: DbDriver): string {
   switch (driver) {
-    case 'postgres':
-      return 'postgresql'
-    case 'mysql':
-      return 'mysql'
-    case 'sqlite':
+    case "postgres":
+      return "postgresql";
+    case "mysql":
+      return "mysql";
+    case "sqlite":
     default:
-      return 'sqlite'
+      return "sqlite";
   }
 }
 
 function envExample(driver: DbDriver): string {
   switch (driver) {
-    case 'postgres':
-      return 'DATABASE_URL=postgresql://user:password@localhost:5432/mydb\n'
-    case 'mysql':
-      return 'DATABASE_URL=mysql://user:password@localhost:3306/mydb\n'
-    case 'sqlite':
+    case "postgres":
+      return "DATABASE_URL=postgresql://user:password@localhost:5432/mydb\n";
+    case "mysql":
+      return "DATABASE_URL=mysql://user:password@localhost:3306/mydb\n";
+    case "sqlite":
     default:
-      return 'DATABASE_URL=file:./local.db\n'
+      return "DATABASE_URL=file:./local.db\n";
   }
 }
 
-export const prismaAddon: AddonDefinition = {
-  id: 'prisma',
-  category: 'database',
-  dependencies() {
-    return ['@prisma/client']
-  },
-  devDependencies() {
-    return ['prisma']
-  },
-  scripts() {
-    return {
-      'db:generate': 'prisma generate',
-      'db:push': 'prisma db push',
-    }
-  },
-  bootBinding() {
-    return {
-      key: 'db',
-      importPath: './db/index.js',
-      factoryName: 'createDb',
-    }
+function driverPackages(driver: DbDriver): string[] {
+  switch (driver) {
+    case "postgres":
+      return ["@prisma/adapter-pg", "pg"];
+    case "mysql":
+      return ["@prisma/adapter-mariadb", "mariadb"];
+    case "sqlite":
+    default:
+      return ["@prisma/adapter-better-sqlite3", "better-sqlite3"];
+  }
+}
+
+function driverDevPackages(driver: DbDriver): string[] {
+  switch (driver) {
+    case "postgres":
+      return ["@types/pg"];
+    case "sqlite":
+      return ["@types/better-sqlite3"];
+    case "mysql":
+    default:
+      return [];
+  }
+}
+
+function dbIndexSource(driver: DbDriver): string {
+  switch (driver) {
+    case "postgres":
+      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 })
+}
+`;
+    case "mysql":
+      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 })
+}
+`;
+    case "sqlite":
+    default:
+      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 })
+}
+`;
+  }
+}
+
+function prismaConfigSource(): string {
+  return `import 'dotenv/config'
+import { defineConfig, env } from 'prisma/config'
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  datasource: {
+    url: env('DATABASE_URL'),
   },
-  async apply(ctx, write) {
-    const driver = ctx.driver ?? 'sqlite'
-    const provider = prismaProvider(driver)
-    await write(
-      'prisma/schema.prisma',
-      `generator client {
-  provider = "prisma-client-js"
+})
+`;
+}
+
+function schemaSource(driver: DbDriver): string {
+  const provider = prismaProvider(driver);
+  return `generator client {
+  provider = "prisma-client"
+  output   = "../src/db/prisma"
 }
 
 datasource db {
   provider = "${provider}"
-  url      = env("DATABASE_URL")
 }
 
 model User {
   id    Int    @id @default(autoincrement())
   email String
 }
-`,
-    )
-    await write(
-      'src/db/index.ts',
-      `import { PrismaClient } from '@prisma/client'
-
-export function createDb() {
-  return new PrismaClient()
+`;
 }
-`,
-    )
-    await write('.env.example', envExample(driver))
+
+export const prismaAddon: AddonDefinition = {
+  id: "prisma",
+  category: "database",
+  dependencies(ctx) {
+    const driver = ctx.driver ?? "sqlite";
+    return ["@prisma/client", ...driverPackages(driver)];
   },
-}
+  devDependencies(ctx) {
+    const driver = ctx.driver ?? "sqlite";
+    return ["prisma", ...driverDevPackages(driver)];
+  },
+  scripts() {
+    return {
+      "db:generate": "prisma generate",
+      "db:push": "prisma db push",
+    };
+  },
+  bootBinding() {
+    return {
+      key: "db",
+      importPath: "./db/index.js",
+      factoryName: "createDb",
+    };
+  },
+  async apply(ctx, write) {
+    const driver = ctx.driver ?? "sqlite";
+    await write("prisma.config.ts", prismaConfigSource());
+    await write("prisma/schema.prisma", schemaSource(driver));
+    await write("src/db/index.ts", dbIndexSource(driver));
+    await write(".env.example", envExample(driver));
+  },
+};

package/src/addons/registry.ts

@@ -1,19 +1,21 @@
-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 { zodAddon } from './zod/index.js'
-import type { AddonDefinition } from './types.js'
-import { winstonAddon } from './winston/index.js'
-import type { CapabilitiesCatalog, ScaffoldContext } from '../core/types.js'
+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 { 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,
-  FRAMEWORKS,
   LOGGERS,
+  PROJECT_TYPES,
   VALIDATORS,
-} from '../core/types.js'
+} from "../core/types.js";
 
 const ALL_ADDONS: AddonDefinition[] = [
   drizzleAddon,
@@ -22,15 +24,17 @@ const ALL_ADDONS: AddonDefinition[] = [
   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')
+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],
+    types: [...PROJECT_TYPES],
     db: {
       odms: [...DB_ODMS],
       drivers: [...DB_DRIVERS],
@@ -38,56 +42,56 @@ export function getCapabilitiesCatalog(): CapabilitiesCatalog {
     },
     loggers: [...LOGGERS],
     validators: [...VALIDATORS],
-  }
+  };
 }
 
 export function resolveAddons(ctx: ScaffoldContext): AddonDefinition[] {
-  const selected: AddonDefinition[] = []
+  const selected: AddonDefinition[] = [];
 
   if (ctx.db) {
-    const dbAddon = DB_ADDONS.find(addon => addon.id === ctx.db)
+    const dbAddon = DB_ADDONS.find((addon) => addon.id === ctx.db);
     if (!dbAddon) {
-      throw new Error(`Unknown database addon "${ctx.db}"`)
+      throw new Error(`Unknown database addon "${ctx.db}"`);
     }
-    selected.push(dbAddon)
+    selected.push(dbAddon);
   }
 
   if (ctx.logger) {
-    const loggerAddon = LOGGER_ADDONS.find(addon => addon.id === ctx.logger)
+    const loggerAddon = LOGGER_ADDONS.find((addon) => addon.id === ctx.logger);
     if (!loggerAddon) {
-      throw new Error(`Unknown logger addon "${ctx.logger}"`)
+      throw new Error(`Unknown logger addon "${ctx.logger}"`);
     }
-    selected.push(loggerAddon)
+    selected.push(loggerAddon);
   }
 
-  const dbCount = selected.filter(addon => addon.category === 'database').length
+  const dbCount = selected.filter((addon) => addon.category === "database").length;
   if (dbCount > 1) {
-    throw new Error('Only one database addon can be selected')
+    throw new Error("Only one database addon can be selected");
   }
 
-  const loggerCount = selected.filter(addon => addon.category === 'logger').length
+  const loggerCount = selected.filter((addon) => addon.category === "logger").length;
   if (loggerCount > 1) {
-    throw new Error('Only one logger addon can be selected')
+    throw new Error("Only one logger addon can be selected");
   }
 
   if (ctx.validator) {
-    const validatorAddon = VALIDATOR_ADDONS.find(addon => addon.id === ctx.validator)
+    const validatorAddon = VALIDATOR_ADDONS.find((addon) => addon.id === ctx.validator);
     if (!validatorAddon) {
-      throw new Error(`Unknown validator addon "${ctx.validator}"`)
+      throw new Error(`Unknown validator addon "${ctx.validator}"`);
     }
-    selected.push(validatorAddon)
+    selected.push(validatorAddon);
   }
 
-  const validatorCount = selected.filter(addon => addon.category === 'validator').length
+  const validatorCount = selected.filter((addon) => addon.category === "validator").length;
   if (validatorCount > 1) {
-    throw new Error('Only one validator addon can be selected')
+    throw new Error("Only one validator addon can be selected");
   }
 
-  return selected
+  return selected;
 }
 
 export function collectBootBindings(ctx: ScaffoldContext) {
   return resolveAddons(ctx)
-    .map(addon => addon.bootBinding?.(ctx))
-    .filter((v): v is NonNullable<typeof v> => Boolean(v))
+    .map((addon) => addon.bootBinding?.(ctx))
+    .filter((v): v is NonNullable<typeof v> => Boolean(v));
 }

package/src/addons/types.ts

@@ -1,19 +1,19 @@
-import type { ScaffoldContext } from '../core/types.js'
+import type { ScaffoldContext } from "../core/types.js";
 
 export type BootBinding = {
-  key: string
-  importPath: string
-  factoryName: string
-}
+  key: string;
+  importPath: string;
+  factoryName: string;
+};
 
-export type FileWriter = (filePath: string, contents: string) => Promise<void>
+export type FileWriter = (filePath: string, contents: string) => Promise<void>;
 
 export type 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>
-}
+  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>;
+};

package/src/addons/valibot/index.ts

@@ -1,3 +1,3 @@
-import { ValidatorAddon } from '../validators.js'
+import { ValidatorAddon } from "../validators.js";
 
-export const valibotAddon = ValidatorAddon('valibot')
+export const valibotAddon = ValidatorAddon("valibot");

package/src/addons/validators.ts

@@ -1,11 +1,11 @@
-import type { ValidatorId } from '../core/types'
-import type { AddonDefinition } from './types'
+import type { ValidatorId } from "../core/types";
+import type { AddonDefinition } from "./types";
 
 export const IMPORT_LINES: Record<ValidatorId, string> = {
   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: `, {
@@ -17,23 +17,23 @@ export const VALIDATION_BLOCK_TEMPLATE: Record<ValidatorId, string> = {
   valibot: `, {
   query: v.object({ name: v.string() }),
 }`,
-}
+};
 
-const ROUTE_TEMPLATE = (validator: ValidatorId) => `
+const ROUTE_TEMPLATE = (validator: ValidatorId) => `import { reply } from '@taserjs/router'
 import { t } from '#src/taser.js'
 ${IMPORT_LINES[validator]}
 
 export const Route = t.get('/'${VALIDATION_BLOCK_TEMPLATE[validator]}).handler((ctx) => {
-  return ctx.reply.json({ message: \`Hello, \${ctx.query.name}!\` })
+  return reply.json({ message: \`Hello, \${ctx.query.name}!\` })
 })
-`
+`;
 
 export const ValidatorAddon = (validator: ValidatorId): AddonDefinition => {
   return {
     id: validator,
-    category: 'validator',
+    category: "validator",
     dependencies: () => [validator],
     devDependencies: () => [],
-    apply: (ctx, write) => write('src/routes/index.get.ts', ROUTE_TEMPLATE(validator)),
-  }
-}
+    apply: (ctx, write) => write("src/routes/index.get.ts", ROUTE_TEMPLATE(validator)),
+  };
+};

package/src/addons/winston/index.ts

@@ -1,24 +1,24 @@
-import type { AddonDefinition } from '../types.js'
+import type { AddonDefinition } from "../types.js";
 
 export const winstonAddon: AddonDefinition = {
-  id: 'winston',
-  category: 'logger',
+  id: "winston",
+  category: "logger",
   dependencies() {
-    return ['winston']
+    return ["winston"];
   },
   devDependencies() {
-    return []
+    return [];
   },
   bootBinding() {
     return {
-      key: 'logger',
-      importPath: './logger.js',
-      factoryName: 'createLogger',
-    }
+      key: "logger",
+      importPath: "./logger.js",
+      factoryName: "createLogger",
+    };
   },
   async apply(_ctx, write) {
     await write(
-      'src/logger.ts',
+      "src/logger.ts",
       `import winston from 'winston'
 
 export function createLogger() {
@@ -29,6 +29,6 @@ export function createLogger() {
   })
 }
 `,
-    )
+    );
   },
-}
+};

package/src/addons/zod/index.ts

@@ -1,3 +1,3 @@
-import { ValidatorAddon } from '../validators.js'
+import { ValidatorAddon } from "../validators.js";
 
-export const zodAddon = ValidatorAddon('zod')
+export const zodAddon = ValidatorAddon("zod");

package/src/cli.ts

@@ -1,57 +1,60 @@
 #!/usr/bin/env node
-import { parseArgs } from 'node:util'
+import { parseArgs } from "node:util";
 
-import * as p from '@clack/prompts'
-import color from 'picocolors'
+import * as p from "@clack/prompts";
+import color from "picocolors";
 
-import { buildParsedArgsFromCli, runCreateCommand } from './commands/create.js'
-import { printJsonError } from './core/json-output.js'
+import { buildParsedArgsFromCli, runCreateCommand } from "./commands/create.js";
+import { printJsonError } from "./core/json-output.js";
 
 async function main(): Promise<void> {
   const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
     options: {
-      framework: { type: 'string' },
-      db: { type: 'string' },
-      logger: { type: 'string' },
-      y: { type: 'boolean', short: 'y' },
-      noInstall: { type: 'boolean' },
-      json: { type: 'boolean' },
+      type: { type: "string", short: "t" },
+      framework: { type: "string" },
+      db: { type: "string" },
+      logger: { type: "string" },
+      validator: { type: "string" },
+      y: { type: "boolean", short: "y" },
+      noInstall: { type: "boolean" },
+      json: { type: "boolean" },
     },
     allowPositionals: true,
-  })
+  });
 
   const parsed = buildParsedArgsFromCli(
     {
+      ...(values.type !== undefined ? { type: values.type } : {}),
       ...(values.framework !== undefined ? { framework: values.framework } : {}),
       ...(values.db !== undefined ? { db: values.db } : {}),
       ...(values.logger !== undefined ? { logger: values.logger } : {}),
+      ...(values.validator !== undefined ? { validator: values.validator } : {}),
       ...(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-taser ')))
+    console.clear();
+    p.intro(color.bgCyan(color.black(" create-taser ")));
   }
 
   try {
-    await runCreateCommand(parsed)
-  }
-  catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
+    await runCreateCommand(parsed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     if (parsed.json) {
-      printJsonError(message)
-      process.exit(1)
+      printJsonError(message);
+      process.exit(1);
     }
-    throw error
+    throw error;
   }
 }
 
 main().catch((error: unknown) => {
-  console.error(error)
-  process.exit(1)
-})
+  console.error(error);
+  process.exit(1);
+});