create-nolly-template 1.0.8 → 1.0.11

package/dist/builder.js

@@ -66,6 +66,13 @@ async function loadDirectoryIntoMap(root, baseDir, fileMap) {
     }
 }
 export async function buildProject(template, selectedFeatures, answers, outputDir) {
+    for (const feature of selectedFeatures) {
+        if (feature.group && feature.exclusive) {
+            const conflict = selectedFeatures.find(f => f.group === feature.group && f.key !== feature.key);
+            if (conflict)
+                throw new Error(`Cannot select "${feature.name}" because it is exclusive with "${conflict.name}" in group "${feature.group}"`);
+        }
+    }
     const fileMap = new Map();
     const baseRoot = path.join(TEMPLATES_ROOT, template.templateRoot);
     await loadDirectoryIntoMap(baseRoot, baseRoot, fileMap);

package/dist/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import prompts from 'prompts';
+import Enquirer from 'enquirer';
 import { registry } from './registry/index.js';
 import { buildProject } from './builder.js';
 import packageJSON from '../package.json' with { type: 'json' };
+const { Select, MultiSelect, Input } = Enquirer;
 async function printHelp() {
     console.log(`
 🚀 create-nolly-template v${packageJSON.version}
@@ -69,57 +70,76 @@ async function main() {
     if (args.includes('--list') || args.includes('-l'))
         return printList();
     console.log('\n🚀 Welcome to create-nolly-template!\n');
-    const { category } = await prompts({
-        type: 'select',
+    const category = await new Select({
         name: 'category',
         message: 'Main category',
-        choices: registry.map(category => ({ title: category.name, value: category }))
-    });
-    const { subCategory } = await prompts({
-        type: 'select',
+        choices: registry.map(c => c.name),
+        result(name) { return registry.find(c => c.name === name); }
+    }).run();
+    const subCategory = await new Select({
         name: 'subCategory',
         message: 'Sub category',
-        choices: category.subCategories.map(subCategory => ({ title: subCategory.name, value: subCategory }))
-    });
-    if (!subCategory)
-        process.exit(0);
-    const { template } = await prompts({
-        type: 'select',
+        choices: category.subCategories.map((s) => s.name),
+        result(name) { return category.subCategories.find((s) => s.name === name); }
+    }).run();
+    const template = await new Select({
         name: 'template',
         message: 'Base template',
-        choices: subCategory.templates.map(template => ({ title: template.name, value: template }))
-    });
-    if (!template)
-        process.exit(0);
+        choices: subCategory.templates.map((t) => t.name),
+        result(name) { return subCategory.templates.find((t) => t.name === name); }
+    }).run();
     let selectedFeatures = [];
     if (template.features && template.features.length > 0) {
-        const { features } = await prompts({
-            type: 'multiselect',
+        const prompt = new MultiSelect({
             name: 'features',
             message: 'Optional features (space to toggle)',
-            choices: template.features.map((feature) => ({
-                title: feature.name,
-                value: feature,
-                description: feature.description
+            hint: 'Space to select · Enter to submit',
+            choices: template.features.map((f) => ({
+                name: f.key,
+                message: f.name,
+                hint: f.description
             })),
-            hint: '- Space to select. Return to submit'
+            result(names) { return names.map(name => template.features.find((f) => f.key === name)); }
         });
-        selectedFeatures = features ?? [];
+        const selected = await prompt.run();
+        const groups = new Map();
+        for (const feat of selected) {
+            if (feat.group && feat.exclusive) {
+                if (groups.has(feat.group)) {
+                    throw new Error(`Feature "${feat.name}" is exclusive with another selected feature in group "${feat.group}"`);
+                }
+                groups.set(feat.group, feat.key);
+            }
+        }
+        selectedFeatures = selected;
+    }
+    const answers = {};
+    for (const prompt of template.prompts) {
+        const value = await new Input({
+            name: prompt.name,
+            message: prompt.message,
+            initial: prompt.initial
+        }).run();
+        answers[prompt.name] = value;
     }
-    const answers = await prompts(template.prompts);
-    const { outputDir } = await prompts({
-        type: 'text',
+    const outputDir = await new Input({
         name: 'outputDir',
         message: 'Output directory',
         initial: `./${answers.name || template.key}`
-    });
+    }).run();
     if (!outputDir)
         process.exit(0);
     await buildProject(template, selectedFeatures, answers, outputDir);
     console.log('\n✅ Project created at', outputDir);
     console.log('   Base:', template.name);
     if (selectedFeatures.length > 0)
-        console.log('   Features:', selectedFeatures.map((feature) => feature.name).join(', '));
+        console.log('   Features:', selectedFeatures.map(f => f.name).join(', '));
+    for (const feature of selectedFeatures) {
+        if (feature.additionalMessages && feature.additionalMessages.length > 0) {
+            console.log(`\n📌 ${feature.name} - ${feature.description}`);
+            feature.additionalMessages.forEach((msg) => console.log(`   • ${msg}`));
+        }
+    }
     console.log('\n   cd', outputDir, '&& pnpm install\n');
 }
 main().catch(error => {

package/dist/registry/web/backend/fastify/base.js

@@ -1,6 +1,7 @@
 import { swagger } from './swagger.js';
 import { websocket } from './websocket.js';
 import { mongodb } from './mongodb.js';
+import { postgresql } from './postgresql.js';
 export const fastify = {
     key: 'fastify',
     name: 'Fastify TypeScript',
@@ -12,6 +13,7 @@ export const fastify = {
     features: [
         swagger,
         websocket,
-        mongodb
+        mongodb,
+        postgresql
     ]
 };

package/dist/registry/web/backend/fastify/mongodb.js

@@ -1,20 +1,35 @@
 export const mongodb = {
     key: 'mongodb',
     name: 'MongoDB support',
-    description: 'Adds MongoDB support',
+    description: 'Adds MongoDB support via prisma directly to your Fastify application.',
     templateRoot: 'web/backend/fastify/mongodb',
     dependencies: {
-        'fastify-plugin': '^5.1.0',
-        'mongodb': '^7.1.0'
+        '@prisma/client': '6.19'
     },
+    devDependencies: {
+        '@types/node': '^18.0.0',
+        'prisma': '6.19'
+    },
+    group: 'database',
+    exclusive: true,
+    additionalMessages: [
+        'This feature will set up Prisma with MongoDB as the database provider.',
+        'It comes with a premade test model in the prisma schema as well as a plugin for Fastify',
+        'Run `pnpx prisma generate` and `pnpx prisma db push` to set up your database after adding this feature.'
+    ],
     patches: [
         {
-            targetPath: 'src/utils/env.ts',
+            targetPath: 'tsconfig.json',
             operations: [
                 {
                     type: 'insertAfter',
-                    pattern: "NODE_ENV: z.enum\\(\\['development', 'production', 'test'\\]\\)\\.default\\('development'\\)",
-                    insert: ",\tMONGO_URI: z.string().default('mongodb://localhost:27017/myapp'),\n\tMONGO_DB: z.string().default('myapp')"
+                    pattern: "\"skipLibCheck\": true",
+                    insert: ",\n\t\"types\": [\"node\"]"
+                },
+                {
+                    type: 'insertAfter',
+                    pattern: "\"src\"",
+                    insert: ", \"prisma.config.ts\""
                 }
             ]
         }

package/dist/registry/web/backend/fastify/postgresql.js

@@ -0,0 +1,40 @@
+export const postgresql = {
+    key: 'postgresql',
+    name: 'PostgreSQL support',
+    description: 'Adds PostgreSQL support via prisma directly to your Fastify application.',
+    templateRoot: 'web/backend/fastify/postgresql',
+    dependencies: {
+        '@prisma/adapter-pg': '^7.4.2',
+        '@prisma/client': '^7.4.2',
+        'pg': '^8.20.0'
+    },
+    devDependencies: {
+        '@types/node': '^18.0.0',
+        '@types/pg': '^8.18.0',
+        'prisma': '^7.4.2'
+    },
+    group: 'database',
+    exclusive: true,
+    additionalMessages: [
+        'This feature will set up Prisma with PostgreSQL as the database provider.',
+        'It comes with a premade test model in the prisma schema as well as a plugin for Fastify',
+        'Run `pnpx prisma generate` and `pnpx prisma db push` to set up your database after adding this feature.'
+    ],
+    patches: [
+        {
+            targetPath: 'tsconfig.json',
+            operations: [
+                {
+                    type: 'insertAfter',
+                    pattern: "\"skipLibCheck\": true",
+                    insert: ",\n\t\"types\": [\"node\"]"
+                },
+                {
+                    type: 'insertAfter',
+                    pattern: "\"src\"",
+                    insert: ", \"prisma.config.ts\""
+                }
+            ]
+        }
+    ]
+};

package/dist/registry/web/backend/fastify/websocket.js

@@ -22,8 +22,8 @@ export const websocket = {
                 },
                 {
                     type: 'insertAfter',
-                    pattern: `await autoRegister\\(app, 'routes/\\*\\*/\\.routes\\.{ts,js}\\)`,
-                    insert: `  await autoRegister(app, 'routes/**/*.ws.{ts,js}', '/ws')`
+                    pattern: `routes\.\\{ts,js\\}\'\\)`,
+                    insert: `await autoRegister(app, 'routes/**/*.ws.{ts,js}', '/ws')`
                 }
             ]
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nolly-template",
-  "version": "1.0.8",
+  "version": "1.0.11",
   "description": "All of my opiniated templates in one place. This is a CLI tool to create a new project based on one of my templates.",
   "license": "MIT",
   "author": "Nolly",
@@ -46,13 +46,12 @@
     "package.json"
   ],
   "dependencies": {
-    "fs-extra": "^11.3.4",
-    "prompts": "^2.4.2"
+    "enquirer": "^2.4.1",
+    "fs-extra": "^11.3.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.5.0",
-    "@types/prompts": "^2.4.9",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
@@ -78,7 +77,7 @@
     }
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc --build tsconfig.cli.json",
+    "build": "rm -rf dist && tsc",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js"
   }

