@currentjs/gen 0.2.2 → 0.3.0

package/dist/utils/migrationUtils.js

@@ -0,0 +1,291 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapYamlTypeToSql = mapYamlTypeToSql;
+exports.getTableName = getTableName;
+exports.getForeignKeyFieldName = getForeignKeyFieldName;
+exports.isRelationshipField = isRelationshipField;
+exports.generateCreateTableSQL = generateCreateTableSQL;
+exports.generateDropTableSQL = generateDropTableSQL;
+exports.generateAddColumnSQL = generateAddColumnSQL;
+exports.generateDropColumnSQL = generateDropColumnSQL;
+exports.generateModifyColumnSQL = generateModifyColumnSQL;
+exports.loadSchemaState = loadSchemaState;
+exports.saveSchemaState = saveSchemaState;
+exports.loadMigrationLog = loadMigrationLog;
+exports.saveMigrationLog = saveMigrationLog;
+exports.compareSchemas = compareSchemas;
+exports.generateTimestamp = generateTimestamp;
+exports.getMigrationFileName = getMigrationFileName;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+const TYPE_MAPPING = {
+    string: 'VARCHAR(255)',
+    number: 'INT',
+    boolean: 'TINYINT(1)',
+    datetime: 'DATETIME',
+    json: 'JSON',
+    array: 'JSON',
+    object: 'JSON'
+};
+function mapYamlTypeToSql(yamlType, availableModels) {
+    // Check if this is a relationship (foreign key)
+    if (availableModels.has(yamlType)) {
+        return 'INT'; // Foreign keys are INT
+    }
+    return TYPE_MAPPING[yamlType] || 'VARCHAR(255)';
+}
+function getTableName(modelName) {
+    return modelName.toLowerCase() + 's';
+}
+function getForeignKeyFieldName(fieldName) {
+    return fieldName + 'Id';
+}
+function isRelationshipField(fieldType, availableModels) {
+    return availableModels.has(fieldType);
+}
+function generateCreateTableSQL(model, availableModels) {
+    const tableName = getTableName(model.name);
+    const columns = [];
+    const indexes = [];
+    const foreignKeys = [];
+    // Add id column
+    columns.push('  id INT AUTO_INCREMENT PRIMARY KEY');
+    // Add model fields
+    model.fields.forEach(field => {
+        if (isRelationshipField(field.type, availableModels)) {
+            // Foreign key field
+            const foreignKeyName = getForeignKeyFieldName(field.name);
+            const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
+            columns.push(`  ${foreignKeyName} INT ${nullable}`);
+            // Add index for foreign key
+            indexes.push(`  INDEX idx_${tableName}_${foreignKeyName} (${foreignKeyName})`);
+            // Add foreign key constraint
+            const refTableName = getTableName(field.type);
+            foreignKeys.push(`  CONSTRAINT fk_${tableName}_${foreignKeyName} \n` +
+                `    FOREIGN KEY (${foreignKeyName}) \n` +
+                `    REFERENCES ${refTableName}(id) \n` +
+                `    ON DELETE RESTRICT \n` +
+                `    ON UPDATE CASCADE`);
+        }
+        else {
+            // Regular field
+            const sqlType = mapYamlTypeToSql(field.type, availableModels);
+            const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
+            columns.push(`  ${field.name} ${sqlType} ${nullable}`);
+            // Add index for filterable fields
+            if (['string', 'number'].includes(field.type)) {
+                indexes.push(`  INDEX idx_${tableName}_${field.name} (${field.name})`);
+            }
+        }
+    });
+    // Add standard timestamp columns
+    columns.push('  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP');
+    columns.push('  updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
+    columns.push('  deleted_at DATETIME NULL DEFAULT NULL');
+    // Add standard indexes
+    indexes.push(`  INDEX idx_${tableName}_deleted_at (deleted_at)`);
+    indexes.push(`  INDEX idx_${tableName}_created_at (created_at)`);
+    // Combine all parts
+    const allParts = [...columns, ...indexes, ...foreignKeys];
+    const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
+    return sql;
+}
+function generateDropTableSQL(tableName) {
+    return `DROP TABLE IF EXISTS ${tableName};`;
+}
+function generateAddColumnSQL(tableName, field, availableModels) {
+    if (isRelationshipField(field.type, availableModels)) {
+        const foreignKeyName = getForeignKeyFieldName(field.name);
+        const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
+        const sqlType = 'INT';
+        return `ALTER TABLE ${tableName} ADD COLUMN ${foreignKeyName} ${sqlType} ${nullable};`;
+    }
+    else {
+        const sqlType = mapYamlTypeToSql(field.type, availableModels);
+        const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
+        return `ALTER TABLE ${tableName} ADD COLUMN ${field.name} ${sqlType} ${nullable};`;
+    }
+}
+function generateDropColumnSQL(tableName, columnName) {
+    return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+}
+function generateModifyColumnSQL(tableName, field, availableModels) {
+    if (isRelationshipField(field.type, availableModels)) {
+        const foreignKeyName = getForeignKeyFieldName(field.name);
+        const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
+        const sqlType = 'INT';
+        return `ALTER TABLE ${tableName} MODIFY COLUMN ${foreignKeyName} ${sqlType} ${nullable};`;
+    }
+    else {
+        const sqlType = mapYamlTypeToSql(field.type, availableModels);
+        const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
+        return `ALTER TABLE ${tableName} MODIFY COLUMN ${field.name} ${sqlType} ${nullable};`;
+    }
+}
+function loadSchemaState(stateFilePath) {
+    if (!fs.existsSync(stateFilePath)) {
+        return null;
+    }
+    const content = fs.readFileSync(stateFilePath, 'utf8');
+    return (0, yaml_1.parse)(content);
+}
+function saveSchemaState(stateFilePath, state) {
+    fs.mkdirSync(path.dirname(stateFilePath), { recursive: true });
+    fs.writeFileSync(stateFilePath, (0, yaml_1.stringify)(state));
+}
+function loadMigrationLog(logFilePath) {
+    if (!fs.existsSync(logFilePath)) {
+        return { appliedMigrations: [] };
+    }
+    const content = fs.readFileSync(logFilePath, 'utf8');
+    return JSON.parse(content);
+}
+function saveMigrationLog(logFilePath, log) {
+    fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
+    fs.writeFileSync(logFilePath, JSON.stringify(log, null, 2));
+}
+/**
+ * Sort models by dependencies so tables are created in the right order
+ * (tables with no foreign keys first, then tables that depend on them)
+ */
+function sortModelsByDependencies(models, availableModels) {
+    const sorted = [];
+    const processed = new Set();
+    const addModel = (model) => {
+        if (processed.has(model.name))
+            return;
+        // Find foreign key dependencies
+        const dependencies = [];
+        model.fields.forEach(field => {
+            if (isRelationshipField(field.type, availableModels)) {
+                dependencies.push(field.type);
+            }
+        });
+        // Add dependencies first
+        dependencies.forEach(depName => {
+            const depModel = models.find(m => m.name === depName);
+            if (depModel && !processed.has(depName)) {
+                addModel(depModel);
+            }
+        });
+        // Then add this model
+        sorted.push(model);
+        processed.add(model.name);
+    };
+    models.forEach(model => addModel(model));
+    return sorted;
+}
+function compareSchemas(oldState, newModels) {
+    const sqlStatements = [];
+    const availableModels = new Set(newModels.map(m => m.name));
+    if (!oldState || oldState.models.length === 0) {
+        // No previous state - generate all CREATE TABLE statements in dependency order
+        const sortedModels = sortModelsByDependencies(newModels, availableModels);
+        sortedModels.forEach(model => {
+            sqlStatements.push(`-- Create ${model.name.toLowerCase()}s table`);
+            sqlStatements.push(generateCreateTableSQL(model, availableModels));
+            sqlStatements.push('');
+        });
+        return sqlStatements;
+    }
+    // Create maps for easy lookup
+    const oldModelsMap = new Map(oldState.models.map(m => [m.name, m]));
+    const newModelsMap = new Map(newModels.map(m => [m.name, m]));
+    // Find dropped tables
+    oldState.models.forEach(oldModel => {
+        if (!newModelsMap.has(oldModel.name)) {
+            const tableName = getTableName(oldModel.name);
+            sqlStatements.push(`-- Drop ${tableName} table`);
+            sqlStatements.push(generateDropTableSQL(tableName));
+            sqlStatements.push('');
+        }
+    });
+    // Find new tables and modified tables
+    newModels.forEach(newModel => {
+        const oldModel = oldModelsMap.get(newModel.name);
+        const tableName = getTableName(newModel.name);
+        if (!oldModel) {
+            // New table
+            sqlStatements.push(`-- Create ${tableName} table`);
+            sqlStatements.push(generateCreateTableSQL(newModel, availableModels));
+            sqlStatements.push('');
+        }
+        else {
+            // Table exists - check for column changes
+            const oldFieldsMap = new Map(oldModel.fields.map(f => [f.name, f]));
+            const newFieldsMap = new Map(newModel.fields.map(f => [f.name, f]));
+            // Find dropped columns
+            oldModel.fields.forEach(oldField => {
+                if (!newFieldsMap.has(oldField.name)) {
+                    const columnName = isRelationshipField(oldField.type, availableModels)
+                        ? getForeignKeyFieldName(oldField.name)
+                        : oldField.name;
+                    sqlStatements.push(`-- Drop column ${columnName} from ${tableName}`);
+                    sqlStatements.push(generateDropColumnSQL(tableName, columnName));
+                    sqlStatements.push('');
+                }
+            });
+            // Find new columns and modified columns
+            newModel.fields.forEach(newField => {
+                const oldField = oldFieldsMap.get(newField.name);
+                if (!oldField) {
+                    // New column
+                    sqlStatements.push(`-- Add column ${newField.name} to ${tableName}`);
+                    sqlStatements.push(generateAddColumnSQL(tableName, newField, availableModels));
+                    sqlStatements.push('');
+                }
+                else {
+                    // Check if column definition changed
+                    const typeChanged = oldField.type !== newField.type;
+                    const requiredChanged = oldField.required !== newField.required;
+                    if (typeChanged || requiredChanged) {
+                        sqlStatements.push(`-- Modify column ${newField.name} in ${tableName}`);
+                        sqlStatements.push(generateModifyColumnSQL(tableName, newField, availableModels));
+                        sqlStatements.push('');
+                    }
+                }
+            });
+        }
+    });
+    return sqlStatements;
+}
+function generateTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, -5);
+}
+function getMigrationFileName(timestamp) {
+    return `${timestamp}.sql`;
+}

