@izara_project/izara-core-generate-service-code 1.0.52 → 1.0.54

package/src/{generators/fromObjectSchema/relationship/update/complete/sns-in-sqs/template.ejs → codeGenerators/resource/sls_yaml/templates/crud/ResourceSqsYaml.ejs}

@@ -1,22 +1,23 @@
-##===== [Queue]
+  ##===== [Queue]
   <%- queueName %>:
     Type: "AWS::SQS::Queue"
     Properties:
       QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>
       RedrivePolicy:
         deadLetterTargetArn:
-        # !GetAtt
           Fn::GetAtt:
             - <%- queueName %>DLQ
             - Arn
         maxReceiveCount: 3
       VisibilityTimeout: 120
-##==== [QueueDLQ]
+
+  ##===== [Queue DLQ]
   <%- queueName %>DLQ:
     Type: AWS::SQS::Queue
     Properties:
       QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>DLQ
-##==== [QueuePolicy]
+
+  ##===== [Queue Policy]
   <%- queueName %>Policy:
     Type: AWS::SQS::QueuePolicy
     Properties:
@@ -27,17 +28,12 @@
             Effect: Allow
             Principal: "*"
             Resource:
-            # !GetAtt
               Fn::GetAtt:
                 - <%- queueName %>
                 - Arn
             Action: "SQS:SendMessage"
       Queues:
         - Ref: <%- queueName %>
+
   #<#<%- queueName %>QueueSetting#>
   #<#/<%- queueName %>QueueSetting#>
-
-
-<%_ function firstLetterLowerCase(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1)
-} _%>

package/src/{generators/fromObjectSchema/endpoint/resourceTemplate.ejs → codeGenerators/resource/sls_yaml/templates/crud/ResourceYaml.ejs}

@@ -10,30 +10,30 @@
     Type: AWS::SNS::Subscription
     Properties:
       TopicArn: !Ref In<%- queueName %>
-      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqs"
+      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>Sqs"
       Protocol: "sqs"
 
   ##===== [Queue]
-  <%- queueName %>HdrSqs:
+  <%- queueName %>Sqs:
     Type: "AWS::SQS::Queue"
     Properties:
-      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqs
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>Sqs
       RedrivePolicy:
         deadLetterTargetArn:
           Fn::GetAtt:
-            - <%- queueName %>HdrSqsDLQ
+            - <%- queueName %>SqsDLQ
             - Arn
         maxReceiveCount: 3
       VisibilityTimeout: 120
 
   ##===== [Queue DLQ]
-  <%- queueName %>HdrSqsDLQ:
+  <%- queueName %>SqsDLQ:
     Type: AWS::SQS::Queue
     Properties:
-      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqsDLQ
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>SqsDLQ
 
   ##===== [Queue Policy]
-  <%- queueName %>HdrSqsPolicy:
+  <%- queueName %>SqsPolicy:
     Type: AWS::SQS::QueuePolicy
     Properties:
       PolicyDocument:
@@ -44,11 +44,11 @@
             Principal: "*"
             Resource:
               Fn::GetAtt:
-                - <%- queueName %>HdrSqs
+                - <%- queueName %>Sqs
                 - Arn
             Action: "SQS:SendMessage"
       Queues:
-        - Ref: <%- queueName %>HdrSqs
+        - Ref: <%- queueName %>Sqs
 
   #<#<%- queueName %>QueueSetting#>
   #<#/<%- queueName %>QueueSetting#>

package/src/core/renderTemplateFile.js

@@ -0,0 +1,22 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+
+async function renderTemplateFile(templatePath, templateData = {}, { views } = {}) {
+  const template = await fs.readFile(templatePath, 'utf8');
+  return ejs.render(template, templateData, views ? { views } : undefined);
+}
+
+async function writeRenderedTemplate(templatePath, outputPath, templateData = {}, options = {}) {
+  const content = await renderTemplateFile(templatePath, templateData, options);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, content, 'utf8');
+}
+
+async function appendRenderedTemplate(templatePath, outputPath, templateData = {}, options = {}) {
+  const content = await renderTemplateFile(templatePath, templateData, options);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.appendFile(outputPath, `\n${content}`, 'utf8');
+}
+
+export { appendRenderedTemplate, renderTemplateFile, writeRenderedTemplate };

