servcraft 0.3.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "servcraft",
-  "version": "0.3.1",
+  "version": "0.4.3",
   "description": "A modular, production-ready Node.js backend framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli/commands/generate.ts

@@ -48,6 +48,7 @@ import { dynamicPrismaTemplate } from '../templates/dynamic-prisma.js';
 import { controllerTestTemplate } from '../templates/controller-test.js';
 import { serviceTestTemplate } from '../templates/service-test.js';
 import { integrationTestTemplate } from '../templates/integration-test.js';
+import { getTemplate } from '../utils/template-loader.js';
 
 export const generateCommand = new Command('generate')
   .alias('g')
@@ -100,41 +101,50 @@ generateCommand
       // Use dynamic templates if fields are provided
       const hasFields = fields.length > 0;
 
+      // Load templates (custom or built-in)
+      const controllerTpl = await getTemplate('controller', controllerTemplate);
+      const serviceTpl = await getTemplate('service', serviceTemplate);
+      const repositoryTpl = await getTemplate('repository', repositoryTemplate);
+      const typesTpl = await getTemplate('types', typesTemplate);
+      const schemasTpl = await getTemplate('schemas', schemasTemplate);
+      const routesTpl = await getTemplate('routes', routesTemplate);
+      const moduleIndexTpl = await getTemplate('module-index', moduleIndexTemplate);
+
       const files = [
         {
           name: `${kebabName}.types.ts`,
           content: hasFields
             ? dynamicTypesTemplate(kebabName, pascalName, fields)
-            : typesTemplate(kebabName, pascalName),
+            : typesTpl(kebabName, pascalName),
         },
         {
           name: `${kebabName}.schemas.ts`,
           content: hasFields
             ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType)
-            : schemasTemplate(kebabName, pascalName, camelName),
+            : schemasTpl(kebabName, pascalName, camelName),
         },
         {
           name: `${kebabName}.service.ts`,
-          content: serviceTemplate(kebabName, pascalName, camelName),
+          content: serviceTpl(kebabName, pascalName, camelName),
         },
         {
           name: `${kebabName}.controller.ts`,
-          content: controllerTemplate(kebabName, pascalName, camelName),
+          content: controllerTpl(kebabName, pascalName, camelName),
         },
-        { name: 'index.ts', content: moduleIndexTemplate(kebabName, pascalName, camelName) },
+        { name: 'index.ts', content: moduleIndexTpl(kebabName, pascalName, camelName) },
       ];
 
       if (options.repository !== false) {
         files.push({
           name: `${kebabName}.repository.ts`,
-          content: repositoryTemplate(kebabName, pascalName, camelName, pluralName),
+          content: repositoryTpl(kebabName, pascalName, camelName, pluralName),
         });
       }
 
       if (options.routes !== false) {
         files.push({
           name: `${kebabName}.routes.ts`,
-          content: routesTemplate(kebabName, pascalName, camelName, pluralName),
+          content: routesTpl(kebabName, pascalName, camelName, pluralName),
         });
       }
 
@@ -147,19 +157,24 @@ generateCommand
       if (options.withTests) {
         const testDir = path.join(moduleDir, '__tests__');
 
+        // Load test templates (custom or built-in)
+        const controllerTestTpl = await getTemplate('controller-test', controllerTestTemplate);
+        const serviceTestTpl = await getTemplate('service-test', serviceTestTemplate);
+        const integrationTestTpl = await getTemplate('integration-test', integrationTestTemplate);
+
         await writeFile(
           path.join(testDir, `${kebabName}.controller.test.ts`),
-          controllerTestTemplate(kebabName, pascalName, camelName)
+          controllerTestTpl(kebabName, pascalName, camelName)
         );
 
         await writeFile(
           path.join(testDir, `${kebabName}.service.test.ts`),
-          serviceTestTemplate(kebabName, pascalName, camelName)
+          serviceTestTpl(kebabName, pascalName, camelName)
         );
 
         await writeFile(
           path.join(testDir, `${kebabName}.integration.test.ts`),
-          integrationTestTemplate(kebabName, pascalName, camelName)
+          integrationTestTpl(kebabName, pascalName, camelName)
         );
       }
 

