@izara_project/izara-core-generate-service-code 1.0.74 → 1.0.75

package/src/emit/system/templates/RegisterWbs_Yaml.ejs

@@ -0,0 +1,7 @@
+RegisterWbs:
+  handler: src/generatedCode/SystemFlowSchemas/Register/source/Register_HdrWbs.main
+  name: ${self:custom.iz_resourcePrefix}RegisterWbs
+  role: RegisterRole
+  events:
+    - websocket:
+        route: register

package/src/emit/system/templates/Register_HdrWbs.ejs

@@ -0,0 +1,56 @@
+import { middlewareHandler as middleware, consts, response } from '@izara_project/izara-middleware';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import registerMain from './Register_Main.js';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import { webSocket } from '@izara_project/izara-core-library-external-request';
+const { postToConnection } = webSocket;
+
+export const main = middleware.wrap(async (event, context) => {
+  event._izContext.logger.debug('Event:', event);
+
+  try {
+    if (event.requestContext) {
+      const route = event.requestContext.routeKey;
+      const connectionId = event.requestContext.connectionId;
+      let correlationId = event._izContext.correlationIds.get(consts.X_CORRELATION_ID);
+
+      switch (route) {
+        case '$default':
+          console.log('Received unknown route:', route);
+          break;
+        case 'register':
+          console.log('event in route register', event);
+          let eventParams = JSON.parse(event.body);
+
+          await dynamodbSharedLib.putItem(
+            event._izContext,
+            await dynamodbSharedLib.tableName(event._izContext, 'WebSocketTask'),
+            {
+              taskKey: correlationId,
+              connectionId: connectionId
+            }
+          );
+
+          let callingFlow = eventParams?.callingFlow ? eventParams.callingFlow : {};
+
+          await registerMain(
+            event._izContext,
+            eventParams,
+            callingFlowSharedLib.addCallingFlowToPassOnProperties(callingFlow)
+          );
+          break;
+      }
+    } else {
+      const connId = event.connId;
+      await postToConnection({ message: event.message }, connId);
+    }
+    return response.webSocketSuccess();
+  } catch (err) {
+    const connId = event.requestContext?.connectionId;
+    event._izContext.logger.error('Error, WebSocket: ', err);
+    if (connId) {
+      await postToConnection({ message: err.message }, connId);
+    }
+    return response.failure(err);
+  }
+});

package/src/emit/system/templates/Register_Main.ejs

@@ -0,0 +1,148 @@
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+import { getObjectSchema, identifiersObject } from '@izara_project/izara-core-library-service-schemas';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import { lambda, webSocket } from '@izara_project/izara-core-library-external-request';
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+import { consts } from '@izara_project/izara-middleware';
+const { postToConnection } = webSocket;
+
+/**
+ * Register main handler
+ * @param {Object} _izContext
+ * @param {Object} requestParams
+ * @param {Object} callingFlowConfig
+ */
+export default async function registerMain(
+  _izContext,
+  requestParams,
+  callingFlowConfig = {}
+) {
+  try {
+    let connectionId = _izContext.correlationIds.get(consts.CONNECTION_ID);
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
+      flowTag: requestParams.flowTag,
+      serviceTag: process.env.iz_serviceTag
+    });
+
+    _izContext.logger.debug('flowSchema', flowSchema);
+    if (!flowSchema) {
+      throw new NoRetryError(`flowTag not found ${requestParams.flowTag}`);
+    }
+
+    const getResult = async (objType) => {
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+        _izContext,
+        {
+          objectType: objType.objectType,
+          serviceTag: objType.serviceTag
+        }
+      );
+
+      _izContext.logger.debug('==> objectSchema', objectSchema);
+
+      const result = await lambda.invokeSync(
+        _izContext,
+        await lambdaSharedLib.lambdaFunctionName(_izContext, 'GetHdrInv'),
+        {
+          identifiers: await identifiersObject.identifiersFromIdentifiersConcat(
+            _izContext,
+            objType,
+            requestParams.identifiersTask
+          ),
+          objectType: objType.objectType
+        }
+      );
+
+      if (!result) {
+        await postToConnection({ message: 'not have record' }, connectionId);
+      } else {
+        for (const [fieldName, fieldNameSetting] of Object.entries(
+          objectSchema.fieldNames
+        )) {
+          if (
+            fieldNameSetting.hasOwnProperty('statusField') &&
+            fieldNameSetting.statusField === true
+          ) {
+            if (
+              result.fields[fieldName] !== 'complete' &&
+              result.fields[fieldName] !== 'error'
+            ) {
+              await dynamodbSharedLib.putItem(
+                _izContext,
+                await dynamodbSharedLib.tableName(_izContext, 'RegisterRecords'),
+                {
+                  identifiersTask: requestParams.identifiersTask,
+                  connectionId: connectionId
+                }
+              );
+            } else {
+              await postToConnection({ message: result }, connectionId);
+            }
+          }
+        }
+      }
+    };
+
+    switch (flowSchema.statusType) {
+      case 'statusField':
+        await getResult(flowSchema.objType);
+        break;
+      case 'storedCache':
+        await getResult(flowSchema.objType);
+        break;
+      case 'triggerCache':
+        await getResult(flowSchema.objType);
+        break;
+      case 'none': {
+        let identifier = {};
+        if (
+          requestParams.hasOwnProperty('identifiersField') &&
+          Array.isArray(requestParams.identifiersField)
+        ) {
+          for (const fieldNames of requestParams.identifiersField) {
+            Object.assign(identifier, {
+              [fieldNames]: requestParams[fieldNames]
+            });
+          }
+        } else {
+          let pureRequestParams = structuredClone(requestParams);
+          delete pureRequestParams.flowTag;
+          identifier = pureRequestParams;
+        }
+
+        let tasks = await dynamodbSharedLib.query(
+          _izContext,
+          await dynamodbSharedLib.tableName(_izContext, 'RegisterRecords'),
+          {
+            identifiersTask: hash(identifier)
+          }
+        );
+        if (tasks.Items && tasks.Items.length > 0) {
+          await Promise.all(
+            tasks.Items.map(async (task) => {
+              await postToConnection({ message: task }, task.connectionId);
+            })
+          );
+          await postToConnection({ message: tasks.Items[0] }, connectionId);
+          return tasks.Items[0];
+        } else {
+          await dynamodbSharedLib.putItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(_izContext, 'RegisterRecords'),
+            {
+              identifiersTask: hash(identifier),
+              connectionId: connectionId
+            }
+          );
+        }
+        break;
+      }
+      default:
+        throw new NoRetryError(`statusType not found ${flowSchema.statusType}`);
+    }
+  } catch (err) {
+    _izContext.logger.error('error WebSocketInvoke: ', err);
+    throw err;
+  }
+}

