create-taserjs 0.0.0

package/dist/esm/frameworks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/frameworks/index.ts"],"sourcesContent":["import type { Framework } from '../core/types.js'\n\nexport function indexTemplate(framework: Framework): string {\n  switch (framework) {\n    case 'express':\n      return `import express from 'express'\nimport { createExpressHandler } from '@taserjs/adapter-express'\n\nimport { routeManifest } from '#src/routeManifest.gen.js'\nimport { t } from '#src/taser.js'\n\nconst router = t.create(routeManifest)\n\nconst taser = createExpressHandler(router)\nconst app = express()\ntaser.mount('/api{/*splat}', app)\n\nconst port = Number(process.env.PORT ?? 3000)\napp.listen(port, () => {\n  console.log(\\`Express listening on http://localhost:\\${port}\\`)\n})\n`\n    case 'hono':\n      return `import { serve } from '@hono/node-server'\nimport { Hono } from 'hono'\n\nimport { routeManifest } from '#src/routeManifest.gen.js'\nimport { t } from '#src/taser.js'\n\nconst router = t.create(routeManifest)\n\nconst app = new Hono()\nconst api = router.base('/api')\napp.all('/api/*', c => api.native(c).fetch(c.req.raw))\n\nconst port = Number(process.env.PORT ?? 3000)\nserve({ fetch: app.fetch, port }, () => {\n  console.log(\\`Hono listening on http://localhost:\\${port}\\`)\n})\n`\n    case 'fastify':\n      return `import Fastify from 'fastify'\nimport { createFastifyHandler } from '@taserjs/adapter-fastify'\n\nimport { routeManifest } from '#src/routeManifest.gen.js'\nimport { t } from '#src/taser.js'\n\nconst router = t.create(routeManifest)\n\nconst taser = createFastifyHandler(router)\nconst app = Fastify()\ntaser.mount('/api/*', app)\n\nconst port = Number(process.env.PORT ?? 3000)\nawait app.listen({ port })\nconsole.log(\\`Fastify listening on http://localhost:\\${port}\\`)\n`\n    case 'node':\n    default:\n      return `import { createServer } from 'node:http'\nimport { createNodeHandler } from '@taserjs/adapter-node'\n\nimport { routeManifest } from '#src/routeManifest.gen.js'\nimport { t } from '#src/taser.js'\n\nconst router = t.create(routeManifest)\n\nconst taser = createNodeHandler(router)\nconst app = createServer()\ntaser.mount('/api/*', app)\n\nconst port = Number(process.env.PORT ?? 3000)\napp.listen(port, () => {\n  console.log(\\`Node listening on http://localhost:\\${port}\\`)\n})\n`\n  }\n}\n\nexport function taserTsTemplate(framework: Framework = 'node'): string {\n  if (framework === 'hono') {\n    return `import type { Context } from 'hono'\nimport { createTaserApp, type InferAppContext } from '@taserjs/router'\n\nimport { context } from '#src/context.js'\n\ndeclare module '@taserjs/router' {\n  interface RouterRegister {\n    NativeContext: Context\n  }\n}\n\nexport const t = createTaserApp({\n  response: { validate: true },\n}).context(context)\n\nexport type AppContext = InferAppContext<typeof context>\n`\n  }\n\n  return `import { createTaserApp, type InferAppContext } from '@taserjs/router'\n\nimport { context } from '#src/context.js'\n\nexport const t = createTaserApp({\n  response: { validate: true },\n}).context(context)\n\nexport type AppContext = InferAppContext<typeof context>\n`\n}\n"],"mappings":";AAEA,SAAgB,cAAc,WAA8B;CAC1D,QAAQ,WAAR;EACE,KAAK,WACH,OAAO;;;;;;;;;;;;;;;;;EAiBT,KAAK,QACH,OAAO;;;;;;;;;;;;;;;;;EAiBT,KAAK,WACH,OAAO;;;;;;;;;;;;;;;;EAiBT,SACE,OAAO;;;;;;;;;;;;;;;;;CAiBX;AACF;AAEA,SAAgB,gBAAgB,YAAuB,QAAgB;CACrE,IAAI,cAAc,QAChB,OAAO;;;;;;;;;;;;;;;;;CAmBT,OAAO;;;;;;;;;;AAUT"}

package/dist/esm/scaffold.d.ts

@@ -0,0 +1,3 @@
+export { scaffoldProject } from './core/scaffold-engine.js';
+export { getPackageGroups, resolvePackages } from './core/resolve-packages.js';
+export type { Framework, ScaffoldOptions, ScaffoldResult, PackageGroups } from './core/types.js';

package/dist/esm/templates/base.d.ts

@@ -0,0 +1,12 @@
+import { BootBinding } from '../addons/types.js';
+import { ScaffoldContext } from '../core/types.js';
+export declare function packageJsonTemplate(projectName: string, scripts?: Record<string, string>): string;
+export declare function tsdownConfigTemplate(): string;
+export declare function tsconfigTemplate(): string;
+export declare function gitignoreTemplate(): string;
+export declare function contextTemplate(bindings: BootBinding[]): string;
+export declare function rootLayoutTemplate(): string;
+export declare function indexRouteTemplate(): string;
+export declare function healthRouteTemplate(ctx: ScaffoldContext): string;
+/** Minimal placeholder until `taser generate` runs. */
+export declare function starterManifestTemplate(): string;

package/dist/esm/templates/base.js

@@ -0,0 +1,178 @@
+//#region src/templates/base.ts
+function packageJsonTemplate(projectName, scripts = {}) {
+	const pkg = {
+		name: projectName,
+		version: "1.0.0",
+		private: true,
+		type: "module",
+		imports: { "#src/*": "./src/*" },
+		scripts: {
+			"dev": "run-p dev:server dev:taser",
+			"dev:server": "tsx watch src/index.ts",
+			"dev:taser": "taser watch",
+			"start": "tsx src/index.ts",
+			"generate": "taser generate",
+			"build": "taser generate && tsdown build",
+			"serve": "node dist/index.js",
+			"typecheck": "tsc --noEmit -p tsconfig.json",
+			...scripts
+		}
+	};
+	return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+function tsdownConfigTemplate() {
+	return `import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: ['./src/index.ts'],
+  format: 'esm',
+  platform: 'node',
+  target: 'node20',
+  outDir: 'dist',
+  clean: true,
+  sourcemap: true,
+})
+`;
+}
+function tsconfigTemplate() {
+	return `${JSON.stringify({
+		compilerOptions: {
+			target: "ES2022",
+			lib: ["ES2022", "DOM"],
+			module: "ESNext",
+			moduleResolution: "bundler",
+			paths: { "#src/*": ["./src/*"] },
+			strict: true,
+			skipLibCheck: true,
+			verbatimModuleSyntax: true,
+			isolatedModules: true,
+			noEmit: true,
+			types: ["node"]
+		},
+		include: ["src"]
+	}, null, 2)}\n`;
+}
+function gitignoreTemplate() {
+	return `node_modules
+dist
+.DS_Store
+*.log
+.env
+local.db
+drizzle
+`;
+}
+function contextTemplate(bindings) {
+	const imports = bindings.map((binding) => `import { ${binding.factoryName} } from '${binding.importPath}'`);
+	const bootBody = bindings.length > 0 ? bindings.map((binding) => `    ${binding.key}: ${binding.factoryName}(),`).join("\n") : "";
+	const bootBlock = bindings.length > 0 ? `  boot: () => ({\n${bootBody}\n  }),` : "";
+	return `${imports.length > 0 ? `${imports.join("\n")}\n\n` : ""}import { createContext } from '@taserjs/router'
+
+export const context = createContext({
+${bootBlock}
+  request: () => ({
+    requestId: crypto.randomUUID(),
+  }),
+})
+`;
+}
+function rootLayoutTemplate() {
+	return `import { bodyLimit } from '@taserjs/router/body-limit'
+import { secureHeaders } from '@taserjs/router/secure-headers'
+
+import { t } from '#src/taser.js'
+
+export const Middleware = t.middleware('/$')
+  .use(secureHeaders())
+  .use(bodyLimit({ maxSize: 1_000_000 }))
+`;
+}
+function indexRouteTemplate() {
+	return `import { t } from '#src/taser.js'
+
+export const Route = t.get('/').handler((ctx) => {
+  return ctx.reply.json({ message: 'Welcome to Taser' })
+})
+`;
+}
+function healthRouteTemplate(ctx) {
+	const lines = [];
+	if (ctx.logger) lines.push("  ctx.logger.info('health check')");
+	if (ctx.db) lines.push("  // ctx.db is available from context boot");
+	return `import { t } from '#src/taser.js'
+
+export const Route = t.get('/health').handler((ctx) => {
+${lines.length > 0 ? `${lines.join("\n")}\n` : ""}  return ctx.reply.json({ ok: true })
+})
+`;
+}
+/** Minimal placeholder until `taser generate` runs. */
+function starterManifestTemplate() {
+	return `/* eslint-disable */
+// Run \`pnpm generate\` (taser generate) to replace this file.
+import { Middleware as RootSplatLayoutImport } from './routes/$.js'
+import { Route as RootIndexGetRouteImport } from './routes/index.get.js'
+import { Route as HealthGetRouteImport } from './routes/health.get.js'
+
+export const routeManifest = {
+  layouts: {
+    '/$': {
+      middlewares: RootSplatLayoutImport,
+    },
+  },
+  routes: {
+    '/': {
+      GET: {
+        layoutChain: ['/$'],
+        route: RootIndexGetRouteImport,
+      },
+    },
+    '/health': {
+      GET: {
+        layoutChain: ['/$'],
+        route: HealthGetRouteImport,
+      },
+    },
+  },
+} as const
+
+export type RoutePathGen = '/' | '/health'
+export type LayoutIdGen = '/$'
+export type LayoutTreeGen = {
+  '/$': {
+    parent: null
+    middlewares: typeof RootSplatLayoutImport
+  }
+}
+export type RouteByPathMethodGen = {
+  '/': {
+    GET: {
+      parent: '/$'
+      layoutChain: ['/$']
+      route: typeof RootIndexGetRouteImport
+    }
+  }
+  '/health': {
+    GET: {
+      parent: '/$'
+      layoutChain: ['/$']
+      route: typeof HealthGetRouteImport
+    }
+  }
+}
+export type RouteManifest = typeof routeManifest
+
+declare module '@taserjs/router' {
+  interface RouterRegister {
+    RoutePath: RoutePathGen
+    LayoutId: LayoutIdGen
+    LayoutTree: LayoutTreeGen
+    RouteByPathMethod: RouteByPathMethodGen
+  }
+}
+`;
+}
+//#endregion
+export { contextTemplate, gitignoreTemplate, healthRouteTemplate, indexRouteTemplate, packageJsonTemplate, rootLayoutTemplate, starterManifestTemplate, tsconfigTemplate, tsdownConfigTemplate };
+
+//# sourceMappingURL=base.js.map

package/dist/esm/templates/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","names":[],"sources":["../../../src/templates/base.ts"],"sourcesContent":["import type { BootBinding } from '../addons/types.js'\nimport type { ScaffoldContext } from '../core/types.js'\n\nexport function packageJsonTemplate(projectName: string, scripts: Record<string, string> = {}): string {\n  const pkg = {\n    name: projectName,\n    version: '1.0.0',\n    private: true,\n    type: 'module',\n    imports: {\n      '#src/*': './src/*',\n    },\n    scripts: {\n      'dev': 'run-p dev:server dev:taser',\n      'dev:server': 'tsx watch src/index.ts',\n      'dev:taser': 'taser watch',\n      'start': 'tsx src/index.ts',\n      'generate': 'taser generate',\n      'build': 'taser generate && tsdown build',\n      'serve': 'node dist/index.js',\n      'typecheck': 'tsc --noEmit -p tsconfig.json',\n      ...scripts,\n    },\n  }\n\n  return `${JSON.stringify(pkg, null, 2)}\\n`\n}\n\nexport function tsdownConfigTemplate(): string {\n  return `import { defineConfig } from 'tsdown'\n\nexport default defineConfig({\n  entry: ['./src/index.ts'],\n  format: 'esm',\n  platform: 'node',\n  target: 'node20',\n  outDir: 'dist',\n  clean: true,\n  sourcemap: true,\n})\n`\n}\n\nexport function tsconfigTemplate(): string {\n  return `${JSON.stringify({\n    compilerOptions: {\n      target: 'ES2022',\n      lib: ['ES2022', 'DOM'],\n      module: 'ESNext',\n      moduleResolution: 'bundler',\n      paths: {\n        '#src/*': ['./src/*'],\n      },\n      strict: true,\n      skipLibCheck: true,\n      verbatimModuleSyntax: true,\n      isolatedModules: true,\n      noEmit: true,\n      types: ['node'],\n    },\n    include: ['src'],\n  }, null, 2)}\\n`\n}\n\nexport function gitignoreTemplate(): string {\n  return `node_modules\ndist\n.DS_Store\n*.log\n.env\nlocal.db\ndrizzle\n`\n}\n\nexport function contextTemplate(bindings: BootBinding[]): string {\n  const imports = bindings.map(\n    binding => `import { ${binding.factoryName} } from '${binding.importPath}'`,\n  )\n\n  const bootBody = bindings.length > 0\n    ? bindings.map(binding => `    ${binding.key}: ${binding.factoryName}(),`).join('\\n')\n    : ''\n\n  const bootBlock = bindings.length > 0\n    ? `  boot: () => ({\\n${bootBody}\\n  }),`\n    : ''\n\n  const importBlock = imports.length > 0 ? `${imports.join('\\n')}\\n\\n` : ''\n\n  return `${importBlock}import { createContext } from '@taserjs/router'\n\nexport const context = createContext({\n${bootBlock}\n  request: () => ({\n    requestId: crypto.randomUUID(),\n  }),\n})\n`\n}\n\nexport function rootLayoutTemplate(): string {\n  return `import { bodyLimit } from '@taserjs/router/body-limit'\nimport { secureHeaders } from '@taserjs/router/secure-headers'\n\nimport { t } from '#src/taser.js'\n\nexport const Middleware = t.middleware('/$')\n  .use(secureHeaders())\n  .use(bodyLimit({ maxSize: 1_000_000 }))\n`\n}\n\nexport function indexRouteTemplate(): string {\n  return `import { t } from '#src/taser.js'\n\nexport const Route = t.get('/').handler((ctx) => {\n  return ctx.reply.json({ message: 'Welcome to Taser' })\n})\n`\n}\n\nexport function healthRouteTemplate(ctx: ScaffoldContext): string {\n  const lines: string[] = []\n\n  if (ctx.logger) {\n    lines.push('  ctx.logger.info(\\'health check\\')')\n  }\n\n  if (ctx.db) {\n    lines.push('  // ctx.db is available from context boot')\n  }\n\n  const body = lines.length > 0 ? `${lines.join('\\n')}\\n` : ''\n\n  return `import { t } from '#src/taser.js'\n\nexport const Route = t.get('/health').handler((ctx) => {\n${body}  return ctx.reply.json({ ok: true })\n})\n`\n}\n\n/** Minimal placeholder until `taser generate` runs. */\nexport function starterManifestTemplate(): string {\n  return `/* eslint-disable */\n// Run \\`pnpm generate\\` (taser generate) to replace this file.\nimport { Middleware as RootSplatLayoutImport } from './routes/$.js'\nimport { Route as RootIndexGetRouteImport } from './routes/index.get.js'\nimport { Route as HealthGetRouteImport } from './routes/health.get.js'\n\nexport const routeManifest = {\n  layouts: {\n    '/$': {\n      middlewares: RootSplatLayoutImport,\n    },\n  },\n  routes: {\n    '/': {\n      GET: {\n        layoutChain: ['/$'],\n        route: RootIndexGetRouteImport,\n      },\n    },\n    '/health': {\n      GET: {\n        layoutChain: ['/$'],\n        route: HealthGetRouteImport,\n      },\n    },\n  },\n} as const\n\nexport type RoutePathGen = '/' | '/health'\nexport type LayoutIdGen = '/$'\nexport type LayoutTreeGen = {\n  '/$': {\n    parent: null\n    middlewares: typeof RootSplatLayoutImport\n  }\n}\nexport type RouteByPathMethodGen = {\n  '/': {\n    GET: {\n      parent: '/$'\n      layoutChain: ['/$']\n      route: typeof RootIndexGetRouteImport\n    }\n  }\n  '/health': {\n    GET: {\n      parent: '/$'\n      layoutChain: ['/$']\n      route: typeof HealthGetRouteImport\n    }\n  }\n}\nexport type RouteManifest = typeof routeManifest\n\ndeclare module '@taserjs/router' {\n  interface RouterRegister {\n    RoutePath: RoutePathGen\n    LayoutId: LayoutIdGen\n    LayoutTree: LayoutTreeGen\n    RouteByPathMethod: RouteByPathMethodGen\n  }\n}\n`\n}\n"],"mappings":";AAGA,SAAgB,oBAAoB,aAAqB,UAAkC,CAAC,GAAW;CACrG,MAAM,MAAM;EACV,MAAM;EACN,SAAS;EACT,SAAS;EACT,MAAM;EACN,SAAS,EACP,UAAU,UACZ;EACA,SAAS;GACP,OAAO;GACP,cAAc;GACd,aAAa;GACb,SAAS;GACT,YAAY;GACZ,SAAS;GACT,SAAS;GACT,aAAa;GACb,GAAG;EACL;CACF;CAEA,OAAO,GAAG,KAAK,UAAU,KAAK,MAAM,CAAC,EAAE;AACzC;AAEA,SAAgB,uBAA+B;CAC7C,OAAO;;;;;;;;;;;;AAYT;AAEA,SAAgB,mBAA2B;CACzC,OAAO,GAAG,KAAK,UAAU;EACvB,iBAAiB;GACf,QAAQ;GACR,KAAK,CAAC,UAAU,KAAK;GACrB,QAAQ;GACR,kBAAkB;GAClB,OAAO,EACL,UAAU,CAAC,SAAS,EACtB;GACA,QAAQ;GACR,cAAc;GACd,sBAAsB;GACtB,iBAAiB;GACjB,QAAQ;GACR,OAAO,CAAC,MAAM;EAChB;EACA,SAAS,CAAC,KAAK;CACjB,GAAG,MAAM,CAAC,EAAE;AACd;AAEA,SAAgB,oBAA4B;CAC1C,OAAO;;;;;;;;AAQT;AAEA,SAAgB,gBAAgB,UAAiC;CAC/D,MAAM,UAAU,SAAS,KACvB,YAAW,YAAY,QAAQ,YAAY,WAAW,QAAQ,WAAW,EAC3E;CAEA,MAAM,WAAW,SAAS,SAAS,IAC/B,SAAS,KAAI,YAAW,OAAO,QAAQ,IAAI,IAAI,QAAQ,YAAY,IAAI,CAAC,CAAC,KAAK,IAAI,IAClF;CAEJ,MAAM,YAAY,SAAS,SAAS,IAChC,qBAAqB,SAAS,WAC9B;CAIJ,OAAO,GAFa,QAAQ,SAAS,IAAI,GAAG,QAAQ,KAAK,IAAI,EAAE,QAAQ,GAEjD;;;EAGtB,UAAU;;;;;;AAMZ;AAEA,SAAgB,qBAA6B;CAC3C,OAAO;;;;;;;;;AAST;AAEA,SAAgB,qBAA6B;CAC3C,OAAO;;;;;;AAMT;AAEA,SAAgB,oBAAoB,KAA8B;CAChE,MAAM,QAAkB,CAAC;CAEzB,IAAI,IAAI,QACN,MAAM,KAAK,mCAAqC;CAGlD,IAAI,IAAI,IACN,MAAM,KAAK,4CAA4C;CAKzD,OAAO;;;EAFM,MAAM,SAAS,IAAI,GAAG,MAAM,KAAK,IAAI,EAAE,MAAM,GAKrD;;;AAGP;;AAGA,SAAgB,0BAAkC;CAChD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DT"}

package/dist/esm/types.d.ts

@@ -0,0 +1 @@
+export type { Framework, DbOdm, DbDriver, LoggerId, ScaffoldOptions, ScaffoldResult, PackageGroups, } from './core/types.js';

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "create-taserjs",
+  "version": "0.0.0",
+  "description": "Scaffold a new Taser application",
+  "type": "module",
+  "sideEffects": false,
+  "bin": {
+    "create-taserjs": "./dist/esm/cli.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "package-manager-detector": "^1.8.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@tanstack/vite-config": "^0.6.0",
+    "publint": "^0.3.22",
+    "typescript": "^5.9.3",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/taserjs/taserjs.git",
+    "directory": "packages/create-taserjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "vite build && publint --strict",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run"
+  }
+}

package/src/addons/drizzle/index.ts

@@ -0,0 +1,145 @@
+import type { AddonDefinition } from '../types.js'
+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'
+
+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'
+
+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'
+
+export const users = sqliteTable('users', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  email: text('email').notNull(),
+})
+`
+  }
+}
+
+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'
+
+export function createDb() {
+  const pool = new pg.Pool({
+    connectionString: process.env.DATABASE_URL,
+  })
+  return drizzle(pool, { schema })
+}
+`
+    case 'mysql':
+      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' })
+}
+`
+    case 'sqlite':
+    default:
+      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 })
+}
+`
+  }
+}
+
+function drizzleConfigSource(driver: DbDriver): string {
+  const dialect = driver === 'postgres' ? 'postgresql' : driver === 'mysql' ? 'mysql' : 'sqlite'
+  return `import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  dialect: '${dialect}',
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? '',
+  },
+})
+`
+}
+
+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':
+    default:
+      return 'DATABASE_URL=file:./local.db\n'
+  }
+}
+
+function driverPackages(driver: DbDriver): string[] {
+  switch (driver) {
+    case 'postgres':
+      return ['pg']
+    case 'mysql':
+      return ['mysql2']
+    case 'sqlite':
+    default:
+      return ['better-sqlite3']
+  }
+}
+
+export const drizzleAddon: AddonDefinition = {
+  id: 'drizzle',
+  category: 'database',
+  dependencies(ctx) {
+    const driver = ctx.driver ?? 'sqlite'
+    return ['drizzle-orm', ...driverPackages(driver)]
+  },
+  devDependencies() {
+    return ['drizzle-kit']
+  },
+  scripts() {
+    return {
+      'db:generate': 'drizzle-kit generate',
+      'db:push': 'drizzle-kit push',
+    }
+  },
+  bootBinding() {
+    return {
+      key: 'db',
+      importPath: './db/index.js',
+      factoryName: 'createDb',
+    }
+  },
+  async apply(ctx, write) {
+    const driver = ctx.driver ?? 'sqlite'
+    await write('src/db/schema.ts', schemaSource(driver))
+    await write('src/db/index.ts', dbIndexSource(driver))
+    await write('drizzle.config.ts', drizzleConfigSource(driver))
+    await write('.env.example', envExample(driver))
+  },
+}

