servcraft 0.1.0

package/src/cli/templates/controller.ts

@@ -0,0 +1,67 @@
+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';
+import { create${pascalName}Schema, update${pascalName}Schema, ${camelName}QuerySchema } from './${name}.schemas.js';
+import { success, created, noContent } from '../../utils/response.js';
+import { parsePaginationParams } from '../../utils/pagination.js';
+import { validateBody, validateQuery } from '../validation/validator.js';
+
+export class ${pascalName}Controller {
+  constructor(private ${camelName}Service: ${pascalName}Service) {}
+
+  async list(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const query = validateQuery(${camelName}QuerySchema, request.query);
+    const pagination = parsePaginationParams(query);
+    const filters = {
+      search: query.search,
+    };
+
+    const result = await this.${camelName}Service.findMany(pagination, filters);
+    success(reply, result);
+  }
+
+  async getById(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const item = await this.${camelName}Service.findById(request.params.id);
+
+    if (!item) {
+      return reply.status(404).send({
+        success: false,
+        message: '${pascalName} not found',
+      });
+    }
+
+    success(reply, item);
+  }
+
+  async create(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const data = validateBody(create${pascalName}Schema, request.body);
+    const item = await this.${camelName}Service.create(data);
+    created(reply, item);
+  }
+
+  async update(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const data = validateBody(update${pascalName}Schema, request.body);
+    const item = await this.${camelName}Service.update(request.params.id, data);
+    success(reply, item);
+  }
+
+  async delete(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    await this.${camelName}Service.delete(request.params.id);
+    noContent(reply);
+  }
+}
+
+export function create${pascalName}Controller(${camelName}Service: ${pascalName}Service): ${pascalName}Controller {
+  return new ${pascalName}Controller(${camelName}Service);
+}
+`;
+}

package/src/cli/templates/dynamic-prisma.ts

@@ -0,0 +1,89 @@
+import type { FieldDefinition } from '../utils/field-parser.js';
+import { prismaTypeMap } from '../utils/field-parser.js';
+
+export function dynamicPrismaTemplate(
+  modelName: string,
+  tableName: string,
+  fields: FieldDefinition[]
+): string {
+  const fieldLines: string[] = [];
+
+  for (const field of fields) {
+    const prismaType = prismaTypeMap[field.type];
+    const optionalMark = field.isOptional ? '?' : '';
+    const arrayMark = field.isArray ? '[]' : '';
+    const annotations: string[] = [];
+
+    if (field.isUnique) {
+      annotations.push('@unique');
+    }
+
+    if (field.defaultValue !== undefined) {
+      // Handle different default value types
+      if (field.type === 'boolean') {
+        annotations.push(`@default(${field.defaultValue})`);
+      } else if (field.type === 'number' || field.type === 'int' || field.type === 'float') {
+        annotations.push(`@default(${field.defaultValue})`);
+      } else {
+        annotations.push(`@default("${field.defaultValue}")`);
+      }
+    }
+
+    // Database-specific annotations
+    if (field.type === 'text') {
+      annotations.push('@db.Text');
+    }
+
+    if (field.type === 'decimal') {
+      annotations.push('@db.Decimal(10, 2)');
+    }
+
+    const annotationStr = annotations.length > 0 ? '  ' + annotations.join(' ') : '';
+    const typePart = `${prismaType}${optionalMark}${arrayMark}`;
+
+    fieldLines.push(`  ${field.name.padEnd(15)} ${typePart.padEnd(12)}${annotationStr}`);
+  }
+
+  // Generate indexes
+  const indexLines: string[] = [];
+
+  // Index for unique fields
+  const uniqueFields = fields.filter((f) => f.isUnique);
+  for (const field of uniqueFields) {
+    indexLines.push(`  @@index([${field.name}])`);
+  }
+
+  // Index for common search fields
+  const searchableFields = fields.filter(
+    (f) => ['string', 'email'].includes(f.type) && !f.isUnique
+  );
+  if (searchableFields.length > 0) {
+    const firstSearchable = searchableFields[0];
+    if (firstSearchable) {
+      indexLines.push(`  @@index([${firstSearchable.name}])`);
+    }
+  }
+
+  return `
+// ==========================================
+// Add this model to your prisma/schema.prisma file
+// ==========================================
+
+model ${modelName} {
+  id              String    @id @default(uuid())
+
+${fieldLines.join('\n')}
+
+  createdAt       DateTime  @default(now())
+  updatedAt       DateTime  @updatedAt
+
+${indexLines.join('\n')}
+  @@map("${tableName}")
+}
+
+// ==========================================
+// After adding the model, run:
+// npm run db:migrate -- --name add_${tableName}
+// ==========================================
+`;
+}

package/src/cli/templates/dynamic-schemas.ts

@@ -0,0 +1,232 @@
+import type { FieldDefinition } from '../utils/field-parser.js';
+import { zodTypeMap, joiTypeMap, yupTypeMap } from '../utils/field-parser.js';
+
+export type ValidatorType = 'zod' | 'joi' | 'yup';
+
+export function dynamicSchemasTemplate(
+  name: string,
+  pascalName: string,
+  camelName: string,
+  fields: FieldDefinition[],
+  validator: ValidatorType = 'zod'
+): string {
+  switch (validator) {
+    case 'joi':
+      return generateJoiSchemas(pascalName, camelName, fields);
+    case 'yup':
+      return generateYupSchemas(pascalName, camelName, fields);
+    default:
+      return generateZodSchemas(pascalName, camelName, fields);
+  }
+}
+
+function generateZodSchemas(
+  pascalName: string,
+  camelName: string,
+  fields: FieldDefinition[]
+): string {
+  const createFields = fields.map((field) => {
+    let validator = zodTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `z.array(${validator})`;
+    }
+
+    if (field.isOptional) {
+      validator += '.optional()';
+    }
+
+    if (field.defaultValue) {
+      validator += `.default(${field.defaultValue})`;
+    }
+
+    // Add extra validations based on type
+    if (field.type === 'string' && !field.isOptional) {
+      validator = validator.replace('z.string()', 'z.string().min(1)');
+    }
+
+    return `  ${field.name}: ${validator},`;
+  });
+
+  const updateFields = fields.map((field) => {
+    let validator = zodTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `z.array(${validator})`;
+    }
+
+    validator += '.optional()';
+
+    return `  ${field.name}: ${validator},`;
+  });
+
+  return `import { z } from 'zod';
+
+export const create${pascalName}Schema = z.object({
+${createFields.join('\n')}
+});
+
+export const update${pascalName}Schema = z.object({
+${updateFields.join('\n')}
+});
+
+export const ${camelName}QuerySchema = z.object({
+  page: z.string().transform(Number).optional(),
+  limit: z.string().transform(Number).optional(),
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).optional(),
+  search: z.string().optional(),
+});
+
+export type Create${pascalName}Input = z.infer<typeof create${pascalName}Schema>;
+export type Update${pascalName}Input = z.infer<typeof update${pascalName}Schema>;
+export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
+`;
+}
+
+function generateJoiSchemas(
+  pascalName: string,
+  camelName: string,
+  fields: FieldDefinition[]
+): string {
+  const createFields = fields.map((field) => {
+    let validator = joiTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `Joi.array().items(${validator})`;
+    }
+
+    if (!field.isOptional) {
+      validator += '.required()';
+    }
+
+    if (field.defaultValue) {
+      validator += `.default(${field.defaultValue})`;
+    }
+
+    return `  ${field.name}: ${validator},`;
+  });
+
+  const updateFields = fields.map((field) => {
+    let validator = joiTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `Joi.array().items(${validator})`;
+    }
+
+    return `  ${field.name}: ${validator},`;
+  });
+
+  return `import Joi from 'joi';
+
+export const create${pascalName}Schema = Joi.object({
+${createFields.join('\n')}
+});
+
+export const update${pascalName}Schema = Joi.object({
+${updateFields.join('\n')}
+});
+
+export const ${camelName}QuerySchema = Joi.object({
+  page: Joi.number().integer().min(1),
+  limit: Joi.number().integer().min(1).max(100),
+  sortBy: Joi.string(),
+  sortOrder: Joi.string().valid('asc', 'desc'),
+  search: Joi.string(),
+});
+
+export type Create${pascalName}Input = {
+${fields.map((f) => `  ${f.name}${f.isOptional ? '?' : ''}: ${getJsType(f)};`).join('\n')}
+};
+
+export type Update${pascalName}Input = Partial<Create${pascalName}Input>;
+export type ${pascalName}QueryInput = {
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+  search?: string;
+};
+`;
+}
+
+function generateYupSchemas(
+  pascalName: string,
+  camelName: string,
+  fields: FieldDefinition[]
+): string {
+  const createFields = fields.map((field) => {
+    let validator = yupTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `yup.array().of(${validator})`;
+    }
+
+    if (!field.isOptional) {
+      validator += '.required()';
+    }
+
+    if (field.defaultValue) {
+      validator += `.default(${field.defaultValue})`;
+    }
+
+    return `  ${field.name}: ${validator},`;
+  });
+
+  const updateFields = fields.map((field) => {
+    let validator = yupTypeMap[field.type];
+
+    if (field.isArray) {
+      validator = `yup.array().of(${validator})`;
+    }
+
+    validator += '.optional()';
+
+    return `  ${field.name}: ${validator},`;
+  });
+
+  return `import * as yup from 'yup';
+
+export const create${pascalName}Schema = yup.object({
+${createFields.join('\n')}
+});
+
+export const update${pascalName}Schema = yup.object({
+${updateFields.join('\n')}
+});
+
+export const ${camelName}QuerySchema = yup.object({
+  page: yup.number().integer().min(1),
+  limit: yup.number().integer().min(1).max(100),
+  sortBy: yup.string(),
+  sortOrder: yup.string().oneOf(['asc', 'desc']),
+  search: yup.string(),
+});
+
+export type Create${pascalName}Input = yup.InferType<typeof create${pascalName}Schema>;
+export type Update${pascalName}Input = yup.InferType<typeof update${pascalName}Schema>;
+export type ${pascalName}QueryInput = yup.InferType<typeof ${camelName}QuerySchema>;
+`;
+}
+
+function getJsType(field: FieldDefinition): string {
+  const typeMap: Record<string, 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',
+  };
+
+  const baseType = typeMap[field.type] || 'unknown';
+  return field.isArray ? `${baseType}[]` : baseType;
+}

package/src/cli/templates/dynamic-types.ts

@@ -0,0 +1,60 @@
+import type { FieldDefinition } from '../utils/field-parser.js';
+import { tsTypeMap } from '../utils/field-parser.js';
+
+export function dynamicTypesTemplate(
+  name: string,
+  pascalName: string,
+  fields: FieldDefinition[]
+): string {
+  const fieldLines = fields.map((field) => {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? '[]' : '';
+    const optionalMark = field.isOptional ? '?' : '';
+    return `  ${field.name}${optionalMark}: ${tsType}${arrayMark};`;
+  });
+
+  const createFieldLines = fields
+    .filter((f) => !f.isOptional)
+    .map((field) => {
+      const tsType = tsTypeMap[field.type];
+      const arrayMark = field.isArray ? '[]' : '';
+      return `  ${field.name}: ${tsType}${arrayMark};`;
+    });
+
+  const createOptionalLines = fields
+    .filter((f) => f.isOptional)
+    .map((field) => {
+      const tsType = tsTypeMap[field.type];
+      const arrayMark = field.isArray ? '[]' : '';
+      return `  ${field.name}?: ${tsType}${arrayMark};`;
+    });
+
+  const updateFieldLines = fields.map((field) => {
+    const tsType = tsTypeMap[field.type];
+    const arrayMark = field.isArray ? '[]' : '';
+    return `  ${field.name}?: ${tsType}${arrayMark};`;
+  });
+
+  return `import type { BaseEntity } from '../../types/index.js';
+
+export interface ${pascalName} extends BaseEntity {
+${fieldLines.join('\n')}
+}
+
+export interface Create${pascalName}Data {
+${[...createFieldLines, ...createOptionalLines].join('\n')}
+}
+
+export interface Update${pascalName}Data {
+${updateFieldLines.join('\n')}
+}
+
+export interface ${pascalName}Filters {
+  search?: string;
+${fields
+  .filter((f) => ['string', 'enum', 'boolean'].includes(f.type))
+  .map((f) => `  ${f.name}?: ${tsTypeMap[f.type]};`)
+  .join('\n')}
+}
+`;
+}

package/src/cli/templates/module-index.ts

@@ -0,0 +1,33 @@
+export function moduleIndexTemplate(name: string, pascalName: string, camelName: string): string {
+  return `import type { FastifyInstance } from 'fastify';
+import { logger } from '../../core/logger.js';
+import { ${pascalName}Service, create${pascalName}Service } from './${name}.service.js';
+import { ${pascalName}Controller, create${pascalName}Controller } from './${name}.controller.js';
+import { ${pascalName}Repository, create${pascalName}Repository } from './${name}.repository.js';
+import { register${pascalName}Routes } from './${name}.routes.js';
+import type { AuthService } from '../auth/auth.service.js';
+
+export async function register${pascalName}Module(
+  app: FastifyInstance,
+  authService: AuthService
+): Promise<void> {
+  // Create repository and service
+  const repository = create${pascalName}Repository();
+  const ${camelName}Service = create${pascalName}Service(repository);
+
+  // Create controller
+  const ${camelName}Controller = create${pascalName}Controller(${camelName}Service);
+
+  // Register routes
+  register${pascalName}Routes(app, ${camelName}Controller, authService);
+
+  logger.info('${pascalName} module registered');
+}
+
+export { ${pascalName}Service, create${pascalName}Service } from './${name}.service.js';
+export { ${pascalName}Controller, create${pascalName}Controller } from './${name}.controller.js';
+export { ${pascalName}Repository, create${pascalName}Repository } from './${name}.repository.js';
+export * from './${name}.types.js';
+export * from './${name}.schemas.js';
+`;
+}

package/src/cli/templates/prisma-model.ts

@@ -0,0 +1,17 @@
+export function prismaModelTemplate(name: string, pascalName: string, tableName: string): string {
+  return `
+// Add this model to your prisma/schema.prisma file
+
+model ${pascalName} {
+  id          String   @id @default(uuid())
+  name        String
+  description String?
+
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+
+  @@index([name])
+  @@map("${tableName}")
+}
+`;
+}

package/src/cli/templates/repository.ts

@@ -0,0 +1,104 @@
+export function repositoryTemplate(name: string, pascalName: string, camelName: string, pluralName: string): string {
+  return `import { randomUUID } from 'crypto';
+import type { PaginatedResult, PaginationParams } from '../../types/index.js';
+import { createPaginatedResult, getSkip } from '../../utils/pagination.js';
+import type { ${pascalName}, Create${pascalName}Data, Update${pascalName}Data, ${pascalName}Filters } from './${name}.types.js';
+
+// In-memory storage (will be replaced by Prisma in production)
+const ${pluralName} = new Map<string, ${pascalName}>();
+
+export class ${pascalName}Repository {
+  async findById(id: string): Promise<${pascalName} | null> {
+    return ${pluralName}.get(id) || null;
+  }
+
+  async findMany(
+    params: PaginationParams,
+    filters?: ${pascalName}Filters
+  ): Promise<PaginatedResult<${pascalName}>> {
+    let items = Array.from(${pluralName}.values());
+
+    // Apply filters
+    if (filters?.search) {
+      const search = filters.search.toLowerCase();
+      items = items.filter((item) =>
+        JSON.stringify(item).toLowerCase().includes(search)
+      );
+    }
+
+    // Sort
+    if (params.sortBy) {
+      const sortKey = params.sortBy as keyof ${pascalName};
+      items.sort((a, b) => {
+        const aVal = a[sortKey];
+        const bVal = b[sortKey];
+        if (aVal === undefined || bVal === undefined) return 0;
+        if (aVal < bVal) return params.sortOrder === 'desc' ? 1 : -1;
+        if (aVal > bVal) return params.sortOrder === 'desc' ? -1 : 1;
+        return 0;
+      });
+    }
+
+    const total = items.length;
+    const skip = getSkip(params);
+    const data = items.slice(skip, skip + params.limit);
+
+    return createPaginatedResult(data, total, params);
+  }
+
+  async create(data: Create${pascalName}Data): Promise<${pascalName}> {
+    const now = new Date();
+    const item: ${pascalName} = {
+      id: randomUUID(),
+      ...data,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    ${pluralName}.set(item.id, item);
+    return item;
+  }
+
+  async update(id: string, data: Update${pascalName}Data): Promise<${pascalName} | null> {
+    const item = ${pluralName}.get(id);
+    if (!item) return null;
+
+    const updated: ${pascalName} = {
+      ...item,
+      ...data,
+      updatedAt: new Date(),
+    };
+
+    ${pluralName}.set(id, updated);
+    return updated;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    return ${pluralName}.delete(id);
+  }
+
+  async count(filters?: ${pascalName}Filters): Promise<number> {
+    if (!filters) return ${pluralName}.size;
+
+    let count = 0;
+    for (const item of ${pluralName}.values()) {
+      if (filters.search) {
+        const search = filters.search.toLowerCase();
+        if (!JSON.stringify(item).toLowerCase().includes(search)) continue;
+      }
+      count++;
+    }
+    return count;
+  }
+
+  // Clear all (for testing)
+  async clear(): Promise<void> {
+    ${pluralName}.clear();
+  }
+}
+
+export function create${pascalName}Repository(): ${pascalName}Repository {
+  return new ${pascalName}Repository();
+}
+`;
+}

package/src/cli/templates/routes.ts

@@ -0,0 +1,70 @@
+import type { FieldDefinition } from '../utils/field-parser.js';
+
+export function routesTemplate(
+  name: string,
+  pascalName: string,
+  camelName: string,
+  pluralName: string,
+  fields: FieldDefinition[] = []
+): string {
+  const serializedFields = JSON.stringify(fields, null, 2);
+  return `import type { FastifyInstance } from 'fastify';
+import type { ${pascalName}Controller } from './${name}.controller.js';
+import type { AuthService } from '../auth/auth.service.js';
+import { createAuthMiddleware, createRoleMiddleware } from '../auth/auth.middleware.js';
+import { generateRouteSchema } from '../swagger/schema-builder.js';
+import type { FieldDefinition } from '../cli/utils/field-parser.js';
+
+const ${camelName}Fields: FieldDefinition[] = ${serializedFields};
+const ${camelName}Schemas = {
+  list: generateRouteSchema('${pascalName}', ${camelName}Fields, 'list'),
+  get: generateRouteSchema('${pascalName}', ${camelName}Fields, 'get'),
+  create: generateRouteSchema('${pascalName}', ${camelName}Fields, 'create'),
+  update: generateRouteSchema('${pascalName}', ${camelName}Fields, 'update'),
+  delete: generateRouteSchema('${pascalName}', ${camelName}Fields, 'delete'),
+};
+
+export function register${pascalName}Routes(
+  app: FastifyInstance,
+  controller: ${pascalName}Controller,
+  authService: AuthService
+): void {
+  const authenticate = createAuthMiddleware(authService);
+  const isAdmin = createRoleMiddleware(['admin', 'super_admin']);
+
+  // Public routes (if any)
+  // app.get('/${pluralName}/public', controller.publicList.bind(controller));
+
+  // Protected routes
+  app.get(
+    '/${pluralName}',
+    { preHandler: [authenticate], ...${camelName}Schemas.list },
+    controller.list.bind(controller)
+  );
+
+  app.get(
+    '/${pluralName}/:id',
+    { preHandler: [authenticate], ...${camelName}Schemas.get },
+    controller.getById.bind(controller)
+  );
+
+  app.post(
+    '/${pluralName}',
+    { preHandler: [authenticate], ...${camelName}Schemas.create },
+    controller.create.bind(controller)
+  );
+
+  app.patch(
+    '/${pluralName}/:id',
+    { preHandler: [authenticate], ...${camelName}Schemas.update },
+    controller.update.bind(controller)
+  );
+
+  app.delete(
+    '/${pluralName}/:id',
+    { preHandler: [authenticate, isAdmin], ...${camelName}Schemas.delete },
+    controller.delete.bind(controller)
+  );
+}
+`;
+}

package/src/cli/templates/schemas.ts

@@ -0,0 +1,26 @@
+export function schemasTemplate(name: string, pascalName: string, camelName: string): string {
+  return `import { z } from 'zod';
+
+export const create${pascalName}Schema = z.object({
+  name: z.string().min(1, 'Name is required').max(255),
+  description: z.string().max(1000).optional(),
+});
+
+export const update${pascalName}Schema = z.object({
+  name: z.string().min(1).max(255).optional(),
+  description: z.string().max(1000).optional(),
+});
+
+export const ${camelName}QuerySchema = z.object({
+  page: z.string().transform(Number).optional(),
+  limit: z.string().transform(Number).optional(),
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).optional(),
+  search: z.string().optional(),
+});
+
+export type Create${pascalName}Input = z.infer<typeof create${pascalName}Schema>;
+export type Update${pascalName}Input = z.infer<typeof update${pascalName}Schema>;
+export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
+`;
+}