@izara_project/izara-core-generate-service-code 1.0.64 → 1.0.66

package/test/core.test.js

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, readdir, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+
+import { buildGenerationPlan } from '../src/plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../src/output/commitArtifacts.js';
+import { compileProject } from '../src/compile/compileProject.js';
+
+test('compiles a request and commits only declared relative artifacts', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-'));
+  const project = compileProject({ rootPath: outputPath });
+  const plan = buildGenerationPlan(project, [
+    { path: 'app/generated/example.js', content: 'export default 1;\n' }
+  ]);
+
+  assert.deepEqual(await commitArtifacts(plan), [{ path: 'app/generated/example.js' }]);
+  assert.equal(
+    await readFile(join(outputPath, 'app/generated/example.js'), 'utf8'),
+    'export default 1;\n'
+  );
+});
+
+test('rejects invalid generation inputs before writing files', async () => {
+  assert.throws(() => compileProject({}), /rootPath/);
+
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-invalid-'));
+  const project = compileProject({ rootPath: outputPath });
+  await assert.rejects(
+    Promise.resolve().then(() => buildGenerationPlan(project, [{ path: '../outside.js', content: '' }])),
+    /escapes output root/
+  );
+  await assert.rejects(
+    Promise.resolve().then(() => buildGenerationPlan(project, [
+      { path: 'same.js', content: '' },
+      { path: 'same.js', content: '' }
+    ])),
+    /Duplicate artifact path/
+  );
+  await assert.rejects(readFile(join(outputPath, 'same.js')));
+});
+
+test('rejects a symlinked output directory', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-output-'));
+  const outsidePath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-outside-'));
+  await symlink(outsidePath, join(outputPath, 'linked'));
+
+  const plan = buildGenerationPlan(compileProject({ rootPath: outputPath }), [
+    { path: 'linked/escaped.js', content: 'export default 1;\n' }
+  ]);
+
+  await assert.rejects(commitArtifacts(plan), /non-directory/);
+  await assert.rejects(readFile(join(outsidePath, 'escaped.js')));
+});
+
+test('does not delete a legacy file before a managed scope has established ownership', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-managed-scope-'));
+  const project = compileProject({ rootPath: outputPath });
+  await writeFile(join(outputPath, 'legacy.js'), 'legacy\n');
+
+  await commitArtifacts(buildGenerationPlan(project, [], {
+    managedPaths: ['legacy.js'],
+    managedScope: 'example-scope'
+  }));
+  assert.equal(await readFile(join(outputPath, 'legacy.js'), 'utf8'), 'legacy\n');
+
+  await commitArtifacts(buildGenerationPlan(project, [{ path: 'legacy.js', content: 'v2\n' }], {
+    managedPaths: ['legacy.js'],
+    managedScope: 'example-scope'
+  }));
+  await commitArtifacts(buildGenerationPlan(project, [], {
+    managedPaths: ['legacy.js'],
+    managedScope: 'example-scope'
+  }));
+  await assert.rejects(readFile(join(outputPath, 'legacy.js')));
+});
+
+test('commits and cleans multiple managed scopes in one transaction', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-multi-scope-'));
+  const project = compileProject({ rootPath: outputPath });
+  const managedScopes = { schemas: ['schemas.js'], application: ['application.js'] };
+  await commitArtifacts(buildGenerationPlan(project, [
+    { path: 'schemas.js', content: 'schema\n' },
+    { path: 'application.js', content: 'application\n' }
+  ], { managedScopes }));
+
+  await commitArtifacts(buildGenerationPlan(project, [
+    { path: 'application.js', content: 'application next\n' }
+  ], { managedScopes }));
+
+  await assert.rejects(readFile(join(outputPath, 'schemas.js')));
+  assert.equal(await readFile(join(outputPath, 'application.js'), 'utf8'), 'application next\n');
+});
+
+test('merges preserved hook blocks into staged source without changing the hook', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-hooks-'));
+  const hookPath = join(outputPath, 'app/generated/hook/example.js');
+  await mkdir(dirname(hookPath), { recursive: true });
+  await writeFile(hookPath, '//(<hookCode>)\ncustom();\n//(</hookCode>)\n');
+
+  await commitArtifacts(buildGenerationPlan(compileProject({ rootPath: outputPath }), [{
+    path: 'app/generated/source/example.js',
+    content: '//(<hookCode>)\ndefault();\n//(</hookCode>)\n'
+  }]));
+
+  assert.equal(
+    await readFile(join(outputPath, 'app/generated/source/example.js'), 'utf8'),
+    '//(<hookCode>)\ncustom();\n//(</hookCode>)\n'
+  );
+  assert.equal(await readFile(hookPath, 'utf8'), '//(<hookCode>)\ncustom();\n//(</hookCode>)\n');
+});
+
+test('rejects an invalid rendered artifact before staging output', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-invalid-render-'));
+  const sourcePath = join(outputPath, 'app/generated/source/example.js');
+  await mkdir(dirname(sourcePath), { recursive: true });
+  await writeFile(sourcePath, 'existing source\n');
+
+  await assert.rejects(
+    commitArtifacts({
+      project: compileProject({ rootPath: outputPath }),
+      artifacts: [{ path: 'app/generated/source/example.js', content: null }]
+    }),
+    /content must be a string/
+  );
+  assert.equal(await readFile(sourcePath, 'utf8'), 'existing source\n');
+  assert.deepEqual(
+    (await readdir(outputPath)).filter(name => name.startsWith('.generate-service-code-v2-stage-')),
+    []
+  );
+});
+
+test('rejects a failed output transaction without partial files, hooks, or staging residue', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-transaction-'));
+  const project = compileProject({ rootPath: outputPath });
+  const sourcePath = join(outputPath, 'app/generated/source/first.js');
+  const hookPath = join(outputPath, 'app/generated/hook/first.js');
+  await mkdir(dirname(sourcePath), { recursive: true });
+  await mkdir(dirname(hookPath), { recursive: true });
+  await writeFile(sourcePath, 'old source\n');
+  await writeFile(hookPath, 'custom hook\n');
+  await mkdir(join(outputPath, 'app/generated/source/second.js'));
+
+  await assert.rejects(
+    commitArtifacts(buildGenerationPlan(project, [
+      { path: 'app/generated/source/first.js', content: 'new source\n' },
+      { path: 'app/generated/source/second.js', content: 'never committed\n' }
+    ])),
+    /not a file/
+  );
+  assert.equal(await readFile(sourcePath, 'utf8'), 'old source\n');
+  assert.equal(await readFile(hookPath, 'utf8'), 'custom hook\n');
+  assert.deepEqual(
+    (await readdir(outputPath)).filter(name => name.startsWith('.generate-service-code-v2-stage-')),
+    []
+  );
+  assert.equal((await readdir(outputPath)).includes('.bak'), false);
+});

