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

package/test/dynamicCrudFlowSchemas.test.js

@@ -0,0 +1,136 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { pathToFileURL } from 'node:url';
+
+import { generateDynamicCrudFlowSchemas } from '../src/emit/crud/generateDynamicCrudFlowSchemas.js';
+
+test('generates dynamic CRUD schemas from local schema modules', async () => {
+  const rootPath = await createProject({
+    generatedBy: 'userGenerated',
+    flow: createHookFlow(['ownTopic'])
+  });
+
+  const result = await generateDynamicCrudFlowSchemas(rootPath);
+  assert.deepEqual(result.files.map(file => file.path), [
+    'app/src/schemas/FlowSchemas/generateCode/Create.js',
+    'app/src/schemas/FlowSchemas/generateCode/Update.js',
+    'app/src/schemas/FlowSchemas/generateCode/Delete.js',
+    'app/src/schemas/FlowSchemas/generateCode/Get.js'
+  ]);
+
+  const create = await readGeneratedFlow(rootPath, 'Create');
+  const get = await readGeneratedFlow(rootPath, 'Get');
+  assert.deepEqual(create.event, ['ownTopic']);
+  assert.deepEqual(create.flowSteps.map(step => step.stepName), ['start', 'BeforeLogical', 'Complete']);
+  assert.deepEqual(create.flowSteps[0].returnValues.messageAttributes, ['userId', 'correlationId']);
+  assert.equal(get.outputTopic, false);
+  assert.deepEqual(get.event, ['lambdaSyncInv', 'lambdaSyncApi']);
+  assert.equal(get.flowSteps[0].returnValues, undefined);
+});
+
+test('accepts singleton object exports used by existing schema files', async () => {
+  const rootPath = await createProject({
+    generatedBy: 'userGenerated',
+    flow: createHookFlow(['ownTopic']),
+    singletonExports: true
+  });
+
+  const result = await generateDynamicCrudFlowSchemas(rootPath);
+
+  assert.equal(result.files.length, 4);
+  assert.deepEqual((await readGeneratedFlow(rootPath, 'Create')).flowSteps.map(step => step.stepName), [
+    'start',
+    'BeforeLogical',
+    'Complete'
+  ]);
+});
+
+test('does not generate CRUD schemas without an applicable object', async () => {
+  const rootPath = await createProject({ generatedBy: 'userGenerated' });
+  await generateDynamicCrudFlowSchemas(rootPath);
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'),
+    "export default [{ objectType: 'order', generatedBy: 'external' }];\n"
+  );
+
+  const result = await generateDynamicCrudFlowSchemas(rootPath);
+
+  assert.deepEqual(result.files, []);
+  await assert.rejects(readGeneratedFile(rootPath, 'Create'));
+});
+
+test('does not allow options to override the rootPath argument', async () => {
+  const rootPath = await createProject({ generatedBy: 'userGenerated' });
+  const ignoredRootPath = await createProject({ generatedBy: 'external' });
+
+  const result = await generateDynamicCrudFlowSchemas(rootPath, { rootPath: ignoredRootPath });
+
+  assert.equal(result.project.rootPath, rootPath);
+  assert.equal(result.files.length, 4);
+});
+
+test('rejects source modules that do not default-export schema objects or arrays', async () => {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-invalid-schema-'));
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(join(objectDirectory, 'Invalid.js'), "export default 'not-a-schema';\n");
+
+  await assert.rejects(
+    generateDynamicCrudFlowSchemas(rootPath),
+    /must default-export an object or array/
+  );
+});
+
+test('reloads changed local flow schemas instead of reusing module cache', async () => {
+  const rootPath = await createProject({
+    generatedBy: 'systemGenerated',
+    flow: createHookFlow(['ownTopic'])
+  });
+  const flowPath = join(rootPath, 'app/src/schemas/FlowSchemas/CreateHook.js');
+
+  await generateDynamicCrudFlowSchemas(rootPath);
+  assert.match(await readGeneratedFile(rootPath, 'Create'), /BeforeLogical/);
+
+  await writeFile(flowPath, `export default [${JSON.stringify(createHookFlow([]))}];\n`);
+  await generateDynamicCrudFlowSchemas(rootPath);
+  assert.doesNotMatch(await readGeneratedFile(rootPath, 'Create'), /BeforeLogical/);
+});
+
+async function createProject({ generatedBy, flow, singletonExports = false }) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-crud-'));
+  const objectPath = join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js');
+  const flowPath = join(rootPath, 'app/src/schemas/FlowSchemas/CreateHook.js');
+  await mkdir(join(rootPath, 'app/src/schemas/ObjectSchemas'), { recursive: true });
+  await mkdir(join(rootPath, 'app/src/schemas/FlowSchemas'), { recursive: true });
+  const object = `{ objectType: 'order', generatedBy: '${generatedBy}' }`;
+  await writeFile(objectPath, `export default ${singletonExports ? object : `[${object}]`};\n`);
+  if (flow) {
+    const flowSource = JSON.stringify(flow);
+    await writeFile(flowPath, `export default ${singletonExports ? flowSource : `[${flowSource}]`};\n`);
+  }
+  return rootPath;
+}
+
+function createHookFlow(event) {
+  return {
+    flowTag: 'CreateHook',
+    event,
+    generatedCodeConfig: {
+      generatedCodeTag: 'create',
+      codeHookTag: 'beforeLogical',
+      invocationType: 'ownTopic'
+    }
+  };
+}
+
+async function readGeneratedFlow(rootPath, action) {
+  const filePath = join(rootPath, 'app/src/schemas/FlowSchemas/generateCode', `${action}.js`);
+  return import(`${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`).then(module => module.default);
+}
+
+function readGeneratedFile(rootPath, action) {
+  return readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode', `${action}.js`), 'utf8');
+}

