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

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

@@ -0,0 +1,154 @@
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+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';
+const { postToConnection } = webSocket;
+
+/**
+ * Register complete main handler
+ * @param {Object} _izContext
+ * @param {string} topicArn
+ * @param {Object} requestParams
+ * @param {Object} callingFlowConfig
+ */
+export default async function registerCompleteMain(
+  _izContext,
+  topicArn,
+  requestParams,
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug('WebSocketInvoke _izContext', _izContext);
+    _izContext.logger.debug('WebSocketInvoke requestParams', requestParams);
+    _izContext.logger.debug('WebSocketInvoke callingFlowConfig', callingFlowConfig);
+
+    if (!topicArn) {
+      throw new NoRetryError('invalid not have topicArn to get flowSchema');
+    }
+
+    let topicName = topicArn.split(':')[5].split('_');
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
+      flowTag: topicName[2],
+      serviceTag: topicName[0]
+    });
+
+    if (!flowSchema) {
+      throw new NoRetryError('not have flowSchema in S3');
+    }
+
+    let identifiersTask = '';
+
+    if (!requestParams.identifiersTask && flowSchema.objType) {
+      identifiersTask = await identifiersObject.identifiersConcatFromIdentifiers(
+        _izContext,
+        flowSchema.objType,
+        requestParams
+      );
+      _izContext.logger.debug('identifiersTask from request params', identifiersTask);
+
+      Object.assign(requestParams, {
+        identifiersTask: identifiersTask
+      });
+    }
+
+    if (!requestParams.identifiersTask) {
+      _izContext.logger.warn('invalid identifiersTask');
+      return 'invalid identifiersTask';
+    }
+
+    const getResult = async (objType) => {
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+        _izContext,
+        {
+          objectType: objType.objectType,
+          serviceTag: objType.serviceTag
+        }
+      );
+
+      _izContext.logger.debug('==> objectSchema', objectSchema);
+
+      let tasks = await dynamodbSharedLib.query(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, 'RegisterRecords'),
+        {
+          identifiersTask: identifiersTask
+        }
+      );
+
+      if (tasks.Items && tasks.Items.length > 0) {
+        const result = await lambda.invokeSync(
+          _izContext,
+          await lambdaSharedLib.lambdaFunctionName(_izContext, 'GetHdrInv'),
+          {
+            identifiers: await identifiersObject.identifiersFromIdentifiersConcat(
+              _izContext,
+              objType,
+              requestParams.identifiersTask
+            ),
+            objectType: objType.objectType
+          }
+        );
+        await Promise.all(
+          tasks.Items.map(async (task) => {
+            if (!result) {
+              await postToConnection({ message: 'not have record' }, task.connectionId);
+            } else {
+              await postToConnection({ message: result }, task.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 {
+          identifier = requestParams;
+        }
+
+        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);
+            })
+          );
+        }
+        break;
+      }
+      default:
+        throw new NoRetryError(`statusType not found ${flowSchema.statusType}`);
+    }
+  } catch (err) {
+    _izContext.logger.error('error WebSocketInvoke: ', err);
+    throw err;
+  }
+}

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

@@ -0,0 +1,17 @@
+RegisterCompleteHdrSqs:
+  handler: src/generatedCode/SystemFlowSchemas/Register/source/RegisterComplete_HdrSqs.main
+  name: ${self:custom.iz_resourcePrefix}RegisterCompleteHdrSqs
+  role: RegisterRole
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}RegisterComplete
+        batchSize: 10
+
+RegisterCompleteDsq:
+  handler: src/generatedCode/SystemFlowSchemas/Register/source/RegisterComplete_HdrDsq.main
+  name: ${self:custom.iz_resourcePrefix}RegisterCompleteDsq
+  role: RegisterRole
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}RegisterCompleteDLQ
+        batchSize: 10

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/src/emit/system/templates/WebSocketComplete_Yaml.ejs

