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

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

@@ -0,0 +1,163 @@
+/*
+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 {
+    let runningTotalReservedId =
+      requestParams?.runningTotalReservedId ||
+      requestParams?.reservedId ||
+      requestParams?.runningTotalReservedUsageId;
+
+    const usedTimestampId =
+      requestParams?.usedTimestampId ||
+      requestParams?.uniqueIdentify;
+
+    const submittedByUserId =
+      requestParams?.submittedByUserId ||
+      _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+    const flowTypeConcat =
+      requestParams?.flowTypeConcat ||
+      requestParams?.limitTag;
+
+    const targetIdentifiers = requestParams?.targetIdentifiers;
+    let identifiersConcat = requestParams?.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    if (!runningTotalReservedId) {
+      if (identifiersConcat && flowTypeConcat) {
+        runningTotalReservedId = `${identifiersConcat}_${flowTypeConcat}`;
+      }
+    }
+
+    if (!runningTotalReservedId || !usedTimestampId) {
+      throw new NoRetryError(
+        'runningTotalReservedId (or identifiersConcat + flowTypeConcat) and usedTimestampId (or uniqueIdentify) are required.'
+      );
+    }
+
+    const reservedRecord = await dynamodbSharedLib.getItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+      {
+        runningTotalReservedId,
+        usedTimestampId
+      }
+    );
+
+    const usageCount = reservedRecord?.usageCount || 0;
+
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+      {
+        runningTotalReservedId,
+        usedTimestampId
+      },
+      {
+        runningTotalUsageStatus: 'cancelled'
+      }
+    );
+
+    if (usageCount > 0 && identifiersConcat && flowTypeConcat) {
+      const usageRecord = await dynamodbSharedLib.getItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+        { identifiersConcat, flowTypeConcat }
+      );
+      if (usageRecord) {
+        const currentTotal = usageRecord.totalCount || 0;
+        const newTotal = Math.max(0, currentTotal - usageCount);
+        const queryElementsWhenUpdate = {
+          additionalAttributes: { currentUuid: usageRecord.updateUuid },
+          logicalElements: [
+            {
+              type: 'logical',
+              comparison: 'equals',
+              lhsAttribute: 'updateUuid',
+              rhsReference: 'currentUuid'
+            }
+          ],
+          returnValues: 'ALL_NEW'
+        };
+
+        const updateAttributes = [
+          { attributeName: 'totalCount', action: 'set', value: newTotal },
+          { attributeName: 'updateUuid', action: 'set', value: _izContext.uniqueRequestId || `${Date.now()}` }
+        ];
+
+        await dynamodbSharedLib.updateItem(
+          _izContext,
+          dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+          { identifiersConcat, flowTypeConcat },
+          updateAttributes,
+          queryElementsWhenUpdate,
+          {
+            complexAttributes: true,
+            errorOnConditionalExpNotPass: false
+          }
+        ).catch(() => null);
+      }
+    }
+
+    await sns.publishMessage(_izContext, {
+      message: {
+        returnResult: {
+          status: true,
+          uniqueIdentify: usedTimestampId,
+          usedTimestampId,
+          runningTotalReservedId
+        }
+      },
+      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,187 @@
+/*
+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 {
+    let runningTotalReservedId =
+      requestParams?.runningTotalReservedId ||
+      requestParams?.reservedId ||
+      requestParams?.runningTotalReservedUsageId;
+
+    const usedTimestampId =
+      requestParams?.usedTimestampId ||
+      requestParams?.uniqueIdentify;
+
+    const submittedByUserId =
+      requestParams?.submittedByUserId ||
+      _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+    const flowTypeConcat =
+      requestParams?.flowTypeConcat ||
+      requestParams?.limitTag;
+
+    const targetIdentifiers = requestParams?.targetIdentifiers;
+    let identifiersConcat = requestParams?.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    if (!runningTotalReservedId) {
+      if (identifiersConcat && flowTypeConcat) {
+        runningTotalReservedId = `${identifiersConcat}_${flowTypeConcat}`;
+      }
+    }
+
+    if (!runningTotalReservedId || !usedTimestampId) {
+      throw new NoRetryError(
+        'runningTotalReservedId (or identifiersConcat + flowTypeConcat) and usedTimestampId (or uniqueIdentify) are required.'
+      );
+    }
+
+    const reservedTable = dynamodbSharedLib.tableName(
+      _izContext,
+      'RunningTotalReservedUsage'
+    );
+
+    const reservedRecord = await dynamodbSharedLib
+      .getItem(_izContext, reservedTable, {
+        runningTotalReservedId,
+        usedTimestampId
+      })
+      .catch(() => null);
+
+    let usageCount = 1;
+    if (reservedRecord && typeof reservedRecord.usageCount === 'number') {
+      usageCount = reservedRecord.usageCount;
+    }
+
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      reservedTable,
+      {
+        runningTotalReservedId,
+        usedTimestampId
+      },
+      {
+        runningTotalUsageStatus: 'confirmed',
+        confirmedAt: new Date().toISOString()
+      }
+    );
+
+    if (identifiersConcat && flowTypeConcat) {
+      const usageTable = dynamodbSharedLib.tableName(
+        _izContext,
+        'RunningTotalUsage'
+      );
+
+      const usageRecord = await dynamodbSharedLib
+        .getItem(_izContext, usageTable, {
+          identifiersConcat,
+          flowTypeConcat
+        })
+        .catch(() => null);
+
+      let currentTotal = 0;
+      let queryElementsWhenUpdate = {};
+
+      if (usageRecord && typeof usageRecord.totalCount === 'number') {
+        currentTotal = usageRecord.totalCount;
+        queryElementsWhenUpdate = {
+          additionalAttributes: { currentUuid: usageRecord.updateUuid },
+          logicalElements: [
+            {
+              type: 'logical',
+              comparison: 'equals',
+              lhsAttribute: 'updateUuid',
+              rhsReference: 'currentUuid'
+            }
+          ],
+          returnValues: 'ALL_NEW'
+        };
+      } else {
+        queryElementsWhenUpdate = {
+          logicalElements: dynamodbSharedLib.generateNotExistLogicalElements({
+            identifiersConcat,
+            flowTypeConcat
+          }),
+          returnValues: 'ALL_NEW'
+        };
+      }
+
+      const updateAttributes = [
+        { attributeName: 'totalCount', action: 'set', value: currentTotal + usageCount },
+        { attributeName: 'updateUuid', action: 'set', value: _izContext.uniqueRequestId || `${Date.now()}` }
+      ];
+
+      await dynamodbSharedLib.updateItem(
+        _izContext,
+        usageTable,
+        { identifiersConcat, flowTypeConcat },
+        updateAttributes,
+        queryElementsWhenUpdate,
+        {
+          complexAttributes: true,
+          errorOnConditionalExpNotPass: false
+        }
+      ).catch(() => null);
+    }
+
+    await sns.publishMessage(_izContext, {
+      message: {
+        returnResult: {
+          status: true,
+          uniqueIdentify: usedTimestampId,
+          usedTimestampId,
+          runningTotalReservedId
+        }
+      },
+      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,85 @@ 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') {
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.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, [
+          {
+            action: 'put',
+            params: {
+              tableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
+              attributes: { roleIdKey, submittedByUserId }
+            }
+          },
+          {
+            action: 'put',
+            params: {
+              tableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+              attributes: { 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,166 @@
+/*
+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 flowTypeConcat =
+      requestParams.flowTypeConcat ||
+      requestParams.limitTag;
+    const {
+      value = 1,
+      usedTimestamp = new Date().toISOString(),
+      roleLimitId
+    } = requestParams;
+
+    const targetIdentifiers = requestParams.targetIdentifiers;
+    let identifiersConcat = requestParams.identifiersConcat;
+    if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
+    }
+    if (!identifiersConcat) {
+      identifiersConcat = submittedByUserId;
+    }
+
+    if (!identifiersConcat) {
+      throw new NoRetryError('Identifier not found.');
+    }
+    if (!flowTypeConcat) {
+      throw new NoRetryError('flowTypeConcat (or limitTag) is required.');
+    }
+
+    const uniqueIdentify = `${usedTimestamp}_${_izContext.uniqueRequestId || Date.now()}`;
+    const roleLimitKeys = Array.isArray(requestParams.roleLimitIds)
+      ? requestParams.roleLimitIds
+      : [roleLimitId || `${identifiersConcat}_${flowTypeConcat}`];
+
+    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, flowTypeConcat }
+    );
+    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}_${flowTypeConcat}`,
+          usedTimestampId: uniqueIdentify,
+          usageCount: value,
+          runningTotalUsageStatus: 'reserved',
+          ttlTimestamp
+        }
+      );
+
+      await dynamodbSharedLib.putItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+        {
+          identifiersConcat,
+          flowTypeConcat,
+          totalCount: currentTotal + value,
+          updateUuid: _izContext.uniqueRequestId || `${Date.now()}`
+        }
+      );
+    }
+
+    const returnResult = {
+      passStatus,
+      uniqueIdentify,
+      flowTypeConcat,
+      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;
+  }
+}