@currentjs/gen 0.1.1

package/dist/generators/templates/controllerTemplates.d.ts

@@ -0,0 +1,43 @@
+export declare const controllerTemplates: {
+    controllerClass: string;
+    controllerMethod: string;
+    userExtraction: string;
+    methodImplementations: {
+        list: string;
+        get: string;
+        create: string;
+        update: string;
+        delete: string;
+        empty: string;
+    };
+    responseFormats: {
+        list: string;
+        get: string;
+        create: string;
+        update: string;
+        delete: string;
+    };
+    statusCodes: {
+        list: {
+            success: number;
+            error: number;
+        };
+        get: {
+            success: number;
+            error: number;
+        };
+        create: {
+            success: number;
+            error: number;
+        };
+        update: {
+            success: number;
+            error: number;
+        };
+        delete: {
+            success: number;
+            error: number;
+        };
+    };
+};
+export declare const controllerFileTemplate = "import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport { {{ENTITY_NAME}}Service } from '../../application/services/{{ENTITY_NAME}}Service';\nimport { {{ENTITY_NAME}}DTO } from '../../application/validation/{{ENTITY_NAME}}Validation';{{JWT_IMPORT}}\nimport { Get, Post, Put, Patch, Delete, Controller, Render } from '@currentjs/router';\nimport type { IContext } from '@currentjs/router';\n\n{{CONTROLLER_CLASS}}";

package/dist/generators/templates/controllerTemplates.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllerFileTemplate = exports.controllerTemplates = void 0;
+exports.controllerTemplates = {
+    controllerClass: `@Controller('{{CONTROLLER_BASE}}', {})
+export class {{CONTROLLER_NAME}} {
+  constructor(
+    private {{ENTITY_LOWER}}Service: {{ENTITY_NAME}}Service
+  ) {}
+
+{{CONTROLLER_METHODS}}
+}`,
+    controllerMethod: `  @{{HTTP_DECORATOR}}("{{ENDPOINT_PATH}}"){{RENDER_DECORATOR}}
+  async {{METHOD_NAME}}(context: IContext): Promise<{{RETURN_TYPE}}> {
+{{METHOD_IMPLEMENTATION}}
+  }`,
+    userExtraction: `    const user = context.request.user;
+    if (!user) {
+      throw new Error('User authentication required');
+    }`,
+    methodImplementations: {
+        list: `{{USER_EXTRACTION}}
+    // Extract pagination from URL parameters
+    const page = parseInt(context.request.parameters.page as string) || 1;
+    const limit = parseInt(context.request.parameters.limit as string) || 10;
+    
+    const {{ENTITY_LOWER}}s = await this.{{ENTITY_LOWER}}Service.list(page, limit{{USER_PARAM}});
+    return {{ENTITY_LOWER}}s;`,
+        get: `{{USER_EXTRACTION}}
+    const id = parseInt(context.request.parameters.id as string);
+    if (isNaN(id)) {
+      throw new Error('Invalid ID parameter');
+    }
+    
+    const {{ENTITY_LOWER}} = await this.{{ENTITY_LOWER}}Service.get(id{{USER_PARAM}});
+    return {{ENTITY_LOWER}};`,
+        create: `{{USER_EXTRACTION}}
+    const new{{ENTITY_NAME}} = await this.{{ENTITY_LOWER}}Service.create(context.request.body as {{ENTITY_NAME}}DTO{{USER_PARAM}});
+    return new{{ENTITY_NAME}};`,
+        update: `{{USER_EXTRACTION}}
+    const id = parseInt(context.request.parameters.id as string);
+    if (isNaN(id)) {
+      throw new Error('Invalid ID parameter');
+    }
+    
+    const updated{{ENTITY_NAME}} = await this.{{ENTITY_LOWER}}Service.update(id, context.request.body as {{ENTITY_NAME}}DTO{{USER_PARAM}});
+    return updated{{ENTITY_NAME}};`,
+        delete: `{{USER_EXTRACTION}}
+    const id = parseInt(context.request.parameters.id as string);
+    if (isNaN(id)) {
+      throw new Error('Invalid ID parameter');
+    }
+    
+    const result = await this.{{ENTITY_LOWER}}Service.delete(id{{USER_PARAM}});
+    return result;`,
+        empty: `{{USER_EXTRACTION}}
+    // Provide an empty/default {{ENTITY_NAME}} for create form rendering
+    // Note: actual create happens via API endpoint using custom form handling
+    return {} as any;`
+    },
+    responseFormats: {
+        list: `{ data: {{ENTITY_LOWER}}s, page, limit }`,
+        get: `{ data: {{ENTITY_LOWER}} }`,
+        create: `{ data: new{{ENTITY_NAME}}, message: '{{ENTITY_NAME}} created successfully' }`,
+        update: `{ data: updated{{ENTITY_NAME}}, message: '{{ENTITY_NAME}} updated successfully' }`,
+        delete: `result`
+    },
+    statusCodes: {
+        list: { success: 200, error: 500 },
+        get: { success: 200, error: 404 },
+        create: { success: 201, error: 400 },
+        update: { success: 200, error: 400 },
+        delete: { success: 200, error: 400 }
+    }
+};
+exports.controllerFileTemplate = `import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';
+import { {{ENTITY_NAME}}Service } from '../../application/services/{{ENTITY_NAME}}Service';
+import { {{ENTITY_NAME}}DTO } from '../../application/validation/{{ENTITY_NAME}}Validation';{{JWT_IMPORT}}
+import { Get, Post, Put, Patch, Delete, Controller, Render } from '@currentjs/router';
+import type { IContext } from '@currentjs/router';
+
+{{CONTROLLER_CLASS}}`;