package/test/customFlowApplicationArtifacts.test.js

@@ -36,7 +36,17 @@ test('emits handlers, function YAML, and IAM roles for supported custom flow eve
   const result = await generateCustomFlowApplicationArtifacts(rootPath);
   await generateResourceArtifacts(rootPath);
 
-  assert.equal(result.files.length, 38);
+  assert.equal(result.files.length, 43);
+  assert.match(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/SystemFlowSchemas/Register/source/Register_Main.js'
+      ),
+      'utf8'
+    ),
+    /registerMain/
+  );
   assert.match(
     await readFile(
       join(
@@ -794,17 +804,18 @@ test('renders nextSteps IAM permissions in InitialSetupConfig', async () => {
     ),
     'utf8'
   );
-  assert.match(initialSetupConfigContent, /roleName: 'ReservationsRole'/);
+  assert.match(initialSetupConfigContent, /roleName: 'Reservations'/);
   assert.match(
     initialSetupConfigContent,
-    /ReservationsRolePublishNextStepsTopics/
+    /ReservationsPublishNextStepsTopics/
   );
   assert.match(
     initialSetupConfigContent,
-    /snsTopicNameByFlowSchema\(_izContext, 'GetDeepPathSearch_In', 'GraphHandler'\)/
+    /\/\/\(<createReservationsRole>\)/
   );
   assert.match(
     initialSetupConfigContent,
-    /snsTopicNameByFlowSchema\(\s*_izContext,\s*'Create_In'\)/
+    /\/\/\(<\/createReservationsRole>\)/
   );
 });
+

package/test/publicApi.test.js

@@ -99,6 +99,27 @@ test('generate commits the system WebSocket completion path for own-topic flows'
         'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.js'
     )
   );
+  assert.ok(
+    result.files.some(
+      (file) =>
+        file.path ===
+        'app/src/generatedCode/SystemFlowSchemas/Register/source/Register_Main.js'
+    )
+  );
+  assert.ok(
+    result.files.some(
+      (file) =>
+        file.path ===
+        'app/src/generatedCode/SystemFlowSchemas/Register/source/Register_HdrWbs.js'
+    )
+  );
+  assert.ok(
+    result.files.some(
+      (file) =>
+        file.path ===
+        'app/src/generatedCode/SystemFlowSchemas/Register/source/RegisterComplete_Main.js'
+    )
+  );
   assert.ok(
     result.files.some(
       (file) =>

package/test/relationshipApplicationArtifacts.test.js

@@ -115,7 +115,7 @@ test('emits relationship action and complete handlers with data-first function Y
   );
   assert.match(
     createCompleteContent,
-    /const {\s*returnValue,\s*status,\s*errorsFound,\s*graphServiceTag\s*} = requestParams;/
+    /const {\s*returnValue,\s*parentFlowId,\s*status,\s*errorsFound,\s*graphServiceTag\s*} = requestParams;/
   );
   assert.doesNotMatch(
     createCompleteContent,

package/test/resourceArtifacts.test.js

@@ -237,6 +237,26 @@ test('emits DynamoDB tables and hooks defined in flowSchemas storageResources',
   assert.match(dynamoYaml, /#<#\/FlowCustomTableTableSetting#>/);
 });
 
+test('emits IAM role for generated DSQ flows in generate-shared-resource.yml', async () => {
+  const rootPath = await createProject();
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/GeneratedDsq.js'),
+    "export default { flowTag: 'generatedDsq', generatedCodeConfig: {}, event: ['dsq'] };\n"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'GeneratedDsqRole');
+  assert.match(role, /GeneratedDsqHdrDsq/);
+});
+
 function roleBlock(iam, roleName) {
   const match = iam.match(
     new RegExp(