@izara_project/izara-core-generate-service-code 1.0.94 → 1.0.96

package/src/generate.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { buildGenerationPlan } from './plan/buildGenerationPlan.js';
 import { commitArtifacts } from './output/commitArtifacts.js';
 import { compileProject } from './compile/compileProject.js';
@@ -59,7 +61,9 @@ import {
   emitAttributeTreeObjectSchemas,
   emitAttributeTreeRelationshipSchemas,
   attributeTreeObjectSchemaManagedPaths,
-  attributeTreeRelationshipSchemaManagedPaths
+  attributeTreeRelationshipSchemaManagedPaths,
+  resolveTargetServicePath,
+  emitAttributeTreeTargetSchemas
 } from './emit/attributeTree/emitAttributeTreeSchemas.js';
 import {
   emitErrorSchemas,
@@ -147,6 +151,11 @@ export async function generate(rootPath, options = {}) {
         )
       );
     }
+    await _emitTargetServiceAttributeTreeSchemas({
+      project,
+      objects,
+      logger: options.logger
+    });
     const durationMs = Date.now() - startedAt;
     console.log(
       `[INFO] [Generate] STATUS=FINISHED | ` +
@@ -343,3 +352,50 @@ async function _emitGroups({
     }
   ];
 }
+
+async function _emitTargetServiceAttributeTreeSchemas({
+  project,
+  objects,
+  logger
+}) {
+  if (!Array.isArray(objects)) {
+    return;
+  }
+  for (const object of objects) {
+    if (!Array.isArray(object?.addOnDataStructure)) {
+      continue;
+    }
+    for (const addOn of object.addOnDataStructure) {
+      if (addOn?.type === 'attributeTree' && addOn?.attributeTreeTag) {
+        const attributeTag = addOn.attributeTreeTag;
+        const targetServiceRoot = resolveTargetServicePath({
+          currentServiceRoot: project.rootPath,
+          attributeTag
+        });
+        if (targetServiceRoot) {
+          const artifacts = emitAttributeTreeTargetSchemas({
+            attributeTag,
+            targetServiceRoot
+          });
+          for (const artifact of artifacts) {
+            await fs.promises.mkdir(path.dirname(artifact.path), {
+              recursive: true
+            });
+            await fs.promises.writeFile(
+              artifact.path,
+              artifact.content,
+              'utf8'
+            );
+          }
+          if (logger && typeof logger.info === 'function') {
+            logger.info(
+              `[INFO] [AttributeTree] Target schemas emitted for ` +
+                `tag=${attributeTag} to ${targetServiceRoot}`
+            );
+          }
+        }
+      }
+    }
+  }
+}
+

package/test/attributeTreeSchemas.test.js

@@ -8,7 +8,9 @@ import {
   emitAttributeTreeObjectSchemas,
   emitAttributeTreeRelationshipSchemas,
   attributeTreeObjectSchemaManagedPaths,
-  attributeTreeRelationshipSchemaManagedPaths
+  attributeTreeRelationshipSchemaManagedPaths,
+  resolveTargetServicePath,
+  emitAttributeTreeTargetSchemas
 } from '../src/emit/attributeTree/emitAttributeTreeSchemas.js';
 import { generate } from '../src/generate.js';
 
@@ -22,7 +24,7 @@ after(async () => {
   );
 });
 