package/dist/generators/templates/index.d.ts

@@ -0,0 +1,5 @@
+export * from './serviceTemplates';
+export * from './controllerTemplates';
+export * from './storeTemplates';
+export * from './validationTemplates';
+export * from './appTemplates';

package/dist/generators/templates/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./serviceTemplates"), exports);
+__exportStar(require("./controllerTemplates"), exports);
+__exportStar(require("./storeTemplates"), exports);
+__exportStar(require("./validationTemplates"), exports);
+__exportStar(require("./appTemplates"), exports);

package/dist/generators/templates/serviceTemplates.d.ts

@@ -0,0 +1,15 @@
+export declare const serviceTemplates: {
+    serviceClass: string;
+    serviceMethod: string;
+    permissionCheck: string;
+    ownerPermissionCheck: string;
+    defaultImplementations: {
+        list: string;
+        getById: string;
+        create: string;
+        update: string;
+        delete: string;
+    };
+    customActionImplementation: string;
+};
+export declare const serviceFileTemplate = "import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport { {{ENTITY_NAME}}Store } from '../../infrastructure/stores/{{ENTITY_NAME}}Store';\nimport { {{ENTITY_NAME}}DTO, validateCreate{{ENTITY_NAME}}, validateUpdate{{ENTITY_NAME}} } from '../validation/{{ENTITY_NAME}}Validation';{{PERMISSIONS_IMPORT}}{{CUSTOM_IMPORTS}}\n\n{{SERVICE_CLASS}}";