package/src/core/validate.js

@@ -0,0 +1,161 @@
+import { getObjectSchema, utils } from '@izara_project/izara-core-library-service-schemas';
+import path from 'path';
+import fs from 'fs/promises';
+import yaml from 'yaml';
+
+export async function validateSchemas(rootPath) {
+    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
+    const serviceConfigPath = path.join(rootPath, 'config', 'serverless.config.yml');
+    const _izContext = { reqId: 'validate-sandbox', logger: console };
+
+    console.log('  [Validator] Validating local schemas with Safe Two-Way S3 Validation...');
+
+    let validateStatus = {
+        status: true,
+        validateErrors: [],
+        referenceErrors: [],
+        warning: []
+    };
+
+    // 1. Read config for bucket name and service tag
+    let configStr = '';
+    let iz_serviceTag = '';
+    let iz_serviceSchemaBucketName = '';
+    try {
+        configStr = await fs.readFile(serviceConfigPath, 'utf8');
+        const config = yaml.parse(configStr);
+        iz_serviceTag = config?.main_config?.iz_serviceTag;
+        iz_serviceSchemaBucketName = config?.main_config?.iz_serviceSchemaBucketName || 'unknown-bucket';
+        
+        if (!iz_serviceTag) {
+            validateStatus.validateErrors.push('Missing iz_serviceTag in serverless.config.yml. This is a critical configuration field.');
+        } else if (!/^[a-zA-Z0-9]+$/.test(iz_serviceTag)) {
+            validateStatus.validateErrors.push(`iz_serviceTag '${iz_serviceTag}' must contain only alphanumeric characters ([a-zA-Z0-9]).`);
+        }
+    } catch (e) {
+        validateStatus.validateErrors.push(`Could not read or parse serverless.config.yml at ${serviceConfigPath}: ${e.message}`);
+    }
+
+    // 2. Fetch local FlowSchemas (Basic validation)
+    try {
+        const flowsResponse = await getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath);
+        const flows = flowsResponse.records || [];
+        for (const flow of flows) {
+            if (flow && flow.flowTag && !/^[A-Z]/.test(flow.flowTag)) {
+                validateStatus.validateErrors.push(`flowTag '${flow.flowTag}' must start with an uppercase letter.`);
+            }
+        }
+    } catch (e) {
+        validateStatus.warning.push(`Failed to load local flows: ${e.message}`);
+    }
+
+    // 3. Fetch local Reference Object Relationships for Two-Way Validation
+    console.log('  [Validator] Checking Cross-Service Reference Relationships...');
+    try {
+        const allReferenceObjectRelationships = await getObjectSchema.getAllLocalRefObjectRelationshipSchema(_izContext, schemasPath);
+        
+        await Promise.all(
+            allReferenceObjectRelationships.map(async refRelSchema => {
+                if (!refRelSchema) return;
+                try {
+                    // Try to fetch relationship schema from S3
+                    const relSchemaFromRef = await getObjectSchema.getRelationshipSchema(
+                        _izContext,
+                        {
+                            serviceTag: refRelSchema.relationshipServiceTag,
+                            relationshipTag: refRelSchema.relationshipTag
+                        },
+                        iz_serviceSchemaBucketName
+                    );
+
+                    if (!relSchemaFromRef) {
+                        validateStatus.referenceErrors.push(`[Safe] Invalid reference: '${refRelSchema.objectType}' -> '${refRelSchema.relationshipTag}' not found in service '${refRelSchema.relationshipServiceTag}' on S3.`);
+                    } else {
+                        // Two-way validation logic via utils
+                        const linkRecords = utils.findLinkByObjTypeV2(
+                            _izContext,
+                            { objectType: refRelSchema.objectType, serviceTag: iz_serviceTag },
+                            { serviceTag: refRelSchema.relationshipServiceTag, relationshipTag: refRelSchema.relationshipTag },
+                            relSchemaFromRef
+                        );
+
+                        if (!linkRecords || !linkRecords.length) {
+                            validateStatus.referenceErrors.push(`[Safe] Two-way validation failed: '${refRelSchema.relationshipTag}' in service '${refRelSchema.relationshipServiceTag}' does not link back to '${refRelSchema.objectType}'.`);
+                        }
+                    }
+                } catch (s3Error) {
+                    // ROBUSTNESS: Catch S3 NoSuchKey or any other SDK errors without crashing
+                    validateStatus.referenceErrors.push(`[Safe] S3 Fetch Error for '${refRelSchema.relationshipServiceTag}': ${s3Error.message || s3Error.Code}`);
+                }
+            })
+        );
+    } catch (e) {
+        validateStatus.warning.push(`Failed to check cross-service relationships: ${e.message}`);
+    }
+
+    // 4. Validate FlowSchemas Cache Fields and Custom Events (Developer Explanations)
+    try {
+        console.log('  [Validator] Checking FlowSchemas for strict compatibility issues (Soft Validation)...');
+        const allObjectSchemas = await getObjectSchema.getAllLocalObjectSchemasWithoutHierarchy(_izContext, schemasPath);
+        const objectSchemasMap = {};
+        if (allObjectSchemas && allObjectSchemas.records) {
+            allObjectSchemas.records.forEach(schema => {
+                if(schema) objectSchemasMap[schema.objectType] = schema;
+            });
+        }
+
+        const flowsResponse = await getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath);
+        const flows = flowsResponse.records || [];
+        for (const flow of flows) {
+            if (!flow) continue;
+
+            // Check unsupported Enum (like dsq)
+            if (flow.event && Array.isArray(flow.event)) {
+                if (flow.event.includes('dsq')) {
+                    const errMsg = `\n  [Developer Error] FlowTag: '${flow.flowTag}' uses Event: 'dsq'\n` +
+                                   `    💡 Detailed Explanation: 'dsq' is a non-standard Event Type not found in the legacy validator enum.\n` +
+                                   `       Please change it to a supported event type (e.g., 'sqs') or update the allowed enums to proceed.`;
+                    validateStatus.validateErrors.push(errMsg);
+                }
+            }
+
+            // Check triggerCache expectations
+            if (flow.statusType === 'triggerCache' || flow.statusType === 'storedCache' || flow.statusType === 'statusField') {
+                if (flow.objType && flow.objType.objectType) {
+                    const targetObj = objectSchemasMap[flow.objType.objectType];
+                    if (targetObj) {
+                        const expectedPrefix = `TST_${flow.flowTag}`; // Example prefix logic
+                        const isMissingFields = !targetObj.fieldNames || !targetObj.fieldNames[`${expectedPrefix}Status`];
+                        
+                        if (isMissingFields) {
+                            const errMsg = `\n  [Developer Error] FlowTag: '${flow.flowTag}' has Cache enabled (statusType: '${flow.statusType}')\n` +
+                                           `    💡 Detailed Explanation: The validator requires Object '${targetObj.objectType}' to define specific cache status fields in DynamoDB when caching is enabled.\n` +
+                                           `       (e.g., Fields: ${expectedPrefix}Status, ${expectedPrefix}ErrorsFound, ${expectedPrefix}CacheComplete, etc.)\n` +
+                                           `       Please add these fields to ${targetObj.objectType}.js before continuing.`;
+                            validateStatus.validateErrors.push(errMsg);
+                        }
+                    }
+                }
+            }
+        }
+    } catch (e) {
+        console.warn(`  [Validator] Failed to run developer explanations: ${e.message}`);
+    }
+
+    // 5. Summarize Validation
+    if (validateStatus.validateErrors.length > 0) {
+        console.error('  [Validator] VALIDATION ERRORS:', validateStatus.validateErrors);
+        throw new Error(`Validation failed with ${validateStatus.validateErrors.length} critical errors.`);
+    }
+
+    if (validateStatus.referenceErrors.length > 0) {
+        console.warn('  [Validator] REFERENCE WARNINGS (S3/Cross-Service):', validateStatus.referenceErrors);
+        console.warn('  [Validator] Continuing generation despite reference warnings (Offline-friendly mode).');
+    }
+
+    if (validateStatus.warning.length > 0) {
+        console.warn('  [Validator] WARNINGS:', validateStatus.warning);
+    }
+
+    console.log('  [Validator] All local critical validations passed successfully.');
+}

