@izara_project/izara-core-generate-service-code 1.0.78 → 1.0.79

package/test/graphDrivenFlowSchema.test.js

@@ -0,0 +1,257 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateFlowSchema } from '../src/compile/flowValidator.js';
+
+test('validateFlowSchema passes for valid Graph-Driven FlowSchema', () => {
+  const validSchema = {
+    flowTag: 'Reservations',
+    event: ['ownTopic'],
+    flowSteps: [
+      {
+        stepName: 'Start',
+        properties: [],
+        messageAttributes: [],
+        nextSteps: [
+          {
+            targetType: 'extTopic',
+            serviceTag: 'GraphHandler',
+            topicName: 'GetDeepPathSearch_In',
+            toStepNames: ['GetDeepPathSearch']
+          }
+        ]
+      },
+      {
+        stepName: 'GetDeepPathSearch',
+        event: ['extTopic'],
+        properties: [],
+        messageAttributes: [],
+        previousSteps: [
+          { sourceType: 'ownTopic', stepName: 'Start' },
+          {
+            sourceType: 'extTopic',
+            serviceTag: 'GraphHandler',
+            topicName: 'GetDeepPathSearch_Out',
+            fromStepNames: ['Start']
+          }
+        ],
+        nextSteps: [
+          {
+            targetType: 'extTopic',
+            serviceTag: 'GraphHandler',
+            topicName: 'Create_In',
+            toStepNames: ['Complete']
+          }
+        ]
+      },
+      {
+        stepName: 'Complete',
+        event: ['extTopic'],
+        properties: [],
+        messageAttributes: [],
+        previousSteps: [
+          {
+            sourceType: 'extTopic',
+            serviceTag: 'GraphHandler',
+            topicName: 'Create_Out',
+            fromStepNames: ['GetDeepPathSearch']
+          }
+        ]
+      }
+    ]
+  };
+
+  assert.equal(validateFlowSchema(validSchema), true);
+});
+
+test('validateFlowSchema rejects flowSteps[0] without stepName Start', () => {
+  const invalidSchema = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Begin',
+        nextSteps: [{ targetType: 'ownTopic', stepName: 'Complete' }]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /Entry step flowSteps\[0\] must have stepName fixed to 'Start'/
+  );
+});
+
+test('validateFlowSchema rejects entry step with previousSteps or event', () => {
+  const schemaWithPrev = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        previousSteps: [{ sourceType: 'ownTopic', stepName: 'Start' }]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(schemaWithPrev),
+    /Entry step flowSteps\[0\] must not define 'previousSteps'/
+  );
+
+  const schemaWithEvent = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        event: ['extTopic']
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(schemaWithEvent),
+    /Entry step flowSteps\[0\] must not define step-level 'event'/
+  );
+});
+
+test('validateFlowSchema rejects nextSteps item missing targetType', () => {
+  const invalidSchema = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [{ stepName: 'GetDeepPathSearch' }]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /nextSteps\[0\] must have targetType/
+  );
+});
+
+test('validateFlowSchema rejects previousSteps item missing sourceType', () => {
+  const invalidSchema = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [{ targetType: 'ownTopic', stepName: 'Complete' }]
+      },
+      {
+        stepName: 'Complete',
+        previousSteps: [{ stepName: 'Start' }]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(invalidSchema),
+    /previousSteps\[0\] must have sourceType/
+  );
+});
+
+test('validateFlowSchema rejects extTopic nextSteps missing toStepNames or serviceTag', () => {
+  const missingToSteps = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [
+          {
+            targetType: 'extTopic',
+            serviceTag: 'GraphHandler',
+            topicName: 'GetDeepPathSearch_In'
+          }
+        ]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(missingToSteps),
+    /extTopic target requires non-empty 'toStepNames'/
+  );
+});
+
+test('validateFlowSchema rejects extTopic previousSteps missing fromStepNames', () => {
+  const missingFromSteps = {
+    flowTag: 'TestFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [{ targetType: 'ownTopic', stepName: 'GetDeepPathSearch' }]
+      },
+      {
+        stepName: 'GetDeepPathSearch',
+        event: ['extTopic'],
+        previousSteps: [
+          {
+            sourceType: 'extTopic',
+            serviceTag: 'GraphHandler',
+            topicName: 'GetDeepPathSearch_Out'
+          }
+        ]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(missingFromSteps),
+    /extTopic source requires non-empty 'fromStepNames'/
+  );
+});
+
+test('validateFlowSchema allows optional omitted nextSteps and previousSteps', () => {
+  const minimalSchema = {
+    flowTag: 'MinimalFlow',
+    flowSteps: [
+      {
+        stepName: 'Start'
+      }
+    ]
+  };
+
+  assert.equal(validateFlowSchema(minimalSchema), true);
+});
+
+test('validateFlowSchema passes for lambdaSyncInv with functionName', () => {
+  const syncInvSchema = {
+    flowTag: 'SyncInvFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [
+          {
+            targetType: 'lambdaSyncInv',
+            serviceTag: 'UserAccountService',
+            functionName: 'VerifyAccountHdrInv'
+          }
+        ]
+      }
+    ]
+  };
+
+  assert.equal(validateFlowSchema(syncInvSchema), true);
+});
+
+test('validateFlowSchema rejects lambdaSyncInv nextSteps missing functionName', () => {
+  const missingFnSchema = {
+    flowTag: 'SyncInvFlow',
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [
+          {
+            targetType: 'lambdaSyncInv',
+            serviceTag: 'UserAccountService'
+          }
+        ]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(missingFnSchema),
+    /lambdaSyncInv target requires non-empty 'functionName'/
+  );
+});