package/dist/generators/templates/serviceTemplates.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceFileTemplate = exports.serviceTemplates = void 0;
+exports.serviceTemplates = {
+    serviceClass: `export class {{ENTITY_NAME}}Service {
+  constructor(
+    private {{ENTITY_LOWER}}Store: {{ENTITY_NAME}}Store{{AUTH_SERVICE_PARAM}}
+  ) {}
+
+{{SERVICE_METHODS}}
+}`,
+    serviceMethod: `  async {{METHOD_NAME}}({{METHOD_PARAMS}}{{USER_PARAM}}): Promise<{{RETURN_TYPE}}> {
+{{PERMISSION_CHECK}}
+    {{METHOD_IMPLEMENTATION}}
+  }`,
+    permissionCheck: `    // Role check: {{REQUIRED_ROLES}}
+    const allowedRoles = [{{ROLES_ARRAY}}];
+    if (allowedRoles.length > 0 && !allowedRoles.includes(user.role)) {
+      throw new Error('Insufficient permissions to perform this action');
+    }`,
+    ownerPermissionCheck: ``,
+    defaultImplementations: {
+        list: `const {{ENTITY_LOWER}}s = await this.{{ENTITY_LOWER}}Store.getAll(page, limit);
+    return {{ENTITY_LOWER}}s;`,
+        getById: `const {{ENTITY_LOWER}} = await this.{{ENTITY_LOWER}}Store.getById(id);
+    if (!{{ENTITY_LOWER}}) {
+      throw new Error('{{ENTITY_NAME}} not found');
+    }
+    return {{ENTITY_LOWER}};`,
+        create: `validateCreate{{ENTITY_NAME}}({{ENTITY_LOWER}}Data);
+    const {{ENTITY_LOWER}} = new {{ENTITY_NAME}}(0, {{CONSTRUCTOR_ARGS}});
+    return await this.{{ENTITY_LOWER}}Store.insert({{ENTITY_LOWER}});`,
+        update: `validateUpdate{{ENTITY_NAME}}({{ENTITY_LOWER}}Data);
+    const existing{{ENTITY_NAME}} = await this.{{ENTITY_LOWER}}Store.getById(id);
+    if (!existing{{ENTITY_NAME}}) {
+      throw new Error('{{ENTITY_NAME}} not found');
+    }
+    {{UPDATE_SETTER_CALLS}}
+    return await this.{{ENTITY_LOWER}}Store.update(id, existing{{ENTITY_NAME}});`,
+        delete: `const success = await this.{{ENTITY_LOWER}}Store.softDelete(id);
+    if (!success) {
+      throw new Error('{{ENTITY_NAME}} not found or could not be deleted');
+    }
+    return { success: true, message: '{{ENTITY_NAME}} deleted successfully' };`
+    },
+    customActionImplementation: `// Custom action implementation
+    const result = await {{CUSTOM_FUNCTION_CALL}};
+    return result;`
+};
+exports.serviceFileTemplate = `import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';
+import { {{ENTITY_NAME}}Store } from '../../infrastructure/stores/{{ENTITY_NAME}}Store';
+import { {{ENTITY_NAME}}DTO, validateCreate{{ENTITY_NAME}}, validateUpdate{{ENTITY_NAME}} } from '../validation/{{ENTITY_NAME}}Validation';{{PERMISSIONS_IMPORT}}{{CUSTOM_IMPORTS}}
+
+{{SERVICE_CLASS}}`;

package/dist/generators/templates/storeTemplates.d.ts

@@ -0,0 +1,9 @@
+export declare const storeTemplates: {
+    rowInterface: string;
+    storeClass: string;
+    conversionMethods: string;
+};
+export declare const fileTemplates: {
+    storeFile: string;
+    storeInterface: string;
+};

