@izara_project/izara-core-generate-service-code 1.0.78 → 1.0.80

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

@@ -0,0 +1,217 @@
+/*
+Copyright (C) 2021 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 {
+  objectHash as hash,
+  identifierUuid
+} from '@izara_project/izara-shared-core';
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import {
+  utils,
+  uploadUseCase,
+  getObjectSchema
+} from '@izara_project/izara-core-library-service-schemas';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+
+const { createObjType } = utils;
+
+import { <%- flowTag %>LogicalLib } from './<%- upperCaseFlowTag %>LogicalLib.js';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+/**
+ * Handles callback after RbacCallback phase — verifies awaitingStep then proceeds to next phase
+ * @param {Object} _izContext - Context object with logger
+ * @param {Object} requestParams - { fieldNames, relationships[] }
+ * @param {Object} callingFlowConfig - Calling flow configuration
+ * @returns {Promise<Object>}
+ */
+export default async function <%- flowTag %>RbacCallbackMain(
+  _izContext,
+  requestParams,
+  flowTag,
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug('[<%- flowTag %>RbacCallbackMain] Started with params:', {
+      requestParams,
+      flowTag,
+      callingFlowConfig
+    });
+
+    const parts = requestParams.parentFlowId.split('_');
+    const rbacType = parts.pop();
+    const rbacPendingStepId = '<%- flowTag %>RbacCallback_' + parts.join('_');
+    const currentAwaitingStepId = requestParams.parentFlowId;
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] Parsed RBAC pending details:',
+      {
+        rbacType,
+        rbacPendingStepId,
+        currentAwaitingStepId,
+        parentFlowId: requestParams.parentFlowId
+      }
+    );
+
+    const rbacAwaitingStepsResult =
+      await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+        _izContext,
+        rbacPendingStepId,
+        currentAwaitingStepId,
+        requestParams.errorsFound,
+        {
+          returnValue: requestParams.returnValue,
+          rbacType
+        }
+      );
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] checkAllAwaitingStepsFinishedWithReturnParams result:',
+      {
+        rbacAwaitingStepsResult
+      }
+    );
+
+    const {
+      isComplete,
+      collectedReturnValueByAwaitingStepId,
+      collectedErrors: errorsFound = [],
+      additionalAttributes
+    } = rbacAwaitingStepsResult;
+
+    if (isComplete === false) {
+      _izContext.logger.debug(
+        '[<%- flowTag %>RbacCallbackMain] Awaiting steps still pending completion:',
+        {
+          rbacPendingStepId,
+          isComplete
+        }
+      );
+
+      return 'all task not completed';
+    }
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] All awaiting steps completed — clearing awaiting steps:',
+      {
+        rbacPendingStepId
+      }
+    );
+
+    await asyncFlowSharedLib.clearAllAwaitingSteps(
+      _izContext,
+      rbacPendingStepId
+    );
+
+    const originalRequestParams = additionalAttributes?.requestParams || {};
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] Retrieved originalRequestParams:',
+      {
+        originalRequestParams
+      }
+    );
+
+    const rbacResults = Object.fromEntries(
+      Object.entries(collectedReturnValueByAwaitingStepId || {}).map(
+        ([stepId, attrs]) => {
+          const type = stepId.split('_').pop();
+          return [type, attrs];
+        }
+      )
+    );
+
+    const rbacCallbackResults = {};
+    const hasError = Object.entries(rbacResults).some(([type, result]) => {
+      if (result && result.error) {
+        errorsFound.push(result.error);
+        return true;
+      }
+      rbacCallbackResults[type] = result;
+      return false;
+    });
+
+    const isAllowed = Object.values(rbacCallbackResults).some(
+      item => item?.returnValue?.permission === true
+    );
+
+    if (!isAllowed) {
+      errorsFound.push('Permission denied');
+    }
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] Final rbacCallbackResults before calling <%- flowTag %>MainLogical:',
+      {
+        rbacCallbackResults,
+        isAllowed,
+        errorsFound
+      }
+    );
+
+    if (hasError || errorsFound.length > 0) {
+      const errorResult = {
+        errorsFound,
+        status: 'rejected',
+        requestParams: originalRequestParams
+      };
+
+      _izContext.logger.debug(
+        '[<%- flowTag %>RbacCallbackMain] RBAC check failed, publishing rejected status:',
+        errorResult
+      );
+
+      await sns.publishAsync(_izContext, {
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          '<%- upperCaseFlowTag %>_Out',
+          process.env.iz_serviceTag
+        ),
+        Message: JSON.stringify(errorResult)
+      });
+
+      return errorResult;
+    }
+
+    //(<rbacCallbackMain>)
+    //(</rbacCallbackMain>)
+
+    const logicalResult = await <%- flowTag %>LogicalLib(
+      _izContext,
+      originalRequestParams,
+      callingFlowConfig,
+      errorsFound,
+      rbacCallbackResults
+    );
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] <%- flowTag %>LogicalLib completed successfully:',
+      {
+        logicalResult
+      }
+    );
+
+    return logicalResult;
+  } catch (err) {
+    _izContext.logger.error('[<%- flowTag %>RbacCallbackMain] Error caught:', {
+      error: err
+    });
+    throw err;
+  }
+}

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