package/src/cli/commands/scaffold.ts

@@ -0,0 +1,211 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import {
+  toPascalCase,
+  toCamelCase,
+  toKebabCase,
+  pluralize,
+  writeFile,
+  success,
+  info,
+  getModulesDir,
+} from '../utils/helpers.js';
+import { DryRunManager } from '../utils/dry-run.js';
+import { parseFields } from '../utils/field-parser.js';
+import { dynamicTypesTemplate } from '../templates/dynamic-types.js';
+import { dynamicSchemasTemplate, type ValidatorType } from '../templates/dynamic-schemas.js';
+import { dynamicPrismaTemplate } from '../templates/dynamic-prisma.js';
+import { controllerTemplate } from '../templates/controller.js';
+import { serviceTemplate } from '../templates/service.js';
+import { repositoryTemplate } from '../templates/repository.js';
+import { routesTemplate } from '../templates/routes.js';
+import { moduleIndexTemplate } from '../templates/module-index.js';
+import { controllerTestTemplate } from '../templates/controller-test.js';
+import { serviceTestTemplate } from '../templates/service-test.js';
+import { integrationTestTemplate } from '../templates/integration-test.js';
+import { getTemplate } from '../utils/template-loader.js';
+
+export const scaffoldCommand = new Command('scaffold')
+  .description('Generate complete CRUD with Prisma model')
+  .argument('<name>', 'Resource name (e.g., product, user)')
+  .option(
+    '--fields <fields>',
+    'Field definitions: "name:string email:string? age:number category:relation"'
+  )
+  .option('--validator <type>', 'Validator type: zod, joi, yup', 'zod')
+  .option('--dry-run', 'Preview changes without writing files')
+  .action(
+    async (
+      name: string,
+      options: { fields?: string; validator?: ValidatorType; dryRun?: boolean }
+    ) => {
+      const dryRun = DryRunManager.getInstance();
+      if (options.dryRun) {
+        dryRun.enable();
+        console.log(chalk.yellow('\n⚠ DRY RUN MODE - No files will be written\n'));
+      }
+
+      if (!options.fields) {
+        console.log(chalk.red('\n✗ Error: --fields option is required\n'));
+        console.log(chalk.gray('Example:'));
+        console.log(
+          chalk.cyan(
+            '  servcraft scaffold product --fields "name:string price:number category:relation"'
+          )
+        );
+        process.exit(1);
+      }
+
+      const spinner = ora('Scaffolding resource...').start();
+
+      try {
+        // Parse fields
+        const fields = parseFields(options.fields || '');
+
+        if (!fields || fields.length === 0) {
+          spinner.fail('No valid fields provided');
+          console.log(chalk.gray(`\nReceived: ${options.fields}`));
+          console.log(chalk.gray(`Parsed: ${JSON.stringify(fields)}`));
+          process.exit(1);
+        }
+
+        // Generate names
+        const kebabName = toKebabCase(name);
+        const pascalName = toPascalCase(name);
+        const camelName = toCamelCase(name);
+        const pluralName = pluralize(camelName);
+        const tableName = pluralize(kebabName);
+
+        // Create module directory
+        const modulesDir = getModulesDir();
+        const moduleDir = path.join(modulesDir, kebabName);
+
+        // Load templates (custom or built-in)
+        const controllerTpl = await getTemplate('controller', controllerTemplate);
+        const serviceTpl = await getTemplate('service', serviceTemplate);
+        const repositoryTpl = await getTemplate('repository', repositoryTemplate);
+        const routesTpl = await getTemplate('routes', routesTemplate);
+        const moduleIndexTpl = await getTemplate('module-index', moduleIndexTemplate);
+
+        // Generate all files
+        const files = [
+          {
+            name: `${kebabName}.types.ts`,
+            content: dynamicTypesTemplate(kebabName, pascalName, fields),
+          },
+          {
+            name: `${kebabName}.schemas.ts`,
+            content: dynamicSchemasTemplate(
+              kebabName,
+              pascalName,
+              camelName,
+              fields,
+              options.validator || 'zod'
+            ),
+          },
+          {
+            name: `${kebabName}.service.ts`,
+            content: serviceTpl(kebabName, pascalName, camelName),
+          },
+          {
+            name: `${kebabName}.controller.ts`,
+            content: controllerTpl(kebabName, pascalName, camelName),
+          },
+          {
+            name: 'index.ts',
+            content: moduleIndexTpl(kebabName, pascalName, camelName),
+          },
+          {
+            name: `${kebabName}.repository.ts`,
+            content: repositoryTpl(kebabName, pascalName, camelName, pluralName),
+          },
+          {
+            name: `${kebabName}.routes.ts`,
+            content: routesTpl(kebabName, pascalName, camelName, pluralName),
+          },
+        ];
+
+        // Write all files
+        for (const file of files) {
+          await writeFile(path.join(moduleDir, file.name), file.content);
+        }
+
+        // Generate test files
+        const testDir = path.join(moduleDir, '__tests__');
+
+        // Load test templates (custom or built-in)
+        const controllerTestTpl = await getTemplate('controller-test', controllerTestTemplate);
+        const serviceTestTpl = await getTemplate('service-test', serviceTestTemplate);
+        const integrationTestTpl = await getTemplate('integration-test', integrationTestTemplate);
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.controller.test.ts`),
+          controllerTestTpl(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.service.test.ts`),
+          serviceTestTpl(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.integration.test.ts`),
+          integrationTestTpl(kebabName, pascalName, camelName)
+        );
+
+        spinner.succeed(`Resource "${pascalName}" scaffolded successfully!`);
+
+        // Show Prisma model
+        console.log('\n' + '─'.repeat(70));
+        info('📋 Prisma model to add to schema.prisma:');
+        console.log(chalk.gray('\n// Copy this to your schema.prisma file:\n'));
+        console.log(dynamicPrismaTemplate(pascalName, tableName, fields));
+        console.log('─'.repeat(70));
+
+        // Show fields summary
+        console.log('\n📋 Fields scaffolded:');
+        fields.forEach((f) => {
+          const opts = [];
+          if (f.isOptional) opts.push('optional');
+          if (f.isArray) opts.push('array');
+          if (f.isUnique) opts.push('unique');
+          if (f.relation) opts.push(`relation: ${f.relation.model}`);
+          const optsStr = opts.length > 0 ? ` (${opts.join(', ')})` : '';
+          success(`  ${f.name}: ${f.type}${optsStr}`);
+        });
+
+        // Show files created
+        console.log('\n📁 Files created:');
+        files.forEach((f) => success(`  src/modules/${kebabName}/${f.name}`));
+        success(`  src/modules/${kebabName}/__tests__/${kebabName}.controller.test.ts`);
+        success(`  src/modules/${kebabName}/__tests__/${kebabName}.service.test.ts`);
+        success(`  src/modules/${kebabName}/__tests__/${kebabName}.integration.test.ts`);
+
+        // Show next steps
+        console.log('\n📌 Next steps:');
+        info('  1. Add the Prisma model to your schema.prisma file');
+        info('  2. Run: npx prisma db push (or prisma migrate dev)');
+        info('  3. Run: npx prisma generate');
+        info('  4. Register the module routes in your app');
+        info('  5. Update the test files with actual test data');
+
+        console.log(
+          chalk.gray('\n💡 Tip: Use --dry-run to preview changes before applying them\n')
+        );
+
+        if (options.dryRun) {
+          dryRun.printSummary();
+        }
+      } catch (error) {
+        spinner.fail('Failed to scaffold resource');
+        if (error instanceof Error) {
+          console.error(chalk.red(`\n✗ ${error.message}\n`));
+          console.error(chalk.gray(error.stack));
+        }
+        process.exit(1);
+      }
+    }
+  );

package/src/cli/commands/templates.ts

@@ -0,0 +1,147 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjectRoot } from '../utils/helpers.js';
+import { validateProject, displayError } from '../utils/error-handler.js';
+
+// Template types available for customization
+const TEMPLATE_TYPES = [
+  'controller',
+  'service',
+  'repository',
+  'types',
+  'schemas',
+  'routes',
+  'module-index',
+  'controller-test',
+  'service-test',
+  'integration-test',
+];
+
+async function initTemplates(): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  const templatesDir = path.join(projectRoot, '.servcraft', 'templates');
+
+  try {
+    // Create .servcraft/templates directory
+    await fs.mkdir(templatesDir, { recursive: true });
+
+    console.log(chalk.cyan('\n📁 Creating custom template directory...\n'));
+
+    // Create example template files
+    const exampleController = `// Custom controller template
+// Available variables: name, pascalName, camelName, pluralName
+export function controllerTemplate(name: string, pascalName: string, camelName: string): string {
+  return \`import type { FastifyRequest, FastifyReply } from 'fastify';
+import type { \${pascalName}Service } from './\${name}.service.js';
+
+export class \${pascalName}Controller {
+  constructor(private \${camelName}Service: \${pascalName}Service) {}
+
+  // Add your custom controller methods here
+  async getAll(request: FastifyRequest, reply: FastifyReply) {
+    const data = await this.\${camelName}Service.getAll();
+    return reply.send({ data });
+  }
+}
+\`;
+}
+`;
+
+    await fs.writeFile(
+      path.join(templatesDir, 'controller.example.ts'),
+      exampleController,
+      'utf-8'
+    );
+
+    console.log(chalk.green('✔ Created template directory: .servcraft/templates/'));
+    console.log(chalk.green('✔ Created example template: controller.example.ts\n'));
+
+    console.log(chalk.bold('📋 Available template types:\n'));
+    TEMPLATE_TYPES.forEach((type) => {
+      console.log(chalk.gray(`  • ${type}.ts`));
+    });
+
+    console.log(chalk.yellow('\n💡 To customize a template:'));
+    console.log(chalk.gray('  1. Copy the example template'));
+    console.log(chalk.gray('  2. Rename it (remove .example)'));
+    console.log(chalk.gray('  3. Modify the template code'));
+    console.log(chalk.gray('  4. Use --template flag when generating\n'));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red(`\n✗ Failed to initialize templates: ${error.message}\n`));
+    }
+  }
+}
+
+async function listTemplates(): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  const projectTemplatesDir = path.join(projectRoot, '.servcraft', 'templates');
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  const userTemplatesDir = path.join(homeDir, '.servcraft', 'templates');
+
+  console.log(chalk.bold.cyan('\n📋 Available Templates\n'));
+
+  // Check project templates
+  console.log(chalk.bold('Project templates (.servcraft/templates/):'));
+  try {
+    const files = await fs.readdir(projectTemplatesDir);
+    const templates = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.example.ts'));
+
+    if (templates.length > 0) {
+      templates.forEach((t) => {
+        console.log(chalk.green(`  ✓ ${t}`));
+      });
+    } else {
+      console.log(chalk.gray('  (none)'));
+    }
+  } catch {
+    console.log(chalk.gray('  (directory not found)'));
+  }
+
+  // Check user templates
+  console.log(chalk.bold('\nUser templates (~/.servcraft/templates/):'));
+  try {
+    const files = await fs.readdir(userTemplatesDir);
+    const templates = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.example.ts'));
+
+    if (templates.length > 0) {
+      templates.forEach((t) => {
+        console.log(chalk.green(`  ✓ ${t}`));
+      });
+    } else {
+      console.log(chalk.gray('  (none)'));
+    }
+  } catch {
+    console.log(chalk.gray('  (directory not found)'));
+  }
+
+  // Show built-in templates
+  console.log(chalk.bold('\nBuilt-in templates:'));
+  TEMPLATE_TYPES.forEach((t) => {
+    console.log(chalk.cyan(`  • ${t}.ts`));
+  });
+
+  console.log(chalk.gray('\n💡 Run "servcraft templates init" to create custom templates\n'));
+}
+
+export const templatesCommand = new Command('templates')
+  .description('Manage code generation templates')
+  .addCommand(
+    new Command('init').description('Initialize custom templates directory').action(initTemplates)
+  )
+  .addCommand(new Command('list').description('List available templates').action(listTemplates));