package/test/dynamicRbacFlowSchemas.test.js

@@ -0,0 +1,101 @@
+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 { pathToFileURL } from 'node:url';
+
+import { generateDynamicRbacFlowSchemas } from '../src/emit/rbac/generateDynamicRbacFlowSchemas.js';
+
+const projectRoots = new Set();
+const STATIC_ACTIONS = [
+  'CreateTargetRole',
+  'ListTargetRole',
+  'DeleteTargetRole',
+  'CreateRolePermissions',
+  'ListRolePermissions',
+  'DeleteRolePermissions',
+  'CreateUserRole',
+  'ListUserInRoles',
+  'DeleteUserFromRole'
+];
+
+after(async () => {
+  await Promise.all([...projectRoots].map(rootPath => rm(rootPath, { recursive: true, force: true })));
+});
+
+test('generates shared and object-specific RBAC flow schemas', async () => {
+  const rootPath = await createProject({ hasRbac: true });
+
+  const result = await generateDynamicRbacFlowSchemas(rootPath, { serviceTag: 'UserAccount' });
+
+  assert.deepEqual(result.files.map(file => file.path), [
+    ...STATIC_ACTIONS.map(action => `app/src/schemas/FlowSchemas/generateCode/${action}.js`),
+    'app/src/schemas/FlowSchemas/generateCode/UserRbacFlow.js'
+  ]);
+  const createTargetRole = await readGeneratedFlow(rootPath, 'CreateTargetRole');
+  const listTargetRole = await readGeneratedFlow(rootPath, 'ListTargetRole');
+  const user = await readGeneratedFlow(rootPath, 'UserRbacFlow');
+  assert.deepEqual(createTargetRole.flowSteps[0].returnValues, {
+    properties: ['returnResult'],
+    messageAttributes: []
+  });
+  assert.deepEqual(listTargetRole.event, ['lambdaSyncApi']);
+  assert.equal(listTargetRole.outputTopic, true);
+  assert.deepEqual(user.objType, { serviceTag: 'UserAccount', objectType: 'user' });
+  assert.deepEqual(user.flowSteps[0].messageAttributes, ['userId', 'correlationId']);
+  assert.equal(user.steps, undefined);
+});
+
+test('removes RBAC schemas when the last RBAC object is removed', async () => {
+  const rootPath = await createProject({ hasRbac: true });
+  const objectPath = join(rootPath, 'app/src/schemas/ObjectSchemas/User.js');
+  await generateDynamicRbacFlowSchemas(rootPath, { serviceTag: 'UserAccount' });
+  await writeFile(objectPath, "export default { objectType: 'user', addOnDataStructure: [] };\n");
+
+  const result = await generateDynamicRbacFlowSchemas(rootPath);
+
+  assert.deepEqual(result.files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/CreateTargetRole.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/UserRbacFlow.js')));
+});
+
+test('requires a serviceTag only when RBAC schemas are needed', async () => {
+  const rbacRoot = await createProject({ hasRbac: true });
+  const plainRoot = await createProject();
+
+  await assert.rejects(
+    generateDynamicRbacFlowSchemas(rbacRoot),
+    /serviceTag is required/
+  );
+  assert.deepEqual((await generateDynamicRbacFlowSchemas(plainRoot)).files, []);
+});
+
+test('removes object-specific RBAC schemas when the ObjectSchema file is deleted', async () => {
+  const rootPath = await createProject({ hasRbac: true });
+  const objectPath = join(rootPath, 'app/src/schemas/ObjectSchemas/User.js');
+  await generateDynamicRbacFlowSchemas(rootPath, { serviceTag: 'UserAccount' });
+  await rm(objectPath);
+
+  await generateDynamicRbacFlowSchemas(rootPath);
+
+  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/UserRbacFlow.js')));
+});
+
+async function createProject({ hasRbac = false } = {}) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-rbac-'));
+  projectRoots.add(rootPath);
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'User.js'),
+    `export default { objectType: 'user', addOnDataStructure: ${hasRbac ? "[{ type: 'rbac' }]" : '[]'} };\n`
+  );
+  return rootPath;
+}
+
+async function readGeneratedFlow(rootPath, flowTag) {
+  const filePath = join(rootPath, 'app/src/schemas/FlowSchemas/generateCode', `${flowTag}.js`);
+  const module = await import(`${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`);
+  return module.default;
+}