package/src/generate.js

@@ -0,0 +1,130 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { join } from 'path';
+import { validator } from '@izara_project/izara-core-library-service-schemas';
+import { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
+import { generateCode } from './generateCode.js';
+import { generateSchema } from './generateSchema.js';
+
+const { validateLocalSchema } = validator;
+
+/**
+ * High-level code generation API.
+ * Consumer only needs to provide rootPath — everything else is auto-resolved.
+ *
+ * Wires legacy API surface (Logger + validateLocalSchema) onto the new
+ * Result-Driven flat-pipeline generators.
+ *
+ * @param {string} rootPath       - Root path containing /app and /config
+ * @param {Object} [options]
+ * @param {Object} [options.logger]          - Custom logger (default: silent)
+ * @param {string} [options.configPath]      - Override config path
+ * @param {boolean} [options.skipValidation] - Skip schema validation (default: false)
+ * @param {boolean} [options.skipGenerateSchema] - Skip auto-generating dynamic schemas (default: false)
+ * @param {string} [options.outputPath]      - Where to write generated code (default: rootPath)
+ * @returns {Promise<{ durationMs: number }>}
+ */
+async function generate(rootPath, options = {}) {
+  const {
+    logger = createSilentLogger(),
+    configPath = join(rootPath, 'config', 'serverless.config.yml'),
+    skipValidation = false,
+    skipGenerateSchema = false,
+    outputPath = rootPath
+  } = options;
+
+  const schemasPath = join(rootPath, 'app', 'src', 'schemas');
+
+  // Auto-generate dynamic schemas before validation (unless skipped)
+  if (!skipGenerateSchema) {
+    await generateSchema(rootPath, { outputPath });
+  }
+
+  // Validate schemas before generating (unless skipped)
+  if (!skipValidation) {
+    patchFlowStepsValidationSchema();
+
+    console.info('[INFO] [generate]     STATUS=VALIDATING| local schemas...');
+    const validateStartTime = Date.now();
+
+    const result = await validateLocalSchema(
+      { logger },
+      schemasPath,
+      configPath
+    );
+
+    const validateDuration = Date.now() - validateStartTime;
+    console.info(
+      `[INFO] [generate]     STATUS=VALIDATED | errors=${result.validateErrors.length} | elapsedMs=${validateDuration}`
+    );
+
+    if (result.validateErrors.length > 0) {
+      logger.error(
+        'Validation failed with following errors:',
+        result.validateErrors
+      );
+      const err = new Error('Schema validation failed');
+      err.validateErrors = result.validateErrors;
+      throw err;
+    }
+  }
+
+  const startTime = Date.now();
+  await generateCode(rootPath, { outputPath });
+  const durationMs = Date.now() - startTime;
+
+  return { durationMs };
+}
+
+function patchFlowStepsValidationSchema() {
+  const flowStepsSchema = basicValidatorSchema.basicFlowSchema?.properties?.flowSteps;
+
+  if (!flowStepsSchema || flowStepsSchema.oneOf) return;
+  const objectStepSchema = {
+    ...flowStepsSchema.items,
+    required: (flowStepsSchema.items.required || []).filter(item => item !== 'stepName')
+  };
+
+  basicValidatorSchema.basicFlowSchema.properties.flowSteps = {
+    oneOf: [
+      flowStepsSchema,
+      {
+        type: 'object',
+        minProperties: 1,
+        patternProperties: {
+          [basicValidatorSchema.strNotEmptyRegex]: objectStepSchema
+        }
+      }
+    ]
+  };
+}
+
+/**
+ * Creates a silent logger that only outputs errors.
+ * @returns {Object} Logger interface
+ */
+function createSilentLogger() {
+  return {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {}
+  };
+}
+
+export { generate };