package/howto.md

@@ -153,6 +153,110 @@ permissions:                            # Role-based access control
 - `number` - Numeric data (integer or float)
 - `boolean` - True/false values
 - `datetime` - Date and time values
+- `ModelName` - Relationship to another model (e.g., `Owner`, `User`, `Post`)
+
+**Multi-Model Endpoint Configuration:**
+
+When working with multiple models in a single module, you have flexible options:
+
+**Option 1: Per-Endpoint Model Override**
+
+Specify `model` on individual endpoints to override the section default:
+
+```yaml
+models:
+  - name: Cat
+  - name: Person
+  # do not forget to describe fields of each model
+
+routes:
+  prefix: /cat
+  model: Cat  # Default for this section
+  endpoints:
+    - path: /create
+      view: catCreate
+      # Uses Cat model
+    
+    - path: /createOwner
+      view: ownerCreate
+      model: Person  # Override for this endpoint
+```
+
+**Option 2: Multiple API/Routes Sections**
+
+Use arrays to organize endpoints by model:
+
+```yaml
+routes:
+  - prefix: /cat
+    model: Cat
+    endpoints: [...]
+  
+  - prefix: /person
+    model: Person
+    endpoints: [...]
+
+# Same works for api sections
+api:
+  - prefix: /api/cat
+    model: Cat
+    endpoints: [...]
+  
+  - prefix: /api/person
+    model: Person
+    endpoints: [...]
+```
+
+**Model Resolution Priority:**
+1. `endpoint.model` (explicit override)
+2. Inferred from action handler (e.g., `Person:default:create`)
+3. `api.model` or `routes.model` (section default)
+4. First model in `models[]` array (fallback)
+
+**🔗 Model Relationships:**
+
+Define relationships by using another model's name as the field type:
+
+```yaml
+models:
+  - name: Owner
+    fields:
+      - name: name
+        type: string
+        required: true
+
+  - name: Cat
+    fields:
+      - name: name
+        type: string
+        required: true
+      - name: owner
+        type: Owner        # Creates relationship with Owner model
+        required: true     # Auto-generates foreign key: ownerId
+        displayFields: [name]  # Optional: fields to show in dropdowns
+```
+
+**Generated Behavior:**
+- **Domain Model**: Rich object with `owner: Owner` (full object, not just ID)
+- **DTOs**: Use `ownerId: number` for API requests
+- **Database**: Stores `ownerId` foreign key column (references `Owner.id`)
+- **Store**: Automatically loads the related Owner object when fetching a Cat
+- **HTML Forms**: Auto-generates select dropdown with "Create New" button
+- **TypeScript**: Full type safety with proper imports
+
+**Naming Convention:**
+Foreign keys are automatically generated following the pattern `fieldName + 'Id'`:
+- `owner` → `ownerId`
+- `author` → `authorId`
+- `parentComment` → `parentCommentId`
+
+**Optional Configuration:**
+```yaml
+- name: author
+  type: User
+  required: true
+  displayFields: [name, email] # Show in dropdown (optional)
+```
 
 **🔄 Handler vs Action Architecture:**
 - **Handler**: Creates a separate service method (one handler = one service method)