package/templates/web/backend/fastify/mongodb/.env

@@ -1,2 +1 @@
-MONGO_URI=YOUR_MONGODB_URI
-MONGO_DB=YOUR_DATABASE_NAME
+DATABASE_URL="mongodb://localhost:27017/mydatabase"

package/templates/web/backend/fastify/mongodb/prisma/schema.prisma

@@ -0,0 +1,25 @@
+generator client {
+  provider = "prisma-client"
+  output   = "../src/prisma"
+}
+
+datasource db {
+  provider = "mongodb"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id    String  @id @default(auto()) @map("_id") @db.ObjectId
+  email String  @unique
+  name  String?
+  posts Post[]
+}
+
+model Post {
+  id        String  @id @default(auto()) @map("_id") @db.ObjectId
+  title     String
+  content   String?
+  published Boolean @default(false)
+  author    User    @relation(fields: [authorId], references: [id])
+  authorId  String  @db.ObjectId
+}

package/templates/web/backend/fastify/mongodb/prisma.config.ts

@@ -0,0 +1,12 @@
+import 'dotenv/config'
+import { defineConfig, env } from 'prisma/config'
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  migrations: {
+    path: 'prisma/migrations',
+  },
+  datasource: {
+    url: env['DATABASE_URL'],
+  },
+})

