@izara_project/izara-core-generate-service-code 1.0.64 → 1.0.66

package/src/{codeGenerators/app/src/generatedCode/ProcessLogical/templates/ProcessLogical_HdrSqs.ejs → emit/crud/templates/FlowHandler_HdrSqs.ejs}

@@ -16,61 +16,45 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
-import Logger from '@izara_project/izara-core-library-logger';
 import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import Logger from '@izara_project/izara-core-library-logger';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
-
-import processLogical from './ProcessLogical_Main.js';
+import <%= functionName %> from './<%= mainFileName %>.js';
 
 // validate event properties in body.Message of sqs event
-middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+let perRecordsValidatorSchema = {
+  //(<validatorSchema>)
+<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+  type: 'object',
+  properties: {
+<% startConfig.properties.forEach((prop, index) => { %>    <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' }<%= index < startConfig.properties.length - 1 ? ',' : '' %>
+<% }) %>  },
+  required: [<%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %>]
+<% } -%>
+  //(</validatorSchema>)
+};
 
-// set schema for record.body.Message
-const perRecordsValidatorSchema = {
+<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.messageAttributes && startConfig.messageAttributes.length > 0) { -%>
+let messageAttributeValidatorSchema = {
   type: 'object',
-  required: ['objType', 'element', 'overWriteCache'],
   properties: {
-    objType: {
+<% startConfig.messageAttributes.forEach((prop, index) => { %>    '<%- prop.propertyName %>': {
       type: 'object',
-      required: ['serviceTag', 'objectType'],
       properties: {
-        serviceTag: {
-          type: 'string',
-          enum: [process.env.iz_serviceTag]
-        },
-        objectType: {
-          type: 'string'
-        }
-      }
-    },
-    element: {
-      type: 'object'
-    },
-    overWriteCache: {
-      type: 'boolean'
-    },
-    callingFlow: {
-      type: 'string',
-      default: ''
-    }
-  }
+        Type: { type: 'string' },
+        Value: { type: '<%- prop.type || 'string' %>' }
+      },
+      required: ['Type', 'Value']
+    }<%= index < startConfig.messageAttributes.length - 1 ? ',' : '' %>
+<% }) %>  },
+  required: [<%- startConfig.messageAttributes.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %>]
 };
+<% } else { -%>
+let messageAttributeValidatorSchema = null;
+<% } -%>
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
 