@@ -374,13 +478,13 @@ try {
 **Basic Usage:**
 ```javascript
 // Translate strings
-t('Hello World')  // Returns translated version or original
-t('Save changes')
+App.lang.t('Hello World')  // Returns translated version or original
+App.lang.t('Save changes')
 
 // Set language
-setLang('pl')     // Switch to Polish
-setLang('en')     // Switch to English
-getCurrentLanguage()  // Get current language code
+App.lang.set('pl')     // Switch to Polish
+App.lang.set('en')     // Switch to English
+App.lang.get()         // Get current language code
 ```
 
 **Translation File (web/translations.json):**
@@ -402,43 +506,35 @@ getCurrentLanguage()  // Get current language code
 
 **Toast Notifications:**
 ```javascript
-showToast('Success message', 'success')  // Green toast
-showToast('Error occurred', 'error')     // Red toast  
-showToast('Information', 'info')         // Blue toast
-showToast('Warning', 'warning')          // Yellow toast
+App.ui.showToast('Success message', 'success')  // Green toast
+App.ui.showToast('Error occurred', 'error')     // Red toast  
+App.ui.showToast('Information', 'info')         // Blue toast
+App.ui.showToast('Warning', 'warning')          // Yellow toast
 ```
 
 **Inline Messages:**
 ```javascript
-showMessage('messageId', 'Success!', 'success')
-showMessage('errorContainer', 'Validation failed', 'error')
+App.ui.showMessage('messageId', 'Success!', 'success')
+App.ui.showMessage('errorContainer', 'Validation failed', 'error')
 ```
 
 **Modal Dialogs:**
 ```javascript
-showModal('confirmModal', 'Item saved successfully', 'success')
-showModal('errorModal', 'Operation failed', 'error')
+App.ui.showModal('confirmModal', 'Item saved successfully', 'success')
+App.ui.showModal('errorModal', 'Operation failed', 'error')
 ```
 
 ### Navigation & Page Actions
 
 **Navigation Functions:**
 ```javascript
-navigateBack()              // Go back in history or to home
-redirectTo('/posts')        // Safe redirect with validation
-reloadPage()               // Reload with loading indicator
-refreshSection('#content') // Refresh specific section
-
 // SPA-style navigation
-navigateToPage('/posts/123')  // Loads via AJAX, updates #main
-```
+App.nav.go('/posts/123')  // Loads via AJAX, updates #main
 
-**Content Management:**
-```javascript
-updateContent('#results', newHtml, 'replace')  // Replace content
-updateContent('#list', itemHtml, 'append')     // Add to end
-updateContent('#list', itemHtml, 'prepend')    // Add to beginning
-removeElement('#item-123')                     // Animate and remove
+// Or use native browser APIs directly
+window.history.back()      // Go back in history
+window.location.href = '/posts'  // Full page redirect
+window.location.reload()   // Reload page
 ```
 
 ### Form Handling & Strategy System
@@ -468,52 +564,26 @@ removeElement('#item-123')                     // Animate and remove
 **Manual Form Submission:**
 ```javascript
 const form = document.querySelector('#myForm');
-submitForm(form, ['toast', 'back'], {
+App.nav.submit(form, ['toast', 'back'], {
   entityName: 'Post',
   basePath: '/posts',
   messageId: 'form-message'
 });
 ```
 
-**Success Handling:**
-```javascript
-handleFormSuccess(response, ['toast', 'back'], {
-  entityName: 'Post',
-  basePath: '/posts',
-  messageId: 'success-msg',
-  modalId: 'success-modal'
-});
-```
-
-### Form Validation & Type Conversion
-
-**Client-side Validation Setup:**
-```javascript
-setupFormValidation('#createForm');  // Adds required field validation
-```
-
-**Field Type Conversion:**
-```javascript
-// Automatic conversion based on data-field-types
-convertFieldValue('123', 'number')    // Returns 123 (number)
-convertFieldValue('true', 'boolean')  // Returns true (boolean)
-convertFieldValue('text', 'string')   // Returns 'text' (string)
-```
-
 ### Loading States & Utilities
 
 **Loading Indicators:**
 ```javascript
-showLoading('#form')      // Show spinner on form
-hideLoading('#form')      // Hide spinner
-showLoading('#main')      // Show spinner on main content
+App.ui.showLoading('#form')      // Show spinner on form
+App.ui.hideLoading('#form')      // Hide spinner
+App.ui.showLoading('#main')      // Show spinner on main content
 ```
 
 **Utility Functions:**
 ```javascript
-debounce(searchFunction, 300)  // Debounce for search inputs
-getElementSafely('#selector') // Safe element selection
-clearForm('#myForm')          // Reset form and clear validation
+App.utils.debounce(searchFunction, 300)  // Debounce for search inputs
+App.utils.$('#selector')                  // Safe element selection
 ```
 
 ### Event Handling & SPA Integration
@@ -531,12 +601,12 @@ clearForm('#myForm')          // Reset form and clear validation
 **Custom Event Listeners:**
 ```javascript
 // Re-initialize after dynamic content loading
-initializeEventListeners();
+App.utils.initializeEventListeners();
 
 // Handle specific link navigation
 document.querySelector('#myLink').addEventListener('click', (e) => {
   e.preventDefault();
-  navigateToPage('/custom/path');
+  App.nav.go('/custom/path');
 });
 ```
 
@@ -545,11 +615,33 @@ document.querySelector('#myLink').addEventListener('click', (e) => {
 **Accessing Functions:**
 ```javascript
 // All functions available under window.App
-App.showToast('Message', 'success');
-App.navigateBack();
-App.t('Translate this');
-App.setLang('pl');
-App.showLoading('#content');
+// Organized by category for better discoverability
+
+// UI Functions
+App.ui.showToast('Message', 'success');
+App.ui.showMessage('elementId', 'Success!', 'success');
+App.ui.showModal('modalId', 'Done!', 'success');
+App.ui.showLoading('#form');
+App.ui.hideLoading('#form');
+
+// Navigation Functions
+App.nav.go('/posts/123');  // SPA-style navigation with AJAX
+App.nav.submit(formElement, ['toast', 'back'], options);  // Submit form via AJAX
+
+// Translation Functions
+App.lang.t('Translate this');  // Translate string
+App.lang.set('pl');  // Set language
+App.lang.get();  // Get current language
+
+// Utility Functions
+App.utils.$('#selector');  // Safe element selection
+App.utils.debounce(fn, 300);  // Debounce function
+App.utils.initializeEventListeners();  // Re-initialize after dynamic content
+
+// Authentication Functions (JWT)
+App.auth.setAuthToken(token);  // Store JWT token
+App.auth.clearAuthToken();  // Remove JWT token
+App.auth.buildAuthHeaders(additionalHeaders);  // Build headers with auth token
 ```
 
 ### Template Data Binding

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@currentjs/gen",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",
@@ -27,7 +27,8 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && npm run copy-templates",
+    "copy-templates": "mkdir -p dist/generators/templates/data && cp src/generators/templates/data/* dist/generators/templates/data/",
     "clean": "rm -rf dist",
     "prepack": "npm run build"
   },