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

package/src/codeGenerators/app/src/generatedCode/FindData/templates/FindData_HdrSqs.ejs

@@ -0,0 +1,87 @@
+import { middlewareHandler as middleware, validatorSchema } from '@izara_project/izara-middleware';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import Logger from '@izara_project/izara-core-library-logger';
+
+import findData from './FindData_Main.js';
+
+// validate event properties in body.Message of sqs event
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+// set schema for record.body.Message
+const perRecordsValidatorSchema = {
+  type: 'object',
+  required: ['fieldName', 'objType', 'identifiers', 'overWriteCache'],
+  properties: {
+    fieldName: {
+      type: 'object'
+    },
+    objType: {
+      type: 'object',
+      required: ['serviceTag', 'objectType'],
+      properties: {
+        serviceTag: {
+          type: 'string',
+          enum: [process.env.iz_serviceTag]
+        },
+        objectType: validatorSchema.stringNotEmpty()
+      }
+    },
+    identifiers: {
+      type: 'object'
+    },
+    overWriteCache: {
+      type: 'boolean'
+    },
+    callingFlow: {
+      type: 'string',
+      default: ''
+    }
+  }
+};
+
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    let recordPromises = [];
+
+    await Promise.all(
+      event.Records.map(async record => {
+        let passOnProperties = [];
+        record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+
+        await recordHandlerSharedLib.validateRecord(
+          record,
+          'FindDataHdrSqs',
+          perRecordsValidatorSchema
+        );
+
+        passOnProperties.push(record.body.Message.fieldName);
+        passOnProperties.push(record.body.Message.objType);
+        passOnProperties.push(record.body.Message.identifiers);
+        passOnProperties.push(record.body.Message.overWriteCache);
+        passOnProperties.push(record.body.Message.callingFlow);
+        record._izContext.logger.debug('passOnProperties in handler', passOnProperties);
+
+        let recordPromise = recordHandlerSharedLib.recordHandler(
+          record,
+          findData,
+          'FindDataHdrSqs',
+          passOnProperties
+        );
+        record._izContext.logger.debug('after recordPromise in handler');
+        recordPromises.push(recordPromise);
+      })
+    );
+
+    Logger.debug('before Promise.all(recordPromises) in handler');
+    try {
+      await Promise.all(recordPromises);
+      return event.Records;
+    } catch {
+      Logger.debug('Promise.all(recordPromises) in handler threw error');
+    }
+    Logger.debug('after Promise.all(recordPromises) in handler');
+  } catch (err) {
+    Logger.error('Unhandled Error, FindDataHdrSqs: ', err);
+    throw err;
+  }
+});

package/src/codeGenerators/app/src/generatedCode/FindData/templates/FindData_Main.ejs