package/test/publicApi.test.js

@@ -23,8 +23,18 @@ test('generate commits schemas, application artifacts, and resources in one publ
   const rootPath = await createCrudProject();
   const result = await generate(rootPath);
 
-  assert.strictEqual(result.files.length, 57);
+  assert.strictEqual(result.files.length, 65);
   assert.equal(result.project.rootPath, rootPath);
+  assert.match(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js'
+      ),
+      'utf8'
+    ),
+    /nameSpace:\s*"Create_/
+  );
   assert.match(
     await readFile(
       join(
@@ -298,7 +308,7 @@ test('generate removes stale CRUD schemas and application artifacts', async () =
 
   const result = await generate(rootPath);
 
-  assert.equal(result.files.length, 28);
+  assert.equal(result.files.length, 29);
   await assert.rejects(
     readFile(
       join(
@@ -335,7 +345,7 @@ async function createCrudProject() {
   await mkdir(objectDirectory, { recursive: true });
   await writeFile(
     join(objectDirectory, 'Order.js'),
-    "export default { objectType: 'order', generatedBy: 'userGenerated' };\n"
+    "export default { objectType: 'order', generatedBy: 'userGenerated', storageResources: { graph: { storageType: 'graph' } } };\n"
   );
   return rootPath;
 }
@@ -361,7 +371,7 @@ async function createOwnTopicProject() {
   await mkdir(flowDirectory, { recursive: true });
   await writeFile(
     join(flowDirectory, 'Track.js'),
-    "export default { flowTag: 'track', event: ['ownTopic'], initiateBy: 'user', outputTopic: true, statusType: 'none', generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical', invocationType: 'ownTopic' } };\n"
+    "export default { flowTag: 'track', event: ['ownTopic'], initiateBy: 'user', outputTopic: true, statusType: 'none', generatedCodeConfig: { generatedCodeTag: 'create' } };\n"
   );
   return rootPath;
 }
@@ -413,4 +423,3 @@ test(
     );
   }
 );
-

package/test/resourceArtifacts.test.js

@@ -80,9 +80,14 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
     roleBlock(iam, 'FlowRbacRole'),
     /RolePermissions|ProcessCreateTargetRoleHdrSqs/
   );
-  // Per-object RBAC flow queue (e.g. OrderRbacFlowHdrSqs from Order with rbac add-on)
-  assert.match(roleBlock(iam, 'FlowRbacRole'), /OrderRbacFlowHdrSqs/);
+  // Per-object RBAC flow queue (e.g. ValidatorRbacHdrSqs from Order with rbac add-on)
+  assert.match(roleBlock(iam, 'FlowRbacRole'), /ValidatorRbacHdrSqs/);
   assert.match(resources, /^  CreateRelationshipHdrSqs:/m);
+  assert.doesNotMatch(resources, /^  CreateCompleteHdrSqs:/m);
+  assert.match(resources, /^  UpdateCompleteHdrSqs:/m);
+  assert.match(resources, /^  DeleteCompleteHdrSqs:/m);
+  assert.doesNotMatch(resources, /RbacCallbackHdrSqs/);
+  assert.doesNotMatch(resources, /FlowHook|beforeLogical/);
   assert.equal(
     (resources.match(/^  CreateRelationshipHdrSqs:/gm) ?? []).length,
     1
@@ -103,7 +108,14 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
   );
   assert.match(roleBlock(iam, 'RegisterRole'), /s3:GetObject/);
   assert.match(roleBlock(iam, 'RegisterRole'), /RegisterComplete/);
-  assert.doesNotMatch(roleBlock(iam, 'RegisterRole'), /dynamodb:|sns:/);
+  assert.match(roleBlock(iam, 'RegisterRole'), /dynamodb:/);
+  assert.match(roleBlock(iam, 'RegisterRole'), /execute-api:ManageConnections/);
+  const procFindDataRole = roleBlock(iam, 'ProcFindDataRole');
+  assert.match(procFindDataRole, /dynamodb:UpdateItem/);
+  assert.match(procFindDataRole, /dynamodb:GetItem/);
+  assert.match(procFindDataRole, /dynamodb:Query/);
+  assert.match(procFindDataRole, /sns:Publish/);
+  assert.match(procFindDataRole, /FindData_Out/);
   assert.doesNotMatch(
     iam,
     /s3:GetObjectVersion|s3:ListBucket|sqs:DeleteMessageBatch|sqs:GetQueueUrl/
@@ -123,7 +135,7 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
   }
 });
 
-test('emits one before-logical queue for flows that share an action', async () => {
+test('rejects deprecated FlowHook schemas', async () => {
   const rootPath = await createProject();
   const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
   await writeFile(
@@ -131,21 +143,10 @@ test('emits one before-logical queue for flows that share an action', async () =
     "export default [{ flowTag: 'first', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical' } }, { flowTag: 'second', event: ['extTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical' } }];\n"
   );
 
-  await generateResourceArtifacts(rootPath);
-
-  const resources = await readFile(
-    join(
-      rootPath,
-      'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'
-    ),
-    'utf8'
-  );
-  assert.equal(
-    (resources.match(/^  CreateBeforeLogicalHdrSqs:/gm) ?? []).length,
-    1
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /generatedCodeConfig\.codeHookTag is no longer supported/
   );
-  assert.match(resources, /SubscriptionOutFirstToCreateBeforeLogical:/);
-  assert.match(resources, /SubscriptionOutSecondToCreateBeforeLogical:/);
 });
 
 test('emits the shared WebSocket completion queue and output-topic subscriptions', async () => {
@@ -161,6 +162,7 @@ test('emits the shared WebSocket completion queue and output-topic subscriptions
   );
   assert.match(resources, /^  WebSocketCompleteHdrSqs:/m);
   assert.match(resources, /SubscriptionToOutCustomWebSocketComplete:/);
+  assert.match(resources, /SubscriptionToOutCustomRegisterComplete:/);
   const iam = await readFile(
     join(
       rootPath,
@@ -187,6 +189,10 @@ test('emits the shared WebSocket completion queue and output-topic subscriptions
     resources,
     /SubscriptionToOutCreateRelationshipWebSocketComplete:/
   );
+  assert.match(
+    resources,
+    /SubscriptionToOutCreateRelationshipRegisterComplete:/
+  );
 });
 
 test('scopes stored-cache permissions to the flow object table', async () => {
@@ -294,7 +300,7 @@ async function createProject() {
   );
   await writeFile(
     join(schemas, 'FlowSchemas/Upload.js'),
-    "export default { flowTag: 'upload', event: ['s3'], s3Subscription: { topicName: 'OutCreate', queueName: 'UploadReservedLimitHdrSqs' } };\n"
+    "export default { flowTag: 'upload', event: ['s3'], outputTopic: true, s3Subscription: { topicName: 'OutCreate', queueName: 'UploadReservedLimitHdrSqs' } };\n"
   );
   return rootPath;
 }

package/test/systemTextSchemas.test.js

@@ -0,0 +1,154 @@
+import assert from 'node:assert/strict';
+import { readFile, rm, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import test, { after } from 'node:test';
+
+import {
+  emitSystemTextSchemas,
+  systemTextSchemaManagedPaths
+} from '../src/emit/systemText/emitSystemTextSchemas.js';
+import { generate } from '../src/generate.js';
+
+const roots = new Set();
+after(() =>
+  Promise.all(
+    [...roots].map((root) => rm(root, { recursive: true, force: true }))
+  )
+);
+
+test('emitSystemTextSchemas produces expected structure for objects, flows, relationships, and notifications', async () => {
+  const artifacts = await emitSystemTextSchemas({
+    project: { serviceTag: 'MyService' },
+    objects: [
+      {
+        objectType: 'product',
+        fieldNames: {
+          productId: { type: 'string' },
+          price: { type: 'number' }
+        },
+        addOnDataStructure: [
+          {
+            type: 'versionedData',
+            fieldNames: {
+              version: { type: 'number' }
+            }
+          }
+        ]
+      }
+    ],
+    relationships: [
+      {
+        hasCategory: {
+          fieldNames: {
+            originTimestamp: { type: 'number' }
+          }
+        }
+      }
+    ],
+    flows: [{ flowTag: 'ProcessOrder' }],
+    notifications: [
+      {
+        notificationGrouping: 'OrderEvents',
+        notificationTag: 'OrderPlaced'
+      }
+    ]
+  });
+
+  assert.equal(artifacts.length, 1);
+  assert.equal(
+    artifacts[0].path,
+    'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js'
+  );
+
+  const content = artifacts[0].content;
+  // Object fields
+  assert.match(content, /nameSpace:\s*"product_MyService_description"/);
+  assert.match(
+    content,
+    /systemTextTag:\s*"productId_product_MyService"/
+  );
+  assert.match(content, /\/\/\(<product_MyServiceproductIdHook>\)/);
+  assert.match(
+    content,
+    /systemTextTag:\s*"version_product_MyService"/
+  );
+
+  // Notification
+  assert.match(content, /nameSpace:\s*"sysNotification_OrderEvents"/);
+  assert.match(content, /systemTextTag:\s*"OrderPlaced"/);
+  assert.match(content, /\/\/\(<OrderPlacedHook>\)/);
+
+  // Relationship
+  assert.match(content, /nameSpace:\s*"hasCategory_MyService_description"/);
+  assert.match(
+    content,
+    /systemTextTag:\s*"originTimestamp_hasCategory_MyService"/
+  );
+
+  // Custom Flow
+  assert.match(content, /nameSpace:\s*"ProcessOrder_MyService"/);
+  assert.match(content, /systemTextTag:\s*"errors_ProcessOrder_MyService"/);
+});
+
+test('emitSystemTextSchemas returns empty array when no inputs provided', async () => {
+  const artifacts = await emitSystemTextSchemas({
+    project: { serviceTag: 'MyService' },
+    objects: [],
+    relationships: [],
+    flows: [],
+    notifications: []
+  });
+
+  assert.deepEqual(artifacts, []);
+  assert.deepEqual(systemTextSchemaManagedPaths(), [
+    'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js'
+  ]);
+});
+
+test('generate preserves user hooks inside SystemTextSchemas.js across regeneration', async () => {
+  const rootPath = join(
+    tmpdir(),
+    `system-text-hook-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  roots.add(rootPath);
+  await mkdir(join(rootPath, 'app/src/schemas/ObjectSchemas'), {
+    recursive: true
+  });
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    'main_config:\n  iz_serviceTag: TestService\n'
+  );
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Item.js'),
+    "export default { objectType: 'item', fieldNames: { itemId: { type: 'string' } }, generatedBy: 'userGenerated' };\n"
+  );
+
+  // First generate
+  await generate(rootPath);
+
+  const targetFile = join(
+    rootPath,
+    'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js'
+  );
+  const initialContent = await readFile(targetFile, 'utf8');
+  assert.match(initialContent, /\/\/\(<item_TestServiceitemIdHook>\)/);
+
+  // User edits inside hook
+  const modifiedContent = initialContent.replace(
+    '//(<item_TestServiceitemIdHook>)\n    //(</item_TestServiceitemIdHook>)',
+    '//(<item_TestServiceitemIdHook>)\n    customTranslation: "Item ID Value",\n    //(</item_TestServiceitemIdHook>)'
+  );
+  await writeFile(targetFile, modifiedContent);
+
+  // Second generate (regeneration)
+  await generate(rootPath);
+
+  const regeneratedContent = await readFile(targetFile, 'utf8');
+  assert.match(
+    regeneratedContent,
+    /customTranslation:\s*"Item ID Value"/
+  );
+});

package/src/emit/crud/templates/CreateComplete_HdrSqs.ejs

@@ -1,99 +0,0 @@
-import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
-import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
-import Logger from '@izara_project/izara-core-library-logger';
-import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
-import CreateComplete from './CreateComplete_Main.js';
-
-//(<optionalRequire>)
-//(</optionalRequire>)
-
-// validate event properties in body.Message of sqs event
-let perRecordsValidatorSchema = {
-  type: 'object',
-  properties: {
-    returnValue: {
-      type: 'object'
-    },
-    parentFlowId: {
-      type: 'string'
-    },
-    status: {
-      type: 'string'
-    },
-    errorsFound: {
-      type: 'array'
-    },
-    graphServiceTag: {
-      type: 'string'
-    }
-  },
-  required: [
-    'returnValue',
-    'parentFlowId',
-    'status',
-    'errorsFound',
-    'graphServiceTag'
-  ]
-  //(<validatorSchema>)
-  //(</validatorSchema>)
-};
-
-let messageAttributeValidatorSchema = null;
-middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
-
-export const main = middleware.wrap(async (event, context) => {
-  try {
-    let recordPromises = [];
-
-    // loop each record and send to mainFunction
-    await Promise.all(
-      event.Records.map(async (record) => {
-        let passOnProperties = [];
-        record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
-
-        //validate message (and MessageAttributes)
-        await recordHandlerSharedLib.validateRecord(
-          record, // one record will send to mainFunction
-          'CreateCompleteHdrSqs', // queue name that need to retry or send to dlq
-          perRecordsValidatorSchema, // schema for record.Message
-          messageAttributeValidatorSchema
-        );
-
-        // add argument (to invoke lambda) to passOnProperties[]
-        passOnProperties.push(record.body.Message);
-        passOnProperties.push(
-          callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
-            record.body.Message
-          )
-        );
-        //(<additionalParams>)
-        //(</additionalParams>)
-        record._izContext.logger.debug(
-          'passOnProperties in handler',
-          passOnProperties
-        );
-
-        // call recordHandlerSharedLib.recordHandler with 3 parameters and return promise(resolve)
-        let recordPromise = recordHandlerSharedLib.recordHandler(
-          record, // one record will send to mainFunction
-          CreateComplete, // mainFunction that need to invoke.
-          'CreateCompleteHdrSqs', // queue name that need to retry or send to dlq
-          passOnProperties // all parameters that mainFunction needed.
-        );
-        record._izContext.logger.debug('after recordPromise in handler');
-        recordPromises.push(recordPromise); // push promise to recordPromises
-      })
-    );
-    try {
-      await Promise.all(recordPromises);
-      return event.Records;
-    } catch {
-      Logger.debug(
-        'Promise.all(recordPromises) in handler threw error (at least one record did no resolve)'
-      );
-    }
-  } catch (error) {
-    Logger.error('Unhandled Error, CreateComplete_HdrSqs: ', error);
-    throw error;
-  }
-});