package/src/addons/kysely/index.ts

@@ -0,0 +1,111 @@
+import type { AddonDefinition } from '../types.js'
+import type { DbDriver } from '../../core/types.js'
+
+function schemaTypesSource(): string {
+  return `export interface UserTable {
+  id: number
+  email: string
+}
+
+export interface DB {
+  users: UserTable
+}
+`
+}
+
+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'
+
+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'
+
+export function createDb() {
+  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'
+
+export function createDb() {
+  const filePath = (process.env.DATABASE_URL ?? 'file:./local.db').replace(/^file:/, '')
+  const database = new Database(filePath)
+  return new Kysely<DB>({
+    dialect: new SqliteDialect({ database }),
+  })
+}
+`
+  }
+}
+
+function driverPackages(driver: DbDriver): string[] {
+  switch (driver) {
+    case 'postgres':
+      return ['pg']
+    case 'mysql':
+      return ['mysql2']
+    case 'sqlite':
+    default:
+      return ['better-sqlite3']
+  }
+}
+
+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':
+    default:
+      return 'DATABASE_URL=file:./local.db\n'
+  }
+}
+
+export const kyselyAddon: AddonDefinition = {
+  id: 'kysely',
+  category: 'database',
+  dependencies(ctx) {
+    const driver = ctx.driver ?? 'sqlite'
+    return ['kysely', ...driverPackages(driver)]
+  },
+  devDependencies() {
+    return []
+  },
+  bootBinding() {
+    return {
+      key: 'db',
+      importPath: './db/index.js',
+      factoryName: 'createDb',
+    }
+  },
+  async apply(ctx, write) {
+    const driver = ctx.driver ?? 'sqlite'
+    await write('src/db/schema.ts', schemaTypesSource())
+    await write('src/db/index.ts', dbIndexSource(driver))
+    await write('.env.example', envExample(driver))
+  },
+}

package/src/addons/pino/index.ts

@@ -0,0 +1,30 @@
+import type { AddonDefinition } from '../types.js'
+
+export const pinoAddon: AddonDefinition = {
+  id: 'pino',
+  category: 'logger',
+  dependencies() {
+    return ['pino']
+  },
+  devDependencies() {
+    return []
+  },
+  bootBinding() {
+    return {
+      key: 'logger',
+      importPath: './logger.js',
+      factoryName: 'createLogger',
+    }
+  },
+  async apply(_ctx, write) {
+    await write(
+      'src/logger.ts',
+      `import pino from 'pino'
+
+export function createLogger() {
+  return pino({ level: process.env.LOG_LEVEL ?? 'info' })
+}
+`,
+    )
+  },
+}

package/src/addons/prisma/index.ts

@@ -0,0 +1,81 @@
+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':
+    default:
+      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':
+    default:
+      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',
+    }
+  },
+  async apply(ctx, write) {
+    const driver = ctx.driver ?? 'sqlite'
+    const provider = prismaProvider(driver)
+    await write(
+      'prisma/schema.prisma',
+      `generator client {
+  provider = "prisma-client-js"
+}
+
+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))
+  },
+}