@izara_project/izara-core-generate-service-code 1.0.88 → 1.0.90

package/test/crudApplicationArtifacts.test.js

@@ -46,6 +46,30 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
     createMain,
     /validateFieldNames\(_izContext, requestParams, objectSchemas, errorsFound\)/
   );
+  assert.doesNotMatch(
+    createMain,
+    /const \{ createDataDetailsLib \} = dataDetailsLib;/
+  );
+  const createLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createLogicalLib,
+    /export async function resolveAndGenerateIdentifiers\(\s*_izContext,\s*requestParams,\s*objectSchema,\s*errorsFound\s*\)/
+  );
+  assert.match(createLogicalLib, /return \{\s*objectSchemas\s*\};/);
+  assert.match(
+    createLogicalLib,
+    /export function validateFieldNames\(\s*_izContext,\s*requestParams,\s*objectSchemas,\s*errorsFound\s*\)/
+  );
+  assert.doesNotMatch(
+    createLogicalLib,
+    /targetIdentifiers\.submittedByUserId\s*=/
+  );
   assert.doesNotMatch(createMain, /FlowHook|beforeLogical|codeHookTag/);
   const yaml = await readFile(
     join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
@@ -277,6 +301,26 @@ test('emits Complete handlers and inlines sync RBAC for Update with Graph', asyn
   );
 });
 
