ondc-code-generator 0.7.0 → 0.7.4

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

@@ -1,511 +0,0 @@
-import { readFileSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { ConfigSyntax, ExternalDataSyntax, TestObjectSyntax, } from "../../../constants/syntax.js";
-import Mustache from "mustache";
-import { markdownMessageGenerator } from "../documentation/markdown-message-generator.js";
-import { getVariablesFromTest as extractVariablesFromText } from "../../../utils/general-utils/test-object-utils.js";
-import { compileInputToGo } from "./go-ast.js";
-import { CodeGenerator, } from "../classes/abstract-generator.js";
-import { writeAndFormatCode } from "../../../utils/fs-utils.js";
-import { MarkdownDocGenerator } from "../documentation/md-generator.js";
-import { collectLoadData } from "../../../utils/config-utils/load-variables.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export class GolangGenerator extends CodeGenerator {
-    constructor() {
-        super(...arguments);
-        this.generateSessionDataCode = async () => {
-            if (!this.codeConfig) {
-                throw new Error("Code config not set. Please call generateCode first.");
-            }
-            const sessionData = this.validationConfig[ConfigSyntax.SessionData];
-            const tests = this.validationConfig[ConfigSyntax.Tests];
-            const relevantSessionData = {};
-            collectLoadData(tests, relevantSessionData);
-            console.log("Relevant Session Data for Loading:", relevantSessionData);
-            // Load storage templates
-            const storageInterfaceTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-interface.mustache"), "utf-8");
-            const storageTypesTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-types.mustache"), "utf-8");
-            const saveUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/save-utils.mustache"), "utf-8");
-            const storageHelpersTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-helpers.mustache"), "utf-8");
-            const indexTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/index.mustache"), "utf-8");
-            const apiSaveTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save.mustache"), "utf-8");
-            const allActions = Object.keys(tests);
-            // Helper to capitalize and sanitize function names
-            const capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
-            const sanitizeName = (name) => name.replace(/[^a-zA-Z0-9_]/g, "");
-            // Generate index code with all actions
-            const indexCode = Mustache.render(indexTemplate, {
-                actions: allActions.map((action) => ({ action })),
-                functionName: capitalize(sanitizeName(this.codeConfig.codeName)),
-            });
-            // Generate individual action storage files
-            for (const action of allActions) {
-                const loadData = relevantSessionData[action] || {};
-                const saveData = sessionData[action] || {};
-                const saveCode = Mustache.render(apiSaveTemplate, {
-                    storeActions: Object.keys(saveData).map((key) => ({
-                        key: key,
-                        value: saveData[key],
-                    })),
-                    loadActions: Object.keys(loadData).map((key) => ({
-                        key: loadData[key],
-                    })),
-                    action: action,
-                });
-                await writeAndFormatCode(this.rootPath, `./storageactions/${action}.go`, saveCode, "go");
-            }
-            // Write common storage files
-            await writeAndFormatCode(this.rootPath, "./utils/save_utils.go", saveUtilsTemplate, "go");
-            await writeAndFormatCode(this.rootPath, "./types/storage_types.go", storageTypesTemplate, "go");
-            await writeAndFormatCode(this.rootPath, "./interfaces/storage_interface.go", storageInterfaceTemplate, "go");
-            await writeAndFormatCode(this.rootPath, "./storageactions/helpers.go", storageHelpersTemplate, "go");
-            await writeAndFormatCode(this.rootPath, "./storageactions/index.go", indexCode, "go");
-        };
-        this.generateValidationCode = async () => {
-            const testConfig = this.validationConfig[ConfigSyntax.Tests];
-            // Helper to avoid Go reserved keywords
-            const goSafeName = (name) => {
-                const reserved = [
-                    "break",
-                    "case",
-                    "chan",
-                    "const",
-                    "continue",
-                    "default",
-                    "defer",
-                    "else",
-                    "fallthrough",
-                    "for",
-                    "func",
-                    "go",
-                    "goto",
-                    "if",
-                    "import",
-                    "init",
-                    "interface",
-                    "map",
-                    "package",
-                    "range",
-                    "return",
-                    "select",
-                    "struct",
-                    "switch",
-                    "type",
-                    "var",
-                ];
-                return reserved.includes(name) ? `${name}Action` : name;
-            };
-            // Helper to capitalize first letter for exported functions
-            const capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
-            for (const key in testConfig) {
-                const testObjects = testConfig[key];
-                const safeName = capitalize(goSafeName(key));
-                const betaConfig = {
-                    [TestObjectSyntax.Name]: safeName + "Validations",
-                    [TestObjectSyntax.Return]: testObjects,
-                };
-                // Collect all functions (main + nested) with API prefix and deduplication
-                const functionNameMap = new Map(); // Track function names to handle duplicates
-                const allFunctions = await this.collectAllFunctions(betaConfig, safeName, functionNameMap);
-                const apiTestTemplate = readFileSync(path.resolve(__dirname, "./templates/api-test.mustache"), "utf-8");
-                const finalCode = Mustache.render(apiTestTemplate, {
-                    functionCode: allFunctions.map((f) => f.code).join("\n\n"),
-                    apiName: safeName,
-                });
-                await writeAndFormatCode(this.rootPath, `./apitests/${key}.go`, finalCode, "go");
-            }
-        };
-        this.generateCode = async (codeConfig) => {
-            this.codeConfig = codeConfig;
-            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 typesCode = Mustache.render(typesTemplate, {
-                externalData: this.getExternalKeys(),
-            });
-            await writeAndFormatCode(this.rootPath, "./utils/json_path_utils.go", jsonPathUtilsCode, "go");
-            await writeAndFormatCode(this.rootPath, "./utils/json_normalizer.go", normalizerTemplate, "go");
-            await writeAndFormatCode(this.rootPath, "./utils/validation_utils.go", validationUtils, "go");
-            await writeAndFormatCode(this.rootPath, "./types/test_config.go", typesCode, "go");
-            await this.generateValidationCode();
-            await writeAndFormatCode(this.rootPath, "error.go", this.generateErrorFile(this.errorCodes), "go");
-            await writeAndFormatCode(this.rootPath, "main.go", this.generateMainFile(Object.keys(this.validationConfig[ConfigSyntax.Tests]), codeConfig.codeName), "go");
-            await writeAndFormatCode(this.rootPath, "go.mod", this.generateGoMod(codeConfig.codeName), "text");
-            await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
-            await this.generateSessionDataCode();
-        };
-        this.generateTestFunction = async (testObject, apiPrefix = "", functionNameMap, isInnerPass = false) => {
-            const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
-            // Calculate function name with API prefix
-            const baseName = apiPrefix
-                ? `${apiPrefix}_${testObject[TestObjectSyntax.Name]}`
-                : testObject[TestObjectSyntax.Name];
-            let funcName = baseName;
-            // Handle duplicates by adding a counter suffix
-            if (functionNameMap) {
-                const usageKey = `${baseName}_usage`;
-                const usageCount = functionNameMap.get(usageKey) || 0;
-                functionNameMap.set(usageKey, usageCount + 1);
-                const totalCount = functionNameMap.get(baseName) || 1;
-                if (totalCount > 1) {
-                    // Always add suffix if there are duplicates: _1, _2, _3, etc.
-                    funcName = `${baseName}_${usageCount + 1}`;
-                }
-            }
-            const view = {
-                name: funcName,
-                scopePath: testObject[TestObjectSyntax.Scope] ?? "$",
-                variables: this.createVariablesCode(testObject),
-                hasContinue: testObject[TestObjectSyntax.Continue] ? true : false,
-                skipCheckStatement: testObject[TestObjectSyntax.Continue]
-                    ? compileInputToGo(testObject[TestObjectSyntax.Continue])
-                    : undefined,
-                validationCode: await this.createValidationLogicCode(testObject, apiPrefix, functionNameMap, isInnerPass),
-                successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
-                errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
-                testName: testObject[TestObjectSyntax.Name],
-                TEST_OBJECT: `${JSON.stringify(testObject)}`,
-            };
-            return {
-                funcName: funcName,
-                code: Mustache.render(template, view),
-            };
-        };
-        this.createValidationLogicCode = async (testObject, apiPrefix = "", functionNameMap, isInnerPass = false) => {
-            const template = readFileSync(path.resolve(__dirname, "./templates/validation-code.mustache"), "utf-8");
-            const skip = testObject[TestObjectSyntax.Continue];
-            const skipList = skip ? [skip] : undefined;
-            if (typeof testObject[TestObjectSyntax.Return] === "string") {
-                const returnStatement = compileInputToGo(testObject[TestObjectSyntax.Return]);
-                // Check if this is a stateful validation
-                let isStateFull = false;
-                for (const k in testObject) {
-                    const value = testObject[k];
-                    if (typeof value === "string") {
-                        if (value.includes(`${ExternalDataSyntax}.`) &&
-                            !value.includes("_SELF")) {
-                            isStateFull = true;
-                            break;
-                        }
-                    }
-                }
-                return Mustache.render(template, {
-                    isNested: false,
-                    isStateFull: isStateFull,
-                    returnStatement: returnStatement,
-                    errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
-                    errorDescription: this.CreateErrorMarkdown(testObject, skipList),
-                    testName: testObject[TestObjectSyntax.Name],
-                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
-                });
-            }
-            else {
-                const subObjects = testObject[TestObjectSyntax.Return];
-                // For nested functions in Go, calculate the correct function names to match definitions
-                const names = subObjects.map((subObj) => {
-                    const baseName = apiPrefix
-                        ? `${apiPrefix}_${subObj[TestObjectSyntax.Name]}`
-                        : subObj[TestObjectSyntax.Name];
-                    let funcName = baseName;
-                    if (functionNameMap) {
-                        const callKey = `${baseName}_calls`;
-                        const currentCalls = functionNameMap.get(callKey) || 0;
-                        functionNameMap.set(callKey, currentCalls + 1);
-                        const totalCount = functionNameMap.get(baseName) || 1;
-                        if (totalCount > 1) {
-                            // Add suffix to match function definition: _1, _2, _3, etc.
-                            funcName = `${baseName}_${currentCalls + 1}`;
-                        }
-                    }
-                    return { name: funcName };
-                });
-                return Mustache.render(template, {
-                    isNested: true,
-                    names: names,
-                    testName: testObject[TestObjectSyntax.Name],
-                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
-                });
-            }
-        };
-    }
-    // Helper to recursively collect all nested functions
-    async collectAllFunctions(testObject, apiPrefix, functionNameMap) {
-        const result = [];
-        // First pass: pre-calculate all function names to build the map
-        this.preCalculateFunctionNames(testObject, apiPrefix, functionNameMap);
-        // Second pass: generate the actual code with correct function references
-        const mainFunc = await this.generateTestFunction(testObject, apiPrefix, functionNameMap);
-        result.push(mainFunc);
-        // If it has nested functions, collect them recursively
-        if (Array.isArray(testObject[TestObjectSyntax.Return])) {
-            for (const subObject of testObject[TestObjectSyntax.Return]) {
-                const nestedFuncs = await this.collectAllFunctionsInner(subObject, apiPrefix, functionNameMap);
-                result.push(...nestedFuncs);
-            }
-        }
-        return result;
-    }
-    // Helper to pre-calculate function names
-    preCalculateFunctionNames(testObject, apiPrefix, functionNameMap) {
-        const baseName = apiPrefix
-            ? `${apiPrefix}_${testObject[TestObjectSyntax.Name]}`
-            : testObject[TestObjectSyntax.Name];
-        const count = functionNameMap.get(baseName) || 0;
-        functionNameMap.set(baseName, count + 1);
-        // Recursively pre-calculate nested function names
-        if (Array.isArray(testObject[TestObjectSyntax.Return])) {
-            for (const subObject of testObject[TestObjectSyntax.Return]) {
-                this.preCalculateFunctionNames(subObject, apiPrefix, functionNameMap);
-            }
-        }
-    }
-    // Inner helper that doesn't pre-calculate (used after first pass)
-    async collectAllFunctionsInner(testObject, apiPrefix, functionNameMap) {
-        const result = [];
-        const mainFunc = await this.generateTestFunction(testObject, apiPrefix, functionNameMap, true);
-        result.push(mainFunc);
-        if (Array.isArray(testObject[TestObjectSyntax.Return])) {
-            for (const subObject of testObject[TestObjectSyntax.Return]) {
-                const nestedFuncs = await this.collectAllFunctionsInner(subObject, apiPrefix, functionNameMap);
-                result.push(...nestedFuncs);
-            }
-        }
-        return result;
-    }
-    CreateErrorMarkdown(testObject, skipList) {
-        return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, testObject[TestObjectSyntax.Name], skipList);
-    }
-    createVariablesCode(testObject) {
-        const variables = [];
-        const varNames = extractVariablesFromText(testObject);
-        for (const name of varNames) {
-            const value = testObject[name];
-            const final = typeof value === "string"
-                ? `utils.GetJSONPath(testObj, "${value}")`
-                : this.convertArrayToInterfaceGo(value);
-            variables.push({
-                name: name,
-                value: final,
-                isAssignment: false,
-            });
-        }
-        // Add _ = variable for unused variables to avoid Go compile errors
-        const returnStatement = testObject[TestObjectSyntax.Return];
-        if (typeof returnStatement === "string") {
-            for (const name of varNames) {
-                if (!returnStatement.includes(name)) {
-                    variables.push({
-                        name: "_",
-                        value: name,
-                        isAssignment: true,
-                    });
-                }
-            }
-        }
-        return variables;
-    }
-    convertArrayToInterfaceGo(value) {
-        // Convert TypeScript array notation to Go slice notation for []interface{}
-        const elements = value.map((v) => {
-            if (typeof v === "string") {
-                // Use raw string literal for strings with backslashes (likely regex)
-                if (v.includes("\\")) {
-                    return "`" + v + "`";
-                }
-                return `"${v}"`;
-            }
-            if (v === null)
-                return "nil";
-            if (typeof v === "boolean")
-                return v ? "true" : "false";
-            if (typeof v === "number")
-                return v.toString();
-            return JSON.stringify(v);
-        });
-        return `[]interface{}{${elements.join(", ")}}`;
-    }
-    generateErrorFile(errors) {
-        const allCodes = errors.map((error) => error.code);
-        if (allCodes.length !== new Set(allCodes).size) {
-            throw new Error("Duplicate error codes found");
-        }
-        errors.push({
-            code: 20006,
-            Description: "Invalid response does not meet API contract specifications",
-        });
-        errors.push({
-            code: 30000,
-            Description: "Invalid request does not meet API contract specifications",
-        });
-        const errorsList = errors
-            .map((error) => `	{Code: ${error.code}, Message: "${error.Description}"}`)
-            .join(",\n");
-        return `package validations
-
-import "fmt"
-
-type Error struct {
-	Code    int
-	Message string
-}
-
-var errors = []Error{
-${errorsList},
-}
-
-func GetError(code int) (*Error, error) {
-	for _, err := range errors {
-		if err.Code == code {
-			return &err, nil
-		}
-	}
-	return nil, fmt.Errorf("error code %d not found", code)
-}
-`;
-    }
-    getExternalKeys() {
-        const apis = Object.keys(this.validationConfig[ConfigSyntax.SessionData]);
-        const result = [];
-        for (const api of apis) {
-            const keys = Object.keys(this.validationConfig[ConfigSyntax.SessionData][api]);
-            for (const key of keys) {
-                if (key !== "_SELF") {
-                    result.push({ name: key });
-                }
-            }
-        }
-        return result;
-    }
-    generateMainFile(apis, functionName = "L1Validations") {
-        functionName = functionName.replace(/[^a-zA-Z0-9_]/g, "");
-        // Helper to avoid Go reserved keywords
-        const goSafeName = (name) => {
-            const reserved = [
-                "break",
-                "case",
-                "chan",
-                "const",
-                "continue",
-                "default",
-                "defer",
-                "else",
-                "fallthrough",
-                "for",
-                "func",
-                "go",
-                "goto",
-                "if",
-                "import",
-                "init",
-                "interface",
-                "map",
-                "package",
-                "range",
-                "return",
-                "select",
-                "struct",
-                "switch",
-                "type",
-                "var",
-            ];
-            const safeName = reserved.includes(name) ? `${name}Action` : name;
-            return safeName.charAt(0).toUpperCase() + safeName.slice(1);
-        };
-        const imports = `package validations
-
-import (
-	"fmt"
-	"L1_validations/apitests"
-	"L1_validations/storageactions"
-	"L1_validations/types"
-	"L1_validations/utils"
-)
-`;
-        const masterFunction = `
-// Perform${functionName} executes validation for the specified action
-func Perform${functionName}(action string, payload map[string]interface{}, config *types.ValidationConfig, externalData map[string]interface{}) ([]types.ValidationOutput, error) {
-	if config == nil {
-		config = &types.ValidationConfig{
-			OnlyInvalid:          true,
-			StandardLogs:         false,
-			HideParentErrors:     true,
-			StateFullValidations: false,
-			Debug:                false,
-		}
-	}
-
-	if config.StateFullValidations && config.Store == nil {
-		return nil, fmt.Errorf("state full validations require a storage interface to be provided in the config")
-	}
-
-	if config.StateFullValidations && config.UniqueKey == "" {
-		return nil, fmt.Errorf("state full validations require a unique_key to be provided in the config")
-	}
-
-	normalizedPayload := utils.NormalizeKeys(payload).(map[string]interface{})
-	
-	if externalData == nil {
-		externalData = make(map[string]interface{})
-	}
-	externalData["_SELF"] = normalizedPayload
-
-	// Load stateful data if enabled
-	if config.StateFullValidations {
-		loadedData, err := storageactions.Perform${functionName}Load(action, config.UniqueKey, config.Store)
-		if err == nil && loadedData != nil {
-			// Merge loaded data with external data
-			for k, v := range loadedData {
-				if _, exists := externalData[k]; !exists {
-					externalData[k] = v
-				}
-			}
-		}
-	}
-
-	input := types.ValidationInput{
-		Payload:      normalizedPayload,
-		ExternalData: externalData,
-		Config:       *config,
-	}
-
-	var result []types.ValidationOutput
-
-	switch action {
-${apis
-            .map((api) => `	case "${api}":
-		result = apitests.${goSafeName(api)}(input)`)
-            .join("\n")}
-	default:
-		return nil, fmt.Errorf("action not found: %s", action)
-	}
-
-	// Save stateful data if enabled
-	if config.StateFullValidations {
-		if err := storageactions.Perform${functionName}Save(action, config.UniqueKey, normalizedPayload, config.Store, config.StorageConfig); err != nil {
-			// Log error but don't fail validation
-			if config.Debug {
-				fmt.Printf("Warning: Failed to save state: %v\\n", err)
-			}
-		}
-	}
-
-	return result, nil
-}
-`;
-        return imports + masterFunction;
-    }
-    generateGoMod(moduleName) {
-        moduleName = moduleName.replace(/[^a-zA-Z0-9_-]/g, "");
-        return `module ${moduleName}
-
-go 1.21
-
-require (
-	github.com/PaesslerAG/jsonpath v0.1.1
-)
-`;
-    }
-}

