@izara_project/izara-core-generate-service-code 1.0.84 → 1.0.86

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

@@ -0,0 +1,221 @@
+/*
+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 asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts } from '@izara_project/izara-core-library-service-schemas';
+import {
+  consts as coreConsts,
+  NoRetryError
+} from '@izara_project/izara-core-library-core';
+
+import {
+  saveDynamoDbRecords,
+  autoProvisionOwnerTargetRole,
+  resolveQuotaDeductionKeys,
+  forwardToQuotaConfirmation
+} from './CreateLogicalLib.js';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+const PREFIX = { ASYNC: 'CreateAsyncEndpoint' };
+
+function empty(value) {
+  return (
+    value == null ||
+    (typeof value === 'object' && Object.keys(value).length === 0)
+  );
+}
+
+function validateInput(returnValue, status, graphServiceTag, errorsFound) {
+  if (!returnValue?.queryResult)
+    errorsFound.push(
+      'message is not have property queryResult, should be not happen'
+    );
+  if (!returnValue?.requestParams?.objType)
+    errorsFound.push(
+      'message is not have property objType, should be not happen'
+    );
+  if (!returnValue?.requestParams?.objInstanceFull)
+    errorsFound.push(
+      'message is not have property objInstance, should be not objInstance'
+    );
+  if (status === 'error' && errorsFound.length === 0)
+    errorsFound.push(
+      '[invalid]status is error not have errorsFound form graphService'
+    );
+  if (status === 'complete' && errorsFound.length > 0)
+    errorsFound.push(
+      '[Invalid] status is complete should be not have errorsFound'
+    );
+  if (graphServiceTag == null)
+    errorsFound.push('[Invalid] graphServerTag is not empty string');
+}
+
+/**
+ * Handles callback after Graph creation node completion
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Callback request parameters
+ * @param {Object} passBackProperties - Pass-back properties
+ * @returns {Promise<Object>} Result object
+ */
+export default async function CreateNodeCallbackMain(
+  _izContext,
+  requestParams,
+  passBackProperties
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateNodeCallback] started`, {
+      requestParams,
+      passBackProperties
+    });
+    const {
+      returnValue,
+      status,
+      errorsFound = [],
+      graphServiceTag,
+      parentFlowId
+    } = requestParams;
+    if (empty(returnValue?.requestParams))
+      throw new NoRetryError('message not an object');
+    validateInput(returnValue, status, graphServiceTag, errorsFound);
+    if (errorsFound.length > 0) errorsFound.push(errorsFound.join(','));
+
+    const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
+      parentFlowId,
+      PREFIX.ASYNC
+    );
+    const pending =
+      await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(
+        _izContext,
+        awaitingStepId
+      );
+    _izContext.logger.debug('[CreateNodeCallback] awaiting step', {
+      awaitingStepId,
+      pending
+    });
+    if (!pending) {
+      _izContext.logger.warn(
+        `No pending step found for awaitingStepId: ${awaitingStepId}`
+      );
+      return { returnValue, status, errorsFound };
+    }
+    const result =
+      await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+        _izContext,
+        pending.pendingStepId,
+        awaitingStepId,
+        errorsFound
+      );
+    _izContext.logger.debug(
+      '[CreateNodeCallback] all awaiting steps result',
+      {
+        isComplete: result.isComplete,
+        awaitingStepId,
+        pendingStepId: pending.pendingStepId
+      }
+    );
+
+    if (result.isComplete) {
+      const nodeResultKey = `returnCreatedNode`;
+      const fallbackNodeResultKey = `returnCreateNode`;
+      const nodeResult =
+        returnValue.queryResult[nodeResultKey] ??
+        returnValue.queryResult[fallbackNodeResultKey] ??
+        {};
+      const node = nodeResult.createNodeResult ?? nodeResult;
+      const existsNode =
+        node.existsNode && Object.keys(node.existsNode).length
+          ? {
+              objType: returnValue.requestParams.objType,
+              objInstanceFull: node.existsNode.objInstanceFull
+            }
+          : null;
+
+      // ── Step 1: Persist DynamoDB records ──────────────────────────────────
+      if (status === 'complete' && errorsFound.length === 0) {
+        const listOfRecords = result?.additionalAttributes?.listOfRecords ?? [];
+        await saveDynamoDbRecords(_izContext, listOfRecords);
+
+        // ── Step 2: Auto-provision TargetRole (Owner) after DynamoDB write ─
+        const submittedByUserId =
+          returnValue?.requestParams?.submittedByUserId ||
+          node?.objInstanceFull?.identifiers?.submittedByUserId ||
+          requestParams?.passBackProperties?.submittedByUserId ||
+          passBackProperties?.passBackProperties?.submittedByUserId ||
+          _izContext.correlationIds?.get(coreConsts.SUBMITTED_BY_USER_ID) ||
+          _izContext.correlationIds?.get('submittedByUserId');
+
+        await autoProvisionOwnerTargetRole(_izContext, {
+          node,
+          submittedByUserId
+        });
+      }
+
+      const callingFlowConfig =
+        result?.additionalAttributes?.callingFlowConfig ||
+        requestParams?.passBackProperties?.parentPassBackProperties ||
+        passBackProperties?.passBackProperties?.parentPassBackProperties ||
+        passBackProperties;
+
+      const actionData = {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        relationships: node.relationships,
+        parentFlowId: parentFlowId || returnValue?.parentFlowId,
+        existsNode,
+        status,
+        errorsFound
+      };
+
+      // ── Step 3: Resolve Quota deduction keys and forward confirmation ─────
+      const quotaKeys = resolveQuotaDeductionKeys(
+        requestParams,
+        passBackProperties,
+        returnValue,
+        callingFlowConfig,
+        _izContext
+      );
+
+      await forwardToQuotaConfirmation(_izContext, {
+        status,
+        errorsFound,
+        quotaKeys,
+        actionData,
+        callingFlowConfig
+      });
+    }
+
+    await asyncFlowSharedLib.removeAwaitingMultipleStep(
+      _izContext,
+      awaitingStepId,
+      pending.pendingStepId,
+      errorsFound
+    );
+    return { returnValue, status, errorsFound };
+  } catch (error) {
+    _izContext.logger.error('[CreateNodeCallback] error:', error);
+    throw error;
+  }
+}

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

@@ -85,6 +85,7 @@ export default async function <%- flowTag %>(
         _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
 
       targetIdentifiers = requestParams.targetIdentifiers;
+      delete requestParams.targetIdentifiers;
 
       if (!targetIdentifiers && objectSchema.belongTo?.objectType === 'user' && submittedByUserId) {
         targetIdentifiers = { submittedByUserId };
@@ -99,12 +100,11 @@ export default async function <%- flowTag %>(
         if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
           targetIdentifiers.submittedByUserId = submittedByUserId;
         }
-        requestParams.targetIdentifiers = targetIdentifiers;
       }
 
       _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`,  {
         submittedByUserId: requestParams.submittedByUserId,
-        targetIdentifiers: requestParams.targetIdentifiers,
+        targetIdentifiers,
         belongTo: objectSchema.belongTo,
         generatedBy: objectSchema.generatedBy
       });
