@currentjs/gen 0.3.2 → 0.5.1

package/dist/generators/templates/data/frontendScriptTemplate

@@ -374,7 +374,10 @@ window.AppConfig = {
    */
   function navigateToPage(url, targetElement = null) {
     const target = targetElement || document.querySelector('#main');
-    if (!target) return;
+    if (!target) {
+      window.location.href = url;
+      return;
+    }
     
     showLoading('#main');
     
@@ -388,18 +391,22 @@ window.AppConfig = {
         if (!response.ok) {
           throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
+        const targetLayout = response.headers.get('X-Layout') || '';
+        const currentLayout = (document.querySelector('meta[name="app-layout"]') || {}).content || '';
+        if (targetLayout !== currentLayout) {
+          window.location.href = url;
+          return null;
+        }
         return response.text();
       })
       .then(html => {
+        if (html === null) return;
         target.innerHTML = html;
-        // Update browser history
         window.history.pushState({}, '', url);
-        // No need to re-initialize - delegation handles new content automatically
       })
       .catch(error => {
         console.error('Navigation failed:', error);
         showToast('Failed to load page', 'error');
-        // Fallback to normal navigation
         window.location.href = url;
       })
       .finally(() => {
@@ -414,7 +421,7 @@ window.AppConfig = {
    * @returns {any} Converted value
    */
   function convertFieldValue(value, fieldType) {
-    if (!value || value === '') {
+    if (value === undefined || value === null || value === '') {
       return null;
     }
     
@@ -422,6 +429,7 @@ window.AppConfig = {
       case 'number':
       case 'int':
       case 'integer':
+      case 'id':
         const intVal = parseInt(value, 10);
         return isNaN(intVal) ? null : intVal;
       
@@ -432,10 +440,15 @@ window.AppConfig = {
       
       case 'boolean':
       case 'bool':
-        if (value === 'true') return true;
-        if (value === 'false') return false;
+        if (value === 'true' || value === 'on' || value === '1') return true;
+        if (value === 'false' || value === 'off' || value === '0') return false;
         return Boolean(value);
+
+      case 'json':
+        try { return JSON.parse(value); } catch { return value; }
       
+      case 'datetime':
+      case 'date':
       case 'enum':
       case 'string':
       case 'text':
@@ -474,6 +487,30 @@ window.AppConfig = {
         jsonData[key] = convertedValue;
       }
     }
+
+    // Unchecked checkboxes are not included in FormData — default to false
+    for (const [fieldName, fieldType] of Object.entries(fieldTypes)) {
+      const ft = fieldType.toLowerCase();
+      if ((ft === 'boolean' || ft === 'bool') && !(fieldName in jsonData)) {
+        jsonData[fieldName] = false;
+      }
+    }
+
+    // Unflatten dot-notation keys (e.g., "amount.currency") into nested objects
+    const finalData = {};
+    for (const [key, value] of Object.entries(jsonData)) {
+      if (key.includes('.')) {
+        const parts = key.split('.');
+        let current = finalData;
+        for (let i = 0; i < parts.length - 1; i++) {
+          if (!(parts[i] in current)) current[parts[i]] = {};
+          current = current[parts[i]];
+        }
+        current[parts[parts.length - 1]] = value;
+      } else {
+        finalData[key] = value;
+      }
+    }
     
     const url = form.getAttribute('data-action') || form.action;
     const method = (form.getAttribute('data-method') || form.method || 'POST').toUpperCase();
@@ -486,16 +523,20 @@ window.AppConfig = {
         'Content-Type': 'application/json',
         'Accept': 'application/json'
       }),
-      body: JSON.stringify(jsonData)
+      body: JSON.stringify(finalData)
     })
-      .then(response => {
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      .then(response =>
+        response.json()
+          .catch(() => ({}))
+          .then(body => ({ ok: response.ok, status: response.status, statusText: response.statusText, body }))
+      )
+      .then(({ ok, status, statusText, body }) => {
+        if (!ok) {
+          const message = body.message || body.error || `HTTP ${status}: ${statusText}`;
+          handleFormError({ message }, options);
+          return;
         }
-        return response.json();
-      })
-      .then(data => {
-        handleFormSuccess(data, strategy, options);
+        handleFormSuccess(body, strategy, options);
       })
       .catch(error => {
         console.error('Form submission failed:', error);

package/dist/generators/templates/data/mainViewTemplate

@@ -5,12 +5,13 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Your App</title>
+  <meta name="app-layout" content="main_view">
   <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
   <script src="/app.js"></script>
 </head>
 <body>
   <div class="container-fluid">
-    <div id="main">{{ content }}</div>
+    <div id="main">{{{ content }}}</div>
   </div>
 </body>
 </html>

package/dist/generators/templates/data/systemTsTemplate

@@ -0,0 +1,5 @@
+export function Injectable() {
+  return function (target: any) {
+    target.__injectable = true;
+  };
+}

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

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

package/dist/generators/templates/index.js

@@ -14,8 +14,5 @@ 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/storeTemplates.d.ts

@@ -1,9 +1,5 @@
 export declare const storeTemplates: {
     rowInterface: string;
     storeClass: string;
-    conversionMethods: string;
-};
-export declare const fileTemplates: {
-    storeFile: string;
-    storeInterface: string;
 };
+export declare const storeFileTemplate = "import { Injectable } from '../../../../system';\nimport { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}\n\n{{ROW_INTERFACE}}\n\n{{STORE_CLASS}}\n";

package/dist/generators/templates/storeTemplates.js

@@ -1,260 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileTemplates = exports.storeTemplates = void 0;
+exports.storeFileTemplate = 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;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string;
 }`,
-    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}}];
-  
+    storeClass: `/**
+ * Data access layer for {{ENTITY_NAME}}
+ */
+@Injectable()
+export class {{ENTITY_NAME}}Store {
+  private tableName = '{{TABLE_NAME}}';
+
   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;
-    }
+  private toMySQLDatetime(date: Date): string {
+    return date.toISOString().slice(0, 19).replace('T', ' ');
   }
 
-  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));
+  private rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
+    return new {{ENTITY_NAME}}(
+      row.id,
+{{ROW_TO_MODEL_MAPPING}}
+    );
   }
 
-  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));
-  }
+{{LIST_METHODS}}
 
-  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 getById(id: number): Promise<{{ENTITY_NAME}} | null> {
+    const result = await this.db.query(
+      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deleted_at IS NULL\`,
+      { id }
+    );
 
-  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 [];
+    if (result.success && result.data && result.data.length > 0) {
+      return this.rowToModel(result.data[0] as {{ENTITY_NAME}}Row);
     }
-    
-    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
+    return null;
   }
 
-  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 insert(entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
+    const now = new Date();
+    const data: Partial<{{ENTITY_NAME}}Row> = {
+{{INSERT_DATA_MAPPING}},
+      created_at: this.toMySQLDatetime(now),
+      updated_at: this.toMySQLDatetime(now)
+    };
 
-  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 fieldsList = Object.keys(data).map(f => \`\\\`\${f}\\\`\`).join(', ');
+    const placeholders = Object.keys(data).map(f => \`:\${f}\`).join(', ');
+
+    const result = await this.db.query(
+      \`INSERT INTO \\\`\${this.tableName}\\\` (\${fieldsList}) VALUES (\${placeholders})\`,
+      data
+    );
+
+    if (result.success && result.insertId) {
+      const newId = typeof result.insertId === 'string' ? parseInt(result.insertId, 10) : result.insertId;
+      return this.getById(newId) as Promise<{{ENTITY_NAME}}>;
     }
-    
-    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);
+
+    throw new Error('Failed to insert {{ENTITY_NAME}}');
   }
 
-  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}}>;
-      }
+  async update(id: number, entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
+    const now = new Date();
+    const data: Partial<{{ENTITY_NAME}}Row> & { id: number } = {
+{{UPDATE_DATA_MAPPING}},
+      updated_at: this.toMySQLDatetime(now),
+      id
+    };
+
+    const updateFields = {{UPDATE_FIELDS_ARRAY}}.map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
+
+    const result = await this.db.query(
+      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updated_at = :updated_at WHERE id = :id\`,
+      data
+    );
+
+    if (result.success) {
+      return this.getById(id) as Promise<{{ENTITY_NAME}}>;
     }
-    
-    return this.insert(model as Omit<{{ENTITY_NAME}}, 'id'>);
+
+    throw new Error('Failed to update {{ENTITY_NAME}}');
   }
 
   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;
-  }
+    const now = new Date();
+    const result = await this.db.query(
+      \`UPDATE \\\`\${this.tableName}\\\` SET deleted_at = :deleted_at WHERE id = :id\`,
+      { deleted_at: this.toMySQLDatetime(now), id }
+    );
 
-  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;
+    return result.success;
   }
 
-{{CONVERSION_METHODS}}
-}`,
-    conversionMethods: `  static rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
-    return new {{ENTITY_NAME}}(
-      row.id,
-{{ROW_TO_MODEL_MAPPING}}
+  async hardDelete(id: number): Promise<boolean> {
+    const result = await this.db.query(
+      \`DELETE FROM \\\`\${this.tableName}\\\` WHERE id = :id\`,
+      { id }
     );
-  }
 
-  static modelToRow(model: {{ENTITY_NAME}}): Partial<{{ENTITY_NAME}}Row> {
-    return {
-      id: model.id,
-{{MODEL_TO_ROW_MAPPING}},
-      updated_at: new Date()
-    };
+    return result.success;
   }
-
-  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;
-  }`
+{{GET_BY_PARENT_ID_METHOD}}
+{{GET_RESOURCE_OWNER_METHOD}}}`
 };
-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';
+exports.storeFileTemplate = `import { Injectable } from '../../../../system';
+import { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';
+import type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}
 
 {{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>;
-}`
-};
+{{STORE_CLASS}}
+`;

package/dist/generators/useCaseGenerator.d.ts

@@ -0,0 +1,13 @@
+import { ModuleConfig } from '../types/configTypes';
+export declare class UseCaseGenerator {
+    private availableAggregates;
+    private generateUseCaseMethod;
+    private generateGetResourceOwnerMethod;
+    private generateUseCase;
+    generateFromConfig(config: ModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}