package/dist/generator/generators/golang/templates/api-test.mustache

@@ -1,48 +0,0 @@
-package apitests
-
-import (
-	"L1_validations/types"
-	"L1_validations/utils"
-)
-
-func {{apiName}}(input types.ValidationInput) []types.ValidationOutput {
-	totalResults := {{apiName}}_{{apiName}}Validations(input)
-
-	if !input.Config.Debug {
-		for i := range totalResults {
-			totalResults[i].DebugInfo = nil
-		}
-	}
-
-	if input.Config.HideParentErrors {
-		filtered := []types.ValidationOutput{}
-		for _, r := range totalResults {
-			if !(r.Valid == false && r.Description == "") {
-				filtered = append(filtered, r)
-			}
-		}
-		totalResults = filtered
-	}
-
-	if input.Config.OnlyInvalid {
-		invalid := []types.ValidationOutput{}
-		for _, r := range totalResults {
-			if !r.Valid {
-				invalid = append(invalid, r)
-			}
-		}
-		if len(invalid) == 0 {
-			for _, r := range totalResults {
-				if r.TestName == "{{apiName}}Validations" {
-					return []types.ValidationOutput{r}
-				}
-			}
-			panic("Critical: Overall test result not found")
-		}
-		return invalid
-	}
-
-	return totalResults
-}
-
-{{{functionCode}}}

