@izara_project/izara-core-generate-service-code 1.0.65 → 1.0.67

package/test/customFlowApplicationArtifacts.test.js

@@ -0,0 +1,297 @@
+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, 38);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Ext/source/Ext_HdrSqs.js'), 'utf8'), /dummyId/);
+  assert.match(await readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Api/source/Api_HdrApi.js'), 'utf8'), /Api/);
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8');
+  assert.match(yaml, /EventHdrInv:/);
+  assert.match(yaml, /rate\(1 minute\)/);
+  assert.match(yaml, /ExtHdrSqs:/);
+  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/);
+  assert.match(yaml, /OwnHdrWbs:/);
+  assert.match(yaml, /OwnHdrSqs:/);
+  assert.ok(yaml.indexOf('OwnHdrWbs:') < yaml.indexOf('OwnHdrSqs:'));
+  assert.match(yaml, /MixedHdrSqs:/);
+  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: ['unsupported'] }];\n");
+
+  assert.deepEqual((await generateCustomFlowApplicationArtifacts(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowSchemas/Ext/source/Ext_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.ok(result.files.some(file => file.path === 'app/src/generatedCode/FlowSchemas/DsqStep/source/DsqStepRetryDsq_HdrDsq.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, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'),
+    /DsqStepRetryDsqHdrDsq:\n  handler: src\/generatedCode\/FlowSchemas\/DsqStep\/source\/DsqStepRetryDsq_HdrDsq.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, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /^  DsqStepRetryDsqHdrDsq:/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 [
+    'CartCheckTriggerCacheCartComplete_Main.js',
+    'CartCheckTriggerCacheCartComplete_HdrSqs.js',
+    'CartTriggerCacheCartComplete_Main.js',
+    'CartTriggerCacheCartComplete_HdrSqs.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 [
+    'CartCheckTriggerCacheCartCompleteHdrSqs',
+    'CartTriggerCacheCartCompleteHdrSqs'
+  ]) {
+    assert.match(flowYaml, new RegExp(`^${functionName}:`, 'm'));
+  }
+  assert.match(
+    await readFile(join(rootPath, `${source}/CartCheckTriggerCacheCartComplete_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, /^  CartHdrSqs:/m);
+  for (const queueName of [
+    'CartHdrSqs',
+    'CartCheckTriggerCacheCartCompleteHdrSqs',
+    'CartTriggerCacheCartCompleteHdrSqs',
+    'CartTriggerCacheCartCompleteHdrDsq'
+  ]) 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');
+
+  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}/CartCheckTriggerCacheCartComplete_Main.js`)));
+  assert.doesNotMatch(await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'), 'utf8'), /CartCheckTriggerCacheCartCompleteHdrSqs/);
+  assert.doesNotMatch(await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'), /CartTriggerCacheCartCompleteHdrDsq/);
+});
+
+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"
+  );
+  await writeFile(
+    join(schemaRoot, 'DsqStep.js'),
+    "export default { flowTag: 'dsqStep', event: ['extTopic'], flowSteps: [{ stepName: 'start' }, { stepName: 'RetryDsq', event: ['dsq'] }] };\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' }, flowSteps: [{ stepName: 'start' }, { stepName: 'CheckTriggerCacheCartComplete', checkTriggerType: 'flowType', event: ['extTopic'] }, { stepName: 'TriggerCacheCartComplete', checkTriggerType: 'complete', event: ['extTopic', 'dsq'] }] };\n"
+  );
+  return rootPath;
+}

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:/);
+});