go-duck-cli 1.0.0

package/generators/graphql.js

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import Handlebars from 'handlebars';
+
+export const generateGraphQLCode = async (config, entities, relationships, outputDir, enums = []) => {
+    const graphDir = path.join(outputDir, 'graph');
+    await fs.ensureDir(graphDir);
+
+    const templatesDir = path.resolve(path.dirname(import.meta.url.replace('file://', '')), '../templates/graphql');
+
+    // 1. Generate schema.graphqls
+    const schemaTemplatePath = path.join(templatesDir, 'schema.graphql.hbs');
+    if (await fs.pathExists(schemaTemplatePath)) {
+        const schemaTemplateSource = await fs.readFile(schemaTemplatePath, 'utf8');
+        const schemaTemplate = Handlebars.compile(schemaTemplateSource);
+        const schemaContent = schemaTemplate({ entities, relationships, enums });
+        await fs.writeFile(path.join(graphDir, 'schema.graphqls'), schemaContent);
+        console.log(chalk.gray('  Generated GraphQL Schema: schema.graphqls'));
+    }
+
+    // 2. Generate resolver.go
+    const resolverTemplatePath = path.join(templatesDir, 'resolver.go.hbs');
+    if (await fs.pathExists(resolverTemplatePath)) {
+        const resolverTemplateSource = await fs.readFile(resolverTemplatePath, 'utf8');
+        const resolverTemplate = Handlebars.compile(resolverTemplateSource);
+        const resolverContent = resolverTemplate({
+            app_name: config.name,
+            entities,
+            relationships,
+            enums
+        });
+        await fs.writeFile(path.join(graphDir, 'resolver.go'), resolverContent);
+        console.log(chalk.gray('  Generated GraphQL Resolvers: resolver.go'));
+    }
+
+    console.log(chalk.green('✅ GraphQL code generated successfully!'));
+};

package/generators/kratos.js

