@izara_project/izara-core-generate-service-code 1.0.87 → 1.0.89

package/test/crudApplicationArtifacts.test.js

@@ -42,6 +42,30 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
       'utf8'
     );
   assert.match(createMain, /CreateLogicalLib/);
+  assert.match(
+    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(createMain, /FlowHook|beforeLogical|codeHookTag/);
   const yaml = await readFile(
     join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
@@ -273,6 +297,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);
 
@@ -398,6 +442,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,
@@ -417,6 +477,822 @@ test('emits targetIdentifiers passed directly to checkRbacPermission options in
   assert.match(deleteMain, /checkRbacPermission\([\s\S]*targetIdentifiers,[\s\S]*rbacObjType/);
 });
 
+test('emits synchronous after-hook invocation in CreateLogicalLib when codeHookTag is after and invocationType is lambdaSyncInv', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/AuditAfterCreate.js'),
+    "export default { flowTag: 'auditAfterCreate', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'after', invocationType: 'lambdaSyncInv', objType: { objectType: 'order' } } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createLogicalLib,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'auditAfterCreate'\s*\)/
+  );
+  assert.match(createLogicalLib, /Hook auditAfterCreate failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+
+  assert.ok(result.files.every((f) => !f.path.includes('CreateAfterHookCallback')));
+});
+
+test('emits synchronous after-hook invocation in CreateNodeCallback_Main when object has graph and hook is sync', async () => {
+  const rootPath = await createRbacProject(false, true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/AuditAfterCreate.js'),
+    "export default { flowTag: 'auditAfterCreate', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'after', invocationType: 'lambdaSyncInv', objType: { objectType: 'order' } } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const nodeCallbackMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    nodeCallbackMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'auditAfterCreate'\s*\)/
+  );
+  assert.match(nodeCallbackMain, /Hook auditAfterCreate failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateNodeCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async after-hook callback and SNS publish in CreateLogicalLib and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/NotifyAfterCreate.js'),
+    "export default { flowTag: 'notifyAfterCreate', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'after', invocationType: 'ownTopic', objType: { objectType: 'order' } } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createLogicalLib = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+    ),
+    'utf8'
+  );
+  assert.match(createLogicalLib, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    createLogicalLib,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'notifyAfterCreate_In'\s*\)/
+  );
+  assert.match(createLogicalLib, /CreateAfterHookCallbackHdrSqs/);
+
+  const afterHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    afterHookMain,
+    /export default async function CreateAfterHookCallbackMain/
+  );
+  assert.match(
+    afterHookMain,
+    /TOPIC_NAME_GENERATE_CODE\.outCreateNodeComplete/
+  );
+
+  const afterHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(afterHookHdrSqs, /CreateAfterHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateAfterHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateLogicalLib.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+
+  const yaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
+    'utf8'
+  );
+  assert.match(yaml, /CreateAfterHookCallbackHdrSqs:/);
+  assert.match(yaml, /CreateAfterHookCallback_HdrSqs\.main/);
+});
+
+test('emits async before-hook callback and SNS publish in Create_Main and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeCreate.js'),
+    "export default { flowTag: 'validateBeforeCreate', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', invocationType: 'ownTopic' }, 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'
+  );
+  assert.match(createMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    createMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeCreate_In'\s*\)/
+  );
+  assert.match(createMain, /CreateBeforeHookCallbackHdrSqs/);
+
+  const beforeHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    beforeHookMain,
+    /export default async function CreateBeforeHookCallbackMain/
+  );
+  assert.match(beforeHookMain, /CreateLogicalLib/);
+
+  const beforeHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(beforeHookHdrSqs, /CreateBeforeHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits sync before-hook in Create_Main with abort check', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeCreateSync.js'),
+    "export default { flowTag: 'validateBeforeCreateSync', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'create', 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'
+  );
+  assert.match(
+    createMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeCreateSync'\s*\)/
+  );
+  assert.match(createMain, /Hook validateBeforeCreateSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async before-hook callback and SNS publish in Update_Main and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeUpdate.js'),
+    "export default { flowTag: 'validateBeforeUpdate', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'update', codeHookTag: 'before', invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(updateMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    updateMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeUpdate_In'\s*\)/
+  );
+  assert.match(updateMain, /UpdateBeforeHookCallbackHdrSqs/);
+
+  const beforeHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    beforeHookMain,
+    /export default async function UpdateBeforeHookCallbackMain/
+  );
+  assert.match(beforeHookMain, /UpdateLogicalLib/);
+  assert.match(beforeHookMain, /handleUpdateError/);
+
+  const beforeHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(beforeHookHdrSqs, /UpdateBeforeHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateBeforeHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits sync before-hook in Update_Main with abort check', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeUpdateSync.js'),
+    "export default { flowTag: 'validateBeforeUpdateSync', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'update', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const updateMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    updateMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeUpdateSync'\s*\)/
+  );
+  assert.match(updateMain, /Hook validateBeforeUpdateSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/Update_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async before-hook callback and SNS publish in Delete_Main and flow-objects.yml', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeDelete.js'),
+    "export default { flowTag: 'validateBeforeDelete', event: ['ownTopic'], generatedCodeConfig: { generateCodeTag: 'delete', codeHookTag: 'before', invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const deleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(deleteMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    deleteMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeDelete_In'\s*\)/
+  );
+  assert.match(deleteMain, /DeleteBeforeHookCallbackHdrSqs/);
+
+  const beforeHookMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    beforeHookMain,
+    /export default async function DeleteBeforeHookCallbackMain/
+  );
+  assert.match(beforeHookMain, /DeleteLogicalLib/);
+  assert.match(beforeHookMain, /handleDeleteError/);
+
+  const beforeHookHdrSqs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(beforeHookHdrSqs, /DeleteBeforeHookCallbackMain/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/DeleteBeforeHookCallback_HdrSqs.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits sync before-hook in Delete_Main with abort check', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeDeleteSync.js'),
+    "export default { flowTag: 'validateBeforeDeleteSync', event: ['lambdaSyncInv'], generatedCodeConfig: { generateCodeTag: 'delete', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const deleteMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    deleteMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeDeleteSync'\s*\)/
+  );
+  assert.match(deleteMain, /Hook validateBeforeDeleteSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Delete/source/Delete_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+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/);
+});
+
 async function createProject(withCrudObject) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-application-')