servcraft 0.1.0

package/src/cli/templates/service.ts

@@ -0,0 +1,58 @@
+export function serviceTemplate(name: string, pascalName: string, camelName: string): string {
+  return `import type { PaginatedResult, PaginationParams } from '../../types/index.js';
+import { NotFoundError, ConflictError } from '../../utils/errors.js';
+import { ${pascalName}Repository, create${pascalName}Repository } from './${name}.repository.js';
+import type { ${pascalName}, Create${pascalName}Data, Update${pascalName}Data, ${pascalName}Filters } from './${name}.types.js';
+import { logger } from '../../core/logger.js';
+
+export class ${pascalName}Service {
+  constructor(private repository: ${pascalName}Repository) {}
+
+  async findById(id: string): Promise<${pascalName} | null> {
+    return this.repository.findById(id);
+  }
+
+  async findMany(
+    params: PaginationParams,
+    filters?: ${pascalName}Filters
+  ): Promise<PaginatedResult<${pascalName}>> {
+    return this.repository.findMany(params, filters);
+  }
+
+  async create(data: Create${pascalName}Data): Promise<${pascalName}> {
+    const item = await this.repository.create(data);
+    logger.info({ ${camelName}Id: item.id }, '${pascalName} created');
+    return item;
+  }
+
+  async update(id: string, data: Update${pascalName}Data): Promise<${pascalName}> {
+    const existing = await this.repository.findById(id);
+    if (!existing) {
+      throw new NotFoundError('${pascalName}');
+    }
+
+    const updated = await this.repository.update(id, data);
+    if (!updated) {
+      throw new NotFoundError('${pascalName}');
+    }
+
+    logger.info({ ${camelName}Id: id }, '${pascalName} updated');
+    return updated;
+  }
+
+  async delete(id: string): Promise<void> {
+    const existing = await this.repository.findById(id);
+    if (!existing) {
+      throw new NotFoundError('${pascalName}');
+    }
+
+    await this.repository.delete(id);
+    logger.info({ ${camelName}Id: id }, '${pascalName} deleted');
+  }
+}
+
+export function create${pascalName}Service(repository?: ${pascalName}Repository): ${pascalName}Service {
+  return new ${pascalName}Service(repository || create${pascalName}Repository());
+}
+`;
+}

package/src/cli/templates/types.ts

@@ -0,0 +1,27 @@
+export function typesTemplate(name: string, pascalName: string): string {
+  return `import type { BaseEntity } from '../../types/index.js';
+
+export interface ${pascalName} extends BaseEntity {
+  // Add your ${pascalName} specific fields here
+  name: string;
+  description?: string;
+  // status?: string;
+  // metadata?: Record<string, unknown>;
+}
+
+export interface Create${pascalName}Data {
+  name: string;
+  description?: string;
+}
+
+export interface Update${pascalName}Data {
+  name?: string;
+  description?: string;
+}
+
+export interface ${pascalName}Filters {
+  search?: string;
+  // Add more filters as needed
+}
+`;
+}

package/src/cli/utils/docs-generator.ts

@@ -0,0 +1,47 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import { createServer } from '../../core/server.js';
+import { registerErrorHandler, registerSecurity } from '../../middleware/index.js';
+import { registerSwagger } from '../../modules/swagger/index.js';
+import { registerAuthModule } from '../../modules/auth/index.js';
+import { registerUserModule } from '../../modules/user/index.js';
+import { config } from '../../config/index.js';
+
+export async function generateDocs(outputPath = 'openapi.json', silent = false): Promise<string> {
+  const spinner = silent ? null : ora('Generating OpenAPI documentation...').start();
+  try {
+    const server = createServer({
+      port: config.server.port,
+      host: config.server.host,
+    });
+    const app = server.instance;
+
+    registerErrorHandler(app);
+    await registerSecurity(app);
+    await registerSwagger(app, {
+      enabled: true,
+      route: config.swagger.route,
+      title: config.swagger.title,
+      description: config.swagger.description,
+      version: config.swagger.version,
+    });
+    const authService = await registerAuthModule(app);
+    await registerUserModule(app, authService);
+
+    await app.ready();
+    const spec = app.swagger();
+
+    const absoluteOutput = path.resolve(outputPath);
+    await fs.mkdir(path.dirname(absoluteOutput), { recursive: true });
+    await fs.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), 'utf8');
+
+    spinner?.succeed(`OpenAPI spec generated at ${absoluteOutput}`);
+
+    await app.close();
+    return absoluteOutput;
+  } catch (error) {
+    spinner?.fail('Failed to generate OpenAPI documentation');
+    throw error;
+  }
+}

