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

package/src/emit/rbac/templates/CancelUsage_Main.ejs

@@ -0,0 +1,103 @@
+/*
+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 { sns } from '@izara_project/izara-core-library-external-request';
+import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
+
+export default async function CancelUsage(_izContext, requestParams) {
+  try {
+    const submittedByUserId =
+      requestParams.submittedByUserId ||
+      _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+    const { limitTag, uniqueIdentify } = requestParams;
+
+    const targetIdentifiers = requestParams.targetIdentifiers;
+    let identifiersConcat = requestParams.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      identifiersConcat = Object.entries(targetIdentifiers)
+        .map(([k, v]) => `${k}#${v}`)
+        .join('_');
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    if (!identifiersConcat || !limitTag || !uniqueIdentify) {
+      throw new NoRetryError(
+        'identifiersConcat, limitTag, and uniqueIdentify are required.'
+      );
+    }
+
+    const runningTotalReservedId = `${identifiersConcat}_${limitTag}`;
+    const reservedRecord = await dynamodbSharedLib.getItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+      {
+        runningTotalReservedId,
+        usedTimestampId: uniqueIdentify
+      }
+    );
+
+    const usageCount = reservedRecord?.usageCount || 0;
+
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+      {
+        runningTotalReservedId,
+        usedTimestampId: uniqueIdentify
+      },
+      {
+        runningTotalUsageStatus: 'cancelled'
+      }
+    );
+
+    if (usageCount > 0) {
+      const usageRecord = await dynamodbSharedLib.getItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+        { identifiersConcat, limitTag }
+      );
+      if (usageRecord) {
+        const newTotal = Math.max(0, (usageRecord.totalCount || 0) - usageCount);
+        await dynamodbSharedLib.putItem(
+          _izContext,
+          dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+          {
+            identifiersConcat,
+            limitTag,
+            totalCount: newTotal,
+            updateUuid: _izContext.uniqueRequestId || `${Date.now()}`
+          }
+        );
+      }
+    }
+
+    await sns.publishMessage(_izContext, {
+      message: { returnResult: { status: true, uniqueIdentify } },
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        'CancelUsage_Out'
+      )
+    });
+  } catch (error) {
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:CancelUsage] error:`, error);
+    throw error;
+  }
+}

package/src/emit/rbac/templates/ConfirmUsage_Main.ejs

@@ -0,0 +1,71 @@
+/*
+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 { sns } from '@izara_project/izara-core-library-external-request';
+import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
+
+export default async function ConfirmUsage(_izContext, requestParams) {
+  try {
+    const submittedByUserId =
+      requestParams.submittedByUserId ||
+      _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+    const { limitTag, uniqueIdentify } = requestParams;
+
+    const targetIdentifiers = requestParams.targetIdentifiers;
+    let identifiersConcat = requestParams.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      identifiersConcat = Object.entries(targetIdentifiers)
+        .map(([k, v]) => `${k}#${v}`)
+        .join('_');
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    if (!identifiersConcat || !limitTag || !uniqueIdentify) {
+      throw new NoRetryError(
+        'identifiersConcat, limitTag, and uniqueIdentify are required.'
+      );
+    }
+
+    const runningTotalReservedId = `${identifiersConcat}_${limitTag}`;
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+      {
+        runningTotalReservedId,
+        usedTimestampId: uniqueIdentify
+      },
+      {
+        runningTotalUsageStatus: 'confirmed'
+      }
+    );
+
+    await sns.publishMessage(_izContext, {
+      message: { returnResult: { status: true, uniqueIdentify } },
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        'ConfirmUsage_Out'
+      )
+    });
+  } catch (error) {
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:ConfirmUsage] error:`, error);
+    throw error;
+  }
+}

package/src/emit/rbac/templates/CreateTargetRole_Main.ejs

@@ -23,23 +23,66 @@ import { consts } from '@izara_project/izara-core-library-core';
 
 export default async function CreateTargetRole(_izContext, requestParams) {
   try {
-    const userId = _izContext.correlationIds.get(consts.BASE_USER_ID);
-    const { roleName } = requestParams;
-    const roleId = identifierUuid();
+    const submittedByUserId =
+      requestParams.submittedByUserId ||
+      _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+
+    const targetIdentifiers = requestParams.targetIdentifiers;
+    let identifiersConcat = requestParams.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      identifiersConcat = Object.entries(targetIdentifiers)
+        .map(([k, v]) => `${k}#${v}`)
+        .join('_');
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    const { roleName = 'owner', roleId: inputRoleId } = requestParams;
+    const roleId = inputRoleId || roleName || identifierUuid();
+    const roleIdKey = `${identifiersConcat}_${roleId}`;
+
     await dynamodbSharedLib.putItem(
       _izContext,
       dynamodbSharedLib.tableName(_izContext, 'TargetRoles'),
-      { targetId: userId, roleIdKey: `${userId}_${roleId}`, roleName }
+      {
+        identifiersConcat,
+        roleIdKey,
+        roleName,
+        submittedByUserId
+      }
     );
+
+    if (submittedByUserId) {
+      try {
+        await dynamodbSharedLib.transactWriteItems(_izContext, [
+          {
+            Put: {
+              TableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
+              Item: { roleIdKey, submittedByUserId }
+            }
+          },
+          {
+            Put: {
+              TableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+              Item: { submittedByUserId, roleIdKey }
+            }
+          }
+        ]);
+      } catch (assignError) {
+        _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateTargetRole] UserRoles transactWrite ignored:', assignError);
+      }
+    }
+
     await sns.publishMessage(_izContext, {
-      message: { returnResult: { roleId } },
+      message: { returnResult: { roleId, roleIdKey } },
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'CreateTargetRole_Out'
       )
     });
   } catch (error) {
-    _izContext.logger.error('[Rbac:CreateTargetRole] error:', error);
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:CreateTargetRole] error:`, error);
     throw error;
   }
 }

package/src/emit/rbac/templates/ListRbac_Main.ejs

@@ -22,8 +22,14 @@ import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
 
 export default async function <%- flowTag %>(_izContext, requestParams) {
   try {
-    <% if (useContextUserId) { -%>
-    const userId = _izContext.correlationIds.get(consts.BASE_USER_ID);
+    <% if (flowTag === 'ListTargetRole') { -%>
+    const userId = requestParams.submittedByUserId || _izContext.correlationIds.get(consts.SUBMITTED_BY_USER_ID);
+    const identifiersConcat =
+      requestParams.identifiersConcat || requestParams.targetId || userId;
+    if (!identifiersConcat) throw new NoRetryError('Identifier not found.');
+    const queryParams = { identifiersConcat };
+    <% } else if (useContextUserId) { -%>
+    const userId = requestParams.submittedByUserId || _izContext.correlationIds.get(consts.SUBMITTED_BY_USER_ID);
     if (!userId) throw new NoRetryError('User Id not found.');
     const queryParams = { userId };
     <% } else { -%>
@@ -43,7 +49,7 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
       )
     });
   } catch (error) {
-    _izContext.logger.error('[Rbac:<%- flowTag %>] error:', error);
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>] error:`, error);
     throw error;
   }
 }

package/src/emit/rbac/templates/RbacMutation_Main.ejs

@@ -36,7 +36,7 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
       )
     });
   } catch (error) {
-    _izContext.logger.error('[Rbac:<%- flowTag %>] error:', error);
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>] error:`, error);
     throw error;
   }
 }

package/src/emit/rbac/templates/ReservedDynamicUsage_Main.ejs

@@ -0,0 +1,147 @@
+/*
+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 { sns } from '@izara_project/izara-core-library-external-request';
+import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
+
+export default async function ReservedDynamicUsage(_izContext, requestParams) {
+  try {
+    const submittedByUserId =
+      requestParams.submittedByUserId ||
+      _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+    const {
+      limitTag,
+      value = 1,
+      usedTimestamp = new Date().toISOString(),
+      roleLimitId
+    } = requestParams;
+
+    const targetIdentifiers = requestParams.targetIdentifiers;
+    let identifiersConcat = requestParams.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      identifiersConcat = Object.entries(targetIdentifiers)
+        .map(([k, v]) => `${k}#${v}`)
+        .join('_');
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    if (!identifiersConcat) {
+      throw new NoRetryError('Identifier not found.');
+    }
+    if (!limitTag) {
+      throw new NoRetryError('limitTag is required.');
+    }
+
+    const uniqueIdentify = `${usedTimestamp}_${_izContext.uniqueRequestId || Date.now()}`;
+    const roleLimitKeys = Array.isArray(requestParams.roleLimitIds)
+      ? requestParams.roleLimitIds
+      : [roleLimitId || `${identifiersConcat}_${limitTag}`];
+
+    let maxLimit = Infinity;
+    const limitRecords = [];
+
+    for (const key of roleLimitKeys) {
+      const record = await dynamodbSharedLib.getItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RoleLimit'),
+        { roleLimitId: key, limitType: 'runningTotal' }
+      );
+      if (record && typeof record.limitValue === 'number') {
+        limitRecords.push(record);
+      }
+    }
+
+    if (limitRecords.length > 0) {
+      const isDecrease = (rec) =>
+        rec.effect === 'decrease' ||
+        rec.actionType === 'decrease' ||
+        rec.action === 'decrease';
+
+      const increaseLimits = limitRecords.filter((rec) => !isDecrease(rec));
+      const decreaseLimits = limitRecords.filter((rec) => isDecrease(rec));
+
+      const maxIncrease =
+        increaseLimits.length > 0
+          ? Math.max(...increaseLimits.map((r) => r.limitValue))
+          : Infinity;
+      const minDecrease =
+        decreaseLimits.length > 0
+          ? Math.min(...decreaseLimits.map((r) => r.limitValue))
+          : Infinity;
+
+      maxLimit = Math.min(maxIncrease, minDecrease);
+    }
+
+    const usageRecord = await dynamodbSharedLib.getItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+      { identifiersConcat, limitTag }
+    );
+    const currentTotal = usageRecord?.totalCount || 0;
+
+    let passStatus = false;
+    if (currentTotal + value <= maxLimit) {
+      passStatus = true;
+      const ttlTimestamp = Math.floor(Date.now() / 1000) + 3600;
+
+      await dynamodbSharedLib.putItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+        {
+          runningTotalReservedId: `${identifiersConcat}_${limitTag}`,
+          usedTimestampId: uniqueIdentify,
+          usageCount: value,
+          runningTotalUsageStatus: 'reserved',
+          ttlTimestamp
+        }
+      );
+
+      await dynamodbSharedLib.putItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+        {
+          identifiersConcat,
+          limitTag,
+          totalCount: currentTotal + value,
+          updateUuid: _izContext.uniqueRequestId || `${Date.now()}`
+        }
+      );
+    }
+
+    const returnResult = {
+      passStatus,
+      uniqueIdentify,
+      limitTag,
+      identifiersConcat
+    };
+
+    await sns.publishMessage(_izContext, {
+      message: { returnResult },
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        'ReservedDynamicUsage_Out'
+      )
+    });
+  } catch (error) {
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:ReservedDynamicUsage] error:`, error);
+    throw error;
+  }
+}

package/src/emit/rbac/templates/UserRbacFlow_Main.ejs

@@ -48,11 +48,11 @@ function _setL1Cache(key, value) {
 // ── L2 Cache (Shared DynamoDB TTL Cache) ──────────────────────────────────────
 const L2_TTL_SECONDS = 5 * 60; // 5 minutes
 
-async function _getL2Cache(_izContext, userId, cacheSubKey) {
+async function _getL2Cache(_izContext, submittedByUserId, cacheSubKey) {
   try {
     const tableName = dynamodbSharedLib.tableName(_izContext, 'RbacPermissionCaches');
     const result = await dynamodbSharedLib.getItem(_izContext, tableName, {
-      userId,
+      submittedByUserId,
       cacheKey: cacheSubKey
     });
     if (result && result.ttlTimestamp && result.ttlTimestamp > Math.floor(Date.now() / 1000)) {
@@ -72,12 +72,12 @@ async function _getL2Cache(_izContext, userId, cacheSubKey) {
   return null;
 }
 
-async function _setL2Cache(_izContext, userId, cacheSubKey, value) {
+async function _setL2Cache(_izContext, submittedByUserId, cacheSubKey, value) {
   try {
     const tableName = dynamodbSharedLib.tableName(_izContext, 'RbacPermissionCaches');
     const ttlTimestamp = Math.floor(Date.now() / 1000) + L2_TTL_SECONDS;
     await dynamodbSharedLib.putItem(_izContext, tableName, {
-      userId,
+      submittedByUserId,
       cacheKey: cacheSubKey,
       permission: value.returnValue ? value.returnValue.permission : value.permission,
       roleIdKey: value.returnValue ? value.returnValue.roleIdKey : value.roleIdKey,
@@ -90,10 +90,17 @@ async function _setL2Cache(_izContext, userId, cacheSubKey, value) {
 }
 
 export default async function <%- flowTag %>(_izContext, requestParams = {}) {
-  const userId = _izContext.correlationIds.get(consts.BASE_USER_ID);
-  const targetId = _izContext.correlationIds.get(consts.TARGET_ID);
-  if (!userId || !targetId) {
-    throw new Error('Missing required request parameters: userId or targetId');
+  const submittedByUserId =
+    requestParams.submittedByUserId ||
+    _izContext.correlationIds.get(consts.SUBMITTED_BY_USER_ID);
+
+  const targetIdentifiers = requestParams.targetIdentifiers;
+  let targetId = targetIdentifiers && typeof targetIdentifiers === 'object'
+    ? Object.entries(targetIdentifiers).map(([k, v]) => `${k}#${v}`).join('_')
+    : undefined;
+
+  if (!submittedByUserId || !targetIdentifiers) {
+    throw new Error('Missing required request parameters: submittedByUserId or targetIdentifiers');
   }
 
   const { flowTypeConcat, inputParameterGroups, parentFlowId } = requestParams;
@@ -101,40 +108,69 @@ export default async function <%- flowTag %>(_izContext, requestParams = {}) {
     throw new Error('Missing flowTypeConcat in requestParams');
   }
 
-  _izContext.logger.debug('[<%- flowTag %>] requestParams:', {
-    userId,
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] requestParams:', {
+    submittedByUserId,
     targetId,
     flowTypeConcat,
     inputParameterGroups
   });
 
   const cacheSubKey = `${targetId}#${flowTypeConcat}#${JSON.stringify(inputParameterGroups || {})}`;
-  const fullCacheKey = `${userId}:${cacheSubKey}`;
+  const fullCacheKey = `${submittedByUserId}:${cacheSubKey}`;
+
+  // ── Fast-path for User Self-Action (submittedByUserId === targetId) ───────────────────
+  const isSelfUser = Boolean(
+    submittedByUserId &&
+      targetId &&
+      (submittedByUserId === targetId ||
+        targetId === `user#${submittedByUserId}` ||
+        targetId === `submittedByUserId#${submittedByUserId}`)
+  );
+
+  if (isSelfUser) {
+    _izContext.logger.debug(
+      '[<%- flowTag %>] Fast-path triggered: user self-action',
+      { submittedByUserId, targetId }
+    );
+    const result = {
+      returnValue: {
+        permission: true,
+        roleIdKey: 'self_user',
+        rbacType: 'self_user'
+      },
+      errorsFound: [],
+      status: 'Completed'
+    };
+    _setL1Cache(fullCacheKey, result);
+    await _setL2Cache(_izContext, submittedByUserId, cacheSubKey, result);
+    await _publicMessageOut(_izContext, { ...result, parentFlowId });
+    return 'Completed';
+  }
 
   // 1. Check L1 In-Memory Cache
   const l1Hit = _getL1Cache(fullCacheKey);
   if (l1Hit) {
-    _izContext.logger.debug('[<%- flowTag %>] L1 Cache hit:', l1Hit);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] L1 Cache hit:', l1Hit);
     await _publicMessageOut(_izContext, { ...l1Hit, parentFlowId });
     return;
   }
 
   // 2. Check L2 Shared DynamoDB Cache
-  const l2Hit = await _getL2Cache(_izContext, userId, cacheSubKey);
+  const l2Hit = await _getL2Cache(_izContext, submittedByUserId, cacheSubKey);
   if (l2Hit) {
-    _izContext.logger.debug('[<%- flowTag %>] L2 Cache hit:', l2Hit);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] L2 Cache hit:', l2Hit);
     _setL1Cache(fullCacheKey, l2Hit);
     await _publicMessageOut(_izContext, { ...l2Hit, parentFlowId });
     return;
   }
 
-  _izContext.logger.debug('[<%- flowTag %>] Cache miss — querying DynamoDB');
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Cache miss — querying DynamoDB');
 
   // 3. Fallback to DB Query
   const userRolesResult = await dynamodbSharedLib.query(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
-    { userId }
+    { submittedByUserId }
   );
 
   let userRoles = [];
@@ -144,7 +180,7 @@ export default async function <%- flowTag %>(_izContext, requestParams = {}) {
     userRoles = userRolesResult.Items;
   }
 
-  _izContext.logger.debug('[<%- flowTag %>] userRoles fetched:', { userRoles });
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] userRoles fetched:', { userRoles });
 
   const targetIdPrefix = `${targetId}_`;
   const targetRoles = [];
@@ -154,13 +190,13 @@ export default async function <%- flowTag %>(_izContext, requestParams = {}) {
     }
   }
 
-  _izContext.logger.debug('[<%- flowTag %>] targetRoles filtered:', {
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] targetRoles filtered:', {
     targetIdPrefix,
     targetRoles
   });
 
   if (targetRoles.length === 0) {
-    _izContext.logger.debug('[<%- flowTag %>] no targetRoles found, permission denied');
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] no targetRoles found, permission denied');
     const result = {
       returnValue: {
         permission: false,
@@ -171,7 +207,7 @@ export default async function <%- flowTag %>(_izContext, requestParams = {}) {
       status: 'Completed'
     };
     _setL1Cache(fullCacheKey, result);
-    await _setL2Cache(_izContext, userId, cacheSubKey, result);
+    await _setL2Cache(_izContext, submittedByUserId, cacheSubKey, result);
     await _publicMessageOut(_izContext, { ...result, parentFlowId });
     return;
   }
@@ -189,7 +225,7 @@ export default async function <%- flowTag %>(_izContext, requestParams = {}) {
     })
   );
 
-  _izContext.logger.debug('[<%- flowTag %>] rolePermissions fetched:', {
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] rolePermissions fetched:', {
     rolePermissions
   });
 
@@ -217,11 +253,11 @@ export default async function <%- flowTag %>(_izContext, requestParams = {}) {
     status: 'Completed'
   };
 
-  _izContext.logger.debug('[<%- flowTag %>] validation result:', cacheResult);
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] validation result:', cacheResult);
 
   // Store in L1 & L2 Cache
   _setL1Cache(fullCacheKey, cacheResult);
-  await _setL2Cache(_izContext, userId, cacheSubKey, cacheResult);
+  await _setL2Cache(_izContext, submittedByUserId, cacheSubKey, cacheResult);
 
   await _publicMessageOut(_izContext, { ...cacheResult, parentFlowId });
 

package/src/emit/rbac/templates/UserRoleMutation_Main.ejs

@@ -47,7 +47,7 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
       )
     });
   } catch (error) {
-    _izContext.logger.error('[Rbac:<%- flowTag %>] error:', error);
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>] error:`, error);
     throw error;
   }
 }

package/src/emit/relationship/emitDynamicRelationshipFlowSchemas.js

@@ -96,7 +96,7 @@ function createDynamicRelationshipFlow(action) {
 
   return {
     flowTag: action,
-    initiateBy: 'systemWithNoUser',
+    initiateBy: 'systemNoUser',
     handleObj: 'one',
     statusType: 'none',
     event: outputTopic

package/src/emit/relationship/templates/ChangeRelationship_Main.ejs

@@ -78,7 +78,7 @@ export default async function <%- functionName %>(
 
     let originTimestamp = Date.now();
     let changedByUserId = _izContext.correlationIds.get(
-      coreConsts.BASE_USER_ID
+      coreConsts.SUBMITTED_BY_USER_ID
     );
     const {
       firstObject,
@@ -191,14 +191,14 @@ export default async function <%- functionName %>(
             */
             // ? [Fix]: The legacy logic incorrectly blocked "user" from regular execution and allowed non-user values.
             // ? It has been corrected to require changeBy === "user" for normal execution.
-            const isUserProcess = Boolean(_izContext.correlationIds?.get(consts.BASE_USER_ID));
+            const isUserProcess = Boolean(_izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID));
             if (isUserProcess) {
               if (canChangeToRelType.changeBy !== 'user' && canChangeToRelType.changeBy !== 'systemWithUser') {
                 errorsFound.push(`CanChangeToRelType changeBy is not user or systemWithUser`);
               }
             } else {
-              if (canChangeToRelType.changeBy !== 'systemWithNoUser' && canChangeToRelType.changeBy !== 'system') {
-                errorsFound.push(`CanChangeToRelType changeBy is not systemWithNoUser`);
+              if (canChangeToRelType.changeBy !== 'systemNoUser') {
+                errorsFound.push(`CanChangeToRelType changeBy is not systemNoUser`);
               }
             }
           }