@@ -0,0 +1,108 @@
+import findDataSharedLib from '@izara_project/izara-core-library-find-data';
+import graphSharedLib from '@izara_project/izara-core-library-graph-service';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
+import { serviceConfig, identifiersObject as identifierObj } from '@izara_project/izara-core-library-service-schemas';
+
+//(<additionalModule>)
+//(</additionalModule>)
+
+/**
+ * triggered from searchResult for each requiredData field per one identifiers
+ */
+async function _getValueFromDynamo(_izContext, fieldName, objType, identifiers, tableName, errorsFound, standardErrorParams, findDataSharedLib, dynamodbSharedLib, identifierObj) {
+  const identifiersBase = await identifierObj.identifiersBaseFromIdentifiers(_izContext, objType, identifiers);
+  _izContext.logger.debug('create identifiersBase from identifiers: ', identifiersBase);
+
+  const objInstanceBase = await dynamodbSharedLib.getItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    identifiersBase
+  );
+  _izContext.logger.debug('objInstanceBase: ', objInstanceBase);
+
+  if (!objInstanceBase) {
+    errorsFound.push(`can't get data in dynamo by ${identifiersBase}`);
+    standardErrorParams.push(errorsFound);
+    await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+    return { _error: 'FindData cannot get data in dynamo' };
+  }
+
+  if (!objInstanceBase.hasOwnProperty(fieldName)) {
+    errorsFound.push(`data in dynamoDB have no ${fieldName}`);
+    standardErrorParams.push(errorsFound);
+    await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+    return { _error: 'Data have no fieldName' };
+  }
+
+  return { _value: objInstanceBase[fieldName] };
+}
+
+export default async function findData(
+  _izContext,
+  fieldName,
+  objType,
+  identifiers,
+  overWriteCache,
+  callingFlow,
+
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('----- findData event params -----', {
+      fieldName: fieldName,
+      objType: objType,
+      identifiers: identifiers,
+      overWriteCache: overWriteCache,
+      callingFlow: callingFlow
+    });
+
+    let removeAttributes = [];
+    //(<removeAttributes>)
+    //(</removeAttributes>)
+
+    let deleteDataTableOnExpired = [];
+
+    let [findDataMainStatus, findDataId, findDataMain] = await findDataSharedLib.checkFindDataMainStatus(
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      callingFlow,
+      removeAttributes,
+      overWriteCache
+    );
+
+    _izContext.logger.debug('result after checkFindDataMainStatus is', {
+      findDataMainStatus: findDataMainStatus,
+      findDataId: findDataId,
+      findDataMain: findDataMain
+    });
+
+    if (findDataMainStatus != 'process') {
+      _izContext.logger.debug(`findDataMainStatus status isn't process :${findDataMainStatus}`);
+      return { returnResponse: 'Function FindData not process' };
+    }
+
+    let errorsFound = [];
+    let standardErrorParams = [
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      null,
+      overWriteCache,
+      callingFlow,
+      'error'
+    ];
+
+<%- objectTypeBlocks %>
+
+    return { returnResponse: 'Function FindData Finish' };
+
+  } catch (err) {
+    _izContext.logger.error('error FindDataMain: ', err);
+    throw err;
+  }
+}

package/src/codeGenerators/app/src/generatedCode/FindData/templates/FindData_Yaml.ejs

@@ -0,0 +1,10 @@
+<%- functionName %>:
+  handler: <%- handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%- functionName %>
+  role: <%- roleName %>Role
+  #<#<%- functionName %>FunctionSetting#>
+  #<#/<%- functionName %>FunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- functionName %>
+        batchSize: 10

package/src/codeGenerators/app/src/generatedCode/FindData/templates/GetByStorage/getByDynamo.ejs

@@ -0,0 +1,32 @@
+//(<beforeGetItem<%- objectType %><%- fieldName.fieldName %>>)
+//(</beforeGetItem<%- objectType %><%- fieldName.fieldName %>>)
+
+const _dynamo_<%- fieldName.fieldName %> = await _getValueFromDynamo(
+  _izContext,
+  '<%- fieldName.fieldName %>',
+  objType,
+  identifiers,
+  '<%- tableName %>',
+  errorsFound,
+  standardErrorParams,
+  findDataSharedLib,
+  dynamodbSharedLib,
+  identifierObj
+);
+if (_dynamo_<%- fieldName.fieldName %>._error) return { returnResponse: _dynamo_<%- fieldName.fieldName %>._error };
+const dataValue = _dynamo_<%- fieldName.fieldName %>._value;
+_izContext.logger.debug('dataValue: ', dataValue);
+
+//(<afterGetItem<%- objectType %><%- fieldName.fieldName %>>)
+//(</afterGetItem<%- objectType %><%- fieldName.fieldName %>>)
+
+await findDataSharedLib.completeFindDataMain(
+  _izContext,
+  findDataMain.fieldName,
+  findDataMain.objType,
+  findDataMain.identifiers,
+  dataValue,
+  overWriteCache,
+  callingFlow,
+  'complete'
+);

package/src/{generators/fromObjectSchema/findData → codeGenerators/app/src/generatedCode/FindData/templates}/GetByStorage/getByGraph.ejs