package/test/createTargetRoleHandler.test.js

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import { generateCreateTargetRoleHandler } from '../src/emit/rbac/generateCreateTargetRoleHandler.js';
+
+const roots = new Set();
+const OWN_TOPIC_FLOWS = [
+  'CreateTargetRole',
+  'CreateRolePermissions',
+  'DeleteRolePermissions',
+  'DeleteTargetRole',
+  'CreateUserRole',
+  'DeleteUserFromRole'
+];
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('generates RBAC own-topic WebSocket entries alongside their SQS handlers', async () => {
+  const rootPath = await createProject(true);
+  const result = await generateCreateTargetRoleHandler(rootPath);
+
+  assert.equal(result.files.length, 36);
+  assert.match(await readFile(join(rootPath, result.files[0].path), 'utf8'), /ProcessCreateTargetRole/);
+  assert.match(await readFile(join(rootPath, result.files[1].path), 'utf8'), /ProcessCreateTargetRoleHdrSqs/);
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'), 'utf8'),
+    /FlowRbacRole/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRbac/ListTargetRole/source/ProcessListTargetRole_HdrApi.js'), 'utf8'),
+    /ProcessListTargetRole/
+  );
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'), 'utf8');
+  for (const flowTag of OWN_TOPIC_FLOWS) {
+    assert.match(
+      await readFile(join(rootPath, `app/src/generatedCode/FlowRbac/${flowTag}/source/${flowTag}_HdrWbs.js`), 'utf8'),
+      new RegExp(`import ${flowTag}`)
+    );
+    assert.match(yaml, new RegExp(`${flowTag}HdrWbs:\\n[\\s\\S]*websocket:`));
+  }
+});
+
+test('removes CreateTargetRole handler when RBAC is removed', async () => {
+  const rootPath = await createProject(true);
+  const objectPath = join(rootPath, 'app/src/schemas/ObjectSchemas/User.js');
+  await generateCreateTargetRoleHandler(rootPath);
+  await writeFile(objectPath, "export default { objectType: 'user', addOnDataStructure: [] };\n");
+
+  assert.deepEqual((await generateCreateTargetRoleHandler(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRbac/CreateTargetRole/source/ProcessCreateTargetRole_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRbac/CreateTargetRole/source/CreateTargetRole_HdrWbs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml')));
+});
+
+async function createProject(hasRbac) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-rbac-handler-'));
+  roots.add(rootPath);
+  const directory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  const addOns = hasRbac ? "[{ type: 'rbac' }]" : '[]';
+  await mkdir(directory, { recursive: true });
+  await writeFile(
+    join(directory, 'User.js'),
+    `export default { objectType: 'user', addOnDataStructure: ${addOns} };\n`
+  );
+  return rootPath;
+}

package/test/crudApplicationArtifacts.test.js

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import { generateCrudApplicationArtifacts } from '../src/emit/crud/generateCrudApplicationArtifacts.js';
+
+const roots = new Set();
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits CRUD handlers and function YAML from schema data without reading generated output', async () => {
+  const rootPath = await createProject(true);
+  const result = await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  assert.equal(result.files.length, 24);
+  assert.ok(result.files.every(file => !file.path.includes('/Process')));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Get/source/Get_Main.js'), 'utf8'),
+    /dataFromGraphV2/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'), 'utf8'),
+    /beforeLogical_order/
+  );
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'), 'utf8');
+  assert.match(yaml, /CreateHdrWbs:/);
+  assert.ok(yaml.indexOf('CreateHdrWbs:') < yaml.indexOf('CreateHdrSqs:'));
+  assert.doesNotMatch(yaml, /handler: .*\/Process/);
+  assert.match(yaml, /path: \/orders\/order\/get/);
+  assert.match(yaml, /GetHdrInv:/);
+  assert.match(yaml, /CreateCompleteHdrSqs:/);
+  assert.match(yaml, /#<#CreateCompleteHdrSqsFunctionSetting#>/);
+  assert.match(yaml, /filterPatterns:[\s\S]*CreateCompleteHdrSqs/);
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'), 'utf8'),
+    /checkAllAwaitingStepsFinishedWithReturnParams/
+  );
+  assert.doesNotMatch(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_WbsMain.js'), 'utf8'),
+    /from '@izara_project\/izara-core-generate-service-code'/
+  );
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/ProcessCreate_Main.js')));
+  for (const action of ['Create', 'Update', 'Delete']) {
+    execFileSync(process.execPath, ['--check', join(rootPath, `app/src/generatedCode/FlowObjects/${action}/source/${action}Complete_Main.js`)], { stdio: 'inherit' });
+    execFileSync(process.execPath, ['--check', join(rootPath, `app/src/generatedCode/FlowObjects/${action}/source/${action}Complete_HdrSqs.js`)], { stdio: 'inherit' });
+  }
+});
+
+test('preserves function-setting hooks across CRUD regeneration', async () => {
+  const rootPath = await createProject(true);
+  const hookPath = join(rootPath, 'app/sls_yaml/generatedCode/hook/flow-objects.yml');
+  await mkdir(join(rootPath, 'app/sls_yaml/generatedCode/hook'), { recursive: true });
+  await writeFile(
+    hookPath,
+    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n'
+  );
+
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  const yamlPath = join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml');
+  const yaml = await readFile(yamlPath, 'utf8');
+  assert.match(yaml, /#<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#\/CreateCompleteHdrSqsFunctionSetting#>/);
+
+  const conflictPath = join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js');
+  await rm(conflictPath);
+  await mkdir(conflictPath);
+
+  await assert.rejects(generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' }), /not a file/);
+  assert.equal(await readFile(yamlPath, 'utf8'), yaml);
+  assert.equal(
+    await readFile(hookPath, 'utf8'),
+    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n'
+  );
+});
+
+test('removes managed CRUD artifacts when no applicable object remains', async () => {
+  const rootPath = await createProject(true);
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+  await writeFile(join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'), "export default { objectType: 'order' };\n");
+
+  assert.deepEqual((await generateCrudApplicationArtifacts(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml')));
+});
+
+async function createProject(withCrudObject) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-crud-application-'));
+  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/Order.js'),
+    withCrudObject
+      ? "export default { objectType: 'order', generatedBy: 'userGenerated' };\n"
+      : "export default { objectType: 'order' };\n"
+  );
+  await writeFile(
+    join(schemaRoot, 'FlowSchemas/OrderBeforeLogical.js'),
+    "export default { flowTag: 'orderHook', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical', invocationType: 'ownTopic', objType: { objectType: 'order' } } };\n"
+  );
+  return rootPath;
+}

package/test/customFlowApplicationArtifacts.test.js

@@ -0,0 +1,294 @@
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import test, { after } from 'node:test';
+
+import { generateCustomFlowApplicationArtifacts } from '../src/emit/custom/generateCustomFlowApplicationArtifacts.js';
+import { generateResourceArtifacts } from '../src/emit/resource/generateResourceArtifacts.js';
+import { renderEventBridgeFunctionYaml } from '../src/emit/function/functionYamlArtifact.js';
+
+const roots = new Set();
+const execFileAsync = promisify(execFile);
+const parseEsmSource = `
+  import { readFile } from 'node:fs/promises';
+  import { SourceTextModule } from 'node:vm';
+  const path = process.argv[1];
+  new SourceTextModule(await readFile(path, 'utf8'), { identifier: path });
+`;
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits handlers, function YAML, and IAM roles for supported custom flow events', async () => {
+  const rootPath = await createProject();
+  const result = await generateCustomFlowApplicationArtifacts(rootPath);
+  await generateResourceArtifacts(rootPath);
+
+  assert.equal(result.files.length, 40);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Ext/source/ProcessExt_HdrSqs.js'), 'utf8'), /dummyId/);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Api/source/ProcessApi_HdrApi.js'), 'utf8'), /ProcessApi/);
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8');
+  assert.match(yaml, /ProcessEventHdrInv:/);
+  assert.match(yaml, /rate\(1 minute\)/);
+  assert.match(yaml, /ProcessExtHdrSqs:/);
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  assert.match(iam, /EventRole:/);
+  assert.match(iam, /ExtRole:/);
+  assert.match(iam, /InvRole:/);
+  assert.match(iam, /ApiRole:/);
+  assert.match(iam, /OwnRole:/);
+  assert.match(iam, /UploadRole:/);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Generated/source/Generated_HdrWbs.js'), 'utf8'), /Generated_WbsMain/);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Own/source/Own_HdrSqs.js'), 'utf8'), /Own_Main/);
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Own/source/Own_Main.js'), 'utf8'),
+    /asyncFlowSharedLib/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Cache/source/Cache_Main.js'), 'utf8'),
+    /"CurrentOrderTable"/
+  );
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Own/source/ProcessOwn_Main.js')));
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Mixed/source/Mixed_HdrSqs.js'), 'utf8'), /Mixed_Main/);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Mixed/source/ProcessMixed_HdrSqs.js'), 'utf8'), /ProcessMixed/);
+  assert.match(yaml, /OwnHdrWbs:/);
+  assert.match(yaml, /OwnHdrSqs:/);
+  assert.ok(yaml.indexOf('OwnHdrWbs:') < yaml.indexOf('OwnHdrSqs:'));
+  assert.match(yaml, /MixedHdrSqs:/);
+  assert.match(yaml, /ProcessMixedHdrSqs:/);
+  assert.match(yaml, /UploadProcessAfterUploadHdrS3:/);
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Upload/source/UploadProcessAfterUpload_Main.js'), 'utf8'),
+    /S3Client/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Upload/source/UploadCreatePreSignUrl_Main.js'), 'utf8'),
+    /createPresignedPost/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Upload/source/UploadConfirmAfterUpload_Main.js'), 'utf8'),
+    /confirmUsageMessage/
+  );
+  for (const path of [
+    'UploadCreateObject_Main.js',
+    'UploadReservedLimit_Main.js',
+    'UploadCreatePreSignUrl_Main.js',
+    'UploadConfirmAfterUpload_Main.js'
+  ]) {
+    assert.doesNotMatch(
+      await readFile(join(rootPath, `app/src/generatedCode/FlowSchemas/Upload/source/${path}`), 'utf8'),
+      /@izara_project\/izara-core-generate-service-code/
+    );
+  }
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Upload/source/UploadProcessAfterUpload_HdrS3.js'), 'utf8'),
+    /s3Record\.bucket,\n\s*s3Record\.object/
+  );
+  for (const path of [
+    'UploadCreateObject_Main.js',
+    'UploadCreateObject_HdrWbs.js',
+    'UploadReservedLimit_Main.js',
+    'UploadReservedLimit_HdrSqs.js',
+    'UploadCreatePreSignUrl_Main.js',
+    'UploadCreatePreSignUrl_HdrSqs.js',
+    'UploadProcessAfterUpload_Main.js',
+    'UploadProcessAfterUpload_HdrS3.js',
+    'UploadConfirmAfterUpload_Main.js',
+    'UploadConfirmAfterUpload_HdrSqs.js'
+  ]) {
+    await parseAsEsm(join(rootPath, `app/src/generatedCode/FlowSchemas/Upload/source/${path}`));
+  }
+  for (const path of ['UploadReservedLimit_Main.js', 'UploadCreatePreSignUrl_Main.js', 'UploadConfirmAfterUpload_Main.js']) {
+    const filePath = join(rootPath, `app/src/generatedCode/FlowSchemas/Upload/source/${path}`);
+    const source = await readFile(filePath, 'utf8');
+    const helperPath = source.match(/from '((?:\.\.\/)+libs\/source\/GenerateCodeLibs\.js)'/)?.[1];
+    assert.ok(helperPath, `${path} imports GenerateCodeLibs`);
+    await access(resolve(dirname(filePath), helperPath));
+  }
+});
+
+test('removes only V2-owned custom-flow application artifacts when supported events are removed', async () => {
+  const rootPath = await createProject();
+  await generateCustomFlowApplicationArtifacts(rootPath);
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Flows.js'), "export default [{ flowTag: 'later', event: ['dsq'] }];\n");
+
+  assert.deepEqual((await generateCustomFlowApplicationArtifacts(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Ext/source/ProcessExt_HdrSqs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Own/source/Own_HdrWbs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml')));
+});
+
+test('emits and removes ext-topic handlers declared by custom flow steps', async () => {
+  const rootPath = await createStepProject();
+  const result = await generateCustomFlowApplicationArtifacts(rootPath);
+  await generateResourceArtifacts(rootPath);
+
+  assert.ok(result.files.some(file => file.path === 'app/src/generatedCode/FlowSchemas/Stepped/source/SteppedComplete_HdrSqs.js'));
+  assert.ok(result.files.some(file => file.path === 'app/src/generatedCode/FlowSchemas/Generated/source/GeneratedComplete_HdrSqs.js'));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Stepped/source/SteppedComplete_Main.js'), 'utf8'),
+    /identifierUuid/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'),
+    /SteppedCompleteHdrSqs:\n  handler: src\/generatedCode\/FlowSchemas\/Stepped\/source\/SteppedComplete_HdrSqs.main/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /^  SteppedCompleteHdrSqs:/m
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8'),
+    /GeneratedRole:/
+  );
+
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Stepped.js'), "export default { flowTag: 'stepped', event: ['ownTopic'] };\n");
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Generated.js'), "export default { flowTag: 'generated', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create' } };\n");
+  await generateCustomFlowApplicationArtifacts(rootPath);
+  await generateResourceArtifacts(rootPath);
+
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Stepped/source/SteppedComplete_HdrSqs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Generated/source/GeneratedComplete_HdrSqs.js')));
+  assert.doesNotMatch(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /^  SteppedCompleteHdrSqs:/m
+  );
+});
+
+test('emits and removes the legacy trigger-cache artifact suite', async () => {
+  const rootPath = await createTriggerCacheProject();
+  await generateCustomFlowApplicationArtifacts(rootPath);
+  await generateResourceArtifacts(rootPath);
+
+  const source = 'app/src/generatedCode/FlowSchemas/Cart/source';
+  for (const fileName of [
+    'ProcessTriggerCacheCart_Main.js',
+    'ProcessTriggerCacheCart_HdrDsq.js',
+    'CheckTriggerCacheCartComplete_Main.js',
+    'CheckTriggerCacheCartComplete_HdrSqs.js',
+    'TriggerCacheCartComplete_Main.js',
+    'TriggerCacheCartComplete_HdrSqs.js',
+    'TriggerCacheCartComplete_HdrDsq.js'
+  ]) {
+    const path = join(rootPath, source, fileName);
+    await access(path);
+    await parseAsEsm(path);
+  }
+
+  const flowYaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8');
+  for (const functionName of [
+    'ProcessTriggerCacheCartHdrDsq',
+    'CheckTriggerCacheCartCompleteHdrSqs',
+    'TriggerCacheCartCompleteHdrSqs',
+    'TriggerCacheCartCompleteHdrDsq'
+  ]) {
+    assert.match(flowYaml, new RegExp(`^${functionName}:`, 'm'));
+  }
+  assert.match(
+    await readFile(join(rootPath, `${source}/CheckTriggerCacheCartComplete_HdrSqs.js`), 'utf8'),
+    /record\.body\.Message\.identifiers/
+  );
+
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.match(resources, /^  OrderCartMain:/m);
+  for (const queueName of [
+    'OrderCart_Main',
+    'CheckTriggerCacheCartCompleteHdrSqs',
+    'TriggerCacheCartCompleteHdrSqs',
+    'TriggerCacheCartCompleteHdrDsq'
+  ]) assert.match(resources, new RegExp('QueueName: \\$\\{self:custom\\.iz_resourcePrefix\\}' + queueName));
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  for (const queueName of ['OrderCart_Main', 'CheckTriggerCacheCartCompleteHdrSqs', 'TriggerCacheCartCompleteHdrSqs', 'TriggerCacheCartCompleteHdrDsq']) {
+    assert.match(iam, new RegExp(`CartRole:[\\s\\S]*${queueName}`));
+  }
+
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Cart.js'), "export default { flowTag: 'cart', event: ['ownTopic'], statusType: 'none' };\n");
+  await generateCustomFlowApplicationArtifacts(rootPath);
+  await generateResourceArtifacts(rootPath);
+
+  await assert.rejects(readFile(join(rootPath, `${source}/ProcessTriggerCacheCart_Main.js`)));
+  assert.doesNotMatch(await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'), /ProcessTriggerCacheCartHdrDsq/);
+  assert.doesNotMatch(await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'), /OrderCart_Main/);
+});
+
+test('rejects an EventBridge schedule without a deployable name and rate', () => {
+  assert.throws(
+    () => renderEventBridgeFunctionYaml({
+      functionName: 'ProcessEventHdrInv',
+      handlerPath: 'src/generatedCode/FlowSchemas/Event/source/ProcessEvent_HdrInv.main',
+      roleName: 'EventRole',
+      flowTag: 'Event',
+      schedules: [{ name: 'missing-rate' }]
+    }),
+    /Each EventBridge schedule/
+  );
+});
+
+async function createProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-custom-flow-'));
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  const objectSchemaRoot = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  const helperRoot = join(rootPath, 'app/src/generatedCode/libs/source');
+  await Promise.all([mkdir(schemaRoot, { recursive: true }), mkdir(objectSchemaRoot, { recursive: true }), mkdir(helperRoot, { recursive: true })]);
+  await writeFile(join(helperRoot, 'GenerateCodeLibs.js'), 'export const getNestObject = () => {};\nexport const processStaticLimit = () => {};\nexport const postToConnection = () => {};\n');
+  await writeFile(
+    join(objectSchemaRoot, 'Order.js'),
+    "export default [{ objectType: 'order', serviceTag: 'Other', storageResources: { main: { storageType: 'dynamoDB', tableName: 'OtherOrderTable' } } }, { objectType: 'order', serviceTag: 'Current', storageResources: { main: { storageType: 'dynamoDB', tableName: 'CurrentOrderTable' } } }];\n"
+  );
+  await writeFile(join(schemaRoot, 'Flows.js'), `
+const base = { flowSteps: [{ stepName: 'start', properties: ['dummyId'] }], stepProperties: { dummyId: { type: 'string' } } };
+export default [
+  { ...base, flowTag: 'event', event: ['eventBridge'], schedules: [{ name: 'every-minute', rate: ['rate(1 minute)'] }] },
+  { ...base, flowTag: 'ext', event: ['extTopic'] },
+  { ...base, flowTag: 'inv', event: ['lambdaSyncInv'] },
+  { ...base, flowTag: 'api', event: ['lambdaSyncApi'] },
+  { ...base, flowTag: 'own', event: ['ownTopic'] },
+  { ...base, flowTag: 'cache', event: ['ownTopic'], statusType: 'storedCache', objType: { objectType: 'order', serviceTag: 'Current' } },
+  { ...base, flowTag: 'mixed', event: ['ownTopic', 'extTopic'] },
+  { ...base, flowTag: 'generated', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create' } },
+  { ...base, flowTag: 'upload', event: ['s3'] }
+];
+`);
+  return rootPath;
+}
+
+async function parseAsEsm(path) {
+  await execFileAsync(process.execPath, [
+    '--experimental-vm-modules',
+    '--input-type=module',
+    '--eval',
+    parseEsmSource,
+    '--',
+    path
+  ]);
+}
+
+async function createStepProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-custom-step-'));
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'Stepped.js'),
+    "export default { flowTag: 'stepped', event: ['ownTopic'], flowSteps: [{ stepName: 'start' }, { stepName: 'Complete', event: ['extTopic'] }] };\n"
+  );
+  await writeFile(
+    join(schemaRoot, 'Generated.js'),
+    "export default { flowTag: 'generated', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create' }, flowSteps: [{ stepName: 'start' }, { stepName: 'Complete', event: ['extTopic'] }] };\n"
+  );
+  return rootPath;
+}
+
+async function createTriggerCacheProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-trigger-cache-'));
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'Cart.js'),
+    "export default { flowTag: 'cart', event: ['ownTopic'], statusType: 'triggerCache', objType: { serviceTag: 'Order' } };\n"
+  );
+  return rootPath;
+}