go-duck-cli 1.0.8 → 1.1.1

package/generators/migrations.js

@@ -5,236 +5,130 @@ import { toLiquibaseType } from '../parser/gdl.js';
 
 export const generateLiquibaseChangelogs = async (entities, relationships, projectRootDir, delta = null, enums = []) => {
     const migrationsDir = path.join(projectRootDir, 'migrations');
-    const liquibaseDir = path.join(migrationsDir, 'liquibase');
-    const changelogsDir = path.join(liquibaseDir, 'changelogs');
+    const sqlDir = path.join(migrationsDir, 'sql');
     await fs.ensureDir(migrationsDir);
-    await fs.ensureDir(liquibaseDir);
-    await fs.ensureDir(changelogsDir);
+    await fs.ensureDir(sqlDir);
 
     const timestamp = new Date().toISOString().replace(/[-:T]/g, '').split('.')[0];
-    const dateStamp = timestamp.substring(0, 8); // YYYYMMDD
 
     // -------------------------------------------------------
-    // STEP 1: Build changesets FIRST — decide on filename after
+    // Core Management Tables (Always present if they don't exist)
     // -------------------------------------------------------
-    let changeSets = '';
+    if (!delta) {
+        const coreFileName = `00000_init_core_tables.sql`;
+        const corePath = path.join(sqlDir, coreFileName);
+        
+        if (!await fs.pathExists(corePath)) {
+            const coreSql = `-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE IF NOT EXISTS tenant_roles (
+    id BIGSERIAL PRIMARY KEY,
+    role_name VARCHAR(255) UNIQUE NOT NULL,
+    db_name VARCHAR(255) NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS audit_log (
+    id BIGSERIAL PRIMARY KEY,
+    entity_name VARCHAR(255) NOT NULL,
+    tenant_db VARCHAR(255),
+    entity_id VARCHAR(255) NOT NULL,
+    action VARCHAR(50) NOT NULL,
+    previous_value TEXT,
+    new_value TEXT,
+    modified_by VARCHAR(255),
+    keycloak_id VARCHAR(255),
+    modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    client_ip VARCHAR(50)
+);
+
+CREATE TABLE IF NOT EXISTS api_usage (
+    id BIGSERIAL PRIMARY KEY,
+    user_id VARCHAR(255) NOT NULL,
+    api_path VARCHAR(255) NOT NULL,
+    tenant_db VARCHAR(255),
+    usage_count BIGINT NOT NULL DEFAULT 0,
+    max_limit BIGINT NOT NULL DEFAULT 1000,
+    last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS tenant_roles CASCADE;
+DROP TABLE IF EXISTS audit_log CASCADE;
+DROP TABLE IF EXISTS api_usage CASCADE;
+-- +goose StatementEnd
+`;
+            await fs.writeFile(corePath, coreSql);
+        }
+    }
+
+    // -------------------------------------------------------
+    // Entity Migrations
+    // -------------------------------------------------------
+    let sqlUp = '-- +goose Up\n-- +goose StatementBegin\n';
+    let sqlDown = '-- +goose Down\n-- +goose StatementBegin\n';
 
     const entitiesToCreate = delta ? delta.newEntities : entities;
-    const relationshipsToAdd = delta ? delta.newRelationships : relationships;
+
+    if (entitiesToCreate.length === 0 && (!delta || (!delta.newFields && !delta.newRelationships))) {
+        return;
+    }
 
     // Create New Tables
     for (const entity of entitiesToCreate) {
-        let columns = `
-            <column name="id" type="BIGINT" autoIncrement="true">
-                <constraints primaryKey="true" nullable="false"/>
-            </column>`;
+        let columns = '    id BIGSERIAL PRIMARY KEY';
 
         for (const field of entity.fields) {
-            const liqType = toLiquibaseType(field, enums);
-            const uniqueConstraint = field.unique ? ' <constraints nullable="' + (field.required ? 'false' : 'true') + '" unique="true"/>' : '';
-            if (field.unique) {
-                columns += `
-            <column name="${field.name.toLowerCase()}" type="${liqType}">
-                <constraints nullable="${field.required ? 'false' : 'true'}" unique="true"/>
-            </column>`;
-            } else {
-                columns += `
-            <column name="${field.name.toLowerCase()}" type="${liqType}">
-                <constraints nullable="${field.required ? 'false' : 'true'}"/>
-            </column>`;
-            }
+            let sqlType = toLiquibaseType(field, enums);
+            if (sqlType === 'JSON') sqlType = 'JSONB'; // Force JSONB for Postgres
+            
+            const constraints = [];
+            if (field.required) constraints.push('NOT NULL');
+            if (field.unique) constraints.push('UNIQUE');
+            
+            columns += `,\n    ${field.name.toLowerCase()} ${sqlType} ${constraints.join(' ')}`;
         }
 
-        // @Audited entities get full audit columns (skip the simpler created_at/updated_at to avoid duplicates)
+        // Auditing / Timestamp columns
         if (entity.annotation === '@Audited') {
-            columns += `
-            <column name="created_by" type="VARCHAR(255)"/>
-            <column name="created_date" type="TIMESTAMP"/>
-            <column name="last_modified_by" type="VARCHAR(255)"/>
-            <column name="last_modified_date" type="TIMESTAMP"/>
-            <column name="last_modified_user_id" type="VARCHAR(255)"/>`;
+            columns += `,\n    created_by VARCHAR(255),\n    created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n    last_modified_by VARCHAR(255),\n    last_modified_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n    last_modified_user_id VARCHAR(255)`;
         } else {
-            columns += `
-            <column name="created_at" type="TIMESTAMP"/>
-            <column name="updated_at" type="TIMESTAMP"/>`;
+            columns += `,\n    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP`;
         }
 
-        changeSets += `
-    <changeSet id="${entity.name.toLowerCase()}-create-${timestamp}" author="go-duck">
-        <preConditions onFail="MARK_RAN"><not><tableExists tableName="${entity.name.toLowerCase()}"/></not></preConditions>
-        <createTable tableName="${entity.name.toLowerCase()}">
-            ${columns}
-        </createTable>
-    </changeSet>
-`;
+        sqlUp += `CREATE TABLE IF NOT EXISTS ${entity.name.toLowerCase()} (\n${columns}\n);\n\n`;
+        sqlDown += `DROP TABLE IF EXISTS ${entity.name.toLowerCase()} CASCADE;\n`;
     }
 
-    // Add New Fields to existing tables
+    // Add New Fields
     if (delta && delta.newFields) {
         for (const [entityName, fields] of Object.entries(delta.newFields)) {
-            if (fields.length === 0) continue;
-            let columnTags = '';
             for (const field of fields) {
-                const liqType = toLiquibaseType(field, enums);
-                if (field.unique) {
-                    columnTags += `
-            <column name="${field.name.toLowerCase()}" type="${liqType}">
-                <constraints nullable="${field.required ? 'false' : 'true'}" unique="true"/>
-            </column>`;
-                } else {
-                    columnTags += `
-            <column name="${field.name.toLowerCase()}" type="${liqType}">
-                <constraints nullable="${field.required ? 'false' : 'true'}"/>
-            </column>`;
-                }
+                let sqlType = toLiquibaseType(field, enums);
+                if (sqlType === 'JSON') sqlType = 'JSONB';
+                const constraints = [];
+                if (field.required) constraints.push('NOT NULL');
+                if (field.unique) constraints.push('UNIQUE');
+
+                sqlUp += `ALTER TABLE ${entityName.toLowerCase()} ADD COLUMN IF NOT EXISTS ${field.name.toLowerCase()} ${sqlType} ${constraints.join(' ')};\n`;
+                sqlDown += `ALTER TABLE ${entityName.toLowerCase()} DROP COLUMN IF EXISTS ${field.name.toLowerCase()};\n`;
             }
-            changeSets += `
-    <changeSet id="${entityName.toLowerCase()}-add-fields-${timestamp}" author="go-duck">
-        <addColumn tableName="${entityName.toLowerCase()}">
-            ${columnTags}
-        </addColumn>
-    </changeSet>
-`;
-        }
-    }
-
-    // Foreign Keys + Index
-    for (const rel of relationshipsToAdd) {
-        if (rel.type === 'OneToMany') {
-            const childTable = rel.to.entity.toLowerCase();
-            const fkNullable = rel.required ? 'false' : 'true';
-            const fkCol = rel.to.field.toLowerCase() + '_id';
-            const parentTable = rel.from.entity.toLowerCase();
-            const fkName = `fk_${childTable}_${rel.to.field.toLowerCase()}`;
-            const idxName = `idx_${childTable}_${fkCol}`;
-            changeSets += `
-    <changeSet id="rel-${parentTable}-${childTable}-${timestamp}" author="go-duck">
-        <preConditions onFail="MARK_RAN">
-            <not>
-                <columnExists tableName="${childTable}" columnName="${fkCol}"/>
-            </not>
-        </preConditions>
-        <addColumn tableName="${childTable}">
-            <column name="${fkCol}" type="BIGINT">
-                <constraints nullable="${fkNullable}" foreignKeyName="${fkName}" referencedTableName="${parentTable}" referencedColumnNames="id"/>
-            </column>
-        </addColumn>
-    </changeSet>
-
-    <changeSet id="idx-${idxName}-${timestamp}" author="go-duck">
-        <preConditions onFail="MARK_RAN">
-            <not><indexExists indexName="${idxName}"/></not>
-        </preConditions>
-        <createIndex indexName="${idxName}" tableName="${childTable}">
-            <column name="${fkCol}"/>
-        </createIndex>
-    </changeSet>
-`;
         }
     }
 
-    // Support Tables (always on initial run, never on incremental)
-    if (!delta) {
-        changeSets += `
-    <changeSet id="management-tables-init" author="go-duck">
-        <preConditions onFail="MARK_RAN"><not><tableExists tableName="tenant_roles"/></not></preConditions>
-        <createTable tableName="tenant_roles">
-            <column name="id" type="BIGINT" autoIncrement="true"><constraints primaryKey="true" nullable="false"/></column>
-            <column name="role_name" type="VARCHAR(255)"><constraints nullable="false" unique="true"/></column>
-            <column name="db_name" type="VARCHAR(255)"><constraints nullable="false"/></column>
-        </createTable>
-    </changeSet>
-
-    <changeSet id="audit-log-table-init" author="go-duck">
-        <preConditions onFail="MARK_RAN"><not><tableExists tableName="audit_log"/></not></preConditions>
-        <createTable tableName="audit_log">
-            <column name="id" type="BIGINT" autoIncrement="true"><constraints primaryKey="true" nullable="false"/></column>
-            <column name="entity_name" type="VARCHAR(255)"><constraints nullable="false"/></column>
-            <column name="entity_id" type="VARCHAR(255)"><constraints nullable="false"/></column>
-            <column name="action" type="VARCHAR(50)"><constraints nullable="false"/></column>
-            <column name="previous_value" type="TEXT"/><column name="new_value" type="TEXT"/>
-            <column name="modified_by" type="VARCHAR(255)"/><column name="keycloak_id" type="VARCHAR(255)"/>
-            <column name="modified_at" type="TIMESTAMP"><constraints nullable="false"/></column>
-            <column name="client_ip" type="VARCHAR(50)"/>
-        </createTable>
-    </changeSet>
-
-    <changeSet id="api-usage-table-init" author="go-duck">
-        <preConditions onFail="MARK_RAN"><not><tableExists tableName="api_usage"/></not></preConditions>
-        <createTable tableName="api_usage">
-            <column name="id" type="BIGINT" autoIncrement="true"><constraints primaryKey="true" nullable="false"/></column>
-            <column name="user_id" type="VARCHAR(255)"><constraints nullable="false"/></column>
-            <column name="api_path" type="VARCHAR(255)"><constraints nullable="false"/></column>
-            <column name="usage_count" type="BIGINT" defaultValueNumeric="0"><constraints nullable="false"/></column>
-            <column name="max_limit" type="BIGINT" defaultValueNumeric="1000"><constraints nullable="false"/></column>
-            <column name="last_accessed" type="TIMESTAMP"/>
-        </createTable>
-    </changeSet>
-`;
-    }
-
-    // -------------------------------------------------------
-    // STEP 2: Only write files if there are real changesets
-    // -------------------------------------------------------
-    if (changeSets.trim() === '') {
-        console.log(chalk.gray('  No database changes detected.'));
-        return;
-    }
+    sqlUp += '-- +goose StatementEnd\n\n';
+    sqlDown += '-- +goose StatementEnd\n';
 
-    // Build descriptive filename from what actually changed
     const descParts = [];
     if (!delta) {
-        const entityNames = entities.map(e => e.name.toLowerCase()).join('-');
-        descParts.push('init');
-        if (entityNames) descParts.push(entityNames);
-    } else {
-        if (delta.newEntities && delta.newEntities.length > 0)
-            descParts.push('create-' + delta.newEntities.map(e => e.name.toLowerCase()).join('-'));
-        if (delta.newFields && Object.keys(delta.newFields).length > 0)
-            descParts.push('add-fields-to-' + Object.keys(delta.newFields).map(n => n.toLowerCase()).join('-'));
-        if (delta.newRelationships && delta.newRelationships.length > 0)
-            descParts.push('add-relations');
-    }
-
-    const changelogFileName = `changelog-${dateStamp}-${descParts.join('__')}.xml`;
-    const changelogPath = path.join(changelogsDir, changelogFileName);
-    const masterPath = path.join(liquibaseDir, 'master.xml');
-
-    // Write the changelog XML
-    const changelogXml = `<?xml version="1.0" encoding="UTF-8"?>
-<databaseChangeLog
-    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
-                      http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
-    ${changeSets}
-</databaseChangeLog>
-`;
-    await fs.writeFile(changelogPath, changelogXml);
-
-    // Register in master.xml (only now that the file exists)
-    let masterXml = '';
-    if (await fs.pathExists(masterPath)) {
-        masterXml = await fs.readFile(masterPath, 'utf8');
-        if (!masterXml.includes(changelogFileName)) {
-            const includeLine = `    <include file="changelogs/${changelogFileName}" relativeToChangelogFile="true"/>`;
-            masterXml = masterXml.replace('</databaseChangeLog>', `${includeLine}\n</databaseChangeLog>`);
-        }
+        descParts.push('initial_schema');
     } else {
-        masterXml = `<?xml version="1.0" encoding="UTF-8"?>
-<databaseChangeLog
-    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
-                      http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
-
-    <include file="changelogs/${changelogFileName}" relativeToChangelogFile="true"/>
-</databaseChangeLog>
-`;
+        if (delta.newEntities?.length > 0) descParts.push('create_' + delta.newEntities.map(e => e.name.toLowerCase()).join('_'));
+        if (delta.newFields) descParts.push('add_fields');
     }
-    await fs.writeFile(masterPath, masterXml);
 
-    console.log(chalk.gray(`  Generated Incremental Changelog: ${changelogFileName}`));
+    const fileName = `${timestamp}_${descParts.join('_')}.sql`;
+    await fs.writeFile(path.join(sqlDir, fileName), sqlUp + sqlDown);
+    console.log(chalk.gray(`  Generated Goose SQL Migration: ${fileName}`));
 };