package/test/dynamicRelationshipFlowSchemas.test.js

@@ -0,0 +1,99 @@
+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 { pathToFileURL } from 'node:url';
+
+import { generateDynamicRelationshipFlowSchemas } from '../src/emit/relationship/generateDynamicRelationshipFlowSchemas.js';
+
+const RELATIONSHIP_ACTIONS = [
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+];
+const projectRoots = new Set();
+
+after(async () => {
+  await Promise.all([...projectRoots].map(rootPath =>
+    rm(rootPath, { recursive: true, force: true })
+  ));
+});
+
+test('generates dynamic relationship schemas even without declared relationships for legacy compatibility', async () => {
+  const rootPath = await createProject();
+
+  const result = await generateDynamicRelationshipFlowSchemas(rootPath);
+
+  assert.deepEqual(
+    result.files.map(file => file.path),
+    RELATIONSHIP_ACTIONS.map(action => `app/src/schemas/FlowSchemas/generateCode/${action}.js`)
+  );
+
+  const create = await readGeneratedFlow(rootPath, 'CreateRelationship');
+  const get = await readGeneratedFlow(rootPath, 'GetRelationship');
+  assert.deepEqual(create.event, ['ownTopic']);
+  assert.deepEqual(create.flowSteps.map(step => step.stepName), ['start', 'Complete']);
+  assert.deepEqual(create.flowSteps[0].returnValues.messageAttributes, ['userId', 'correlationId']);
+  assert.deepEqual(get.event, ['lambdaSyncInv', 'lambdaSyncApi', 'dsq', 'ownTopic']);
+  assert.equal(get.outputTopic, false);
+  assert.equal(get.flowSteps[0].returnValues, undefined);
+  assert.equal(get.flowSteps.find(step => step.stepName === 'Complete'), undefined);
+});
+
+test('accepts singleton and array RelationshipSchema exports', async () => {
+  const singletonRoot = await createProject({ singletonExport: true });
+  const arrayRoot = await createProject();
+
+  assert.equal((await generateDynamicRelationshipFlowSchemas(singletonRoot)).files.length, 6);
+  assert.equal((await generateDynamicRelationshipFlowSchemas(arrayRoot)).files.length, 6);
+});
+
+test('reloads a changed RelationshipSchema instead of reusing the module cache', async () => {
+  const rootPath = await createProject();
+  const relationshipPath = join(rootPath, 'app/src/schemas/RelationshipSchemas/OrderCustomer.js');
+
+  await generateDynamicRelationshipFlowSchemas(rootPath);
+  await writeFile(relationshipPath, "export default 'not-a-schema';\n");
+
+  await assert.rejects(
+    generateDynamicRelationshipFlowSchemas(rootPath),
+    /must default-export an object or array/
+  );
+});
+
+test('does not allow options to override the rootPath argument', async () => {
+  const rootPath = await createProject();
+  const ignoredRootPath = await createProject();
+
+  const result = await generateDynamicRelationshipFlowSchemas(rootPath, { rootPath: ignoredRootPath });
+
+  assert.equal(result.project.rootPath, rootPath);
+  assert.equal(result.files.length, 6);
+  assert.match(
+    await readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/CreateRelationship.js'), 'utf8'),
+    /export default/
+  );
+});
+
+async function createProject({ singletonExport = false } = {}) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-relationship-'));
+  projectRoots.add(rootPath);
+  const relationshipDirectory = join(rootPath, 'app/src/schemas/RelationshipSchemas');
+  await mkdir(relationshipDirectory, { recursive: true });
+  const relationship = { relationshipTag: 'orderCustomer', links: [] };
+  await writeFile(
+    join(relationshipDirectory, 'OrderCustomer.js'),
+    `export default ${JSON.stringify(singletonExport ? relationship : [relationship])};\n`
+  );
+  return rootPath;
+}
+
+async function readGeneratedFlow(rootPath, action) {
+  const filePath = join(rootPath, 'app/src/schemas/FlowSchemas/generateCode', `${action}.js`);
+  const module = await import(`${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`);
+  return module.default;
+}