-// set schema for record.body.MessageAttributes
-// const messageAttributeValidatorSchema = {
-//   type: "object",
-//   required: ['msgAtrrParam1', 'msgAtrrParam2'],
-//   properties: {
-//     msgAtrrParam1: {
-//       type: "string"
-//     },
-//     msgAtrrParam2: {
-//       type: "object"
-//     }
-//   }
-// };
-
-export const main = middleware.wrap(async (event, context, callback) => {
+export const main = middleware.wrap(async (event, context) => {
   try {
     let recordPromises = [];
 
@@ -82,19 +66,31 @@ export const main = middleware.wrap(async (event, context, callback) => {
         let passOnProperties = [];
         record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
 
-        // validate message (and MessageAttributes)
+        //validate message (and MessageAttributes)
         await recordHandlerSharedLib.validateRecord(
           record, // one record will send to mainFunction
-          'ProcessLogicalHdrSqs', // queue name that need to retry or send to dlq
-          perRecordsValidatorSchema // schema for record.Message
-          // messageAttributeValidatorSchema  // ----- for msgAttr default is null -> do not send this parameter if not want to validate msgAtt
+          '<%= queueName %>', // queue name that need to retry or send to dlq
+          perRecordsValidatorSchema, // schema for record.Message
+          messageAttributeValidatorSchema
         );
 
         // add argument (to invoke lambda) to passOnProperties[]
-        passOnProperties.push(record.body.Message.objType);
-        passOnProperties.push(record.body.Message.element);
-        passOnProperties.push(record.body.Message.overWriteCache);
-        passOnProperties.push(record.body.Message.callingFlow);
+        passOnProperties.push(record.body.Message);
+<% if (typeof usePassBack === 'undefined' ? functionName.endsWith('Complete') : usePassBack) { %>
+        passOnProperties.push(
+          callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
+            record.body.Message
+          )
+        );
+<% } else { %>
+        passOnProperties.push(
+          callingFlowSharedLib.addCallingFlowToPassOnProperties(
+            record.body.Message
+          )
+        );
+<% } %>
+        //(<additionalParams>)
+        //(</additionalParams>)
         record._izContext.logger.debug(
           'passOnProperties in handler',
           passOnProperties
@@ -103,8 +99,8 @@ export const main = middleware.wrap(async (event, context, callback) => {
         // call recordHandlerSharedLib.recordHandler with 3 parameters and return promise(resolve)
         let recordPromise = recordHandlerSharedLib.recordHandler(
           record, // one record will send to mainFunction
-          processLogical, // mainFunction that need to invoke.
-          'ProcessLogicalHdrSqs', // queue name that need to retry or send to dlq
+          <%= functionName %>, // mainFunction that need to invoke.
+          '<%= queueName %>', // queue name that need to retry or send to dlq
           passOnProperties // all parameters that mainFunction needed.
         );
         record._izContext.logger.debug('after recordPromise in handler');
@@ -125,7 +121,7 @@ export const main = middleware.wrap(async (event, context, callback) => {
     }
     Logger.debug('after Promise.all(recordPromises) in handler');
   } catch (err) {
-    Logger.error('Unhandled Error, ProcessLogicalHdrSqs: ', err);
+    Logger.error('Unhandled Error, LambdaFunctionHdrSqs: ', err);
     throw err;
   }
-});
+});

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint → emit/crud/templates}/FlowMain_Wbs.ejs

@@ -27,8 +27,6 @@ import { sns, webSocket } from '@izara_project/izara-core-library-external-reque
 
 import { NoRetryError } from '@izara_project/izara-core-library-core';
 import { consts as coreConsts } from "@izara_project/izara-middleware";
-import { consts as generateCodeConsts } from '@izara_project/izara-core-generate-service-code';
-const { TOPIC_NAME_GENERATE_CODE } = generateCodeConsts;
 const { postToConnection } = webSocket;
 
 //(<optionalRequire>)
@@ -107,4 +105,4 @@ export default async function <%- typeof functionName !== 'undefined' ? function
     _izContext.logger.error('error WebSocketInvoke: ', err)
     throw (err)
   }
-}
+}

package/src/emit/crud/templates/GetRangeEndpoint_Main.ejs

@@ -0,0 +1,127 @@
+/*
+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 />.
+*/
+
+// ==================== Izara Core Service Schemas ====================
+import {
+  getObjectSchema,
+  consts,
+  utils,
+  dataDetailsLib
+} from '@izara_project/izara-core-library-service-schemas';
+const { getObjSchemaS3WithHierarchy } = getObjectSchema;
+const { createObjType } = utils;
+const { createGetDataDetails } = dataDetailsLib;
+
+// ==================== Shared Utility Libraries ====================
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+/**
+ * Gets a range of objects by processing DynamoDB query
+ * @param {Object} _izContext - Context object with logger
+ * @param {Object} requestParams - { objectType, pk, sk, itemNum, additionalParams }
+ * @param {Object} callingFlowConfig - Calling flow configuration
+ * @returns {Promise<Object>} DynamoDB query result (Items, LastEvaluatedKey, etc.)
+ */
+export default async function <%- mainFileName %>(
+  _izContext,
+  requestParams,
+  callingFlowConfig = {}
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('function <%- mainFileName %>:', {
+      requestParams,
+      callingFlowConfig
+    });
+
+    const objType = createObjType(requestParams.objectType);
+
+    // ── Load schema ───────────────────────────────────────────────────────────
+    const objectSchema = await getObjSchemaS3WithHierarchy(_izContext, objType);
+    _izContext.logger.debug('objectSchema:', objectSchema);
+
+    // ── Build getDataDetails ──────────────────────────────────────────────────
+    const getDataDetails = await createGetDataDetails(_izContext, objectSchema);
+    _izContext.logger.debug('getDataDetails:', getDataDetails);
+
+    const { pk, sk, itemNum } = requestParams;
+    
+    if (!pk) {
+      throw new Error('Partition key (pk) is required for getRange');
+    }
+
+    const queryElements = {};
+    if (itemNum) {
+      queryElements.limit = parseInt(itemNum, 10);
+    }
+
+    if (sk) {
+      if (typeof sk === 'object') {
+        queryElements.exclusiveStartKey = sk;
+      } else {
+        queryElements.exclusiveStartKey = { pk: pk, sk: sk };
+      }
+    }
+
+    //(<beforeQuery>)
+    //(</beforeQuery>)
+
+    // ── Process storage resources (DynamoDB only for getRange) ────────────────
+    let queryResult = null;
+
+    await Promise.all(
+      Object.entries(getDataDetails).map(async ([, getDataDetail]) => {
+        if (getDataDetail.storageType !== consts.STORAGE_TYPES.graph) {
+          const tableName = await dynamodbSharedLib.tableName(
+            _izContext,
+            getDataDetail.tableName,
+            getDataDetail.serviceTag
+          );
+
+          const pkName = getDataDetail.partitionKey || 'pk';
+          const partitionKeyValue = { [pkName]: pk };
+
+          //(<beforeGetRangeDynamoDb>)
+          //(</beforeGetRangeDynamoDb>)
+
+          let dataFromDynamoDb = await dynamodbSharedLib.query(
+            _izContext,
+            tableName,
+            partitionKeyValue,
+            queryElements
+          );
+          _izContext.logger.debug('dataFromDynamoDb:', dataFromDynamoDb);
+          
+          queryResult = dataFromDynamoDb;
+
+          //(<afterGetRangeDynamoDb>)
+          //(</afterGetRangeDynamoDb>)
+        }
+      })
+    );
+
+    return queryResult;
+  } catch (err) {
+    _izContext.logger.error('error <%- mainFileName %>:', err);
+    throw err;
+  }
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/crud → emit/crud/templates}/UpdateEndpoint_Main.ejs