package/templates/web/backend/fastify/mongodb/src/plugins/prisma.plugin.ts

@@ -0,0 +1,23 @@
+import FastifyPlugin from 'fastify-plugin'
+import { FastifyInstance } from 'fastify'
+import { PrismaClient } from '../prisma/client'
+import { env } from 'prisma/config'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    database: PrismaClient
+  }
+}
+
+function hidePassword(): string {
+  const url = env('DATABASE_URL')
+  return url.replace(/\/\/(.*):(.*)@/, '//$1:****@')
+}
+
+export default FastifyPlugin(async (fastify: FastifyInstance) => {
+  const database = new PrismaClient()
+  await database.$connect()
+  fastify.log.info(`Database connected to ${hidePassword()}`)
+  fastify.decorate('database', database)
+  fastify.addHook('onClose', async (fastify) => await fastify.database.$disconnect())
+})

package/templates/web/backend/fastify/postgresql/.env

@@ -0,0 +1 @@
+DATABASE_URL="mongodb://localhost:27017/mydatabase"

package/templates/web/backend/fastify/postgresql/prisma/schema.prisma

@@ -0,0 +1,24 @@
+generator client {
+  provider = "prisma-client"
+  output   = "../src/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id    String  @id @default(uuid())
+  email String  @unique
+  name  String?
+  posts Post[]
+}
+
+model Post {
+  id        String  @id @default(uuid())
+  title     String
+  content   String?
+  published Boolean @default(false)
+  author    User    @relation(fields: [authorId], references: [id])
+  authorId  String
+}

