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

package/src/emit/rbac/emitRbacApplicationArtifacts.js

@@ -10,6 +10,7 @@ import {
 import { rbacFlowTag } from './rbacFlowTag.js';
 
 const FLOW_RBAC_YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-rbac.yml';
+const FLOW_LIMITS_YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-limits.yml';
 const CRUD_TEMPLATE_URL = new URL('../crud/templates/', import.meta.url);
 const RBAC_TEMPLATE_URL = new URL('./templates/', import.meta.url);
 
@@ -23,7 +24,8 @@ export async function emitRbacApplicationArtifacts(objects) {
   }
   const hasSelfRbac = objects.some(hasSelfRbacAddOn);
   const flowTags = [...new Set(rbacObjects.map(rbacFlowTag))];
-  const handlers = await Promise.all([
+
+  const rbacHandlers = await Promise.all([
     ...(hasSelfRbac
       ? [
           createTargetRoleHandler(),
@@ -34,23 +36,47 @@ export async function emitRbacApplicationArtifacts(objects) {
       : []),
     ...flowTags.map(createUserRbacFlowHandler)
   ]);
-  return [
-    ...handlers.flatMap((handler) => handler.artifacts),
+
+  const limitHandlers = await Promise.all(
+    hasSelfRbac
+      ? [
+          ...LIMIT_LIST_DEFINITIONS.map(createLimitListHandler),
+          ...LIMIT_MUTATION_DEFINITIONS.map(createLimitMutationHandler),
+          ...ACCOUNT_LIMIT_HANDLERS.map(createAccountLimitHandler)
+        ]
+      : []
+  );
+
+  const artifacts = [
+    ...rbacHandlers.flatMap((handler) => handler.artifacts),
+    ...limitHandlers.flatMap((handler) => handler.artifacts),
     {
       path: FLOW_RBAC_YAML_PATH,
-      content: handlers
+      content: rbacHandlers
         .flatMap((handler) => handler.functions)
         .map(renderFunctionYaml)
         .join('\n')
     }
   ];
+
+  if (hasSelfRbac) {
+    artifacts.push({
+      path: FLOW_LIMITS_YAML_PATH,
+      content: limitHandlers
+        .flatMap((handler) => handler.functions)
+        .map(renderFunctionYaml)
+        .join('\n')
+    });
+  }
+
+  return artifacts;
 }
 
 const LIST_DEFINITIONS = [
   {
     flowTag: 'ListTargetRole',
     tableName: 'TargetRoles',
-    requestProperty: 'userId',
+    requestProperty: 'identifiersConcat',
     useContextUserId: true
   },
   {
@@ -64,6 +90,15 @@ const LIST_DEFINITIONS = [
     requestProperty: 'roleIdKey'
   }
 ];
+
+const LIMIT_LIST_DEFINITIONS = [
+  {
+    flowTag: 'ListRoleLimits',
+    tableName: 'RoleLimit',
+    requestProperty: 'roleLimitId'
+  }
+];
+
 const MUTATION_DEFINITIONS = [
   {
     flowTag: 'CreateRolePermissions',
@@ -81,14 +116,36 @@ const MUTATION_DEFINITIONS = [
     flowTag: 'DeleteTargetRole',
     tableName: 'TargetRoles',
     method: 'deleteItem',
-    fields: ['targetId', 'roleIdKey']
+    fields: ['identifiersConcat', 'roleIdKey']
   }
 ];
+
+const LIMIT_MUTATION_DEFINITIONS = [
+  {
+    flowTag: 'CreateRoleLimit',
+    tableName: 'RoleLimit',
+    method: 'putItem',
+    fields: ['roleLimitId', 'limitType', 'limitValue', 'actionType']
+  },
+  {
+    flowTag: 'DeleteRoleLimit',
+    tableName: 'RoleLimit',
+    method: 'deleteItem',
+    fields: ['roleLimitId', 'limitType']
+  }
+];
+
 const USER_ROLE_MUTATIONS = [
   { flowTag: 'CreateUserRole', operation: 'Put' },
   { flowTag: 'DeleteUserFromRole', operation: 'Delete' }
 ];
 
+const ACCOUNT_LIMIT_HANDLERS = [
+  'ReservedDynamicUsage',
+  'ConfirmUsage',
+  'CancelUsage'
+];
+
 const STATIC_RBAC_APPLICATION_PATHS = [
   'app/src/generatedCode/FlowRbac/CreateTargetRole/source/CreateTargetRole_Main.js',
   'app/src/generatedCode/FlowRbac/CreateTargetRole/source/CreateTargetRole_HdrSqs.js',
@@ -118,6 +175,27 @@ const STATIC_RBAC_APPLICATION_PATHS = [
   FLOW_RBAC_YAML_PATH
 ];
 
+const STATIC_LIMIT_APPLICATION_PATHS = [
+  ...LIMIT_LIST_DEFINITIONS.flatMap(({ flowTag }) => [
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_Main.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrSqs.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrApi.js`
+  ]),
+  ...LIMIT_MUTATION_DEFINITIONS.flatMap(({ flowTag }) => [
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_Main.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrSqs.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_WbsMain.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrWbs.js`
+  ]),
+  ...ACCOUNT_LIMIT_HANDLERS.flatMap((flowTag) => [
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_Main.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrSqs.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_WbsMain.js`,
+    `app/src/generatedCode/FlowLimit/${flowTag}/source/${flowTag}_HdrWbs.js`
+  ]),
+  FLOW_LIMITS_YAML_PATH
+];
+
 export function rbacApplicationManagedPaths(objects = []) {
   if (!Array.isArray(objects)) {
     throw new TypeError('objects must be an array');
@@ -131,7 +209,126 @@ export function rbacApplicationManagedPaths(objects = []) {
       `${sourcePath}/${flowTag}_HdrSqs.js`
     ];
   });
-  return [...new Set([...STATIC_RBAC_APPLICATION_PATHS, ...sourcePaths])];
+  return [
+    ...new Set([
+      ...STATIC_RBAC_APPLICATION_PATHS,
+      ...STATIC_LIMIT_APPLICATION_PATHS,
+      ...sourcePaths
+    ])
+  ];
+}
+
+async function createAccountLimitHandler(flowTag) {
+  const sourcePath = `app/src/generatedCode/FlowLimit/${flowTag}/source`;
+  const handlerPath = `src/generatedCode/FlowLimit/${flowTag}/source`;
+  const webSocket = await createWebSocketEntry(
+    flowTag,
+    sourcePath,
+    handlerPath
+  );
+  return {
+    artifacts: [
+      {
+        path: `${sourcePath}/${flowTag}_Main.js`,
+        content: await renderRbacTemplate(`${flowTag}_Main.ejs`, { flowTag })
+      },
+      {
+        path: `${sourcePath}/${flowTag}_HdrSqs.js`,
+        content: await renderRbacTemplate('ListRbac_HdrSqs.ejs', { flowTag })
+      },
+      ...webSocket.artifacts
+    ],
+    functions: [
+      {
+        type: 'sqs',
+        functionName: `${flowTag}HdrSqs`,
+        handlerPath: `${handlerPath}/${flowTag}_HdrSqs.main`,
+        roleName: 'FlowRbacRole',
+        queueName: `${flowTag}HdrSqs`,
+        flowTag: flowTag,
+        flowStepName: ''
+      },
+      ...webSocket.functions
+    ]
+  };
+}
+
+async function createLimitListHandler(definition) {
+  const sourcePath = `app/src/generatedCode/FlowLimit/${definition.flowTag}/source`;
+  const handlerPath = `src/generatedCode/FlowLimit/${definition.flowTag}/source`;
+  return {
+    artifacts: [
+      {
+        path: `${sourcePath}/${definition.flowTag}_Main.js`,
+        content: await renderRbacTemplate('ListRbac_Main.ejs', {
+          ...definition,
+          useContextUserId: definition.useContextUserId ?? false
+        })
+      },
+      {
+        path: `${sourcePath}/${definition.flowTag}_HdrSqs.js`,
+        content: await renderRbacTemplate('ListRbac_HdrSqs.ejs', definition)
+      },
+      {
+        path: `${sourcePath}/${definition.flowTag}_HdrApi.js`,
+        content: await renderRbacTemplate('ListRbac_HdrApi.ejs', definition)
+      }
+    ],
+    functions: [
+      {
+        type: 'sqs',
+        functionName: `${definition.flowTag}HdrSqs`,
+        handlerPath: `${handlerPath}/${definition.flowTag}_HdrSqs.main`,
+        roleName: 'FlowRbacRole',
+        queueName: `${definition.flowTag}HdrSqs`,
+        flowTag: definition.flowTag,
+        flowStepName: ''
+      },
+      {
+        type: 'api',
+        functionName: `${definition.flowTag}HdrApi`,
+        handlerPath: `${handlerPath}/${definition.flowTag}_HdrApi.main`,
+        roleName: 'FlowRbacRole',
+        flowTag: definition.flowTag,
+        flowStepName: ''
+      }
+    ]
+  };
+}
+
+async function createLimitMutationHandler(definition) {
+  const sourcePath = `app/src/generatedCode/FlowLimit/${definition.flowTag}/source`;
+  const handlerPath = `src/generatedCode/FlowLimit/${definition.flowTag}/source`;
+  const webSocket = await createWebSocketEntry(
+    definition.flowTag,
+    sourcePath,
+    handlerPath
+  );
+  return {
+    artifacts: [
+      {
+        path: `${sourcePath}/${definition.flowTag}_Main.js`,
+        content: await renderRbacTemplate('RbacMutation_Main.ejs', definition)
+      },
+      {
+        path: `${sourcePath}/${definition.flowTag}_HdrSqs.js`,
+        content: await renderRbacTemplate('ListRbac_HdrSqs.ejs', definition)
+      },
+      ...webSocket.artifacts
+    ],
+    functions: [
+      {
+        type: 'sqs',
+        functionName: `${definition.flowTag}HdrSqs`,
+        handlerPath: `${handlerPath}/${definition.flowTag}_HdrSqs.main`,
+        roleName: 'FlowRbacRole',
+        queueName: `${definition.flowTag}HdrSqs`,
+        flowTag: definition.flowTag,
+        flowStepName: ''
+      },
+      ...webSocket.functions
+    ]
+  };
 }
 
 async function createTargetRoleHandler() {

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;
   }
 }