+test('omits CreateComplete_Main and CreateCompleteHdrSqs when hasCreateNodeCallback is true', async () => {
+  const rootPath = await createRbacProject(false, true);
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+  const createPaths = result.files
+    .map((file) => file.path)
+    .filter((path) => path.includes('/FlowObjects/Create/source/'));
+
+  assert.ok(createPaths.includes(
+    'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+  ));
+  assert.ok(!createPaths.includes(
+    'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'
+  ));
+  assert.ok(!createPaths.includes(
+    'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_HdrSqs.js'
+  ));
+});
+
 test('rejects deprecated FlowHook schemas', async () => {
   const rootPath = await createRbacProject(true);
 
@@ -402,6 +446,22 @@ test('emits targetIdentifiers passed directly to checkRbacPermission options in
     serviceTag: 'orders'
   });
 
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createMain,
+    /targetIdentifiers:\s*requestParams\.rbacTargetIdentifiers\s*\|\|\s*requestParams\.targetIdentifiers/
+  );
+  assert.doesNotMatch(
+    createMain,
+    /const\s*\{[^}]*targetIdentifiers[^}]*\}\s*=\s*await\s*resolveSchemaAndIdentity/
+  );
+
   const updateMain = await readFile(
     join(
       rootPath,
@@ -581,6 +641,31 @@ test('emits async after-hook callback and SNS publish in CreateLogicalLib and fl
     { stdio: 'inherit' }
   );
 
+  const createCompleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createCompleteMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'notifyAfterCreate_In'\s*\)/
+  );
+  assert.match(createCompleteMain, /CreateAfterHookCallbackHdrSqs/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+
   const yaml = await readFile(
     join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
     'utf8'
@@ -948,6 +1033,361 @@ test('emits sync before-hook in Delete_Main with abort check', async () => {
   );
 });
 
+test('emits hooks across multiple endpoints when generateCodeTag is an array', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/CheckOrderMulti.js'),
+    "export default { flowTag: 'checkOrderMulti', event: ['lambdaSyncInv'], " +
+      "generatedCodeConfig: { generateCodeTag: ['create', 'update'], " +
+      "codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, " +
+      "objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  const updateMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+    ),
+    'utf8'
+  );
+  const deleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+    ),
+    'utf8'
+  );
+
+  assert.match(createMain, /'checkOrderMulti'/);
+  assert.match(updateMain, /'checkOrderMulti'/);
+  assert.doesNotMatch(deleteMain, /'checkOrderMulti'/);
+});
+
+test('emits ownTopic before-hook callbacks across multiple endpoints when generateCodeTag is an array', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateOrderMulti.js'),
+    "export default { flowTag: 'validateOrderMulti', event: ['ownTopic'], " +
+      "generatedCodeConfig: { generateCodeTag: ['update', 'delete'], " +
+      "codeHookTag: 'before', invocationType: 'ownTopic' }, " +
+      "objType: { objectType: 'order' } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateCallbackExists = result.files.some((f) =>
+    f.path.includes('UpdateBeforeHookCallback_Main.js')
+  );
+  const deleteCallbackExists = result.files.some((f) =>
+    f.path.includes('DeleteBeforeHookCallback_Main.js')
+  );
+  const createCallbackExists = result.files.some((f) =>
+    f.path.includes('CreateBeforeHookCallback_Main.js')
+  );
+
+  assert.strictEqual(updateCallbackExists, true);
+  assert.strictEqual(deleteCallbackExists, true);
+  assert.strictEqual(createCallbackExists, false);
+});
+
+test('emits synchronous ConfirmUsage and CancelUsage invocation in CreateLogicalLib when object has rbac and graph', async () => {
+  const rootPath = await createRbacProject(false, true);
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  const createLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+
+  assert.match(createLogicalLib, /ConfirmUsageHdrInv/);
+  assert.match(createLogicalLib, /CancelUsageHdrInv/);
+  assert.match(createLogicalLib, /lambda\.invokeSync\(/);
+  assert.match(createLogicalLib, /publishCompletionMessage\(/);
+});
+
+test('emits synchronous AfterHook invocation in Update and Delete handlers', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/AuditOrderMulti.js'),
+    "export default { flowTag: 'auditOrderMulti', event: ['lambdaSyncInv'], " +
+      "generatedCodeConfig: { generateCodeTag: ['update', 'delete'], " +
+      "codeHookTag: 'after', invocationType: 'lambdaSyncInv' }, " +
+      "objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateComplete = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
+    ),
+    'utf8'
+  );
+  const updateLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  const deleteComplete = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteComplete_Main.js'
+    ),
+    'utf8'
+  );
+  const deleteLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteLogicalLib.js'
+    ),
+    'utf8'
+  );
+
+  assert.match(updateComplete, /'auditOrderMulti'/);
+  assert.match(updateComplete, /lambda\.invokeSync\(/);
+  assert.match(updateLogicalLib, /'auditOrderMulti'/);
+  assert.match(updateLogicalLib, /lambda\.invokeSync\(/);
+  assert.match(deleteComplete, /'auditOrderMulti'/);
+  assert.match(deleteComplete, /lambda\.invokeSync\(/);
+  assert.match(deleteLogicalLib, /'auditOrderMulti'/);
+  assert.match(deleteLogicalLib, /lambda\.invokeSync\(/);
+});
+
+test('emits ownTopic after-hook callbacks and dispatch for update and delete', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/NotifyOrderMulti.js'),
+    "export default { flowTag: 'notifyOrderMulti', event: ['ownTopic'], " +
+      "generatedCodeConfig: { generateCodeTag: ['update', 'delete'], " +
+      "codeHookTag: 'after', invocationType: 'ownTopic' }, " +
+      "objType: { objectType: 'order' } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateCallbackExists = result.files.some((f) =>
+    f.path.includes('UpdateAfterHookCallback_Main.js')
+  );
+  const deleteCallbackExists = result.files.some((f) =>
+    f.path.includes('DeleteAfterHookCallback_Main.js')
+  );
+  assert.strictEqual(updateCallbackExists, true);
+  assert.strictEqual(deleteCallbackExists, true);
+
+  const updateComplete = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
+    ),
+    'utf8'
+  );
+  const updateLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  const deleteComplete = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteComplete_Main.js'
+    ),
+    'utf8'
+  );
+  const deleteLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteLogicalLib.js'
+    ),
+    'utf8'
+  );
+
+  assert.match(updateComplete, /'notifyOrderMulti_In'/);
+  assert.match(updateComplete, /UpdateAfterHookCallbackHdrSqs/);
+  assert.match(updateLogicalLib, /'notifyOrderMulti_In'/);
+  assert.match(updateLogicalLib, /UpdateAfterHookCallbackHdrSqs/);
+  assert.match(deleteComplete, /'notifyOrderMulti_In'/);
+  assert.match(deleteComplete, /DeleteAfterHookCallbackHdrSqs/);
+  assert.match(deleteLogicalLib, /'notifyOrderMulti_In'/);
+  assert.match(deleteLogicalLib, /DeleteAfterHookCallbackHdrSqs/);
+});
+
+test('supports objType in generatedCodeConfig with string, array, and global hook', async () => {
+  const rootPath = await createProject(true);
+  const schemaRoot = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemaRoot, 'ObjectSchemas/Cart.js'),
+    "export default { objectType: 'cart', generatedBy: 'user' };\n"
+  );
+  await writeFile(
+    join(schemaRoot, 'FlowSchemas/HookWithCustomObjType.js'),
+    `export default {
+      flowTag: 'hookWithCustomObj',
+      objType: { objectType: 'rootAudit' },
+      event: ['lambdaSyncInv'],
+      generatedCodeConfig: {
+        generateCodeTag: 'create',
+        codeHookTag: 'before',
+        invocationType: 'lambdaSyncInv',
+        objType: 'cart'
+      }
+    };\n`
+  );
+  await writeFile(
+    join(schemaRoot, 'FlowSchemas/HookWithMultiObjType.js'),
+    `export default {
+      flowTag: 'hookWithMultiObj',
+      objType: { objectType: 'rootAudit' },
+      event: ['ownTopic'],
+      outputTopic: true,
+      generatedCodeConfig: {
+        generateCodeTag: 'update',
+        codeHookTag: 'after',
+        invocationType: 'ownTopic',
+        objType: ['order', 'cart']
+      }
+    };\n`
+  );
+  await writeFile(
+    join(schemaRoot, 'FlowSchemas/GlobalHook.js'),
+    `export default {
+      flowTag: 'globalDeleteHook',
+      event: ['lambdaSyncInv'],
+      generatedCodeConfig: {
+        generateCodeTag: 'delete',
+        codeHookTag: 'before',
+        invocationType: 'lambdaSyncInv'
+      }
+    };\n`
+  );
+
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  // 1. Before hook with custom objType 'cart' should be attached to cart, not rootAudit
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(createMain, /if \(requestParams\.objectType === 'cart'\)/);
+  assert.match(createMain, /hookPayload_hookWithCustomObj/);
+
+  // 2. After hook with multi objType ['order', 'cart'] should check array
+  const updateComplete = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(updateComplete, /\["order","cart"\]\.includes/);
+  assert.match(updateComplete, /hookPayload_hookWithMultiObj/);
+
+  // 3. Global delete hook without objType should be present
+  const deleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(deleteMain, /hookPayload_globalDeleteHook/);
+});
+
+test('omits autoProvisionOwnerTargetRole in CreateNodeCallback when service only has child RBAC objects', async () => {
+  const rootPath = await createRbacProject(false, true);
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const callbackMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.doesNotMatch(callbackMain, /autoProvisionOwnerTargetRole\(_izContext/);
+
+  const logicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(logicalLib, /const ROOT_RBAC_OBJECT_TYPES = new Set\(\[\s*\]\);/);
+});
+
+test('emits autoProvisionOwnerTargetRole in CreateNodeCallback when service has root RBAC object', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-crud-root-rbac-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas');
+  await mkdir(join(schemaRoot, 'ObjectSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'FlowSchemas'), { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'ObjectSchemas/Workspace.js'),
+    "export default { objectType: 'workspace', generatedBy: 'user', addOnDataStructure: [{ type: 'rbac' }], storageResources: { graph: { storageType: 'graph' } } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'workspaces'
+  });
+
+  const callbackMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    callbackMain,
+    /await autoProvisionOwnerTargetRole\(_izContext,\s*\{\s*node,\s*submittedByUserId,\s*objType: returnValue\?\.requestParams\?\.objType\s*\}\);/
+  );
+
+  const logicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    logicalLib,
+    /const ROOT_RBAC_OBJECT_TYPES = new Set\(\[\s*'workspace',\s*\]\);/
+  );
+});
+
 async function createProject(withCrudObject) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-application-')