@@ -78,10 +78,10 @@ await findDataSharedLib.completeFindDataMain(
 );
 
 <%_ function createNameTagBefore(objectType, fieldName){
-  return `//(<beforeGetNode${objectType}${fieldName}>)
-          //(</beforeGetNode${objectType}${fieldName}>)`
+  return `//(<beforeGetNode${objectType}${fieldName.fieldName}>)
+//(</beforeGetNode${objectType}${fieldName.fieldName}>)`
 } _%>
 <%_ function createNameTagAfter(objectType, fieldName){
-  return `//(<afterGetNode${objectType}${fieldName}>)
-          //(</afterGetNode${objectType}${fieldName}>)`
-} _%>
+  return `//(<afterGetNode${objectType}${fieldName.fieldName}>)
+//(</afterGetNode${objectType}${fieldName.fieldName}>)`
+} _%>

package/src/{generators/fromObjectSchema/endpoint/main/create/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/CreateEndpoint_Main.ejs}

@@ -55,7 +55,7 @@ const PREFIX = {
  * @param {Object} beforeLogicalResults - Results from beforeLogical
  * @returns {Promise<Object>} Result with objType, objInstanceFull, relationships, status, errorsFound
  */
-export async function createMainLogical(
+export async function <%- flowTag %>MainLogical(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -398,7 +398,7 @@ export async function createMainLogical(
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
-export default async function createMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}
@@ -484,7 +484,7 @@ export default async function createMain(
     _izContext.logger.debug('errorsFound::', errorsFound);
 
     if (errorsFound.length > 0)
-      return await createMainLogical(
+      return await <%- flowTag %>MainLogical(
         _izContext,
         requestParams,
         callingFlowConfig,
@@ -517,7 +517,7 @@ export default async function createMain(
 
     // ── beforeLogical phase check ─────────────────────────────────────────────
     <%_
-    const groupedByObjType = generatedCodeConfig
+    const groupedByObjType = generateCode
       .filter(c => c.codeHookTag === 'beforeLogical')
       .reduce((acc, config) => {
         const key = config.objType.objectType;
@@ -648,7 +648,7 @@ export default async function createMain(
         return acc;
       }, {});
 
-      return await createMainLogical(
+      return await <%- flowTag %>MainLogical(
         _izContext,
         requestParams,
         callingFlowConfig,
@@ -662,7 +662,7 @@ export default async function createMain(
     //(</beforeCreateMainLogical>)
 
     // ── No beforeLogical → proceed directly to logical ────────────────────────
-    return await createMainLogical(
+    return await <%- flowTag %>MainLogical(
       _izContext,
       requestParams,
       callingFlowConfig

package/src/{generators/fromObjectSchema/endpoint/main/delete/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/DeleteEndpoint_Main.ejs}

@@ -45,7 +45,7 @@ const { TOPIC_NAME_GENERATE_CODE } = consts;
  * @param {Object} beforeLogicalResults - Results from beforeLogical phase
  * @returns {Promise<Object>}
  */
-export async function deleteMainLogical(
+export async function <%- flowTag %>MainLogical(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -149,7 +149,7 @@ export async function deleteMainLogical(
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
-export default async function deleteMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}
@@ -193,7 +193,7 @@ export default async function deleteMain(
 
     // ── beforeLogical phase check ─────────────────────────────────────────────
     <%_
-    const groupedByObjType = generatedCodeConfig
+    const groupedByObjType = generateCode
       .filter(c => c.codeHookTag === 'beforeLogical')
       .reduce((acc, config) => {
         const key = config.objType.objectType;
@@ -323,7 +323,7 @@ export default async function deleteMain(
           return acc;
         }, {});
 
-        return await deleteMainLogical(
+        return await <%- flowTag %>MainLogical(
           _izContext,
           requestParams,
           callingFlowConfig,
@@ -337,7 +337,7 @@ export default async function deleteMain(
     //(</beforeDeleteMainLogical>)
 
     // ── No beforeLogical → proceed directly to logical ────────────────────────
-    return await deleteMainLogical(
+    return await <%- flowTag %>MainLogical(
       _izContext,
       requestParams,
       callingFlowConfig

package/src/{generators/fromObjectSchema/endpoint/main/get/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/GetEndpoint_Main.ejs}

@@ -55,7 +55,7 @@ import { sns } from '@izara_project/izara-core-library-external-request';
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>} Collected get result
  */
-export default async function getMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}

package/src/{generators/fromObjectSchema/endpoint/main/update/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/templates/crud/UpdateEndpoint_Main.ejs}

@@ -49,7 +49,7 @@ import { sns, lambda } from '@izara_project/izara-core-library-external-request'
  * @param {Object} beforeLogicalResults - Results from beforeLogical phase
  * @returns {Promise<Object>}
  */
-export async function updateMainLogical(
+export async function <%- flowTag %>MainLogical(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -327,7 +327,7 @@ export async function updateMainLogical(
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
-export default async function updateMain(
+export default async function <%- flowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {}
@@ -354,7 +354,7 @@ export default async function updateMain(
 
     // ── beforeLogical phase check ─────────────────────────────────────────────
     <%_
-    const groupedByObjType = generatedCodeConfig
+    const groupedByObjType = generateCode
       .filter(c => c.codeHookTag === 'beforeLogical')
       .reduce((acc, config) => {
         const key = config.objType.objectType;
@@ -484,7 +484,7 @@ export default async function updateMain(
           return acc;
         }, {});
 
-        return await updateMainLogical(
+        return await <%- flowTag %>MainLogical(
           _izContext,
           requestParams,
           callingFlowConfig,
@@ -498,7 +498,7 @@ export default async function updateMain(
     //(</beforeUpdateMainLogical>)
 
     // ── No beforeLogical → proceed directly to logical ────────────────────────
-    return await updateMainLogical(
+    return await <%- flowTag %>MainLogical(
       _izContext,
       requestParams,
       callingFlowConfig

package/src/codeGenerators/app/src/generatedCode/Flow/FlowRbac/RbacFlowGenerator.js

@@ -0,0 +1,73 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { isRbacFlow } from '../_internal/shared/flowClassifier.js';
+import { getFlowsForGeneration } from '../_internal/shared/flowSelection.js';
+import { processFunctionName, processMainFileName, upperFirst } from '../_internal/shared/flowNaming.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateRbacFlows(allSchemas, options) {
+    console.log('  [RbacFlowGenerator] Generating Custom RBAC Flows...');
+    const baseOutputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode', 'FlowRbac');
+    // Local templates/ folder (3-way shared handlers via symlink + rbac/ specific templates)
+    const templateDir = path.join(__dirname, 'templates');
+
+    // Read handler templates
+    const templates = {
+        sqs: await fs.readFile(path.join(templateDir, 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
+        api: await fs.readFile(path.join(templateDir, 'FlowHandler_HdrApi.ejs'), 'utf-8'),
+        inv: await fs.readFile(path.join(templateDir, 'FlowHandler_HdrInv.ejs'), 'utf-8')
+    };
+
+    let generatedCount = 0;
+
+    const flows = getFlowsForGeneration(allSchemas);
+
+    for (const flow of flows) {
+        const flowTag = flow.flowTag;
+
+        // Process only if it's an RBAC flow
+        if (!isRbacFlow(flowTag)) continue;
+
+        const flowOutputDir = path.join(baseOutputDir, flowTag, 'source');
+        await fs.mkdir(flowOutputDir, { recursive: true });
+
+        // Generate Process Step for RBAC
+        const mainFileName = processMainFileName(flowTag);
+
+        // 1. Generate Main Logic File (from specific RBAC templates)
+        const templatePath = path.join(__dirname, 'templates', 'rbac', `${flowTag}.ejs`);
+        let mainTemplateStr;
+        try {
+            mainTemplateStr = await fs.readFile(templatePath, 'utf-8');
+        } catch (err) {
+            console.warn(`  [RbacFlowGenerator] Warning: RBAC template not found for ${flowTag}. Skipping.`);
+            continue;
+        }
+
+        const mainContent = ejs.render(mainTemplateStr, {
+            flowTag: flowTag
+        });
+        await fs.writeFile(path.join(flowOutputDir, `${mainFileName}.js`), mainContent, 'utf-8');
+        generatedCount++;
+
+        // 2. Generate SQS Handler for Process Step
+        const handlerFileName = `Process${flowTag}_HdrSqs`;
+        
+        // Ensure to pass functionName that matches what the template exports
+        const handlerContent = ejs.render(templates.sqs, {
+            flowTag: flowTag,
+            flowStepName: '', 
+            mainFileName: mainFileName,
+            functionName: processFunctionName(flowTag),
+            queueName: `Process${upperFirst(flowTag)}HdrSqs`
+        });
+        await fs.writeFile(path.join(flowOutputDir, `${handlerFileName}.js`), handlerContent, 'utf-8');
+        generatedCount++;
+    }
+
+    console.log(`  [RbacFlowGenerator] Generated ${generatedCount} files for RBAC Flows.`);
+}

package/src/codeGenerators/app/src/generatedCode/Flow/FlowRbac/templates/rbac/CreateRolePermissions.ejs

@@ -0,0 +1,135 @@
+/*
+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 dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import sqsSharedLib from '@izara_project/izara-core-library-sqs';
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+
+//(<optionalImport>)
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import {
+  lambda,
+  sns,
+  sqs
+} from '@izara_project/izara-core-library-external-request';
+import { identifierUuid } from '@izara_project/izara-shared-core';
+import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
+import { utils } from '@izara_project/izara-core-library-service-schemas';
+
+const { createFlowTypeConcat } = utils;
+//(</optionalImport>)
+
+/**
+ *
+ *
+ * description of function.
+ * @param {Object} _izContext
+ * @param {CorrelationIds} _izContext.correlationIds - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Object} requestParams - request params
+ * @param {Object} requestParams.identifiers - identifiers for get data
+ * @param {Object} requestParams.additionalRequest - additionalRequest
+ *
+ *
+ * @returns {object} description of return value
+ */
+
+export default async function Process<%=  flowTag %>(
+  _izContext,
+  requestParams,
+  callingFlowConfig = {}
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug(
+      'Process<%= flowTag %> _izContext',
+      _izContext
+    );
+    _izContext.logger.debug(
+      'Process<%= flowTag %> requestParams',
+      requestParams
+    );
+    _izContext.logger.debug(
+      'Process<%= flowTag %> callingFlowConfig',
+      callingFlowConfig
+    );
+
+    const userId = _izContext.correlationIds.get(consts.BASE_USER_ID);
+
+    _izContext.logger.debug(
+      '[Rbac:Process<%=  flowTag %>] userId',
+      userId
+    );
+
+    const { roleIdKey, flowTypeConcat, parameterGroups } = requestParams;
+
+    _izContext.logger.debug(
+      '[Rbac:Process<%=  flowTag %>] inputs',
+      {
+        roleIdKey,
+        flowTypeConcat,
+        parameterGroups
+      }
+    );
+
+    const resultPutItem = await dynamodbSharedLib.putItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RolePermissions'),
+      {
+        roleIdKey,
+        flowTypeConcat,
+        parameterGroups
+      }
+    );
+
+    _izContext.logger.debug(
+      '[Rbac:Process<%=  flowTag %>] result putItem',
+      resultPutItem
+    );
+
+    const message = {
+      returnResult: {
+        roleIdKey,
+        flowTypeConcat,
+        parameterGroups
+      }
+    };
+
+    const messageResult = {
+      message,
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(_izContext, `<%- flowTag %>_Out`)
+    };
+
+    _izContext.logger.debug(
+      '[Rbac:Process<%=  flowTag %>] messageResult',
+      messageResult
+    );
+
+    await sns.publishMessage(_izContext, messageResult);
+  } catch (err) {
+    _izContext.logger.error(
+      '[Rbac:Process<%=  flowTag %>] error: ',
+      err
+    );
+    throw err;
+  }
+}