@@ -508,4 +508,4 @@ export default async function <%- flowTag %>(
     _izContext.logger.error('error updateMain:', err);
     throw err;
   }
-}
+}

package/src/emit/custom/customFlows.js

@@ -0,0 +1,70 @@
+const SUPPORTED_EVENTS = new Set(['eventBridge', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'ownTopic', 's3']);
+
+export function supportedCustomFlows(flows) {
+  if (!Array.isArray(flows)) {
+    throw new TypeError('flows must be an array');
+  }
+  return flows.filter(flow => (
+    typeof flow?.flowTag === 'string' && flow.flowTag !== '' &&
+    !flow.generatedCodeConfig &&
+    Array.isArray(flow.event) &&
+    flow.event.some(event => SUPPORTED_EVENTS.has(event))
+  ));
+}
+
+export function customFlowRoleName(flowTag) {
+  return `${upperFirst(flowTag)}Role`;
+}
+
+export function flowExtTopicSteps(flows) {
+  if (!Array.isArray(flows)) {
+    throw new TypeError('flows must be an array');
+  }
+  return flows.flatMap(flow => {
+    if (typeof flow?.flowTag !== 'string' || flow.flowTag === '') {
+      return [];
+    }
+    return (flow.flowSteps ?? []).flatMap(step => (
+      typeof step?.stepName === 'string' && step.stepName !== '' &&
+      step.stepName.toLowerCase() !== 'start' &&
+      Array.isArray(step.event) && step.event.includes('extTopic')
+        ? [{ flow, step, flowTag: upperFirst(flow.flowTag), stepName: upperFirst(step.stepName) }]
+        : []
+    ));
+  });
+}
+
+export function generatedOwnTopicFlows(flows) {
+  if (!Array.isArray(flows)) {
+    throw new TypeError('flows must be an array');
+  }
+  return flows.filter(flow => (
+    typeof flow?.flowTag === 'string' && flow.flowTag !== '' &&
+    flow.generatedCodeConfig &&
+    Array.isArray(flow.event) && flow.event.includes('ownTopic')
+  ));
+}
+
+export function triggerCacheFlows(flows) {
+  if (!Array.isArray(flows)) {
+    throw new TypeError('flows must be an array');
+  }
+  return flows.filter(flow => (
+    typeof flow?.flowTag === 'string' && flow.flowTag !== '' &&
+    flow.statusType === 'triggerCache'
+  ));
+}
+
+export function triggerCacheQueueNames(flow) {
+  const tag = upperFirst(flow.flowTag);
+  return [
+    `TriggerCache${tag}HdrDsq`,
+    `CheckTriggerCache${tag}CompleteHdrSqs`,
+    `TriggerCache${tag}CompleteHdrSqs`,
+    `TriggerCache${tag}CompleteHdrDsq`
+  ];
+}
+
+export function upperFirst(value) {
+  return value[0].toUpperCase() + value.slice(1);
+}