package/dist/generator/generators/golang/templates/json-normalizer.mustache

@@ -1,46 +0,0 @@
-package utils
-
-import (
-	"encoding/json"
-	"strings"
-)
-
-// NormalizeKeys converts all keys in a JSON object to snake_case
-func NormalizeKeys(data interface{}) interface{} {
-	switch v := data.(type) {
-	case map[string]interface{}:
-		normalized := make(map[string]interface{})
-		for key, value := range v {
-			normalizedKey := toSnakeCase(key)
-			normalized[normalizedKey] = NormalizeKeys(value)
-		}
-		return normalized
-	case []interface{}:
-		normalized := make([]interface{}, len(v))
-		for i, value := range v {
-			normalized[i] = NormalizeKeys(value)
-		}
-		return normalized
-	default:
-		return v
-	}
-}
-
-// toSnakeCase converts a string to snake_case
-func toSnakeCase(s string) string {
-	var result strings.Builder
-	for i, r := range s {
-		if i > 0 && r >= 'A' && r <= 'Z' {
-			result.WriteRune('_')
-		}
-		result.WriteRune(r)
-	}
-	return strings.ToLower(result.String())
-}
-
-// FromJSON parses JSON bytes into interface{}
-func FromJSON(data []byte) (interface{}, error) {
-	var result interface{}
-	err := json.Unmarshal(data, &result)
-	return result, err
-}