package/test/dynamicCrudFlowSchemas.test.js

@@ -142,7 +142,7 @@ test('generates a direct Complete step for RBAC-only Update flows', async () =>
   assert.equal(update.flowSteps[1].properties.length, 0);
 });
 
-test('generates CreateNodeCallback and Complete for Create when RBAC and Graph are present', async () => {
+test('generates CreateNodeCallback for Create when RBAC and Graph are present', async () => {
   const rootPath = await createProject({
     generatedBy: 'user',
   });
@@ -160,8 +160,14 @@ test('generates CreateNodeCallback and Complete for Create when RBAC and Graph a
   const create = await readGeneratedFlow(rootPath, 'Create');
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
-    'CreateNodeCallback',
-    'Complete'
+    'CreateNodeCallback'
+  ]);
+  assert.deepEqual(create.flowSteps[1].nextSteps, [
+    {
+      targetType: 'lambdaSyncInv',
+      serviceTag: 'Rbac',
+      functionName: 'ConfirmUsageHdrInv'
+    }
   ]);
 });
 
@@ -185,8 +191,7 @@ test('uses CreateNodeCallback step when Graph storage is present with sync RBAC'
   const create = await readGeneratedFlow(rootPath, 'Create');
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
-    'CreateNodeCallback',
-    'Complete'
+    'CreateNodeCallback'
   ]);
   assert.deepEqual(create.flowSteps[1].properties, [
     'returnValue',

package/test/dynamicRbacFlowSchemas.test.js

@@ -69,6 +69,27 @@ test('generates shared and object-specific RBAC flow schemas', async () => {
   });
   assert.deepEqual(user.event, ['ownTopic']);
   assert.equal(user.steps, undefined);
+
+  const confirmUsage = await readGeneratedFlow(
+    rootPath,
+    'ConfirmUsage',
+    'FlowLimit'
+  );
+  const cancelUsage = await readGeneratedFlow(
+    rootPath,
+    'CancelUsage',
+    'FlowLimit'
+  );
+  assert.deepEqual(confirmUsage.event, [
+    'ownTopic',
+    'lambdaSyncInv',
+    'lambdaSyncApi'
+  ]);
+  assert.deepEqual(cancelUsage.event, [
+    'ownTopic',
+    'lambdaSyncInv',
+    'lambdaSyncApi'
+  ]);
 });
 
 test('removes RBAC schemas when the last RBAC object is removed', async () => {
@@ -144,10 +165,11 @@ async function createProject({ hasRbac = false } = {}) {
   return rootPath;
 }
 
-async function readGeneratedFlow(rootPath, flowTag) {
+async function readGeneratedFlow(rootPath, flowTag, folder = 'FlowRbac') {
   const filePath = join(
     rootPath,
-    'app/src/schemas/FlowSchemas/generateCode/FlowRbac',
+    'app/src/schemas/FlowSchemas/generateCode',
+    folder,
     `${flowTag}.js`
   );
   const module = await import(

package/test/graphDrivenFlowSchema.test.js

@@ -255,3 +255,39 @@ test('validateFlowSchema rejects lambdaSyncInv nextSteps missing functionName',
     /lambdaSyncInv target requires non-empty 'functionName'/
   );
 });
+
+test('validateFlowSchema passes for mixed sync and async events with single Start step', () => {
+  const mixedSingleStepSchema = {
+    flowTag: 'ConfirmUsage',
+    event: ['ownTopic', 'lambdaSyncInv', 'lambdaSyncApi'],
+    flowSteps: [
+      {
+        stepName: 'Start'
+      }
+    ]
+  };
+
+  assert.equal(validateFlowSchema(mixedSingleStepSchema), true);
+});
+
+test('validateFlowSchema rejects flow with synchronous events having multiple flowSteps', () => {
+  const mixedMultiStepSchema = {
+    flowTag: 'ConfirmUsage',
+    event: ['ownTopic', 'lambdaSyncInv'],
+    flowSteps: [
+      {
+        stepName: 'Start',
+        nextSteps: [{ targetType: 'ownTopic', stepName: 'StepTwo' }]
+      },
+      {
+        stepName: 'StepTwo',
+        previousSteps: [{ sourceType: 'ownTopic', stepName: 'Start' }]
+      }
+    ]
+  };
+
+  assert.throws(
+    () => validateFlowSchema(mixedMultiStepSchema),
+    /Flow 'ConfirmUsage' with synchronous events .* must only define a single entry step 'Start'/
+  );
+});