package/templates/web/backend/fastify/postgresql/prisma.config.ts

@@ -0,0 +1,12 @@
+import 'dotenv/config'
+import { defineConfig, env } from 'prisma/config'
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  migrations: {
+    path: 'prisma/migrations',
+  },
+  datasource: {
+    url: env['DATABASE_URL'],
+  },
+})

package/templates/web/backend/fastify/postgresql/src/plugins/prisma.plugin.ts

@@ -0,0 +1,25 @@
+import FastifyPlugin from 'fastify-plugin'
+import { FastifyInstance } from 'fastify'
+import { PrismaClient } from '../prisma/client'
+import { PrismaPg } from '@prisma/adapter-pg'
+import { env } from 'prisma/config'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    database: PrismaClient
+  }
+}
+
+function hidePassword(): string {
+  const url = env('DATABASE_URL')
+  return url.replace(/\/\/(.*):(.*)@/, '//$1:****@')
+}
+
+export default FastifyPlugin(async (fastify: FastifyInstance) => {
+  const adapter = new PrismaPg({ connectionString: env('DATABASE_URL') })
+  const database = new PrismaClient({ adapter })
+  await database.connect()
+  fastify.log.info(`Database connected to ${hidePassword()}`)
+  fastify.decorate('database', database)
+  fastify.addHook('onClose', async (fastify) => await fastify.database.disconnect())
+})

package/templates/web/backend/fastify/mongodb/src/plugins/mongo.plugin.ts

@@ -1,53 +0,0 @@
-import fastifyPlugin from 'fastify-plugin'
-import { MongoClient, Db } from 'mongodb'
-import { FastifyInstance } from 'fastify'
-import path from 'path'
-import { fileURLToPath, pathToFileURL } from 'url'
-import fastGlob from 'fast-glob'
-import { env } from '../utils/env'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-export type ModelFactory = (db: Db, app: FastifyInstance) => any
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    mongo: {
-      client: MongoClient
-      db: Db
-    }
-    models: Record<string, any>
-  }
-}
-
-async function autoLoadModels(app: FastifyInstance, db: Db) {
-  const pattern = path.join(__dirname, '../models/**/*.model.{ts,js}').replace(/\\/g, '/')
-  const files = fastGlob.sync(pattern)
-  const models: Record<string, any> = {}
-  for (const file of files) {
-    const module = await import(pathToFileURL(file).href)
-    const factory: ModelFactory = module.default || module[Object.keys(module)[0]]
-    if (typeof factory !== 'function') continue
-    const model = factory(db, app)
-    if (!model?.name) throw new Error(`Model in ${file} must return { name: string }`)
-    models[model.name] = model
-  }
-  return models
-}
-
-export default fastifyPlugin(async function mongoPlugin(app) {
-  const client = new MongoClient(env.MONGO_URI, { serverSelectionTimeoutMS: 5000 })
-  try {
-    await client.connect()
-  } catch (error: any) {
-    app.log.error('Mongo connection failed:', error)
-    throw error
-  }
-  const db = client.db(env.MONGO_DB)
-  app.decorate('mongo', { client, db })
-  const models = await autoLoadModels(app, db)
-  app.decorate('models', models)
-  app.addHook('onClose', async () => { await client.close() })
-  app.log.info(`📦 Mongo connected: ${env.MONGO_DB}`)
-}, { name: 'mongoPlugin' })