ondc-code-generator 0.8.7 → 0.8.9

package/alpha/validationpkg/validationutils/validation_utils.go

@@ -0,0 +1,429 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/dlclark/regexp2"
+)
+
+// toStringSlice converts []interface{} to []string, returns false if any element is not a string
+func toStringSlice(operand []interface{}) ([]string, bool) {
+	result := make([]string, len(operand))
+	for i, v := range operand {
+		str, ok := v.(string)
+		if !ok {
+			// Try to convert to string
+			if v == nil {
+				result[i] = "null"
+			} else {
+				result[i] = fmt.Sprintf("%v", v)
+			}
+		} else {
+			result[i] = str
+		}
+	}
+	return result, true
+}
+
+func AreUnique(operand []interface{}) bool {
+	strs, ok := toStringSlice(operand)
+	if !ok {
+		return false
+	}
+
+	valuesSet := make(map[string]struct{})
+	for _, v := range strs {
+		valuesSet[v] = struct{}{}
+	}
+	return len(valuesSet) == len(strs)
+}
+
+func ArePresent(operand []interface{}) bool {
+	strs, ok := toStringSlice(operand)
+	if !ok {
+		return false
+	}
+	return NoneIn(operand, []interface{}{"null", "undefined"}) && len(strs) > 0
+}
+
+// Lookup interface for abstraction
+type lookup interface {
+	contains(string) bool
+	isEmpty() bool
+}
+
+// Map-based lookup (O(1))
+type mapLookup struct {
+	items map[string]bool
+}
+
+func (m *mapLookup) contains(item string) bool {
+	return m.items[item]
+}
+
+func (m *mapLookup) isEmpty() bool {
+	return len(m.items) == 0
+}
+
+// Slice-based lookup (O(n))
+type sliceLookup struct {
+	items []string
+}
+
+func (s *sliceLookup) contains(item string) bool {
+	for _, v := range s.items {
+		if v == item {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *sliceLookup) isEmpty() bool {
+	return len(s.items) == 0
+}
+
+// Smart lookup creation - auto-detects and optimizes
+func createLookup(right []interface{}) (lookup, bool) {
+	// Case 1: Check if right contains a single map
+	if len(right) == 1 {
+		switch m := right[0].(type) {
+		case map[string]interface{}:
+			result := make(map[string]bool, len(m))
+			for k := range m {
+				result[k] = true
+			}
+			return &mapLookup{items: result}, true
+		case map[string]bool:
+			return &mapLookup{items: m}, true
+		case map[string]string:
+			result := make(map[string]bool, len(m))
+			for k := range m {
+				result[k] = true
+			}
+			return &mapLookup{items: result}, true
+		}
+	}
+
+	// Case 2: Convert slice to string slice
+	rightStrs, ok := toStringSlice(right)
+	if !ok {
+		return nil, false
+	}
+
+	// Optimization: Convert large slices to maps for better performance
+	const threshold = 10
+	if len(rightStrs) > threshold {
+		m := make(map[string]bool, len(rightStrs))
+		for _, v := range rightStrs {
+			m[v] = true
+		}
+		return &mapLookup{items: m}, true
+	}
+
+	return &sliceLookup{items: rightStrs}, true
+}
+
+// Updated comparison functions
+func AllIn(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	if !ok1 {
+		return false
+	}
+
+	rightLookup, ok2 := createLookup(right)
+	if !ok2 {
+		return false
+	}
+
+	if len(leftStrs) == 0 && !rightLookup.isEmpty() {
+		return false
+	}
+
+	for _, v := range leftStrs {
+		if !rightLookup.contains(v) {
+			return false
+		}
+	}
+	return true
+}
+
+func AnyIn(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	if !ok1 {
+		return false
+	}
+
+	rightLookup, ok2 := createLookup(right)
+	if !ok2 {
+		return false
+	}
+
+	if len(leftStrs) == 0 && !rightLookup.isEmpty() {
+		return false
+	}
+
+	for _, v := range leftStrs {
+		if rightLookup.contains(v) {
+			return true
+		}
+	}
+	return false
+}
+
+func NoneIn(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	if !ok1 {
+		return false
+	}
+
+	rightLookup, ok2 := createLookup(right)
+	if !ok2 {
+		return false
+	}
+
+	for _, v := range leftStrs {
+		if rightLookup.contains(v) {
+			return false
+		}
+	}
+	return true
+}
+func EqualTo(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	rightStrs, ok2 := toStringSlice(right)
+	if !ok1 || !ok2 {
+		return false
+	}
+
+	if len(leftStrs) != len(rightStrs) {
+		return false
+	}
+	for i, v := range leftStrs {
+		if v != rightStrs[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func GreaterThan(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	rightStrs, ok2 := toStringSlice(right)
+	if !ok1 || !ok2 {
+		return false
+	}
+
+	areAllISO := func(arr []string) bool {
+		for _, v := range arr {
+			if !isISO8601(v) {
+				return false
+			}
+		}
+		return true
+	}
+
+	areAllNumbers := func(arr []string) bool {
+		for _, v := range arr {
+			if _, err := strconv.ParseFloat(v, 64); err != nil {
+				return false
+			}
+		}
+		return true
+	}
+
+	if areAllISO(leftStrs) && areAllISO(rightStrs) {
+		leftDates := make([]int64, len(leftStrs))
+		for i, date := range leftStrs {
+			t, _ := time.Parse(time.RFC3339, date)
+			leftDates[i] = t.UnixMilli()
+		}
+
+		rightDates := make([]int64, len(rightStrs))
+		for i, date := range rightStrs {
+			t, _ := time.Parse(time.RFC3339, date)
+			rightDates[i] = t.UnixMilli()
+		}
+
+		for i, ld := range leftDates {
+			if i >= len(rightDates) || ld <= rightDates[i] {
+				if i < len(rightDates) {
+					return false
+				}
+			}
+		}
+		return true
+	} else if areAllNumbers(leftStrs) && areAllNumbers(rightStrs) {
+		leftNumbers := make([]float64, len(leftStrs))
+		for i, v := range leftStrs {
+			leftNumbers[i], _ = strconv.ParseFloat(v, 64)
+		}
+
+		rightNumbers := make([]float64, len(rightStrs))
+		for i, v := range rightStrs {
+			rightNumbers[i], _ = strconv.ParseFloat(v, 64)
+		}
+
+		for i, ln := range leftNumbers {
+			if i >= len(rightNumbers) || ln <= rightNumbers[i] {
+				if i < len(rightNumbers) {
+					return false
+				}
+			}
+		}
+		return true
+	}
+
+	return false
+}
+
+func LessThan(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	rightStrs, ok2 := toStringSlice(right)
+	if !ok1 || !ok2 {
+		return false
+	}
+
+	areAllISO := func(arr []string) bool {
+		for _, v := range arr {
+			if !isISO8601(v) {
+				return false
+			}
+		}
+		return true
+	}
+
+	areAllNumbers := func(arr []string) bool {
+		for _, v := range arr {
+			if _, err := strconv.ParseFloat(v, 64); err != nil {
+				return false
+			}
+		}
+		return true
+	}
+
+	if areAllISO(leftStrs) && areAllISO(rightStrs) {
+		leftDates := make([]int64, len(leftStrs))
+		for i, date := range leftStrs {
+			t, _ := time.Parse(time.RFC3339, date)
+			leftDates[i] = t.UnixMilli()
+		}
+
+		rightDates := make([]int64, len(rightStrs))
+		for i, date := range rightStrs {
+			t, _ := time.Parse(time.RFC3339, date)
+			rightDates[i] = t.UnixMilli()
+		}
+
+		for i, ld := range leftDates {
+			if i >= len(rightDates) || ld >= rightDates[i] {
+				if i < len(rightDates) {
+					return false
+				}
+			}
+		}
+		return true
+	} else if areAllNumbers(leftStrs) && areAllNumbers(rightStrs) {
+		leftNumbers := make([]float64, len(leftStrs))
+		for i, v := range leftStrs {
+			leftNumbers[i], _ = strconv.ParseFloat(v, 64)
+		}
+
+		rightNumbers := make([]float64, len(rightStrs))
+		for i, v := range rightStrs {
+			rightNumbers[i], _ = strconv.ParseFloat(v, 64)
+		}
+
+		for i, ln := range leftNumbers {
+			if i >= len(rightNumbers) || ln >= rightNumbers[i] {
+				if i < len(rightNumbers) {
+					return false
+				}
+			}
+		}
+		return true
+	}
+
+	return false
+}
+
+var regexCache sync.Map // cache compiled regexes
+
+func FollowRegex(left []interface{}, regexArray []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	regexStrs, ok2 := toStringSlice(regexArray)
+	if !ok1 || !ok2 {
+		return false
+	}
+
+	if len(leftStrs) == 0 && len(regexStrs) != 0 {
+		return false
+	}
+
+	for _, regexStr := range regexStrs {
+		var re *regexp2.Regexp
+		regexStr = sanitizeRegex(regexStr)
+		fmt.Printf("Using regex: %s\n", regexStr)
+		// Check cache first
+		if cached, ok := regexCache.Load(regexStr); ok {
+			re = cached.(*regexp2.Regexp)
+		} else {
+			compiled, err := regexp2.Compile(regexStr, 0)
+			if err != nil {
+				fmt.Printf("Invalid regex '%s': %v\n", regexStr, err)
+				return false
+			}
+			regexCache.Store(regexStr, compiled)
+			re = compiled
+		}
+
+		for _, v := range leftStrs {
+			match, err := re.MatchString(v)
+			if err != nil || !match {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+// Only fixes escapes that are invalid in regexp2
+func sanitizeRegex(regex string) string {
+	regex = strings.ReplaceAll(regex, `\_`, `_`) // escaped underscore → literal
+	regex = strings.ReplaceAll(regex, `\-`, `-`) // escaped hyphen → literal
+	return regex
+}
+
+func isISO8601(str string) bool {
+	iso8601Regex, err := regexp2.Compile(`^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$`, 0)
+	if err != nil {
+		return false
+	}
+
+	match, err := iso8601Regex.MatchString(str)
+	if err != nil || !match {
+		return false
+	}
+
+	_, err = time.Parse(time.RFC3339, str)
+	return err == nil
+}
+
+// StringSliceToInterface converts []string to []interface{}
+func StringSliceToInterface(strs []string) []interface{} {
+	result := make([]interface{}, len(strs))
+	for i, v := range strs {
+		result[i] = v
+	}
+	return result
+}
+
+// UnusedFunction to avoid unused variable errors
+func UnusedFunction(item interface{}) {}

package/dist/bin/cli.js

@@ -23,9 +23,10 @@ program
     .option("-f, --function-name <name>", "Name of the validation function to generate")
     .option("-o, --output <directory>", "Output directory for generated code")
     .option("-l, --lang <language>", "Target programming language (typescript, python, javascript, go)")
+    .option("-p, --packageName <name>", "Package name for generated code (applicable for Go)", "validationpkg")
     .description("Generate validation code")
     .action(async (options) => {
-    const { config, output, lang, functionName } = options;
+    const { config, output, lang, functionName, packageName } = options;
     console.log(Cli.title("Ondc Validation Code Generator"));
     if (!config || !output || !lang) {
         console.log(Cli.description.error("Please provide all required options: --config, --output, --lang"));
@@ -34,6 +35,7 @@ program
     try {
         console.log(Cli.description.info(`Generating validation code for language: ${lang}`));
         const functionName = options.functionName || "L1validations";
+        const packageName = options.packageName || "validationpkg";
         const language = getSupportedLanguage(lang);
         const compiler = new ConfigCompiler(language);
         const buildPath = path.resolve(process.cwd(), config);
@@ -44,7 +46,7 @@ program
         const validPaths = await compiler.generateValidPaths();
         writeFileSync(path.resolve(output, "validPaths.json"), JSON.stringify(validPaths, null, 2));
         console.log(Cli.description.info("Generating validation code..."));
-        await compiler.generateValidationFromBuild(functionName, output, true);
+        await compiler.generateValidationFromBuild(functionName, output, true, packageName);
         console.log(Cli.description.success(`Validation code generated successfully in ${output} for language ${lang}`));
     }
     catch (error) {
@@ -122,6 +124,8 @@ function getSupportedLanguage(lang) {
             return SupportedLanguages.Javascript;
         case "go":
             return SupportedLanguages.Golang;
+        case "md":
+            return SupportedLanguages.Markdown;
         default:
             throw new Error(`Unsupported language: ${lang}. Supported languages are: ${getValidLanguageOptions()}`);
     }

package/dist/generator/config-compiler.d.ts

@@ -20,10 +20,10 @@ export declare class ConfigCompiler {
     initialize: (buildYaml: string, generatorConfig?: Partial<CodeGeneratorConfig>) => Promise<void>;
     performValidations: (valConfig: ValidationConfig) => Promise<void>;
     withMinimalValidations: (valConfig: ValidationConfig) => Promise<void>;
-    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string, absolutePath?: boolean) => Promise<void>;
+    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string, absolutePath?: boolean, goPackageName?: string) => Promise<void>;
     generateL0Schema: (outputPath?: string, type?: "json" | "typescript", absolutePath?: boolean) => Promise<void>;
     generateValidPaths: () => Promise<Record<string, string[]>>;
-    generateValidationFromBuild: (codeName: string, outputPath: string, absolutePath?: boolean) => Promise<void>;
+    generateValidationFromBuild: (codeName: string, outputPath: string, absolutePath?: boolean, goPackageName?: string) => Promise<void>;
     extractPayloadsFromBuild: (outputPath: string) => Promise<void>;
 }
 export {};

package/dist/generator/config-compiler.js

@@ -12,6 +12,7 @@ import { duplicateVariablesInChildren } from "../utils/config-utils/duplicateVar
 import { PythonGenerator } from "./generators/python/py-generator.js";
 import { JavascriptGenerator } from "./generators/javascript/js-generator.js";
 import { GoGenerator } from "./generators/go/go-generator.js";
+import { MarkdownDocGenerator } from "./generators/documentation/md-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -27,7 +28,8 @@ export class ConfigCompiler {
             this.generatorConfig = finalConfig;
             this.buildData = await loadAndDereferenceYaml(buildYaml);
             this.jsonSchemas = await this.SchemaExtractionService.extractSchemas(this.buildData, finalConfig.removeRequiredFromSchema, finalConfig.removeEnumsFromSchema);
-            this.possibleJsonPaths = this.SchemaExtractionService.extractPossiblePaths(this.jsonSchemas);
+            this.possibleJsonPaths =
+                this.SchemaExtractionService.extractPossiblePaths(this.jsonSchemas);
             const errors = this.buildData["x-errorcodes"];
             this.errorDefinitions = errors.code;
         };
@@ -57,7 +59,7 @@ export class ConfigCompiler {
             // throw new Error("validation failed");
         };
         // };
-        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./", absolutePath = false) => {
+        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./", absolutePath = false, goPackageName = "validationpkg") => {
             try {
                 console.log("[ CODE GENERATION ] Starting code generation...");
                 valConfig = JSON.parse(JSON.stringify(valConfig));
@@ -93,8 +95,12 @@ export class ConfigCompiler {
                     case SupportedLanguages.Golang:
                         await new GoGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                             codeName: codeName,
+                            goPkgName: goPackageName,
                         });
                         break;
+                    case SupportedLanguages.Markdown:
+                        await new MarkdownDocGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode();
+                        break;
                     default:
                         throw new Error("Language not supported");
                 }
@@ -144,13 +150,13 @@ export class ConfigCompiler {
             // );
             return this.possibleJsonPaths;
         };
-        this.generateValidationFromBuild = async (codeName, outputPath, absolutePath = false) => {
+        this.generateValidationFromBuild = async (codeName, outputPath, absolutePath = false, goPackageName = "validationpkg") => {
             if (!this.buildData)
                 throw new Error("Build data not initialized");
             const valConfig = this.buildData["x-validations"];
             if (!valConfig)
                 throw new Error("No validation config found in build data");
-            await this.generateCode(valConfig, codeName, false, outputPath, absolutePath);
+            await this.generateCode(valConfig, codeName, false, outputPath, absolutePath, goPackageName);
         };
         this.extractPayloadsFromBuild = async (outputPath) => {
             if (!this.buildData)

package/dist/generator/generators/classes/abstract-generator.d.ts

@@ -2,6 +2,7 @@ import { ValidationConfig } from "../../../types/config-types";
 import { ErrorDefinition } from "../../../types/error-codes";
 export type CodeGeneratorProps = {
     codeName: string;
+    goPkgName?: string;
 };
 export declare abstract class CodeGenerator {
     validationConfig: ValidationConfig;

package/dist/generator/generators/go/go-generator.js

@@ -13,27 +13,33 @@ import { markdownMessageGenerator } from "../documentation/markdown-message-gene
 import { MarkdownDocGenerator } from "../documentation/md-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const packageName = "validationpkg";
+const defaultPkgName = "validationpkg";
 export class GoGenerator extends CodeGenerator {
     constructor() {
         super(...arguments);
         this.generateCode = async (codeConfig) => {
             this.codeConfig = codeConfig;
+            if (!this.codeConfig.goPkgName) {
+                this.codeConfig.goPkgName = defaultPkgName;
+            }
             const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.mustache"), "utf-8");
             const validationUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.mustache"), "utf-8");
             const typesTemplate = readFileSync(path.resolve(__dirname, "./templates/test-config.mustache"), "utf-8");
             const normalizerTemplate = readFileSync(path.resolve(__dirname, "./templates/json-normalizer.mustache"), "utf-8");
             const goMod = readFileSync(path.resolve(__dirname, "./templates/go-mod.mustache"), "utf-8");
+            const goModCode = Mustache.render(goMod, {
+                pkgName: codeConfig.goPkgName,
+            });
             const typesCode = Mustache.render(typesTemplate, {
                 externalData: this.getExternalKeys(),
             });
-            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/json_path_utils.go`, jsonPathUtilsCode, "go");
-            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/validation_utils.go`, validationUtils, "go");
-            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/test-config.go`, typesCode, "go");
-            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/json_normalizer.go`, normalizerTemplate, "go");
+            writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/validationutils/json_path_utils.go`, jsonPathUtilsCode, "go");
+            writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/validationutils/validation_utils.go`, validationUtils, "go");
+            writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/validationutils/test-config.go`, typesCode, "go");
+            writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/validationutils/json_normalizer.go`, normalizerTemplate, "go");
             await this.generateValidationCode();
-            await writeAndFormatCode(this.rootPath, `./${packageName}/main-validator.go`, this.generateIndexFile(Object.keys(this.validationConfig[ConfigSyntax.Tests]), codeConfig.codeName), "go");
-            await writeAndFormatCode(this.rootPath, `./${packageName}/go.mod`, goMod, "text");
+            await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/main-validator.go`, this.generateIndexFile(Object.keys(this.validationConfig[ConfigSyntax.Tests]), codeConfig.codeName), "go");
+            await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/go.mod`, goModCode, "text");
             await this.generateSessionDataCode();
             await this.generateUnitTestingCode();
             await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
@@ -69,16 +75,23 @@ export class GoGenerator extends CodeGenerator {
         const relevantSessionData = {};
         collectLoadData(tests, relevantSessionData);
         const sessionDataUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/save-utils.mustache"), "utf-8");
+        const sessionDataUtilsCode = Mustache.render(sessionDataUtilsTemplate, {
+            pkgName: this.codeConfig.goPkgName,
+        });
         const storageInterfaceTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-interface.mustache"), "utf-8");
         const indexTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/index.mustache"), "utf-8");
         const saveActionTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save.mustache"), "utf-8");
         const saveActionUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save-utils.mustache"), "utf-8");
+        const saveActionUtilsCode = Mustache.render(saveActionUtilsTemplate, {
+            pkgName: this.codeConfig.goPkgName,
+        });
         const allActions = Object.keys(tests);
         const indexCode = Mustache.render(indexTemplate, {
             actions: Array.from(allActions).map((action) => {
                 return { action: action };
             }),
             functionName: this.codeConfig.codeName.replace(/[^a-zA-Z0-9_]/g, ""),
+            pkgName: this.codeConfig.goPkgName,
         });
         for (const action of allActions) {
             const loadData = relevantSessionData[action] || {};
@@ -101,13 +114,14 @@ export class GoGenerator extends CodeGenerator {
                     key: value,
                 })),
                 action: action,
+                pkgName: this.codeConfig.goPkgName,
             });
-            await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/${action}.go`, saveCode, "go");
+            await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/storageutils/${action}.go`, saveCode, "go");
         }
-        await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/save_utils.go`, sessionDataUtilsTemplate, "go");
-        await writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/storage-interface.go`, storageInterfaceTemplate, "go");
-        await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/index.go`, indexCode, "go");
-        await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/api_save_utils.go`, saveActionUtilsTemplate, "go");
+        await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/storageutils/save_utils.go`, sessionDataUtilsCode, "go");
+        await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/validationutils/storage-interface.go`, storageInterfaceTemplate, "go");
+        await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/storageutils/index.go`, indexCode, "go");
+        await writeAndFormatCode(this.rootPath, `./${this.codeConfig.goPkgName}/storageutils/api_save_utils.go`, saveActionUtilsCode, "go");
     }
     async generateValidationCode() {
         const testConfig = this.validationConfig[ConfigSyntax.Tests];
@@ -122,18 +136,19 @@ export class GoGenerator extends CodeGenerator {
             const finalCode = Mustache.render(apiTestTemplate, {
                 functionCode: testFunction.code,
                 apiName: stringToCaps(key),
+                pkgName: this.codeConfig?.goPkgName,
             });
-            await writeAndFormatCode(this.rootPath, `./${packageName}/jsonvalidations/${key}.go`, finalCode, "go");
+            await writeAndFormatCode(this.rootPath, `./${this.codeConfig?.goPkgName}/jsonvalidations/${key}.go`, finalCode, "go");
         }
     }
     generateIndexFile(apis, functionName = "L1Validations") {
         functionName = functionName.replace(/[^a-zA-Z0-9_]/g, "");
         let importList = [
-            `"validationpkg/validationutils"`,
-            `"validationpkg/jsonvalidations"`,
+            `"${this.codeConfig?.goPkgName}/validationutils"`,
+            `"${this.codeConfig?.goPkgName}/jsonvalidations"`,
             `"fmt"`,
             `"encoding/json"`,
-            `"validationpkg/storageutils"`,
+            `"${this.codeConfig?.goPkgName}/storageutils"`,
         ];
         const masterTemplate = readFileSync(path.resolve(__dirname, "./templates/index.mustache"), "utf-8");
         const masterFunction = `func Perform${functionName}(
@@ -254,6 +269,7 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
         return Mustache.render(masterTemplate, {
             importCode: importCode,
             masterFunction: masterFunction,
+            pkgName: this.codeConfig?.goPkgName,
         });
     }
     getExternalKeys() {
@@ -365,8 +381,9 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
         const testTemplate = readFileSync(path.resolve(__dirname, "./templates/test-templates/validator-test.mustache"), "utf-8");
         const finalTestCode = Mustache.render(testTemplate, {
             functionName: this.codeConfig?.codeName ?? "L1Validations",
+            pkgName: this.codeConfig?.goPkgName ?? defaultPkgName,
         });
-        await writeAndFormatCode(this.rootPath, `./${packageName}/main-validator_test.go`, finalTestCode, "go");
+        await writeAndFormatCode(this.rootPath, `./${this.codeConfig?.goPkgName ?? defaultPkgName}/main-validator_test.go`, finalTestCode, "go");
     }
 }
 function stringToCaps(str) {

package/dist/generator/generators/go/templates/api-tests.mustache

@@ -3,7 +3,7 @@
 package jsonvalidations
 
 import (
-    "validationpkg/validationutils"
+    "{{pkgName}}/validationutils"
 )
 
 func {{apiName}}_Tests(input validationutils.ValidationInput) ([]validationutils.ValidationOutput, error) {

package/dist/generator/generators/go/templates/go-mod.mustache

@@ -1,3 +1,3 @@
-module validationpkg
+module {{pkgName}}
 
 go 1.24.4