@@ -116,6 +116,37 @@ export default async function <%- flowTag %>(
     // ── Build identifiers used by asynchronous processing ────────────────────
     const identifiers = requestParams.identifiers;
 
+    if (!objectSchema.hasOwnProperty('belongTo')) {
+      if (!targetIdentifiers && identifiers) {
+        targetIdentifiers = { ...identifiers };
+      } else if (targetIdentifiers && identifiers) {
+        for (const [key, value] of Object.entries(identifiers)) {
+          if (targetIdentifiers[key] === undefined && value !== undefined) {
+            targetIdentifiers[key] = value;
+          }
+        }
+      }
+      if (targetIdentifiers) {
+        if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
+          targetIdentifiers.submittedByUserId = submittedByUserId;
+        }
+      }
+    }
+
+    if (targetIdentifiers && identifiers) {
+      for (const [key, value] of Object.entries(identifiers)) {
+        if (
+          targetIdentifiers[key] !== undefined &&
+          value !== undefined &&
+          targetIdentifiers[key] !== value
+        ) {
+          errorsFound.push(
+            `targetIdentifiers.${key} must match identifiers.${key}`
+          );
+        }
+      }
+    }
+
     if (errorsFound.length > 0)
       return await <%- flowTag %>LogicalLib(
         _izContext,
@@ -131,8 +162,8 @@ export default async function <%- flowTag %>(
     for (const o of rbacObjects) {
       const belongToTargets = o?.belongTo
         ? Array.isArray(o.belongTo)
-          ? o.belongTo
-          : [o.belongTo]
+        ? o.belongTo
+        : [o.belongTo]
         : [];
       if (belongToTargets.length > 0 && belongToTargets[0]?.serviceTag) {
         rbacServiceTagMap[o.objectType] = `'${belongToTargets[0].serviceTag}'`;
@@ -164,6 +195,7 @@ export default async function <%- flowTag %>(
         },
         parameterGroups,
         {
+          targetIdentifiers,
           rbacObjType: {
             serviceTag: <%- rbacServiceTags.length === 1 ? rbacServiceTags[0] : `{ ${Object.entries(rbacServiceTagMap).map(([k, v]) => `'${k}': ${v}`).join(', ')} }[requestParams.objectType] || process.env.iz_serviceTag` %>
           },

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

@@ -30,7 +30,11 @@ import { sns } from '@izara_project/izara-core-library-external-request';
 
 const { createObjType } = utils;
 
-import { <%- flowTag %>LogicalLib } from './<%- upperCaseFlowTag %>LogicalLib.js';
+import {
+  <%- flowTag %>LogicalLib,
+  collectRbacAwaitingResults,
+  assertRbacPermission
+} from './<%- upperCaseFlowTag %>LogicalLib.js';
 
 //(<optionalRequire>)
 //(</optionalRequire>)
@@ -39,6 +43,7 @@ import { <%- flowTag %>LogicalLib } from './<%- upperCaseFlowTag %>LogicalLib.js
  * 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 {string} flowTag - Flow tag name
  * @param {Object} callingFlowConfig - Calling flow configuration
  * @returns {Promise<Object>}
  */
@@ -49,149 +54,44 @@ export default async function <%- flowTag %>RbacCallbackMain(
   callingFlowConfig = {}
 ) {
   try {
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>RbacCallback] Started with params:`,  {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>RbacCallback] 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
-      }
-    );
-
+    // 1. Wait until all awaiting steps (App/Target RBAC) are complete
     const {
       isComplete,
-      collectedReturnValueByAwaitingStepId,
-      collectedErrors: errorsFound = [],
-      additionalAttributes
-    } = rbacAwaitingStepsResult;
+      rbacResults,
+      originalRequestParams,
+      collectedErrors = []
+    } = await collectRbacAwaitingResults(_izContext, requestParams);
 
     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
-      }
-    );
+    const errorsFound = [...collectedErrors];
 
-    await asyncFlowSharedLib.clearAllAwaitingSteps(
+    // 2. Validate RBAC permission results
+    const { hasError, errorResult, rbacCallbackResults } = await assertRbacPermission(
       _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,
+        rbacResults,
+        originalRequestParams,
         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)
-      });
-
+    if (hasError) {
       return errorResult;
     }
 
     //(<rbacCallbackMain>)
     //(</rbacCallbackMain>)
 
+    // 3. Permission granted -> Proceed with core logical processing
     const logicalResult = await <%- flowTag %>LogicalLib(
       _izContext,
       originalRequestParams,
@@ -209,7 +109,7 @@ export default async function <%- flowTag %>RbacCallbackMain(
 
     return logicalResult;
   } catch (err) {
-    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>RbacCallback] Error caught:`,  {
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>RbacCallback] Error caught:`, {
       error: err
     });
     throw err;

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

@@ -39,7 +39,7 @@ import <%- typeof functionName !== 'undefined' ? functionName : upperCaseFlowTag
 //(</optionalRequire>)
 
 export const main = middleware.wrap(async (event, context) => {
-  event._izContext.logger.debug('Event:', event);
+  event._izContext.logger.debug('[FlowEndpoint_HdrWbs] WebSocket event received', { event });
 
   try {
     if (event.requestContext) {
@@ -49,12 +49,21 @@ export const main = middleware.wrap(async (event, context) => {
         consts.X_CORRELATION_ID
       );
 
+      event._izContext.logger.debug('[FlowEndpoint_HdrWbs] request context info', {
+        route,
+        connectionId,
+        correlationId
+      });
+
       switch (route) {
         case '$default':
-          console.log('Received unknown route:', route);
+          event._izContext.logger.debug('[FlowEndpoint_HdrWbs] Received unknown route', { route });
           break;
         case '<%- flowTag %>':
-          console.log('event in route webSocket', event);
+          event._izContext.logger.debug('[FlowEndpoint_HdrWbs] matched route <%- flowTag %>', {
+            route,
+            body: event.body
+          });
           let eventParams = JSON.parse(event.body);
 
           //(<createIdentifiersFlow>)
@@ -69,11 +78,22 @@ export const main = middleware.wrap(async (event, context) => {
             }
           );
 
+          event._izContext.logger.debug('[FlowEndpoint_HdrWbs] flow schema resolved', {
+            flowTag: '<%- flowTag %>',
+            statusType: flowSchema?.statusType
+          });
+
           if (
             flowSchema.statusType === 'statusField' ||
             flowSchema.statusType === 'storedCache' ||
             flowSchema.statusType === 'triggerCache'
           ) {
+            const taskKey = `${createFlowTypeConcat(event._izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${identifiers}`;
+            event._izContext.logger.debug('[FlowEndpoint_HdrWbs] registering WebSocketTask with ttl', {
+              taskKey,
+              connectionId,
+              ttl: 600
+            });
             await dynamodbSharedLib.putItem(
               event._izContext,
               await dynamodbSharedLib.tableName(
@@ -81,12 +101,17 @@ export const main = middleware.wrap(async (event, context) => {
                 'WebSocketTask'
               ),
               {
-                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${identifiers}`,
+                taskKey,
                 connectionId: connectionId,
                 ttl: 600
               }
             );
           } else if (flowSchema.statusType === 'none') {
+            const taskKey = `${createFlowTypeConcat(event._izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${correlationId}`;
+            event._izContext.logger.debug('[FlowEndpoint_HdrWbs] registering WebSocketTask for status none', {
+              taskKey,
+              connectionId
+            });
             await dynamodbSharedLib.putItem(
               event._izContext,
               await dynamodbSharedLib.tableName(
@@ -94,22 +119,52 @@ export const main = middleware.wrap(async (event, context) => {
                 'WebSocketTask'
               ),
               {
-                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${correlationId}`,
+                taskKey,
                 connectionId: connectionId
               }
             );
           }
 
-          if (!eventParams.submittedByUserId) {
-            const contextUserId = event._izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
-            if (contextUserId) {
-              eventParams.submittedByUserId = contextUserId;
+          const authorizerUserId =
+            event.requestContext?.authorizer?.submittedByUserId ||
+            event.requestContext?.authorizer?.principalId;
+          const resolvedUserId =
+            authorizerUserId ||
+            eventParams.submittedByUserId ||
+            event._izContext?.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+
+          if (resolvedUserId) {
+            if (event._izContext?.correlationIds) {
+              event._izContext.correlationIds.set(
+                consts.SUBMITTED_BY_USER_ID,
+                resolvedUserId
+              );
             }
+            if (
+              !eventParams.targetIdentifiers ||
+              typeof eventParams.targetIdentifiers !== 'object'
+            ) {
+              eventParams.targetIdentifiers = {};
+            }
+            eventParams.targetIdentifiers.submittedByUserId = resolvedUserId;
           }
 
+          event._izContext.logger.debug('[FlowEndpoint_HdrWbs] resolved user and target identifiers', {
+            authorizerUserId,
+            resolvedUserId,
+            targetIdentifiers: eventParams.targetIdentifiers
+          });
+
           let callingFlow = eventParams?.callingFlow
             ? eventParams.callingFlow
             : {};
+
+          event._izContext.logger.debug('[FlowEndpoint_HdrWbs] invoking main function', {
+            flowTag: '<%- flowTag %>',
+            eventParams,
+            callingFlow
+          });
+
           await <%- typeof functionName !== 'undefined' ? functionName : upperCaseFlowTag %>(
             event._izContext,
             eventParams,
@@ -122,16 +177,23 @@ export const main = middleware.wrap(async (event, context) => {
       }
     } else {
       const connId = event.connId;
-      // await postMessage({ message: event.message }, connId);
+      event._izContext.logger.debug('[FlowEndpoint_HdrWbs] direct postToConnection', {
+        connId,
+        message: event.message
+      });
       await postToConnection(event._izContext, { message: event.message }, connId);
     }
 
     return response.webSocketSuccess();
   } catch (err) {
-    const connId = event.requestContext.connectionId;
-    event._izContext.logger.error('Error, WebSocket: ', err);
-    // await sendErrorMessage({ message: err.message }, connId);
-    await postToConnection(event._izContext, { message: err.message }, connId);
+    const connId = event.requestContext?.connectionId;
+    event._izContext.logger.error('[FlowEndpoint_HdrWbs] Error, WebSocket: ', {
+      error: err,
+      connectionId: connId
+    });
+    if (connId) {
+      await postToConnection(event._izContext, { message: err.message }, connId);
+    }
     return response.failure(err);
   }
 });