@@ -0,0 +1,157 @@
+import fs from 'fs-extra';
+import path from 'path';
+import Handlebars from 'handlebars';
+import chalk from 'chalk';
+
+export const generateKratosCode = async (entities, projectRootDir, projectName, enums = []) => {
+    console.log(chalk.cyan('Generating Kratos gRPC Services...'));
+
+    const apiDir = path.join(projectRootDir, 'api', 'v1');
+    const serviceDir = path.join(projectRootDir, 'internal', 'service');
+    const serverDir = path.join(projectRootDir, 'internal', 'server');
+
+    await fs.ensureDir(apiDir);
+    await fs.ensureDir(serviceDir);
+    await fs.ensureDir(serverDir);
+
+    const protoTemplateSource = await fs.readFile(path.join(process.cwd(), 'templates', 'proto', 'entity.proto.hbs'), 'utf8');
+    const protoTemplate = Handlebars.compile(protoTemplateSource);
+
+    const serviceTemplateSource = await fs.readFile(path.join(process.cwd(), 'templates', 'kratos', 'service.go.hbs'), 'utf8');
+    const serviceTemplate = Handlebars.compile(serviceTemplateSource);
+
+    // Helpers for Proto types
+    Handlebars.registerHelper('toProtoType', (type) => {
+        const isEnum = enums.some(e => e.name === type);
+        // Map enums to string in proto to match the Go string enums for simpler POC
+        if (isEnum) return 'string';
+
+        const map = {
+            'String': 'string',
+            'Integer': 'int32',
+            'Long': 'int64',
+            'Float': 'float',
+            'BigDecimal': 'double',
+            'Boolean': 'bool',
+            'LocalDate': 'string',
+            'Instant': 'string',
+            'Text': 'string',
+            'JSON': 'string',
+            'JSONB': 'string'
+        };
+        return map[type] || 'string';
+    });
+
+    Handlebars.registerHelper('toGoCast', (type) => {
+        const isEnum = enums.some(e => e.name === type);
+        if (isEnum) return `models.${type}`;
+
+        const map = {
+            'Integer': 'int',
+            'Long': 'int64',
+            'Float': 'float64',
+            'BigDecimal': 'float64',
+            'Boolean': 'bool',
+            'JSON': 'datatypes.JSON',
+            'JSONB': 'datatypes.JSON'
+        };
+        return map[type] || '';
+    });
+
+    Handlebars.registerHelper('toProtoCast', (type) => {
+        const isEnum = enums.some(e => e.name === type);
+        if (isEnum) return 'string';
+
+        const map = {
+            'Integer': 'int32',
+            'Long': 'int64',
+            'Float': 'float32',
+            'BigDecimal': 'double',
+            'JSON': 'string',
+            'JSONB': 'string'
+        };
+        return map[type] || '';
+    });
+
+    Handlebars.registerHelper('add', (a, b) => {
+        return a + b;
+    });
+
+    Handlebars.registerHelper('hasJson', (fields) => {
+        if (!fields || !Array.isArray(fields)) return false;
+        return fields.some(f => f.type === 'JSON' || f.type === 'JSONB');
+    });
+
+    Handlebars.registerHelper('isJson', (type) => type === 'JSON' || type === 'JSONB');
+
+    for (const entity of entities) {
+        const context = {
+            name: entity.name,
+            capitalize: (s) => s.charAt(0).toUpperCase() + s.slice(1),
+            lower: (s) => s.toLowerCase(),
+            fields: entity.fields,
+            projectName,
+            enums
+        };
+
+        // 1. Generate Proto
+        const protoContent = protoTemplate(context);
+        await fs.writeFile(path.join(apiDir, `${entity.name.toLowerCase()}.proto`), protoContent);
+
+        // 2. Generate Service Implementation
+        const serviceContent = serviceTemplate(context);
+        await fs.writeFile(path.join(serviceDir, `${entity.name.toLowerCase()}.go`), serviceContent);
+    }
+
+    // 3. Generate Auth Middleware & gRPC Server with Kratos
+    await generateKratosServer(serverDir, projectName, entities);
+
+    console.log(chalk.green('✅ Kratos gRPC code generated successfully!'));
+};
+
+const generateKratosServer = async (serverDir, projectName, entities) => {
+    const grpcServerTemplate = `package server
+
+import (
+	"context"
+	"github.com/go-kratos/kratos/v2/middleware/auth/jwt"
+	"github.com/go-kratos/kratos/v2/middleware/recovery"
+	"github.com/go-kratos/kratos/v2/transport/grpc"
+	"github.com/golang-jwt/jwt/v4"
+    v1 "{{projectName}}/api/v1"
+    "{{projectName}}/internal/service"
+    "{{projectName}}/internal/repository"
+    "{{projectName}}/config"
+)
+
+func NewGRPCServer(conf *config.Config, repo *repository.Repository) *grpc.Server {
+	var opts = []grpc.ServerOption{
+		grpc.Middleware(
+			recovery.Recovery(),
+			jwt.Server(func(token *jwt.Token) (interface{}, error) {
+				return []byte(conf.GoDuck.Security.KeycloakSecret), nil
+			}),
+		),
+	}
+	if conf.GoDuck.Server.GRPC.Addr != "" {
+		opts = append(opts, grpc.Address(conf.GoDuck.Server.GRPC.Addr))
+	}
+	srv := grpc.NewServer(opts...)
+    
+    // Register Services
+    {{#each entities}}
+    v1.Register{{capitalize name}}ServiceServer(srv, service.New{{capitalize name}}Service(repo))
+    {{/each}}
+    // go-duck-needle-add-grpc-service
+
+	return srv
+}
+`;
+    const template = Handlebars.compile(grpcServerTemplate);
+    const content = template({
+        projectName,
+        entities,
+        capitalize: (s) => s.charAt(0).toUpperCase() + s.slice(1)
+    });
+    await fs.writeFile(path.join(serverDir, 'grpc.go'), content);
+};