@@ -6,6 +6,7 @@ WebSocketCompleteHdrSqs:
     - sqs:
         arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}WebSocketCompleteHdrSqs
         batchSize: 10
+        #<#WebSocketCompleteHdrSqsFilterPatterns#>
         filterPatterns:
           - body:
               MessageAttributes:
@@ -17,3 +18,4 @@ WebSocketCompleteHdrSqs:
                 callingFlow:
                   Value:
                     - exists: false
+        #<#/WebSocketCompleteHdrSqsFilterPatterns#>

package/test/crudApplicationArtifacts.test.js

@@ -137,6 +137,27 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
     /#<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#\/CreateCompleteHdrSqsFunctionSetting#>/
   );
 
+  const customFilterHook =
+    '        #<#CreateCompleteHdrSqsFilterPatterns#>\n        filterPatterns:\n          - body: custom\n        #<#/CreateCompleteHdrSqsFilterPatterns#>';
+  const withFilterHook = yaml.replace(
+    /        #<#CreateCompleteHdrSqsFilterPatterns#>[\s\S]*?#<#\/CreateCompleteHdrSqsFilterPatterns#>/,
+    customFilterHook
+  );
+  assert.notEqual(
+    yaml,
+    withFilterHook,
+    'filterPatterns hook placeholder must exist in generated YAML'
+  );
+  await writeFile(yamlPath, withFilterHook);
+
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  yaml = await readFile(yamlPath, 'utf8');
+  assert.match(
+    yaml,
+    /#<#CreateCompleteHdrSqsFilterPatterns#>\n        filterPatterns:\n          - body: custom\n        #<#\/CreateCompleteHdrSqsFilterPatterns#>/
+  );
+
   const conflictPath = join(
     rootPath,
     'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
@@ -151,6 +172,7 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   assert.equal(await readFile(yamlPath, 'utf8'), yaml);
 });
 
+
 test('removes managed CRUD artifacts when no applicable object remains', async () => {
   const rootPath = await createProject(true);
   await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });

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(
@@ -673,3 +683,139 @@ test('supports step-level required overrides in flowSteps properties and message
     /messageAttributeValidatorSchema = {[\s\S]*required: \[\]/
   );
 });