package/dist/generators/templates/storeTemplates.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileTemplates = exports.storeTemplates = void 0;
+exports.storeTemplates = {
+    rowInterface: `export interface {{ENTITY_NAME}}Row {
+  id: number;
+{{ROW_FIELDS}}
+  created_at: Date;
+  updated_at: Date;
+  deleted_at?: Date;
+}`,
+    storeClass: `export class {{ENTITY_NAME}}Store implements StoreInterface<{{ENTITY_NAME}}, {{ENTITY_NAME}}Row> {
+  private static readonly FILTERABLE_FIELDS = [{{FILTERABLE_FIELDS_ARRAY}}];
+  private static readonly UPDATABLE_FIELDS = [{{UPDATABLE_FIELDS_ARRAY}}];
+  
+  constructor(private db: ISqlProvider) {}
+
+  async getById(id: number): Promise<{{ENTITY_NAME}} | null> {
+    try {
+      const query = 'SELECT * FROM {{TABLE_NAME}} WHERE id = :id AND deleted_at IS NULL';
+      const result = await this.db.query(query, { id });
+      
+      if (!result.success || result.data.length === 0) {
+        return null;
+      }
+      
+      return {{ENTITY_NAME}}Store.rowToModel(result.data[0] as {{ENTITY_NAME}}Row);
+    } catch (error) {
+      if (error instanceof MySQLConnectionError) {
+        throw new Error(\`Database connection error while fetching {{ENTITY_NAME}} with id \${id}: \${error.message}\`);
+      } else if (error instanceof MySQLQueryError) {
+        throw new Error(\`Query error while fetching {{ENTITY_NAME}} with id \${id}: \${error.message}\`);
+      }
+      throw error;
+    }
+  }
+
+  async getAll(page: number = 1, limit: number = 10): Promise<{{ENTITY_NAME}}[]> {
+    const offset = (page - 1) * limit;
+    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE deleted_at IS NULL ORDER BY created_at DESC LIMIT \${limit} OFFSET \${offset}\`;
+    const result = await this.db.query(query, {});
+    
+    if (!result.success) {
+      return [];
+    }
+    
+    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
+  }
+
+  async getAllByUserId(userId: number, page: number = 1, limit: number = 10): Promise<{{ENTITY_NAME}}[]> {
+    const offset = (page - 1) * limit;
+    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE user_id = :userId AND deleted_at IS NULL ORDER BY created_at DESC LIMIT \${limit} OFFSET \${offset}\`;
+    const result = await this.db.query(query, { userId });
+    
+    if (!result.success) {
+      return [];
+    }
+    
+    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
+  }
+
+  async getBy(filters: Partial<Pick<{{ENTITY_NAME}}Row, {{FILTERABLE_FIELDS}}>>): Promise<{{ENTITY_NAME}} | null> {
+    const filterKeys = Object.keys(filters);
+    
+    // Runtime validation against SQL injection
+    for (const key of filterKeys) {
+      if (!{{ENTITY_NAME}}Store.FILTERABLE_FIELDS.includes(key)) {
+        throw new Error(\`Invalid filter field: \${key}\`);
+      }
+    }
+    
+    const whereConditions = filterKeys.map(key => \`\${key} = :\${key}\`);
+    
+    if (whereConditions.length === 0) {
+      throw new Error('At least one filter condition is required');
+    }
+    
+    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE \${whereConditions.join(' AND ')} AND deleted_at IS NULL LIMIT 1\`;
+    const result = await this.db.query(query, filters);
+    
+    if (!result.success || result.data.length === 0) {
+      return null;
+    }
+    
+    return {{ENTITY_NAME}}Store.rowToModel(result.data[0] as {{ENTITY_NAME}}Row);
+  }
+
+  async getAllBy(filters: Partial<Pick<{{ENTITY_NAME}}Row, {{FILTERABLE_FIELDS}}>>): Promise<{{ENTITY_NAME}}[]> {
+    const filterKeys = Object.keys(filters);
+    
+    // Runtime validation against SQL injection
+    for (const key of filterKeys) {
+      if (!{{ENTITY_NAME}}Store.FILTERABLE_FIELDS.includes(key)) {
+        throw new Error(\`Invalid filter field: \${key}\`);
+      }
+    }
+    
+    const whereConditions = filterKeys.map(key => \`\${key} = :\${key}\`);
+    
+    if (whereConditions.length === 0) {
+      return this.getAll();
+    }
+    
+    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE \${whereConditions.join(' AND ')} AND deleted_at IS NULL ORDER BY created_at DESC\`;
+    const result = await this.db.query(query, filters);
+    
+    if (!result.success) {
+      return [];
+    }
+    
+    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
+  }
+
+  async insert(model: Omit<{{ENTITY_NAME}}, 'id'>): Promise<{{ENTITY_NAME}}> {
+    try {
+      const row = {{ENTITY_NAME}}Store.modelToRow(model as {{ENTITY_NAME}});
+      delete row.id; // Remove id for insert
+      row.created_at = new Date();
+      row.updated_at = new Date();
+      
+      const fields = Object.keys(row);
+      const placeholders = fields.map(field => \`:\${field}\`).join(', ');
+      
+      const query = \`INSERT INTO {{TABLE_NAME}} (\${fields.join(', ')}) VALUES (\${placeholders})\`;
+      const result = await this.db.query(query, row);
+      
+      if (!result.success || !result.insertId) {
+        throw new Error('Failed to insert {{ENTITY_NAME}}: Insert operation did not return a valid ID');
+      }
+      
+      return this.getById(Number(result.insertId));
+    } catch (error) {
+      if (error instanceof MySQLQueryError) {
+        throw new Error(\`Failed to insert {{ENTITY_NAME}}: \${error.message}\`);
+      } else if (error instanceof MySQLConnectionError) {
+        throw new Error(\`Database connection error while inserting {{ENTITY_NAME}}: \${error.message}\`);
+      }
+      throw error;
+    }
+  }
+
+  async update(id: number, updates: Partial<Omit<{{ENTITY_NAME}}, 'id' | 'createdAt'>>): Promise<{{ENTITY_NAME}} | null> {
+    const existing = await this.getById(id);
+    if (!existing) {
+      return null;
+    }
+    
+    // Extract only data properties, not methods
+    const updateData = this.extractDataProperties(updates);
+    const updateKeys = Object.keys(updateData);
+    
+    // Runtime validation against SQL injection
+    for (const key of updateKeys) {
+      if (!{{ENTITY_NAME}}Store.UPDATABLE_FIELDS.includes(key)) {
+        throw new Error(\`Invalid update field: \${key}\`);
+      }
+    }
+    
+    const updateFields = updateKeys.map(key => \`\${key} = :\${key}\`);
+    
+    if (updateFields.length === 0) {
+      return existing;
+    }
+    
+    const params = { ...updateData, updated_at: new Date(), id };
+    
+    const query = \`UPDATE {{TABLE_NAME}} SET \${updateFields.join(', ')}, updated_at = :updated_at WHERE id = :id\`;
+    await this.db.query(query, params);
+    
+    return this.getById(id);
+  }
+
+  async upsert(model: Partial<{{ENTITY_NAME}}>): Promise<{{ENTITY_NAME}}> {
+    if (model.id) {
+      const existing = await this.getById(model.id);
+      if (existing) {
+        return this.update(model.id, model) as Promise<{{ENTITY_NAME}}>;
+      }
+    }
+    
+    return this.insert(model as Omit<{{ENTITY_NAME}}, 'id'>);
+  }
+
+  async softDelete(id: number): Promise<boolean> {
+    const query = 'UPDATE {{TABLE_NAME}} SET deleted_at = :deleted_at WHERE id = :id AND deleted_at IS NULL';
+    const result = await this.db.query(query, { deleted_at: new Date(), id });
+    
+    return result.success && (result.affectedRows || 0) > 0;
+  }
+
+  async count(filters?: Partial<Pick<{{ENTITY_NAME}}Row, {{FILTERABLE_FIELDS}}>>): Promise<number> {
+    let query = 'SELECT COUNT(*) as count FROM {{TABLE_NAME}} WHERE deleted_at IS NULL';
+    let params: Record<string, any> = {};
+    
+    if (filters && Object.keys(filters).length > 0) {
+      const whereConditions = Object.keys(filters).map(key => \`\${key} = :\${key}\`);
+      params = { ...filters };
+      query += \` AND \${whereConditions.join(' AND ')}\`;
+    }
+    
+    const result = await this.db.query(query, params);
+    
+    if (!result.success || result.data.length === 0) {
+      return 0;
+    }
+    
+    return result.data[0].count;
+  }
+
+{{CONVERSION_METHODS}}
+}`,
+    conversionMethods: `  static rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
+    return new {{ENTITY_NAME}}(
+      row.id,
+{{ROW_TO_MODEL_MAPPING}}
+    );
+  }
+
+  static modelToRow(model: {{ENTITY_NAME}}): Partial<{{ENTITY_NAME}}Row> {
+    return {
+      id: model.id,
+{{MODEL_TO_ROW_MAPPING}},
+      updated_at: new Date()
+    };
+  }
+
+  private extractDataProperties(obj: any): Record<string, any> {
+    const result: Record<string, any> = {};
+    
+    for (const [key, value] of Object.entries(obj)) {
+      // Only include properties that are not functions and are in updatable fields
+      if (typeof value !== 'function' && {{ENTITY_NAME}}Store.UPDATABLE_FIELDS.includes(key)) {
+        result[key] = value;
+      }
+    }
+    
+    return result;
+  }`
+};
+exports.fileTemplates = {
+    storeFile: `import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';
+import { StoreInterface } from '../interfaces/StoreInterface';
+import { ProviderMysql, ISqlProvider, MySQLQueryError, MySQLConnectionError } from '@currentjs/provider-mysql';
+
+{{ROW_INTERFACE}}
+
+{{STORE_CLASS}}`,
+    storeInterface: `export interface StoreInterface<TModel, TRow> {
+  getById(id: number): Promise<TModel | null>;
+  getAll(page?: number, limit?: number): Promise<TModel[]>;
+  getAllByUserId(userId: number, page?: number, limit?: number): Promise<TModel[]>;
+  getBy(filters: Partial<TRow>): Promise<TModel | null>;
+  getAllBy(filters: Partial<TRow>): Promise<TModel[]>;
+  insert(model: Omit<TModel, 'id'>): Promise<TModel>;
+  update(id: number, updates: Partial<Omit<TModel, 'id' | 'createdAt'>>): Promise<TModel | null>;
+  upsert(model: Partial<TModel>): Promise<TModel>;
+  softDelete(id: number): Promise<boolean>;
+  count(filters?: Partial<TRow>): Promise<number>;
+}`
+};