package/generators/logger.js

@@ -0,0 +1,68 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateLoggerCode = async (config, outputDir) => {
+    const loggerDir = path.join(outputDir, 'logger');
+    await fs.ensureDir(loggerDir);
+
+    const loggerGo = `
+package logger
+
+import (
+	"log"
+	"os"
+	"{{app_name}}/config"
+
+	"github.com/DataDog/datadog-go/statsd"
+)
+
+var (
+	Statsd *statsd.Client
+)
+
+// InitLogger initializes the application logging and monitoring
+func InitLogger(cfg *config.Config) {
+	if cfg.GoDuck.Logging.Datadog.Enabled {
+		log.Printf("Initializing Datadog Monitoring for service: %s", cfg.GoDuck.Logging.Datadog.Service)
+		
+		// In a real implementation, you'd use a Datadog logging hook or library
+		// Here we initialize Statsd as an example of DD integration
+		client, err := statsd.New("127.0.0.1:8125")
+		if err == nil {
+			Statsd = client
+			Statsd.Namespace = cfg.GoDuck.Logging.Datadog.Service + "."
+			Statsd.Tags = []string{"environment:" + cfg.Environment.ActiveProfile}
+		} else {
+			log.Printf("Warning: Failed to initialize Datadog statsd: %v", err)
+		}
+	} else {
+		log.Println("Datadog logging is disabled. Using standard console output.")
+	}
+
+	// Set standard logger output
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	log.SetOutput(os.Stdout)
+}
+
+// Info logs information messages
+func Info(format string, v ...interface{}) {
+	log.Printf("[INFO] "+format, v...)
+}
+
+// Error logs error messages
+func Error(format string, v ...interface{}) {
+	log.Printf("[ERROR] "+format, v...)
+}
+
+// Trace metric (example of DD analytics)
+func TraceMetric(name string, value float64, tags []string) {
+	if Statsd != nil {
+		Statsd.Gauge(name, value, tags, 1)
+	}
+}
+`;
+
+    await fs.writeFile(path.join(loggerDir, 'logger.go'), loggerGo.replace(/{{app_name}}/g, config.name));
+    console.log(chalk.gray('  Generated Datadog-ready Logger Package'));
+};

package/generators/metering.js