+
+test(
+  'picks properties from inProcess flowStep and renders default keys ' +
+    'in handler validator schema',
+  async () => {
+    const rootPath = await mkdtemp(
+      join(tmpdir(), 'generate-service-code-v2-inprocess-')
+    );
+    roots.add(rootPath);
+    const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+    await mkdir(schemaRoot, { recursive: true });
+
+    await writeFile(
+      join(schemaRoot, 'InProcessFlow.js'),
+      `export default {
+      flowTag: 'InProcessFlow',
+      event: ['extTopic', 'lambdaSyncApi'],
+      stepProperties: {
+        status: { propertyName: 'status', type: 'string', default: 'ACTIVE' },
+        retryCount: { propertyName: 'retryCount', type: 'number', default: 0 }
+      },
+      flowSteps: [
+        {
+          stepName: 'inProcess',
+          properties: ['status', { key: 'retryCount', default: 3 }]
+        }
+      ]
+    };\n`
+    );
+
+    const result = await generateCustomFlowApplicationArtifacts(rootPath);
+    assert.ok(result);
+
+    const sqsHdrContent = await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowSchemas/InProcessFlow/source/' +
+          'InProcessFlow_HdrSqs.js'
+      ),
+      'utf8'
+    );
+    assert.match(
+      sqsHdrContent,
+      /status: {[\s\S]*type: 'string',[\s\S]*default: 'ACTIVE'/
+    );
+    assert.match(
+      sqsHdrContent,
+      /retryCount: {[\s\S]*type: 'number',[\s\S]*default: 3/
+    );
+
+    const apiHdrContent = await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowSchemas/InProcessFlow/source/' +
+          'InProcessFlow_HdrApi.js'
+      ),
+      'utf8'
+    );
+    assert.match(
+      apiHdrContent,
+      /status: { type: 'string', default: 'ACTIVE' }/
+    );
+    assert.match(apiHdrContent, /retryCount: { type: 'number', default: 3 }/);
+  }
+);
+
+test('renders nextSteps IAM permissions in InitialSetupConfig', async () => {
+  const { generate } = await import('../src/generate.js');
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-nextsteps-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+
+  await writeFile(
+    join(schemaRoot, 'Reservations.js'),
+    `export default {
+      flowTag: 'Reservations',
+      event: ['ownTopic'],
+      flowSteps: [
+        {
+          stepName: 'Start',
+          nextSteps: [
+            {
+              targetType: 'extTopic',
+              serviceTag: 'GraphHandler',
+              topic: 'GetDeepPathSearch_In'
+            }
+          ]
+        },
+        {
+          stepName: 'GetDeepPathSearch',
+          event: ['extTopic'],
+          nextSteps: [
+            {
+              targetType: 'ownTopic',
+              topic: 'Create_In'
+            }
+          ]
+        },
+        {
+          stepName: 'Complete',
+          event: ['extTopic']
+        }
+      ]
+    };\n`
+  );
+
+  const result = await generate(rootPath, {
+    serviceTag: 'ReservationsService'
+  });
+  assert.ok(result);
+
+  const initialSetupConfigContent = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/CoreFunctions/InitialSetupConfig.js'
+    ),
+    'utf8'
+  );
+  assert.match(initialSetupConfigContent, /roleName: 'Reservations'/);
+  assert.match(
+    initialSetupConfigContent,
+    /ReservationsPublishNextStepsTopics/
+  );
+  assert.match(
+    initialSetupConfigContent,
+    /\/\/\(<createReservationsRole>\)/
+  );
+  assert.match(
+    initialSetupConfigContent,
+    /\/\/\(<\/createReservationsRole>\)/
+  );
+});
+

package/test/functionYamlArtifact.test.js

@@ -80,12 +80,15 @@ test('filters all SQS functions by their calling flow', () => {
 
   assert.match(
     completion,
-    /filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateCompleteHdrSqs/
+    /#<#CreateCompleteHdrSqsFilterPatterns#>[\s\S]*filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateCompleteHdrSqs/
   );
+  assert.match(completion, /#<#\/CreateCompleteHdrSqsFilterPatterns#>/);
   assert.match(completion, /exists: false/);
   assert.match(
     ordinary,
-    /filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateHdrSqs/
+    /#<#CreateHdrSqsFilterPatterns#>[\s\S]*filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateHdrSqs/
   );
+  assert.match(ordinary, /#<#\/CreateHdrSqsFilterPatterns#>/);
   assert.match(ordinary, /exists: false/);
 });
+

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) =>
@@ -347,3 +368,32 @@ async function createTriggerCacheProject() {
   );
   return rootPath;
 }
+
+test(
+  'emits ignoreExternalServices hooks in UploadSchema_Main.js and ' +
+    'commands/uploadSchema.js',
+  async () => {
+    const rootPath = await createCrudProject();
+    await generate(rootPath);
+
+    const uploadSchemaMain = await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/CoreFunctions/UploadSchema_Main.js'
+      ),
+      'utf8'
+    );
+    assert.match(uploadSchemaMain, /\/\/\(<ignoreExternalServices>\)/);
+    assert.match(uploadSchemaMain, /\/\/\(<\/ignoreExternalServices>\)/);
+
+    const commandUploadSchema = await readFile(
+      join(
+        rootPath,
+        'app/initial_setup/generatedCode/source/commands/uploadSchema.js'
+      ),
+      'utf8'
+    );
+    assert.match(commandUploadSchema, /\/\/\(<ignoreExternalServices>\)/);
+    assert.match(commandUploadSchema, /\/\/\(<\/ignoreExternalServices>\)/);
+  }
+);