package/dist/generators/templates/validationTemplates.d.ts

@@ -0,0 +1,25 @@
+export declare const validationTemplates: {
+    inputInterface: string;
+    validationFunction: string;
+    requiredStringValidation: string;
+    optionalStringValidation: string;
+    requiredNumberValidation: string;
+    optionalNumberValidation: string;
+    requiredBooleanValidation: string;
+    optionalBooleanValidation: string;
+    requiredDateValidation: string;
+    optionalDateValidation: string;
+    requiredComplexValidation: string;
+    optionalComplexValidation: string;
+    validationFileTemplate: string;
+    dtoInterface: string;
+};
+export declare const typeMapping: {
+    string: string;
+    number: string;
+    boolean: string;
+    datetime: string;
+    json: string;
+    object: string;
+    array: string;
+};

package/dist/generators/templates/validationTemplates.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeMapping = exports.validationTemplates = void 0;
+exports.validationTemplates = {
+    inputInterface: `export interface {{INTERFACE_NAME}} {
+{{INTERFACE_FIELDS}}
+}`,
+    validationFunction: `export function {{FUNCTION_NAME}}(data: any): boolean {
+  const errors: string[] = [];
+  
+{{VALIDATION_LOGIC}}
+  
+  if (errors.length > 0) {
+    throw new Error(\`Validation failed: \${errors.join(', ')}\`);
+  }
+  
+  return true;
+}`,
+    requiredStringValidation: `  if (!data.{{FIELD_NAME}} || typeof data.{{FIELD_NAME}} !== 'string') {
+    errors.push('{{FIELD_NAME}} is required and must be a string');
+  }`,
+    optionalStringValidation: `  if (data.{{FIELD_NAME}} !== undefined && typeof data.{{FIELD_NAME}} !== 'string') {
+    errors.push('{{FIELD_NAME}} must be a string');
+  }`,
+    requiredNumberValidation: `  if (data.{{FIELD_NAME}} === undefined || data.{{FIELD_NAME}} === null || typeof data.{{FIELD_NAME}} !== 'number' || isNaN(data.{{FIELD_NAME}})) {
+    errors.push('{{FIELD_NAME}} is required and must be a number');
+  }`,
+    optionalNumberValidation: `  if (data.{{FIELD_NAME}} !== undefined && (typeof data.{{FIELD_NAME}} !== 'number' || isNaN(data.{{FIELD_NAME}}))) {
+    errors.push('{{FIELD_NAME}} must be a number');
+  }`,
+    requiredBooleanValidation: `  if (data.{{FIELD_NAME}} === undefined || data.{{FIELD_NAME}} === null || typeof data.{{FIELD_NAME}} !== 'boolean') {
+    errors.push('{{FIELD_NAME}} is required and must be a boolean');
+  }`,
+    optionalBooleanValidation: `  if (data.{{FIELD_NAME}} !== undefined && typeof data.{{FIELD_NAME}} !== 'boolean') {
+    errors.push('{{FIELD_NAME}} must be a boolean');
+  }`,
+    requiredDateValidation: `  if (!data.{{FIELD_NAME}} || !(data.{{FIELD_NAME}} instanceof Date) && isNaN(Date.parse(data.{{FIELD_NAME}}))) {
+    errors.push('{{FIELD_NAME}} is required and must be a valid date');
+  }`,
+    optionalDateValidation: `  if (data.{{FIELD_NAME}} !== undefined && !(data.{{FIELD_NAME}} instanceof Date) && isNaN(Date.parse(data.{{FIELD_NAME}}))) {
+    errors.push('{{FIELD_NAME}} must be a valid date');
+  }`,
+    // For complex types, just pass through for now
+    requiredComplexValidation: `  if (data.{{FIELD_NAME}} === undefined || data.{{FIELD_NAME}} === null) {
+    errors.push('{{FIELD_NAME}} is required');
+  }`,
+    optionalComplexValidation: `  // {{FIELD_NAME}} - complex type validation to be implemented later`,
+    validationFileTemplate: `// Generated validation for {{ENTITY_NAME}}
+
+{{DTO_INTERFACES}}
+
+{{VALIDATION_FUNCTIONS}}
+`,
+    dtoInterface: `export interface {{DTO_NAME}} {
+{{DTO_FIELDS}}
+}`
+};
+exports.typeMapping = {
+    string: 'string',
+    number: 'number',
+    boolean: 'boolean',
+    datetime: 'Date',
+    json: 'any',
+    object: 'any',
+    array: 'any[]'
+};

package/dist/generators/templates/viewTemplates.d.ts

@@ -0,0 +1,16 @@
+type FieldConfig = {
+    name: string;
+    type: string;
+    required?: boolean;
+    auto?: boolean;
+    unique?: boolean;
+    enum?: string[];
+};
+export declare function toFileNameFromTemplateName(name: string): string;
+export declare function renderListTemplate(entityName: string, templateName: string, basePath: string, fields: FieldConfig[], apiBase?: string): string;
+export declare function renderDetailTemplate(entityName: string, templateName: string, fields: FieldConfig[]): string;
+export declare function renderCreateTemplate(entityName: string, templateName: string, apiBase: string, fields: FieldConfig[], strategy?: string[], basePath?: string): string;
+export declare function renderUpdateTemplate(entityName: string, templateName: string, apiBase: string, fields: FieldConfig[], strategy?: string[], basePath?: string): string;
+export declare function renderDeleteTemplate(entityName: string, templateName: string, apiBase: string, strategy?: string[], basePath?: string): string;
+export declare function renderLayoutTemplate(layoutName: string): string;
+export {};