-test('emitAttributeTreeObjectSchemas returns 4 object schemas per attributeTree tag', () => {
+test('emitAttributeTreeObjectSchemas returns 3 object schemas per attributeTree tag', () => {
   const objects = [
     {
       objectType: 'sellOffer',
@@ -47,16 +49,21 @@ test('emitAttributeTreeObjectSchemas returns 4 object schemas per attributeTree
   ];
 
   const artifacts = emitAttributeTreeObjectSchemas({ objects });
-  assert.equal(artifacts.length, 4);
+  assert.equal(artifacts.length, 3);
 
   const paths = artifacts.map((a) => a.path);
   assert.deepEqual(paths, [
     'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/attributeSellOfferTermValue.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLabel.js',
-    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermValueStandard.js'
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermValue.js',
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLabel.js'
   ]);
 
+  const valueArtifact = artifacts.find((a) =>
+    a.path.endsWith('sellOfferTermValue.js')
+  );
+  assert.match(valueArtifact.content, /"objectType": "sellOfferTermValue"/);
+  assert.match(valueArtifact.content, /"sellOfferTermValueId"/);
+
   for (const artifact of artifacts) {
     assert.doesNotMatch(artifact.content, /dynamoDB/);
     assert.match(artifact.content, /GraphHandler/);
@@ -101,6 +108,31 @@ test('emitAttributeTreeRelationshipSchemas returns 4 relationship schemas per at
     'app/src/schemas/RelationshipSchemas/generatedAttributeTree/isSellOfferTermLabel.js'
   ]);
 
+  const hasRel = artifacts.find((a) => a.path.endsWith('hasSellOfferTermLink.js'));
+  assert.match(hasRel.content, /"generatedBy": "user"/);
+  assert.match(hasRel.content, /"requiredOnCreate": true/);
+
+  const disabledRel = artifacts.find((a) =>
+    a.path.endsWith('disabledSellOfferTermLink.js')
+  );
+  assert.match(disabledRel.content, /"generatedBy": "user"/);
+
+  const isRel = artifacts.find((a) => a.path.endsWith('isSellOfferTerm.js'));
+  assert.match(isRel.content, /"generatedBy": "systemNoUser"/);
+  assert.match(isRel.content, /"objectType": "sellOfferTermValue"/);
+  assert.match(isRel.content, /"requiredOnCreate": true/);
+
+  const isLabelRel = artifacts.find((a) =>
+    a.path.endsWith('isSellOfferTermLabel.js')
+  );
+  assert.match(isLabelRel.content, /"generatedBy": "systemNoUser"/);
+  assert.match(isLabelRel.content, /"requiredOnCreate": true/);
+  // from objType should be sellOfferTermValue
+  assert.match(
+    isLabelRel.content,
+    /"from":\s*\{\s*"objType":\s*\{[^}]*"objectType": "sellOfferTermValue"/
+  );
+
   for (const artifact of artifacts) {
     assert.doesNotMatch(artifact.content, /dynamoDB/);
     assert.match(artifact.content, /GraphHandler/);
@@ -217,3 +249,53 @@ async function createProjectWithAttributeTree({
 
   return rootPath;
 }
+
+test('resolveTargetServicePath prioritizes dev suffix and matches attributeTag', async () => {
+  const tmpRoot = await mkdtemp(join(tmpdir(), 'izara-services-test-'));
+  projectRoots.add(tmpRoot);
+
+  const currentServiceDir = join(
+    tmpRoot,
+    'izara-market-products-sell-offer-manager-pong'
+  );
+  const targetWithSuffix = join(
+    tmpRoot,
+    'izara-market-products-sell-offer-term-pong'
+  );
+  const targetOtherDev = join(
+    tmpRoot,
+    'izara-market-products-sell-offer-term-alice'
+  );
+  const unrelatedService = join(
+    tmpRoot,
+    'izara-market-products-cart-pong'
+  );
+
+  await mkdir(join(currentServiceDir, 'app/src'), { recursive: true });
+  await mkdir(join(targetWithSuffix, 'app/src'), { recursive: true });
+  await mkdir(join(targetOtherDev, 'app/src'), { recursive: true });
+  await mkdir(join(unrelatedService, 'app/src'), { recursive: true });
+
+  const resolved = resolveTargetServicePath({
+    currentServiceRoot: currentServiceDir,
+    attributeTag: 'sellOfferTerm'
+  });
+
+  assert.equal(resolved, targetWithSuffix);
+});
+
+test('emitAttributeTreeTargetSchemas produces expected standard schemas', () => {
+  const targetDir = '/dummy/path/izara-market-products-sellOfferTerm';
+  const artifacts = emitAttributeTreeTargetSchemas({
+    attributeTag: 'sellOfferTerm',
+    targetServiceRoot: targetDir
+  });
+
+  assert.equal(artifacts.length, 3);
+  const paths = artifacts.map((a) => a.path);
+
+  assert.ok(paths.some((p) => p.endsWith('sellOfferTermValueStandardPropertyLabel.js')));
+  assert.ok(paths.some((p) => p.endsWith('sellOfferTermValueStandardPropertyValue.js')));
+  assert.ok(paths.some((p) => p.endsWith('sellOfferTermValueStandard.js')));
+});
+

package/test/customFlowApplicationArtifacts.test.js

@@ -88,6 +88,15 @@ test('emits handlers, function YAML, and IAM roles for supported custom flow eve
   assert.match(iam, /ApiRole:/);
   assert.match(iam, /OwnRole:/);
   assert.match(iam, /UploadRole:/);
+  const customSqsYaml = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-custom-flows.yml'
+    ),
+    'utf8'
+  );
+  assert.match(customSqsYaml, /ExtHdrSqs:/);
+  assert.doesNotMatch(customSqsYaml, /ProcessExtHdrSqs/);
   assert.match(
     await readFile(
       join(
@@ -1412,4 +1421,251 @@ test('emits early return cacheMain on cache hit in FlowEndpoint_Main for storedC
   await parseAsEsm(mainPath);
 });
 
+test('emits canonical checkStatusField and hooks in FlowEndpoint_Main for statusField', async () => {
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/FlowSchemas/StatusFieldFlow.js'),
+    `export default {
+  flowTag: 'statusFieldOrder',
+  event: ['ownTopic'],
+  statusType: 'statusField',
+  objType: { objectType: 'order', serviceTag: 'Current' },
+  flowSteps: [{ stepName: 'Start' }]
+};\n`
+  );
+
+  await generateCustomFlowApplicationArtifacts(rootPath);
+
+  const mainPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/StatusFieldOrder/source/StatusFieldOrder_Main.js'
+  );
+  const mainContent = await readFile(mainPath, 'utf8');
+  assert.match(
+    mainContent,
+    /import statusFieldSharedLib from '@izara_project\/izara-core-library-status-field';/
+  );
+  assert.match(mainContent, /statusFieldSharedLib\.checkStatusField/);
+  assert.match(mainContent, /\/\/\(<beforeCheckedStatusField>\)/);
+  assert.match(mainContent, /\/\/\(<identifiers>\)/);
+  assert.match(mainContent, /\/\/\(<overwriteUniqueRequestId>\)/);
+  assert.match(mainContent, /\/\/\(<afterCheckStatusField>\)/);
+  assert.match(mainContent, /\/\/\(<afterValidateStatusField>\)/);
+  assert.match(mainContent, /\/\/\(<checkStatusFieldHook>\)/);
+  assert.match(mainContent, /\/\/\(<endpointHook>\)/);
+  assert.match(mainContent, /\/\/\(<beforeCompleteStatusField>\)/);
+  assert.match(mainContent, /statusFieldSharedLib\.completeStatusField/);
+  assert.match(mainContent, /\/\/\(<statusField>\)/);
+  assert.match(mainContent, /\/\/\(<errorFounds>\)/);
+  assert.match(mainContent, /\/\/\(<afterCompleteStatusField>\)/);
+  assert.match(
+    mainContent,
+    /_izContext\.logger\.debug\('\[StatusFieldOrder_Main\] started', \{\s*requestParams,\s*callingFlowConfig\s*\}\);/
+  );
+  await parseAsEsm(mainPath);
+});
+
+test('does not emit RbacCallback artifacts or duplicate artifact paths for custom flow with RBAC', async () => {
+  const { generate } = await import('../src/generate.js');
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/ComAcc.js'),
+    `export default {
+  objectType: 'comAcc',
+  belongTo: {
+    objectType: 'user',
+    serviceTag: 'UserAccount'
+  }
+};\n`
+  );
+  await writeFile(
+    join(
+      rootPath,
+      'app/src/schemas/FlowSchemas/CreateBusinessToComAcc.js'
+    ),
+    `export default {
+  flowTag: 'createBusinessToComAcc',
+  event: ['lambdaSyncInv', 'ownTopic'],
+  objType: {
+    objectType: 'comAcc',
+    serviceTag: 'ComAcc'
+  },
+  flowSteps: [{ stepName: 'Start' }]
+};\n`
+  );
+
+  const result = await generate(rootPath, {
+    serviceTag: 'BusinessService'
+  });
+  assert.ok(result);
+
+  const sourceDir = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/CreateBusinessToComAcc/source'
+  );
+  const mainPath = join(sourceDir, 'CreateBusinessToComAcc_Main.js');
+  const mainContent = await readFile(mainPath, 'utf8');
+  assert.match(mainContent, /checkRbacPermission/);
+  assert.doesNotMatch(mainContent, /CreateBusinessToComAccRbacCallback/);
+
+  await assert.rejects(
+    () =>
+      readFile(
+        join(sourceDir, 'CreateBusinessToComAccRbacCallback_Main.js'),
+        'utf8'
+      ),
+    { code: 'ENOENT' }
+  );
+  await assert.rejects(
+    () =>
+      readFile(
+        join(sourceDir, 'CreateBusinessToComAccRbacCallback_HdrSqs.js'),
+        'utf8'
+      ),
+    { code: 'ENOENT' }
+  );
+
+  const initialSetupConfigContent = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/CoreFunctions/InitialSetupConfig.js'
+    ),
+    'utf8'
+  );
+  assert.doesNotMatch(
+    initialSetupConfigContent,
+    /CreateBusinessToComAccRbacCallbackHdrSqs/
+  );
+});
+
+test('skips checkRbacPermission in FlowEndpoint_Main when initiateBy is systemNoUser', async () => {
+  const { generate } = await import('../src/generate.js');
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/ComAcc.js'),
+    `export default {
+  objectType: 'comAcc',
+  belongTo: {
+    objectType: 'user',
+    serviceTag: 'UserAccount'
+  }
+};\n`
+  );
+  await writeFile(
+    join(
+      rootPath,
+      'app/src/schemas/FlowSchemas/SystemCronFlow.js'
+    ),
+    `export default {
+  flowTag: 'systemCronFlow',
+  event: ['ownTopic'],
+  initiateBy: 'systemNoUser',
+  objType: {
+    objectType: 'comAcc',
+    serviceTag: 'ComAcc'
+  },
+  flowSteps: [{ stepName: 'Start' }]
+};\n`
+  );
+
+  const result = await generate(rootPath, {
+    serviceTag: 'BusinessService'
+  });
+  assert.ok(result);
+
+  const mainPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/SystemCronFlow/source/SystemCronFlow_Main.js'
+  );
+  const mainContent = await readFile(mainPath, 'utf8');
+  assert.doesNotMatch(mainContent, /checkRbacPermission/);
+  await parseAsEsm(mainPath);
+});
+
+test('emits completeStatusField only in the final flowStep for statusType statusField', async () => {
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/FlowSchemas/MultiStepStatus.js'),
+    `export default {
+  flowTag: 'multiStepStatus',
+  event: ['ownTopic'],
+  statusType: 'statusField',
+  objType: { objectType: 'order', serviceTag: 'Current' },
+  flowSteps: [
+    {
+      stepName: 'Start',
+      nextSteps: [
+        {
+          targetType: 'extTopic',
+          serviceTag: 'PaymentService',
+          topicName: 'Process_In',
+          toStepNames: ['Process']
+        }
+      ]
+    },
+    {
+      stepName: 'Process',
+      event: ['extTopic'],
+      previousSteps: [{ sourceType: 'ownTopic', stepName: 'Start' }],
+      nextSteps: [
+        {
+          targetType: 'extTopic',
+          serviceTag: 'PaymentService',
+          topicName: 'Finalize_In',
+          toStepNames: ['Finalize']
+        }
+      ]
+    },
+    {
+      stepName: 'Finalize',
+      event: ['extTopic'],
+      previousSteps: [{ sourceType: 'extTopic', serviceTag: 'PaymentService', topicName: 'Process_Out', fromStepNames: ['Process'] }]
+    }
+  ]
+};\n`
+  );
+
+  await generateCustomFlowApplicationArtifacts(rootPath);
+
+  // 1. Start step (FlowEndpoint_Main) has checkStatusField, NOT completeStatusField
+  const startPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/MultiStepStatus/source/MultiStepStatus_Main.js'
+  );
+  const startContent = await readFile(startPath, 'utf8');
+  assert.match(startContent, /statusFieldSharedLib\.checkStatusField/);
+  assert.doesNotMatch(startContent, /completeStatusField/);
+  await parseAsEsm(startPath);
+
+  // 2. Middle step (Process) is not the last step, so NO completeStatusField
+  const processPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/MultiStepStatus/source/MultiStepStatusProcess_Main.js'
+  );
+  const processContent = await readFile(processPath, 'utf8');
+  assert.doesNotMatch(processContent, /statusFieldSharedLib/);
+  assert.doesNotMatch(processContent, /completeStatusField/);
+  await parseAsEsm(processPath);
+
+  // 3. Final step (Finalize) IS the last step, so it has completeStatusField and canonical hooks
+  const finalizePath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/MultiStepStatus/source/MultiStepStatusFinalize_Main.js'
+  );
+  const finalizeContent = await readFile(finalizePath, 'utf8');
+  assert.match(
+    finalizeContent,
+    /import statusFieldSharedLib from '@izara_project\/izara-core-library-status-field';/
+  );
+  assert.match(finalizeContent, /\/\/\(<beforeCompleteStatusField>\)/);
+  assert.match(finalizeContent, /statusFieldSharedLib\.completeStatusField/);
+  assert.match(finalizeContent, /flowTag:\s*'multiStepStatus'/);
+  assert.match(finalizeContent, /\/\/\(<identifiers>\)/);
+  assert.match(finalizeContent, /\/\/\(<statusField>\)/);
+  assert.match(finalizeContent, /\/\/\(<errorFounds>\)/);
+  assert.match(finalizeContent, /\/\/\(<afterCompleteStatusField>\)/);
+  await parseAsEsm(finalizePath);
+});
+
+
 

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, {