-
-const _unused = null; // toLiquibaseType imported from parser/gdl.js

package/generators/mqtt.js

@@ -6,29 +6,16 @@ export const generateMQTTCode = async (config, outputDir) => {
     const messagingDir = path.join(outputDir, 'messaging');
     await fs.ensureDir(messagingDir);
 
-    const mqttClientGo = `
-package messaging
+    const mqttClientGo = `package messaging
 
 import (
-	"encoding/json"
-	"fmt"
 	"log"
-	"time"
-
 	"{{app_name}}/config"
 	mq "github.com/eclipse/paho.mqtt.golang"
 )
 
 var MQTTClient mq.Client
 
-type EventMessage struct {
-	Action        string      \`json:"action"\`
-	Entity        string      \`json:"entity"\`
-	EventTime     time.Time   \`json:"event_time"\`
-	Payload       interface{} \`json:"payload"\`
-	PreviousValue interface{} \`json:"previous_value,omitempty"\`
-}
-
 func InitMQTT(cfg *config.Config) {
 	if !cfg.GoDuck.Messaging.MQTT.Enabled {
 		log.Println("MQTT Messaging is disabled.")
@@ -56,32 +43,8 @@ func InitMQTT(cfg *config.Config) {
 
 	MQTTClient = client
 }
-
-func PublishEvent(topicPrefix string, action string, entity string, payload interface{}, prev interface{}) {
-	if MQTTClient == nil || !MQTTClient.IsConnected() {
-		return
-	}
-
-	msg := EventMessage{
-		Action:        action,
-		Entity:        entity,
-		EventTime:     time.Now(),
-		Payload:       payload,
-		PreviousValue: prev,
-	}
-
-	data, err := json.Marshal(msg)
-	if err != nil {
-		log.Printf("Error marshaling MQTT message: %v", err)
-		return
-	}
-
-	topic := fmt.Sprintf("%s/%s/%s", topicPrefix, entity, action)
-	token := MQTTClient.Publish(topic, 0, false, data)
-	token.Wait()
-}
 `;
 
     await fs.writeFile(path.join(messagingDir, 'mqtt.go'), mqttClientGo.replace(/{{app_name}}/g, config.name));
-    console.log(chalk.gray('  Generated MQTT Messaging Package'));
+    console.log(chalk.gray('  Generated MQTT Connection Client'));
 };