package/dist/generator/generators/golang/templates/json-path-utils.mustache

@@ -1,21 +0,0 @@
-package utils
-
-import (
-	"github.com/PaesslerAG/jsonpath"
-)
-
-// GetJSONPath extracts values from a JSON object using JSONPath
-func GetJSONPath(data interface{}, path string) []interface{} {
-	result, err := jsonpath.Get(path, data)
-	if err != nil {
-		return []interface{}{}
-	}
-
-	// If result is already a slice, return it
-	if slice, ok := result.([]interface{}); ok {
-		return slice
-	}
-
-	// Otherwise, wrap the single result in a slice
-	return []interface{}{result}
-}

package/dist/generator/generators/golang/templates/storage-templates/api-save.mustache

@@ -1,30 +0,0 @@
-package storageactions
-
-import (
-	"L1_validations/interfaces"
-	"L1_validations/types"
-)
-
-// Store_{{action}} saves data for the {{action}} action
-func Store_{{action}}(uniquePrefix string, payload map[string]interface{}, store interfaces.StorageInterface, config types.StorageConfig) error {
-	{{#storeActions}}
-	if err := SaveFunction(payload, uniquePrefix, "{{{key}}}", "{{{value}}}", "{{action}}", store, config); err != nil {
-		return err
-	}
-	{{/storeActions}}
-	return nil
-}
-
-// LoadFor_{{action}} loads data for the {{action}} action
-func LoadFor_{{action}}(uniquePrefix string, store interfaces.StorageInterface) (map[string]interface{}, error) {
-	result := make(map[string]interface{})
-	
-	{{#loadActions}}
-	{{{key}}}Data, err := LoadFunction(store, uniquePrefix, "{{{key}}}")
-	if err == nil {
-		result["{{{key}}}"] = {{{key}}}Data
-	}
-	{{/loadActions}}
-	
-	return result, nil
-}