@@ -58,7 +58,7 @@ import { sns } from '@izara_project/izara-core-library-external-request';
 export default async function <%- flowTag %>(
   _izContext,
   requestParams,
-  callingFlowConfig = {}
+  callingFlowConfig = {},
   //(<additionalParams>)
   //(</additionalParams>)
 ) {

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

@@ -36,14 +36,14 @@ import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 /**
  * 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} requestParams - { objectType, identifierField, pk, startKey, sk, itemNumber, 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 = {}
+  callingFlowConfig = {},
   //(<additionalParams>)
   //(</additionalParams>)
 ) {
@@ -63,22 +63,50 @@ export default async function <%- mainFileName %>(
     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 {
+      identifierField,
+      pk,
+      startKey,
+      sk,
+      itemNumber,
+      itemNum
+    } = requestParams;
+
+    let partitionKeyValue = {};
+    if (
+      identifierField &&
+      typeof identifierField === 'object' &&
+      Object.keys(identifierField).length > 0
+    ) {
+      partitionKeyValue = identifierField;
+    } else if (pk) {
+      const pkIdentifier = objectSchema.identifiers?.find(
+        (id) => id.type === 'partitionKey'
+      );
+      const pkName =
+        pkIdentifier?.fieldName ||
+        pkIdentifier?.name ||
+        'pk';
+      partitionKeyValue = { [pkName]: pk };
+    } else {
+      throw new Error('Partition key (identifierField or pk) is required for getRange');
     }
 
     const queryElements = {};
-    if (itemNum) {
-      queryElements.limit = parseInt(itemNum, 10);
+    const limitVal = itemNumber || itemNum;
+    if (limitVal) {
+      queryElements.limit = parseInt(limitVal, 10);
     }
 
-    if (sk) {
-      if (typeof sk === 'object') {
-        queryElements.exclusiveStartKey = sk;
+    const effectiveStartKey = startKey || sk;
+    if (effectiveStartKey) {
+      if (typeof effectiveStartKey === 'object') {
+        queryElements.exclusiveStartKey = effectiveStartKey;
       } else {
-        queryElements.exclusiveStartKey = { pk: pk, sk: sk };
+        queryElements.exclusiveStartKey = {
+          ...partitionKeyValue,
+          sk: effectiveStartKey
+        };
       }
     }
 
@@ -86,38 +114,91 @@ export default async function <%- mainFileName %>(
     //(</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 queryResults = [];
+
+    for (const [, getDataDetail] of Object.entries(getDataDetails)) {
+      if (getDataDetail.storageType !== consts.STORAGE_TYPES.graph) {
+        const tableName = await dynamodbSharedLib.tableName(
+          _izContext,
+          getDataDetail.tableName,
+          getDataDetail.serviceTag
+        );
+
+        let queryPartitionKeyValue = partitionKeyValue;
+        if (
+          !identifierField ||
+          typeof identifierField !== 'object' ||
+          Object.keys(identifierField).length === 0
+        ) {
+          const pkIdentifier = objectSchema.identifiers?.find(
+            (id) => id.type === 'partitionKey'
           );
+          const pkName =
+            getDataDetail.groupByPartitionKeyField ||
+            pkIdentifier?.fieldName ||
+            pkIdentifier?.name ||
+            'pk';
+          queryPartitionKeyValue = { [pkName]: pk };
+        }
 
-          const pkName = getDataDetail.partitionKey || 'pk';
-          const partitionKeyValue = { [pkName]: pk };
+        //(<beforeGetRangeDynamoDb>)
+        //(</beforeGetRangeDynamoDb>)
 
-          //(<beforeGetRangeDynamoDb>)
-          //(</beforeGetRangeDynamoDb>)
+        const dataFromDynamoDb = await dynamodbSharedLib.query(
+          _izContext,
+          tableName,
+          queryPartitionKeyValue,
+          queryElements
+        );
+        _izContext.logger.debug('dataFromDynamoDb:', dataFromDynamoDb);
 
-          let dataFromDynamoDb = await dynamodbSharedLib.query(
-            _izContext,
-            tableName,
-            partitionKeyValue,
-            queryElements
-          );
-          _izContext.logger.debug('dataFromDynamoDb:', dataFromDynamoDb);
+        queryResults.push(dataFromDynamoDb);
 
-          queryResult = dataFromDynamoDb;
+        //(<afterGetRangeDynamoDb>)
+        //(</afterGetRangeDynamoDb>)
+      }
+    }
 
-          //(<afterGetRangeDynamoDb>)
-          //(</afterGetRangeDynamoDb>)
+    let queryResult = null;
+    if (queryResults.length === 1) {
+      queryResult = queryResults[0];
+    } else if (queryResults.length > 1) {
+      const mergedItemsMap = new Map();
+      const sortKeyIdentifier = objectSchema.identifiers?.find(
+        (id) => id.type === 'sortKey'
+      );
+      const skField =
+        sortKeyIdentifier?.fieldName ||
+        sortKeyIdentifier?.name ||
+        'sk';
+
+      for (const res of queryResults) {
+        let items = [];
+        if (Array.isArray(res)) {
+          items = res;
+        } else if (res && res.Items) {
+          items = res.Items;
+        }
+
+        for (const item of items) {
+          let key = item[skField];
+          if (typeof key === 'undefined' || key === null) {
+            key = JSON.stringify(item);
+          }
+          if (mergedItemsMap.has(key)) {
+            mergedItemsMap.set(key, { ...mergedItemsMap.get(key), ...item });
+          } else {
+            mergedItemsMap.set(key, { ...item });
+          }
         }
-      })
-    );
+      }
+
+      queryResult = {
+        Items: Array.from(mergedItemsMap.values()),
+        Count: mergedItemsMap.size,
+        queryResults: queryResults
+      };
+    }
 
     return queryResult;
   } catch (err) {

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

@@ -118,8 +118,10 @@ export default async function UpdateComplete(
             }
           : null;
       if (status === 'complete') {
+        const listOfRecords =
+          result?.additionalAttributes?.listOfRecords ?? [];
         await Promise.all(
-          (pending.listOfRecords ?? []).flatMap((records) =>
+          (listOfRecords ?? []).flatMap((records) =>
             Object.values(records).map(async (record) =>
               dynamodbSharedLib.putItem(
                 _izContext,
@@ -137,9 +139,12 @@ export default async function UpdateComplete(
           )
         );
       }
+      const callingFlowConfig =
+        result?.additionalAttributes?.callingFlowConfig ||
+        passBackProperties;
       const message =
         callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
-          passBackProperties,
+          callingFlowConfig,
           {
             objType: returnValue.requestParams.objType,
             objInstanceFull: node.objInstanceFull,
@@ -152,7 +157,7 @@ export default async function UpdateComplete(
         );
       const messageAttributes =
         callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
-          passBackProperties,
+          callingFlowConfig,
           {}
         );
       const topicArn = snsSharedLib.snsTopicArnByFlowSchema(