package/test/functionYamlArtifact.test.js

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  renderApiFunctionYaml,
+  renderEventBridgeFunctionYaml,
+  renderInvFunctionYaml,
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../src/emit/function/functionYamlArtifact.js';
+
+test('renders function-setting hooks for every function transport', () => {
+  const functions = [
+    ['CreateHdrSqs', renderSqsFunctionYaml({ functionName: 'CreateHdrSqs', handlerPath: 'src/create.main', roleName: 'Role', queueName: 'CreateHdrSqs' })],
+    ['GetHdrApi', renderApiFunctionYaml({ functionName: 'GetHdrApi', handlerPath: 'src/get.main', roleName: 'Role', routes: [{ path: '/orders/get', upperName: 'Get' }] })],
+    ['CreateHdrWbs', renderWbsFunctionYaml({ functionName: 'CreateHdrWbs', handlerPath: 'src/create.main', roleName: 'Role', routeName: 'create' })],
+    ['GetHdrInv', renderInvFunctionYaml({ functionName: 'GetHdrInv', handlerPath: 'src/get.main', roleName: 'Role' })],
+    ['ScheduledHdrInv', renderEventBridgeFunctionYaml({ functionName: 'ScheduledHdrInv', handlerPath: 'src/scheduled.main', roleName: 'Role', flowTag: 'scheduled', schedules: [{ name: 'daily', rate: ['rate(1 day)'] }] })]
+  ];
+
+  for (const [functionName, yaml] of functions) {
+    assert.match(yaml, new RegExp(`#<#${functionName}FunctionSetting#>`));
+    assert.match(yaml, new RegExp(`#<#/${functionName}FunctionSetting#>`));
+  }
+});
+
+test('filters only completion SQS functions by their calling flow', () => {
+  const completion = renderSqsFunctionYaml({ functionName: 'CreateCompleteHdrSqs', handlerPath: 'src/create.main', roleName: 'Role', queueName: 'CreateCompleteHdrSqs' });
+  const ordinary = renderSqsFunctionYaml({ functionName: 'CreateHdrSqs', handlerPath: 'src/create.main', roleName: 'Role', queueName: 'CreateHdrSqs' });
+
+  assert.match(completion, /filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateCompleteHdrSqs/);
+  assert.match(completion, /exists: false/);
+  assert.doesNotMatch(ordinary, /filterPatterns:/);
+});