package/src/cli/index.ts

@@ -11,6 +11,8 @@ import { removeCommand } from './commands/remove.js';
 import { doctorCommand } from './commands/doctor.js';
 import { updateCommand } from './commands/update.js';
 import { completionCommand } from './commands/completion.js';
+import { scaffoldCommand } from './commands/scaffold.js';
+import { templatesCommand } from './commands/templates.js';
 
 const program = new Command();
 
@@ -49,4 +51,10 @@ program.addCommand(updateCommand);
 // Shell completion
 program.addCommand(completionCommand);
 
+// Scaffold resource
+program.addCommand(scaffoldCommand);
+
+// Template management
+program.addCommand(templatesCommand);
+
 program.parse();

package/src/cli/utils/template-loader.ts

@@ -0,0 +1,80 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjectRoot } from './helpers.js';
+
+/**
+ * Template loader that checks for custom templates in priority order:
+ * 1. Project templates (.servcraft/templates/)
+ * 2. User templates (~/.servcraft/templates/)
+ * 3. Built-in templates (fallback)
+ */
+
+export type TemplateType =
+  | 'controller'
+  | 'service'
+  | 'repository'
+  | 'types'
+  | 'schemas'
+  | 'routes'
+  | 'module-index'
+  | 'controller-test'
+  | 'service-test'
+  | 'integration-test';
+
+interface TemplateFunction {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: (...args: any[]) => string;
+}
+
+/**
+ * Load a custom template if available, otherwise return null
+ */
+export async function loadCustomTemplate(
+  templateType: TemplateType
+): Promise<TemplateFunction | null> {
+  const projectRoot = getProjectRoot();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+
+  const locations = [
+    path.join(projectRoot, '.servcraft', 'templates', `${templateType}.ts`),
+    path.join(homeDir, '.servcraft', 'templates', `${templateType}.ts`),
+  ];
+
+  for (const location of locations) {
+    try {
+      await fs.access(location);
+      // Template file exists, dynamically import it
+      const templateModule = (await import(`file://${location}`)) as TemplateFunction;
+
+      // Look for the template function (e.g., controllerTemplate, serviceTemplate)
+      const functionName = `${templateType.replace(/-/g, '')}Template`;
+
+      if (templateModule[functionName]) {
+        return templateModule;
+      }
+    } catch {
+      // File doesn't exist or import failed, try next location
+      continue;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get template function with fallback to built-in
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function getTemplate<T extends (...args: any[]) => string>(
+  templateType: TemplateType,
+  builtInTemplate: T
+): Promise<T> {
+  const customTemplate = await loadCustomTemplate(templateType);
+
+  if (customTemplate) {
+    const functionName = `${templateType.replace(/-/g, '')}Template`;
+    return customTemplate[functionName] as T;
+  }
+
+  return builtInTemplate;
+}

package/src/modules/user/user.repository.ts

@@ -2,7 +2,24 @@ import { prisma } from '../../database/prisma.js';
 import type { PaginatedResult, PaginationParams } from '../../types/index.js';
 import { createPaginatedResult, getSkip } from '../../utils/pagination.js';
 import type { User, CreateUserData, UpdateUserData, UserFilters } from './types.js';
-import { UserRole, UserStatus } from '@prisma/client';
+
+// Use string literal enums for ESM/CommonJS compatibility
+const UserRole = {
+  USER: 'USER',
+  MODERATOR: 'MODERATOR',
+  ADMIN: 'ADMIN',
+  SUPER_ADMIN: 'SUPER_ADMIN',
+} as const;
+
+const UserStatus = {
+  ACTIVE: 'ACTIVE',
+  INACTIVE: 'INACTIVE',
+  SUSPENDED: 'SUSPENDED',
+  BANNED: 'BANNED',
+} as const;
+
+type UserRole = (typeof UserRole)[keyof typeof UserRole];
+type UserStatus = (typeof UserStatus)[keyof typeof UserStatus];
 
 /**
  * User Repository - Prisma Implementation