package/src/cli/utils/field-parser.ts

@@ -0,0 +1,315 @@
+export interface FieldDefinition {
+  name: string;
+  type: FieldType;
+  isOptional: boolean;
+  isArray: boolean;
+  isUnique: boolean;
+  defaultValue?: string;
+  relation?: {
+    model: string;
+    type: 'one-to-one' | 'one-to-many' | 'many-to-one';
+  };
+}
+
+export type FieldType =
+  | 'string'
+  | 'number'
+  | 'boolean'
+  | 'date'
+  | 'datetime'
+  | 'text'
+  | 'json'
+  | 'email'
+  | 'url'
+  | 'uuid'
+  | 'int'
+  | 'float'
+  | 'decimal'
+  | 'enum';
+
+// Map field types to TypeScript types
+export const tsTypeMap: Record<FieldType, string> = {
+  string: 'string',
+  number: 'number',
+  boolean: 'boolean',
+  date: 'Date',
+  datetime: 'Date',
+  text: 'string',
+  json: 'Record<string, unknown>',
+  email: 'string',
+  url: 'string',
+  uuid: 'string',
+  int: 'number',
+  float: 'number',
+  decimal: 'number',
+  enum: 'string',
+};
+
+// Map field types to Prisma types
+export const prismaTypeMap: Record<FieldType, string> = {
+  string: 'String',
+  number: 'Int',
+  boolean: 'Boolean',
+  date: 'DateTime',
+  datetime: 'DateTime',
+  text: 'String',
+  json: 'Json',
+  email: 'String',
+  url: 'String',
+  uuid: 'String',
+  int: 'Int',
+  float: 'Float',
+  decimal: 'Decimal',
+  enum: 'String',
+};
+
+// Map field types to Zod validators
+export const zodTypeMap: Record<FieldType, string> = {
+  string: 'z.string()',
+  number: 'z.number()',
+  boolean: 'z.boolean()',
+  date: 'z.coerce.date()',
+  datetime: 'z.coerce.date()',
+  text: 'z.string()',
+  json: 'z.record(z.unknown())',
+  email: 'z.string().email()',
+  url: 'z.string().url()',
+  uuid: 'z.string().uuid()',
+  int: 'z.number().int()',
+  float: 'z.number()',
+  decimal: 'z.number()',
+  enum: 'z.string()',
+};
+
+// Map field types to Joi validators
+export const joiTypeMap: Record<FieldType, string> = {
+  string: 'Joi.string()',
+  number: 'Joi.number()',
+  boolean: 'Joi.boolean()',
+  date: 'Joi.date()',
+  datetime: 'Joi.date()',
+  text: 'Joi.string()',
+  json: 'Joi.object()',
+  email: 'Joi.string().email()',
+  url: 'Joi.string().uri()',
+  uuid: 'Joi.string().uuid()',
+  int: 'Joi.number().integer()',
+  float: 'Joi.number()',
+  decimal: 'Joi.number()',
+  enum: 'Joi.string()',
+};
+
+// Map field types to Yup validators
+export const yupTypeMap: Record<FieldType, string> = {
+  string: 'yup.string()',
+  number: 'yup.number()',
+  boolean: 'yup.boolean()',
+  date: 'yup.date()',
+  datetime: 'yup.date()',
+  text: 'yup.string()',
+  json: 'yup.object()',
+  email: 'yup.string().email()',
+  url: 'yup.string().url()',
+  uuid: 'yup.string().uuid()',
+  int: 'yup.number().integer()',
+  float: 'yup.number()',
+  decimal: 'yup.number()',
+  enum: 'yup.string()',
+};
+
+/**
+ * Parse field definition string
+ * Format: name:type[:modifiers]
+ * Examples:
+ *   - title:string
+ *   - price:number
+ *   - email:email:unique
+ *   - description:text?
+ *   - tags:string[]
+ *   - isActive:boolean:default=true
+ *   - category:relation:Category
+ */
+export function parseField(fieldStr: string): FieldDefinition {
+  const parts = fieldStr.split(':');
+  let name = parts[0] || '';
+  let typeStr = parts[1] || 'string';
+  const modifiers = parts.slice(2);
+
+  // Check for optional (?)
+  const isOptional = name.endsWith('?') || typeStr.endsWith('?');
+  name = name.replace('?', '');
+  typeStr = typeStr.replace('?', '');
+
+  // Check for array ([])
+  const isArray = typeStr.endsWith('[]');
+  typeStr = typeStr.replace('[]', '');
+
+  // Validate type
+  const validTypes: FieldType[] = [
+    'string', 'number', 'boolean', 'date', 'datetime',
+    'text', 'json', 'email', 'url', 'uuid', 'int', 'float', 'decimal', 'enum'
+  ];
+
+  let type: FieldType = 'string';
+  if (validTypes.includes(typeStr as FieldType)) {
+    type = typeStr as FieldType;
+  }
+
+  // Parse modifiers
+  let isUnique = false;
+  let defaultValue: string | undefined;
+  let relation: FieldDefinition['relation'];
+
+  for (const mod of modifiers) {
+    if (mod === 'unique') {
+      isUnique = true;
+    } else if (mod.startsWith('default=')) {
+      defaultValue = mod.replace('default=', '');
+    } else if (typeStr === 'relation') {
+      relation = {
+        model: mod,
+        type: 'many-to-one',
+      };
+      type = 'string'; // Relations use string IDs
+    }
+  }
+
+  return {
+    name,
+    type,
+    isOptional,
+    isArray,
+    isUnique,
+    defaultValue,
+    relation,
+  };
+}
+
+/**
+ * Parse multiple fields from command line
+ * Example: "title:string price:number description:text?"
+ */
+export function parseFields(fieldsStr: string): FieldDefinition[] {
+  if (!fieldsStr) return [];
+
+  return fieldsStr
+    .split(/\s+/)
+    .filter(Boolean)
+    .map(parseField);
+}
+
+/**
+ * Generate TypeScript interface from fields
+ */
+export function generateTypeInterface(
+  name: string,
+  fields: FieldDefinition[],
+  includeBase = true
+): string {
+  const lines: string[] = [];
+
+  if (includeBase) {
+    lines.push(`import type { BaseEntity } from '../../types/index.js';`);
+    lines.push('');
+    lines.push(`export interface ${name} extends BaseEntity {`);
+  } else {
+    lines.push(`export interface ${name} {`);
+  }
+
+  for (const field of fields) {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? '[]' : '';
+    const optionalMark = field.isOptional ? '?' : '';
+    lines.push(`  ${field.name}${optionalMark}: ${tsType}${arrayMark};`);
+  }
+
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate Zod schema from fields
+ */
+export function generateZodSchema(
+  name: string,
+  fields: FieldDefinition[],
+  schemaType: 'create' | 'update' = 'create'
+): string {
+  const lines: string[] = [];
+
+  lines.push(`export const ${schemaType}${name}Schema = z.object({`);
+
+  for (const field of fields) {
+    let validator = zodTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `z.array(${validator})`;
+    }
+
+    if (field.isOptional || schemaType === 'update') {
+      validator += '.optional()';
+    }
+
+    if (field.defaultValue && schemaType === 'create') {
+      validator += `.default(${field.defaultValue})`;
+    }
+
+    lines.push(`  ${field.name}: ${validator},`);
+  }
+
+  lines.push('});');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate Prisma model from fields
+ */
+export function generatePrismaModel(
+  modelName: string,
+  tableName: string,
+  fields: FieldDefinition[]
+): string {
+  const lines: string[] = [];
+
+  lines.push(`model ${modelName} {`);
+  lines.push('  id          String   @id @default(uuid())');
+
+  for (const field of fields) {
+    const prismaType = prismaTypeMap[field.type];
+    const optionalMark = field.isOptional ? '?' : '';
+    const annotations: string[] = [];
+
+    if (field.isUnique) {
+      annotations.push('@unique');
+    }
+
+    if (field.defaultValue) {
+      annotations.push(`@default(${field.defaultValue})`);
+    }
+
+    if (field.type === 'text') {
+      annotations.push('@db.Text');
+    }
+
+    const annotationStr = annotations.length > 0 ? ' ' + annotations.join(' ') : '';
+    lines.push(`  ${field.name.padEnd(11)} ${prismaType}${optionalMark}${annotationStr}`);
+  }
+
+  lines.push('');
+  lines.push('  createdAt   DateTime @default(now())');
+  lines.push('  updatedAt   DateTime @updatedAt');
+  lines.push('');
+
+  // Add indexes for unique fields
+  const uniqueFields = fields.filter(f => f.isUnique);
+  for (const field of uniqueFields) {
+    lines.push(`  @@index([${field.name}])`);
+  }
+
+  lines.push(`  @@map("${tableName}")`);
+  lines.push('}');
+
+  return lines.join('\n');
+}

package/src/cli/utils/helpers.ts

@@ -0,0 +1,89 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+
+export function toPascalCase(str: string): string {
+  return str
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+export function toCamelCase(str: string): string {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+export function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+export function toSnakeCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/[\s-]+/g, '_')
+    .toLowerCase();
+}
+
+export function pluralize(str: string): string {
+  if (str.endsWith('y')) {
+    return str.slice(0, -1) + 'ies';
+  }
+  if (str.endsWith('s') || str.endsWith('x') || str.endsWith('ch') || str.endsWith('sh')) {
+    return str + 'es';
+  }
+  return str + 's';
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function writeFile(filePath: string, content: string): Promise<void> {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, 'utf-8');
+}
+
+export function log(message: string): void {
+  console.log(message);
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('✓'), message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('✗'), message);
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function getProjectRoot(): string {
+  return process.cwd();
+}
+
+export function getSourceDir(): string {
+  return path.join(getProjectRoot(), 'src');
+}
+
+export function getModulesDir(): string {
+  return path.join(getSourceDir(), 'modules');
+}

package/src/config/env.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import dotenv from 'dotenv';
+import { logger } from '../core/logger.js';
+
+// Load .env file
+dotenv.config();
+
+const envSchema = z.object({
+  // Server
+  NODE_ENV: z.enum(['development', 'staging', 'production', 'test']).default('development'),
+  PORT: z.string().transform(Number).default('3000'),
+  HOST: z.string().default('0.0.0.0'),
+
+  // Database
+  DATABASE_URL: z.string().optional(),
+
+  // JWT
+  JWT_SECRET: z.string().min(32).optional(),
+  JWT_ACCESS_EXPIRES_IN: z.string().default('15m'),
+  JWT_REFRESH_EXPIRES_IN: z.string().default('7d'),
+
+  // Security
+  CORS_ORIGIN: z.string().default('*'),
+  RATE_LIMIT_MAX: z.string().transform(Number).default('100'),
+  RATE_LIMIT_WINDOW_MS: z.string().transform(Number).default('60000'),
+
+  // Email
+  SMTP_HOST: z.string().optional(),
+  SMTP_PORT: z.string().transform(Number).optional(),
+  SMTP_USER: z.string().optional(),
+  SMTP_PASS: z.string().optional(),
+  SMTP_FROM: z.string().optional(),
+
+  // Redis (optional)
+  REDIS_URL: z.string().optional(),
+
+  // Swagger/OpenAPI
+  SWAGGER_ENABLED: z
+    .union([z.literal('true'), z.literal('false')])
+    .default('true')
+    .transform((val) => val === 'true'),
+  SWAGGER_ROUTE: z.string().default('/docs'),
+  SWAGGER_TITLE: z.string().default('Servcraft API'),
+  SWAGGER_DESCRIPTION: z.string().default('API documentation'),
+  SWAGGER_VERSION: z.string().default('1.0.0'),
+
+  // Logging
+  LOG_LEVEL: z.enum(['fatal', 'error', 'warn', 'info', 'debug', 'trace']).default('info'),
+});
+
+export type Env = z.infer<typeof envSchema>;
+
+function validateEnv(): Env {
+  const parsed = envSchema.safeParse(process.env);
+
+  if (!parsed.success) {
+    logger.error({ errors: parsed.error.flatten().fieldErrors }, 'Invalid environment variables');
+    throw new Error('Invalid environment variables');
+  }
+
+  return parsed.data;
+}
+
+export const env = validateEnv();
+
+export function isDevelopment(): boolean {
+  return env.NODE_ENV === 'development';
+}
+
+export function isProduction(): boolean {
+  return env.NODE_ENV === 'production';
+}
+
+export function isTest(): boolean {
+  return env.NODE_ENV === 'test';
+}
+
+export function isStaging(): boolean {
+  return env.NODE_ENV === 'staging';
+}