@izara_project/izara-core-generate-service-code 1.0.93 → 1.0.95

package/test/graphDrivenFlowSchema.test.js

@@ -66,6 +66,7 @@ test('validateFlowSchema passes for valid Graph-Driven FlowSchema', () => {
 test('validateFlowSchema rejects flowSteps[0] without stepName Start', () => {
   const invalidSchema = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Begin',
@@ -83,6 +84,7 @@ test('validateFlowSchema rejects flowSteps[0] without stepName Start', () => {
 test('validateFlowSchema rejects entry step with previousSteps or event', () => {
   const schemaWithPrev = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -98,6 +100,7 @@ test('validateFlowSchema rejects entry step with previousSteps or event', () =>
 
   const schemaWithEvent = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -115,6 +118,7 @@ test('validateFlowSchema rejects entry step with previousSteps or event', () =>
 test('validateFlowSchema rejects nextSteps item missing targetType', () => {
   const invalidSchema = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -132,6 +136,7 @@ test('validateFlowSchema rejects nextSteps item missing targetType', () => {
 test('validateFlowSchema rejects previousSteps item missing sourceType', () => {
   const invalidSchema = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -153,6 +158,7 @@ test('validateFlowSchema rejects previousSteps item missing sourceType', () => {
 test('validateFlowSchema rejects extTopic nextSteps missing toStepNames or serviceTag', () => {
   const missingToSteps = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -176,6 +182,7 @@ test('validateFlowSchema rejects extTopic nextSteps missing toStepNames or servi
 test('validateFlowSchema rejects extTopic previousSteps missing fromStepNames', () => {
   const missingFromSteps = {
     flowTag: 'TestFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -204,6 +211,7 @@ test('validateFlowSchema rejects extTopic previousSteps missing fromStepNames',
 test('validateFlowSchema allows optional omitted nextSteps and previousSteps', () => {
   const minimalSchema = {
     flowTag: 'MinimalFlow',
+    event: ['ownTopic'],
     flowSteps: [
       {
         stepName: 'Start'
@@ -217,6 +225,7 @@ test('validateFlowSchema allows optional omitted nextSteps and previousSteps', (
 test('validateFlowSchema passes for lambdaSyncInv with functionName', () => {
   const syncInvSchema = {
     flowTag: 'SyncInvFlow',
+    event: ['lambdaSyncInv'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -237,6 +246,7 @@ test('validateFlowSchema passes for lambdaSyncInv with functionName', () => {
 test('validateFlowSchema rejects lambdaSyncInv nextSteps missing functionName', () => {
   const missingFnSchema = {
     flowTag: 'SyncInvFlow',
+    event: ['lambdaSyncInv'],
     flowSteps: [
       {
         stepName: 'Start',
@@ -291,3 +301,318 @@ test('validateFlowSchema rejects flow with synchronous events having multiple fl
     /Flow 'ConfirmUsage' with synchronous events .* must only define a single entry step 'Start'/
   );
 });
+
+test('validateFlowSchema rejects statusType triggerCache without triggerFlowTypes', () => {
+  const invalidSchema = {
+    flowTag: 'cart',
+    event: ['ownTopic'],
+    statusType: 'triggerCache',
+    objType: { serviceTag: 'Order' },
+    flowSteps: [{ stepName: 'Start' }]
+  };
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /Flow 'cart' with statusType 'triggerCache' requires a non-empty 'triggerFlowTypes' array/
+  );
+});
+
+test('validateFlowSchema rejects statusType triggerCache with empty triggerFlowTypes', () => {
+  const invalidSchema = {
+    flowTag: 'cart',
+    event: ['ownTopic'],
+    statusType: 'triggerCache',
+    triggerFlowTypes: [],
+    objType: { serviceTag: 'Order' },
+    flowSteps: [{ stepName: 'Start' }]
+  };
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /Flow 'cart' with statusType 'triggerCache' requires a non-empty 'triggerFlowTypes' array/
+  );
+});
+
+test('validateFlowSchema rejects statusType triggerCache without objType', () => {
+  const invalidSchema = {
+    flowTag: 'cart',
+    event: ['ownTopic'],
+    statusType: 'triggerCache',
+    triggerFlowTypes: ['OrderCheckout'],
+    flowSteps: [{ stepName: 'Start' }]
+  };
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /Flow 'cart' with statusType 'triggerCache' requires 'objType'/
+  );
+});
+
+test('validateFlowSchema rejects statusType storedCache without objType', () => {
+  const invalidSchema = {
+    flowTag: 'cache',
+    event: ['ownTopic'],
+    statusType: 'storedCache',
+    flowSteps: [{ stepName: 'Start' }]
+  };
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /Flow 'cache' with statusType 'storedCache' requires 'objType'/
+  );
+});
+
+test('validateFlowSchema rejects checktrigger step without triggerFlowTypes', () => {
+  const invalidSchema = {
+    flowTag: 'customCheck',
+    event: ['ownTopic'],
+    flowSteps: [
+      { stepName: 'Start' },
+      { stepName: 'CheckTriggerFlows', event: ['extTopic'] }
+    ]
+  };
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /Flow 'customCheck' defines step 'CheckTriggerFlows' but requires a non-empty 'triggerFlowTypes' array/
+  );
+});
+
+test('validateFlowSchema passes for valid triggerCache and storedCache schemas', () => {
+  const validTriggerCache = {
+    flowTag: 'cart',
+    event: ['ownTopic'],
+    statusType: 'triggerCache',
+    triggerFlowTypes: ['OrderCheckout'],
+    objType: { serviceTag: 'Order' },
+    flowSteps: [{ stepName: 'Start' }]
+  };
+  assert.equal(validateFlowSchema(validTriggerCache), true);
+
+  const validStoredCache = {
+    flowTag: 'cache',
+    event: ['ownTopic'],
+    statusType: 'storedCache',
+    objType: { objectType: 'order' },
+    flowSteps: [{ stepName: 'Start' }]
+  };
+  assert.equal(validateFlowSchema(validStoredCache), true);
+});
+
+test('validateFlowSchema rejects missing or empty flowTag', () => {
+  assert.throws(
+    () => validateFlowSchema({ event: ['ownTopic'], flowSteps: [{ stepName: 'Start' }] }),
+    /flowTag is required and must be a non-empty string/
+  );
+  assert.throws(
+    () => validateFlowSchema({ flowTag: '  ', event: ['ownTopic'], flowSteps: [{ stepName: 'Start' }] }),
+    /flowTag is required and must be a non-empty string/
+  );
+});
+
+test('validateFlowSchema rejects missing, non-array, or empty event', () => {
+  assert.throws(
+    () => validateFlowSchema({ flowTag: 'testFlow', flowSteps: [{ stepName: 'Start' }] }),
+    /Flow 'testFlow' requires a non-empty 'event' array/
+  );
+  assert.throws(
+    () => validateFlowSchema({ flowTag: 'testFlow', event: 'ownTopic', flowSteps: [{ stepName: 'Start' }] }),
+    /Flow 'testFlow' requires a non-empty 'event' array/
+  );
+  assert.throws(
+    () => validateFlowSchema({ flowTag: 'testFlow', event: [], flowSteps: [{ stepName: 'Start' }] }),
+    /Flow 'testFlow' requires a non-empty 'event' array/
+  );
+});
+
+test('validateFlowSchema rejects unsupported event in event array', () => {
+  assert.throws(
+    () => validateFlowSchema({ flowTag: 'testFlow', event: ['invalidEvent'], flowSteps: [{ stepName: 'Start' }] }),
+    /event\[0\] 'invalidEvent' is invalid/
+  );
+});
+
+test('validateFlowSchema rejects generateCode event without generatedCodeConfig', () => {
+  assert.throws(
+    () => validateFlowSchema({ flowTag: 'testFlow', event: ['generateCode'], flowSteps: [{ stepName: 'Start' }] }),
+    /with event 'generateCode' requires 'generatedCodeConfig'/
+  );
+});
+
+test('validateFlowSchema rejects non-ownTopic hook without codeHookTag', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'testHook',
+        event: ['lambdaSyncInv'],
+        generatedCodeConfig: { generateCodeTag: 'create' },
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /requires 'codeHookTag' \('before' \| 'after'\)/
+  );
+});
+
+test('validateFlowSchema rejects ownTopic hook with generateCodeTag without codeHookTag', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'testOwnHook',
+        event: ['ownTopic'],
+        generatedCodeConfig: {
+          generateCodeTag: 'create',
+          invocationType: 'ownTopic'
+        },
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /requires 'codeHookTag' \('before' \| 'after'\)/
+  );
+});
+
+test('validateFlowSchema rejects generateCode co-existing with other events', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'testHook',
+        event: ['generateCode', 'ownTopic'],
+        generatedCodeConfig: {
+          generateCodeTag: 'create',
+          codeHookTag: 'before',
+          invocationType: 'ownTopic'
+        },
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'testHook' with event 'generateCode' must be a standalone event and cannot co-exist with other events/
+  );
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'testHook',
+        event: ['extTopic', 'generateCode'],
+        generatedCodeConfig: {
+          generateCodeTag: 'create',
+          codeHookTag: 'after',
+          invocationType: 'lambdaSyncInv'
+        },
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'testHook' with event 'generateCode' must be a standalone event and cannot co-exist with other events/
+  );
+});
+
+test('validateFlowSchema passes when generateCode is the sole event with valid config', () => {
+  assert.equal(
+    validateFlowSchema({
+      flowTag: 'testHook',
+      event: ['generateCode'],
+      generatedCodeConfig: {
+        generateCodeTag: 'create',
+        codeHookTag: 'before',
+        invocationType: 'lambdaSyncInv'
+      },
+      flowSteps: [{ stepName: 'Start' }]
+    }),
+    true
+  );
+});
+
+test('validateFlowSchema rejects s3 event without bucketName', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'uploadFlow',
+        event: ['s3'],
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'uploadFlow' with event 's3' requires 'bucketName' as a non-empty string/
+  );
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'uploadFlow',
+        event: ['s3'],
+        bucketName: '   ',
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'uploadFlow' with event 's3' requires 'bucketName' as a non-empty string/
+  );
+});
+
+test('validateFlowSchema passes for s3 event with valid bucketName', () => {
+  assert.equal(
+    validateFlowSchema({
+      flowTag: 'uploadFlow',
+      event: ['s3'],
+      bucketName: 'MyUploadBucket',
+      flowSteps: [{ stepName: 'Start' }]
+    }),
+    true
+  );
+});
+
+test('validateFlowSchema rejects event with storedCache or triggerCache as invalid event', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'cacheFlow',
+        event: ['storedCache'],
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'cacheFlow' event\[0\] 'storedCache' is invalid\. Must be one of/
+  );
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'triggerFlow',
+        event: ['triggerCache'],
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'triggerFlow' event\[0\] 'triggerCache' is invalid\. Must be one of/
+  );
+});
+
+test('validateFlowSchema rejects statusType storedCache with invalid objType object', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'cacheFlow',
+        event: ['ownTopic'],
+        statusType: 'storedCache',
+        objType: {},
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'cacheFlow' with statusType 'storedCache' requires 'objType' to be a non-empty string or object with string 'objectType'/
+  );
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'cacheFlow',
+        event: ['ownTopic'],
+        statusType: 'storedCache',
+        objType: { objectType: '  ' },
+        flowSteps: [{ stepName: 'Start' }]
+      }),
+    /Flow 'cacheFlow' with statusType 'storedCache' requires 'objType' to be a non-empty string or object with string 'objectType'/
+  );
+});
+
+test('validateFlowSchema passes statusType storedCache with string objType or object objType', () => {
+  assert.equal(
+    validateFlowSchema({
+      flowTag: 'cacheFlow1',
+      event: ['ownTopic'],
+      statusType: 'storedCache',
+      objType: 'order',
+      flowSteps: [{ stepName: 'Start' }]
+    }),
+    true
+  );
+  assert.equal(
+    validateFlowSchema({
+      flowTag: 'cacheFlow2',
+      event: ['ownTopic'],
+      statusType: 'storedCache',
+      objType: { objectType: 'order' },
+      flowSteps: [{ stepName: 'Start' }]
+    }),
+    true
+  );
+});
+
+
+
+

package/test/relationshipApplicationArtifacts.test.js

@@ -125,6 +125,35 @@ test('emits relationship action and complete handlers with data-first function Y
   assert.match(yaml, /CreateRelationshipCompleteHdrSqs:/);
 });
 
+test('emits valid hook tags without trailing periods and with correct callingFlowProperties placement in relationship Main files', async () => {
+  const rootPath = await createProject(true);
+  await generateRelationshipApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const actions = ['Create', 'Update', 'Delete', 'Move', 'Change'];
+  for (const action of actions) {
+    const mainContent = await readFile(
+      join(
+        rootPath,
+        `app/src/generatedCode/FlowRelationships/${action}Relationship/source/${action}Relationship_Main.js`
+      ),
+      'utf8'
+    );
+    assert.doesNotMatch(mainContent, /\/\/\(<\/[^>]+>\)\./);
+  }
+
+  const changeMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowRelationships/ChangeRelationship/source/ChangeRelationship_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(changeMain, /\/\/\(<requestParamChangeRel>\)/);
+  assert.doesNotMatch(changeMain, /\/\/\(<requestParamCreateRel>\)/);
+});
+
 test('removes managed relationship artifacts after relationships are removed', async () => {
   const rootPath = await createProject(true);
   await generateRelationshipApplicationArtifacts(rootPath, {

package/test/resourceArtifacts.test.js

@@ -236,6 +236,51 @@ test('rejects empty generateCodeTag array configuration', async () => {
   );
 });
 
+test('rejects FlowHook schema missing codeHookTag at loader', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'MissingHookTag.js'),
+    "export default { flowTag: 'missingHookTag', event: ['lambdaSyncInv'], " +
+      "generatedCodeConfig: { generateCodeTag: 'create' } };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /Flow 'missingHookTag' with generatedCodeConfig requires 'codeHookTag' \('before' or 'after'\)/
+  );
+});
+
+test('rejects ownTopic FlowHook schema missing codeHookTag at loader', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'MissingOwnHookTag.js'),
+    "export default { flowTag: 'missingOwnHookTag', event: ['ownTopic'], " +
+      "generatedCodeConfig: { generateCodeTag: 'create', invocationType: 'ownTopic' } };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /Flow 'missingOwnHookTag' with generatedCodeConfig requires 'codeHookTag' \('before' or 'after'\)/
+  );
+});
+
+test('rejects FlowHook schema with invalid codeHookTag at loader', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'InvalidCodeHookTag.js'),
+    "export default { flowTag: 'invalidCodeHookTag', event: ['lambdaSyncInv'], " +
+      "generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'middle' } };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /generatedCodeConfig\.codeHookTag 'middle' is invalid\. Must be 'before' or 'after'/
+  );
+});
+
 test('emits the shared WebSocket completion queue and output-topic subscriptions', async () => {
   const rootPath = await createProject();
   await generateResourceArtifacts(rootPath);
@@ -807,7 +852,7 @@ async function createProject() {
   );
   await writeFile(
     join(schemas, 'FlowSchemas/Upload.js'),
-    "export default { flowTag: 'upload', event: ['s3'], outputTopic: true, s3Subscription: { topicName: 'OutCreate', queueName: 'UploadReservedLimitHdrSqs' } };\n"
+    "export default { flowTag: 'upload', event: ['s3'], bucketName: 'UploadBucket', outputTopic: true, s3Subscription: { topicName: 'OutCreate', queueName: 'UploadReservedLimitHdrSqs' } };\n"
   );
   return rootPath;
 }

package/test/systemFindDataArtifacts.test.js

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { emitSystemFindDataArtifacts } from '../src/emit/system/emitSystemFindDataArtifacts.js';
+
+test('emitSystemFindDataArtifacts returns empty when no objects have storage resources', async () => {
+  const result = await emitSystemFindDataArtifacts([
+    { objectType: 'plainObject' }
+  ]);
+  assert.deepEqual(result.artifacts, []);
+  assert.deepEqual(result.functions, []);
+});
+
+test('emitSystemFindDataArtifacts omits FindData handlers and YAML function when no fields qualify for find data', async () => {
+  const objects = [
+    {
+      objectType: 'item',
+      storageResources: {
+        main: { storageType: 'dynamoDB', tableName: 'Items' }
+      },
+      fieldNames: {
+        description: { type: 'boolean' }
+      }
+    }
+  ];
+
+  const result = await emitSystemFindDataArtifacts(objects);
+  assert.ok(result.artifacts.length > 0);
+  assert.ok(
+    !result.artifacts.some((a) => a.path.includes('FindData')),
+    'FindData artifacts must not be emitted when no fields qualify'
+  );
+  assert.ok(
+    !result.functions.some((fn) => fn.includes('FindDataHdrSqs:')),
+    'FindData YAML function must not be emitted when no fields qualify'
+  );
+  assert.ok(
+    result.functions.some((fn) => fn.includes('ProcessLogicalHdrSqs:')),
+    'ProcessLogical functions should still be emitted'
+  );
+});
+
+test('emitSystemFindDataArtifacts includes FindData handlers and YAML function when fields qualify', async () => {
+  const objects = [
+    {
+      objectType: 'product',
+      storageResources: {
+        main: { storageType: 'dynamoDB', tableName: 'Products' }
+      },
+      identifiers: [{ fieldName: 'productId' }],
+      fieldNames: {
+        productId: {
+          type: 'string',
+          storageResourceTags: ['main']
+        }
+      }
+    }
+  ];
+
+  const result = await emitSystemFindDataArtifacts(objects);
+  assert.ok(
+    result.artifacts.some((a) => a.path.includes('FindData_Main.js')),
+    'FindData_Main.js must be emitted'
+  );
+  assert.ok(
+    result.artifacts.some((a) => a.path.includes('FindData_HdrSqs.js')),
+    'FindData_HdrSqs.js must be emitted'
+  );
+  assert.ok(
+    result.functions.some((fn) => fn.includes('FindDataHdrSqs:')),
+    'FindDataHdrSqs YAML function must be emitted'
+  );
+});