package/test/intTestApi.test.js

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  generateIntTest,
+  generateResourceIntTest
+} from '../index.js';
+
+test('exports IntTest generators and requires a service tag', async () => {
+  const rootPath = await mkdtemp(path.join(os.tmpdir(), 'generate-service-code-inttest-'));
+  await mkdir(path.join(rootPath, 'config'));
+  await writeFile(path.join(rootPath, 'config', 'serverless.config.yml'), 'main_config: {}\n');
+
+  try {
+    await assert.rejects(
+      generateIntTest(rootPath),
+      /Missing iz_serviceTag/
+    );
+    await assert.rejects(
+      generateResourceIntTest(rootPath),
+      /Missing iz_serviceTag/
+    );
+  } finally {
+    await rm(rootPath, { recursive: true, force: true });
+  }
+});

package/test/publicApi.test.js

@@ -0,0 +1,209 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import * as publicApi from '../index.js';
+
+const { generate } = publicApi;
+
+test('public package surface exposes generation and IntTest APIs', () => {
+  assert.deepEqual(Object.keys(publicApi), [
+    'generate',
+    'generateIntTest',
+    'generateResourceIntTest'
+  ]);
+});
+
+test('generate commits schemas, application artifacts, and resources in one public result', async () => {
+  const rootPath = await createCrudProject();
+  const result = await generate(rootPath);
+
+  assert.equal(result.files.length, 36);
+  assert.equal(result.project.rootPath, rootPath);
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'), 'utf8'),
+    /CreateMainLogical/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-dynamoDB-table.yml'), 'utf8'),
+    /Resources:/
+  );
+});
+
+test('generate logs its lifecycle through the supplied logger', async () => {
+  const rootPath = await createCrudProject();
+  const messages = [];
+  const logger = Object.fromEntries(['info', 'debug', 'error'].map(level => [level, message => messages.push(message)]));
+
+  await generate(rootPath, { logger });
+
+  assert.match(messages[0], /STATUS=STARTED/);
+  assert.ok(messages.some(message => /STATUS=SCHEMAS_LOADED/.test(message)));
+  assert.ok(messages.some(message => /STATUS=ARTIFACTS_EMITTED/.test(message)));
+  assert.match(messages.at(-1), /STATUS=FINISHED/);
+});
+
+test('generate commits RBAC WebSocket entries for own-topic mutation flows', async () => {
+  const rootPath = await createRbacProject();
+
+  const result = await generate(rootPath, { serviceTag: 'UserAccount' });
+
+  assert.ok(result.files.some(file => file.path === 'app/src/generatedCode/FlowRbac/CreateTargetRole/source/CreateTargetRole_HdrWbs.js'));
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'), 'utf8'),
+    /CreateTargetRoleHdrWbs:\n[\s\S]*websocket:/
+  );
+});
+
+test('generate commits the system WebSocket completion path for own-topic flows', async () => {
+  const rootPath = await createOwnTopicProject();
+  const result = await generate(rootPath);
+
+  assert.ok(result.files.some(file => file.path === 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.js'));
+  assert.ok(result.files.some(file => file.path === 'app/src/generatedCode/FlowSchemas/Track/source/Track_HdrWbs.js'));
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'),
+    /WebSocketConnect:[\s\S]*route: \$connect[\s\S]*WebSocketCompleteHdrSqs:/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'),
+    /filterPatterns:[\s\S]*WebSocketCompleteHdrSqs/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /WebSocketCompleteHdrSqs:[\s\S]*SubscriptionToOutTrackWebSocketComplete:/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8'),
+    /WebSocketMainRole:/
+  );
+  for (const path of [
+    'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketConnect.js',
+    'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_Main.js',
+    'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.js',
+    'app/src/generatedCode/FlowSchemas/Track/source/Track_Main.js',
+    'app/src/generatedCode/FlowSchemas/Track/source/Track_HdrSqs.js',
+    'app/src/generatedCode/FlowSchemas/Track/source/Track_WbsMain.js',
+    'app/src/generatedCode/FlowSchemas/Track/source/Track_HdrWbs.js'
+  ]) {
+    execFileSync(process.execPath, ['--check', join(rootPath, path)], { stdio: 'inherit' });
+  }
+  const webSocketComplete = await readFile(join(rootPath, 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_Main.js'), 'utf8');
+  assert.match(webSocketComplete, /\(\<createIdentifiersFlow\>\)/);
+  assert.match(webSocketComplete, /\(\<beforePostMessage\>\)/);
+  const webSocketHandler = await readFile(join(rootPath, 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.js'), 'utf8');
+  assert.match(webSocketHandler, /record\.body\.TopicArn/);
+  assert.match(webSocketHandler, /addCallingFlowToPassOnProperties/);
+});
+
+test('generate commits the legacy trigger-cache suite with its queues', async () => {
+  const rootPath = await createTriggerCacheProject();
+  const result = await generate(rootPath);
+
+  for (const path of [
+    'app/src/generatedCode/FlowSchemas/Cart/source/ProcessTriggerCacheCart_Main.js',
+    'app/src/generatedCode/FlowSchemas/Cart/source/CheckTriggerCacheCartComplete_HdrSqs.js',
+    'app/src/generatedCode/FlowSchemas/Cart/source/TriggerCacheCartComplete_HdrDsq.js'
+  ]) assert.ok(result.files.some(file => file.path === path));
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'),
+    /ProcessTriggerCacheCartHdrDsq:[\s\S]*TriggerCacheCartCompleteHdrDsq:/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /OrderCartMain:[\s\S]*TriggerCacheCartCompleteHdrDsq/
+  );
+});
+
+test('generate removes the system WebSocket path when the last own-topic flow is removed', async () => {
+  const rootPath = await createOwnTopicProject();
+  await generate(rootPath);
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Track.js'), "export default { flowTag: 'track', event: ['dsq'] };\n");
+
+  await generate(rootPath);
+
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Track/source/Track_HdrWbs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml')));
+  assert.doesNotMatch(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /WebSocketCompleteHdrSqs/
+  );
+});
+
+test('generate rolls back every slice when one output target conflicts', async () => {
+  const rootPath = await createCrudProject();
+  await mkdir(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'), { recursive: true });
+
+  await assert.rejects(
+    generate(rootPath),
+    /not a file/
+  );
+  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/Create.js')));
+});
+
+test('generate removes stale CRUD schemas and application artifacts', async () => {
+  const rootPath = await createCrudProject();
+  await generate(rootPath);
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'),
+    "export default { objectType: 'order', generatedBy: 'external' };\n"
+  );
+
+  const result = await generate(rootPath);
+
+  assert.equal(result.files.length, 10);
+  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/Create.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js')));
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-dynamoDB-table.yml'), 'utf8'),
+    /WebSocketTask/
+  );
+});
+
+async function createCrudProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-public-'));
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'Order.js'),
+    "export default { objectType: 'order', generatedBy: 'userGenerated' };\n"
+  );
+  return rootPath;
+}
+
+async function createRbacProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-public-rbac-'));
+  const objectDirectory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  await mkdir(objectDirectory, { recursive: true });
+  await writeFile(
+    join(objectDirectory, 'User.js'),
+    "export default { objectType: 'user', addOnDataStructure: [{ type: 'rbac' }] };\n"
+  );
+  return rootPath;
+}
+
+async function createOwnTopicProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-public-websocket-'));
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(flowDirectory, { recursive: true });
+  await writeFile(
+    join(flowDirectory, 'Track.js'),
+    "export default { flowTag: 'track', event: ['ownTopic'], outputTopic: true, statusType: 'none', generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical', invocationType: 'ownTopic' } };\n"
+  );
+  return rootPath;
+}
+
+async function createTriggerCacheProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-public-trigger-cache-'));
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(flowDirectory, { recursive: true });
+  await writeFile(
+    join(flowDirectory, 'Cart.js'),
+    "export default { flowTag: 'cart', event: ['ownTopic'], statusType: 'triggerCache', objType: { serviceTag: 'Order' } };\n"
+  );
+  return rootPath;
+}