@@ -0,0 +1,143 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateMeteringCode = async (config, outputDir) => {
+    const middlewareDir = path.join(outputDir, 'middleware');
+    const modelsDir = path.join(outputDir, 'models');
+    const controllersDir = path.join(outputDir, 'controllers');
+
+    await fs.ensureDir(middlewareDir);
+    await fs.ensureDir(modelsDir);
+    await fs.ensureDir(controllersDir);
+
+    const meteringModel = `
+package models
+
+import (
+	"time"
+)
+
+type APIUsage struct {
+	ID          uint      \`gorm:"primaryKey" json:"id"\`
+	UserID      string    \`json:"userId" gorm:"index:idx_user_api,unique"\`
+	APIPath     string    \`json:"apiPath" gorm:"index:idx_user_api,unique"\`
+	UsageCount  int64     \`json:"usageCount"\`
+	MaxLimit    int64     \`json:"maxLimit" gorm:"default:1000"\`
+	LastAccessed time.Time \`json:"lastAccessed"\`
+}
+`;
+
+    const meteringMiddleware = `
+package middleware
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"{{app_name}}/models"
+)
+
+func MeteringMiddleware(db *gorm.DB) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		userID := c.GetHeader("X-Keycloak-Id")
+		if userID == "" {
+			c.Next()
+			return
+		}
+
+		path := c.Request.URL.Path
+		var usage models.APIUsage
+
+		// Get usage and limit
+		result := db.Where("user_id = ? AND api_path = ?", userID, path).First(&usage)
+		if result.Error == gorm.ErrRecordNotFound {
+			usage = models.APIUsage{
+				UserID:     userID,
+				APIPath:    path,
+				UsageCount: 1,
+				MaxLimit:   1000, // Default limit
+				LastAccessed: time.Now(),
+			}
+			db.Create(&usage)
+		} else {
+			if usage.UsageCount >= usage.MaxLimit {
+				c.JSON(http.StatusTooManyRequests, gin.H{
+					"error": "Usage limit exceeded",
+					"limit": usage.MaxLimit,
+					"usage": usage.UsageCount,
+				})
+				c.Abort()
+				return
+			}
+			db.Model(&usage).Updates(map[string]interface{}{
+				"usage_count":   usage.UsageCount + 1,
+				"last_accessed": time.Now(),
+			})
+		}
+
+		c.Next()
+	}
+}
+`;
+
+    const meteringController = `
+package controllers
+
+import (
+	"net/http"
+	"{{app_name}}/models"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type MeteringController struct {
+	DB *gorm.DB
+}
+
+func (mc *MeteringController) SetLimit(c *gin.Context) {
+	var req struct {
+		UserID   string \`json:"userId" binding:"required"\`
+		APIPath  string \`json:"apiPath" binding:"required"\`
+		MaxLimit int64  \`json:"maxLimit" binding:"required"\`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var usage models.APIUsage
+	result := mc.DB.Where("user_id = ? AND api_path = ?", req.UserID, req.APIPath).First(&usage)
+	
+	if result.Error == gorm.ErrRecordNotFound {
+		usage = models.APIUsage{
+			UserID:     req.UserID,
+			APIPath:    req.APIPath,
+			MaxLimit:   req.MaxLimit,
+			UsageCount: 0,
+		}
+		mc.DB.Create(&usage)
+	} else {
+		mc.DB.Model(&usage).Update("max_limit", req.MaxLimit)
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "Limit updated successfully"})
+}
+
+func (mc *MeteringController) GetUsage(c *gin.Context) {
+	var usages []models.APIUsage
+	mc.DB.Find(&usages)
+	c.JSON(http.StatusOK, usages)
+}
+`;
+
+    await fs.writeFile(path.join(modelsDir, 'api_usage.go'), meteringModel);
+    await fs.writeFile(path.join(middlewareDir, 'metering_middleware.go'), meteringMiddleware.replace('{{app_name}}', config.name));
+    await fs.writeFile(path.join(controllersDir, 'metering_controller.go'), meteringController.replace('{{app_name}}', config.name));
+
+    console.log(chalk.gray('  Generated Metering Model, Middleware & Controller'));
+};

package/generators/migrations.js

@@ -0,0 +1,240 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+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');
+    await fs.ensureDir(migrationsDir);
+    await fs.ensureDir(liquibaseDir);
+    await fs.ensureDir(changelogsDir);
+
+    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
+    // -------------------------------------------------------
+    let changeSets = '';
+
+    const entitiesToCreate = delta ? delta.newEntities : entities;
+    const relationshipsToAdd = delta ? delta.newRelationships : relationships;
+
+    // Create New Tables
+    for (const entity of entitiesToCreate) {
+        let columns = `
+            <column name="id" type="BIGINT" autoIncrement="true">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>`;
+
+        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>`;
+            }
+        }
+
+        // @Audited entities get full audit columns (skip the simpler created_at/updated_at to avoid duplicates)
+        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)"/>`;
+        } else {
+            columns += `
+            <column name="created_at" type="TIMESTAMP"/>
+            <column name="updated_at" type="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>
+`;
+    }
+
+    // Add New Fields to existing tables
+    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>`;
+                }
+            }
+            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;
+    }
+
+    // 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>`);
+        }
+    } 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>
+`;
+    }
+    await fs.writeFile(masterPath, masterXml);
+
+    console.log(chalk.gray(`  Generated Incremental Changelog: ${changelogFileName}`));
+};
+
+const _unused = null; // toLiquibaseType imported from parser/gdl.js