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

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.strictEqual(result.files.length, 38);
+  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/CartCheckTriggerCacheCartComplete_HdrSqs.js',
+    'app/src/generatedCode/FlowSchemas/Cart/source/CartCheckTriggerCacheCartComplete_Main.js',
+    'app/src/generatedCode/FlowSchemas/Cart/source/CartTriggerCacheCartComplete_HdrSqs.js',
+    'app/src/generatedCode/FlowSchemas/Cart/source/CartTriggerCacheCartComplete_Main.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'),
+    /CartCheckTriggerCacheCartCompleteHdrSqs:[\s\S]*CartTriggerCacheCartCompleteHdrSqs:/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8'),
+    /CartCheckTriggerCacheCartCompleteHdrSqs:[\s\S]*CartTriggerCacheCartCompleteHdrSqs/
+  );
+});
+
+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')));
+  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'], initiateBy: 'user', 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' }, flowSteps: [{ stepName: 'CheckTriggerCacheCartComplete', event: ['extTopic'], checkTriggerType: 'flowType' }, { stepName: 'TriggerCacheCartComplete', event: ['extTopic'], checkTriggerType: 'complete' }] };\n"
+  );
+  return rootPath;
+}

package/test/relationshipApplicationArtifacts.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 { generateRelationshipApplicationArtifacts } from '../src/emit/relationship/generateRelationshipApplicationArtifacts.js';
+
+const roots = new Set();
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits relationship action and complete handlers with data-first function YAML', async () => {
+  const rootPath = await createProject(true);
+  const result = await generateRelationshipApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  assert.equal(result.files.length, 40);
+  assert.ok(result.files.every(file => !file.path.includes('/Process')));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/GetRelationship/source/GetRelationship_HdrDsq.js'), 'utf8'),
+    /import GetRelationship/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationshipComplete_HdrSqs.js'), 'utf8'),
+    /import CreateRelationshipComplete/
+  );
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-relationships.yml'), 'utf8');
+  assert.match(yaml, /GetRelHdrApi:/);
+  assert.doesNotMatch(yaml, /handler: .*\/Process/);
+  assert.match(yaml, /CreateRelHdrSqs:[\s\S]*?iz_resourcePrefix}CreateRelationshipHdrSqs\n/);
+  assert.doesNotMatch(yaml, /Process(?:Create|Update|Delete|Get|Change|Move)Relationship/);
+  assert.match(yaml, /path: \/orders\/orderCustomer\/get/);
+  assert.match(yaml, /CreateRelationshipHdrWbs:[\s\S]*websocket:/);
+  assert.ok(yaml.indexOf('CreateRelationshipHdrWbs:') < yaml.indexOf('CreateRelHdrSqs:'));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationship_HdrWbs.js'), 'utf8'),
+    /import CreateRelationship from '\.\/CreateRelationship_WbsMain\.js'/
+  );
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/ProcessCreateRelationship_Main.js')));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationship_Main.js'), 'utf8'),
+    /export default async function createRelationship/
+  );
+  assert.match(yaml, /CreateRelationshipCompleteHdrSqs:/);
+});
+
+test('removes managed relationship artifacts after relationships are removed', async () => {
+  const rootPath = await createProject(true);
+  await generateRelationshipApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+  await rm(join(rootPath, 'app/src/schemas/RelationshipSchemas/OrderCustomer.js'));
+
+  assert.deepEqual((await generateRelationshipApplicationArtifacts(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRelationships/CreateRelationship/source/CreateRelationship_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-relationships.yml')));
+});
+
+async function createProject(withRelationship) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-relationship-application-'));
+  roots.add(rootPath);
+  const relationshipDirectory = join(rootPath, 'app/src/schemas/RelationshipSchemas');
+  await mkdir(relationshipDirectory, { recursive: true });
+  if (withRelationship) {
+    await writeFile(
+      join(relationshipDirectory, 'OrderCustomer.js'),
+      "export default { relationshipTag: 'orderCustomer', links: [] };\n"
+    );
+  }
+  return rootPath;
+}

package/test/resourceArtifacts.test.js

@@ -0,0 +1,121 @@
+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 { generateResourceArtifacts } from '../src/emit/resource/generateResourceArtifacts.js';
+
+const roots = new Set();
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits queues, topics, tables, and IAM roles from schema data', async () => {
+  const rootPath = await createProject();
+  const result = await generateResourceArtifacts(rootPath);
+
+  assert.equal(result.files.length, 4);
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.match(resources, /InCreate:/);
+  for (const queueName of ['FindDataHdrSqs', 'ProcessLogicalHdrSqs', 'PaginateProcessLogicalHdrDsq', 'PaginateProcessLogicalHdrSqs']) {
+    assert.match(resources, new RegExp(`^  ${queueName}:`, 'm'));
+  }
+  assert.match(
+    await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-dynamoDB-table.yml'), 'utf8'),
+    /OrdersTable:/
+  );
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  assert.match(iam, /FlowObjectsRole:/);
+  assert.match(iam, /FlowRelationshipRole:/);
+  assert.match(iam, /FlowRbacRole:/);
+  assert.match(iam, /sqs:ReceiveMessage/);
+  assert.match(iam, /sns:Publish/);
+  assert.doesNotMatch(roleBlock(iam, 'WebSocketMainRole'), /Orders|RolePermissions|CreateHdrSqs/);
+  assert.match(roleBlock(iam, 'WebSocketMainRole'), /UserUploadRecords|WebSocketTask|WebSocketCompleteHdrSqs/);
+  assert.doesNotMatch(roleBlock(iam, 'FlowRbacRole'), /Orders|ProcessCreateRelationshipHdrSqs/);
+  assert.match(roleBlock(iam, 'FlowRbacRole'), /RolePermissions|ProcessCreateTargetRoleHdrSqs/);
+  assert.match(resources, /^  CreateRelationshipHdrSqs:/m);
+  assert.equal((resources.match(/^  CreateRelationshipHdrSqs:/gm) ?? []).length, 1);
+  assert.match(resources, /^  CreateRelationshipCompleteHdrSqs:/m);
+  assert.match(resources, /^  GetRelationshipHdrDsq:/m);
+  assert.doesNotMatch(resources, /Process(?:Create|Update|Delete|Get|Change|Move)Relationship/);
+  const relationshipRole = roleBlock(iam, 'FlowRelationshipRole');
+  assert.match(relationshipRole, /CreateRelationshipHdrSqs/);
+  assert.match(relationshipRole, /CreateRelationshipCompleteHdrSqs/);
+  assert.match(relationshipRole, /GetRelationshipHdrDsq/);
+  assert.doesNotMatch(relationshipRole, /Process(?:Create|Update|Delete|Get|Change|Move)Relationship/);
+  assert.match(roleBlock(iam, 'RegisterRole'), /s3:GetObject/);
+  assert.doesNotMatch(roleBlock(iam, 'RegisterRole'), /dynamodb:|sqs:|sns:/);
+  assert.doesNotMatch(iam, /s3:GetObjectVersion|s3:ListBucket|sqs:DeleteMessageBatch|sqs:GetQueueUrl/);
+  assert.match(iam, /#<#\/\w+StatementHookCode#>\n\n  \w+Role:/);
+  for (const filePath of [
+    'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml',
+    'resource/sls_yaml/generatedCode/source/generated-sns-out.yml',
+    'resource/sls_yaml/generatedCode/source/generated-dynamoDB-table.yml',
+    'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+  ]) {
+    assert.doesNotMatch(await readFile(join(rootPath, filePath), 'utf8'), /\n\n$/);
+  }
+});
+
+test('emits one before-logical queue for flows that share an action', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'BeforeLogical.js'),
+    "export default [{ flowTag: 'first', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical' } }, { flowTag: 'second', event: ['extTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical' } }];\n"
+  );
+
+  await generateResourceArtifacts(rootPath);
+
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.equal((resources.match(/^  CreateBeforeLogicalHdrSqs:/gm) ?? []).length, 1);
+  assert.match(resources, /SubscriptionOutFirstToCreateBeforeLogical:/);
+  assert.match(resources, /SubscriptionOutSecondToCreateBeforeLogical:/);
+});
+
+test('emits the shared WebSocket completion queue and output-topic subscriptions', async () => {
+  const rootPath = await createProject();
+  await generateResourceArtifacts(rootPath);
+
+  const resources = await readFile(join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-in-sqs.yml'), 'utf8');
+  assert.match(resources, /^  WebSocketCompleteHdrSqs:/m);
+  assert.match(resources, /SubscriptionToOutCustomWebSocketComplete:/);
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  for (const roleName of ['WebSocketMainRole', 'FlowObjectsRole', 'FlowRelationshipRole', 'FlowRbacRole', 'CustomRole', 'UploadRole']) {
+    const role = roleBlock(iam, roleName);
+    assert.match(role, /execute-api:ManageConnections/);
+    assert.match(role, /arn:aws:execute-api:\$\{self:custom\.iz_region\}:\$\{self:custom\.iz_accountId\}:\*\/\*/);
+  }
+  assert.match(resources, /SubscriptionToOutCreateRelationshipWebSocketComplete:/);
+});
+
+test('scopes stored-cache permissions to the flow object table', async () => {
+  const rootPath = await createProject();
+  await writeFile(join(rootPath, 'app/src/schemas/ObjectSchemas/Cache.js'), "export default { objectType: 'cache', storageResources: { main: { storageType: 'dynamoDB', tableName: 'CurrentData' } } };\n");
+  await writeFile(join(rootPath, 'app/src/schemas/FlowSchemas/Cache.js'), "export default { flowTag: 'cacheFlow', event: ['lambdaSyncApi'], statusType: 'storedCache', objType: { objectType: 'cache' } };\n");
+
+  await generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'), 'utf8');
+  const role = roleBlock(iam, 'CacheFlowRole');
+  assert.match(role, /CurrentData/);
+  assert.doesNotMatch(role, /Orders|WebSocketTask/);
+});
+
+function roleBlock(iam, roleName) {
+  const match = iam.match(new RegExp(`^  ${roleName}:\\n(?:(?!^  [A-Za-z][A-Za-z0-9]*Role:\\n)[\\s\\S])*`, 'm'));
+  assert.ok(match, `Missing ${roleName} in generated IAM`);
+  return match[0];
+}
+
+async function createProject() {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-resource-'));
+  roots.add(rootPath);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await Promise.all(['ObjectSchemas', 'RelationshipSchemas', 'FlowSchemas'].map(directory => mkdir(join(schemas, directory), { recursive: true })));
+  await writeFile(join(schemas, 'ObjectSchemas/Order.js'), "export default { objectType: 'order', generatedBy: 'userGenerated', addOnDataStructure: [{ type: 'rbac' }], identifiers: [{ type: 'partitionKey', fieldName: 'orderId' }], storageResources: { main: { storageType: 'dynamoDB', tableName: 'Orders' } } };\n");
+  await writeFile(join(schemas, 'RelationshipSchemas/OrderCustomer.js'), "export default { relationshipTag: 'orderCustomer', links: [] };\n");
+  await writeFile(join(schemas, 'FlowSchemas/Custom.js'), "export default { flowTag: 'custom', event: ['ownTopic'], outputTopic: true };\n");
+  await writeFile(join(schemas, 'FlowSchemas/Upload.js'), "export default { flowTag: 'upload', event: ['s3'] };\n");
+  return rootPath;
+}

package/jsconfig.json

@@ -1,9 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": "src",
-    "paths": {
-      "#libs/*": ["libs/*"]
-    }
-  },
-  "include": ["src"]
-}

package/src/__tests__/getIntTestConfig.test.js

@@ -1,51 +0,0 @@
-import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
-import libs from '../generateResources/IntTest/libs/libs.js';
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-
-const { getIntTestConfig } = libs;
-
-describe('getIntTestConfig path resolution', () => {
-  let originalGetDataFromPath;
-  let passedArgs;
-
-  beforeEach(() => {
-    originalGetDataFromPath = getObjectSchema.getDataFromPath;
-    passedArgs = null;
-    getObjectSchema.getDataFromPath = async (_izContext, folderName, rootFolderPath, options) => {
-      passedArgs = { folderName, rootFolderPath, options };
-      return [];
-    };
-  });
-
-  afterEach(() => {
-    getObjectSchema.getDataFromPath = originalGetDataFromPath;
-  });
-
-  it('Case 1: should resolve correctly when rootPath includes generateIntegrationTest', async () => {
-    const rootPath = '/home/ironfist/Pong/Izara Project/Izara-Market-Product/izara-market-products-sell-offer-price-pong/app/src/generateIntegrationTest/';
-    await getIntTestConfig({ logger: console }, 'generateIntegrationTest/libs/', rootPath);
-    
-    expect(passedArgs).not.toBeNull();
-    expect(passedArgs.folderName).toBe('libs');
-    expect(passedArgs.rootFolderPath).toBe('/home/ironfist/Pong/Izara Project/Izara-Market-Product/izara-market-products-sell-offer-price-pong/app/src/generateIntegrationTest');
-  });
-
-  it('Case 2: should resolve correctly when rootPath is repo root with app/src/... structure', async () => {
-    const tmpDir = path.join(os.tmpdir(), 'get-int-test-config-scratch');
-    fs.mkdirSync(tmpDir, { recursive: true });
-    fs.mkdirSync(path.join(tmpDir, 'app', 'src', 'generateIntegrationTest', 'libs'), { recursive: true });
-
-    try {
-      await getIntTestConfig({ logger: console }, 'generateIntegrationTest/libs/', tmpDir);
-      
-      expect(passedArgs).not.toBeNull();
-      expect(passedArgs.folderName).toBe('libs');
-      expect(passedArgs.rootFolderPath).toBe(path.join(tmpDir, 'app', 'src', 'generateIntegrationTest'));
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-});

package/src/__tests__/intTestGeneratorShared.test.cjs

@@ -1,169 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-let getIntTestOutputPath;
-let runTemplateItems;
-
-const tempDirs = [];
-
-beforeAll(async () => {
-  ({ getIntTestOutputPath, runTemplateItems } =
-    await import('../intTestGeneratorShared.js'));
-});
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('getIntTestOutputPath', () => {
-  it('uses app/src when app directory exists', () => {
-    const rootPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-app-')
-    );
-    tempDirs.push(rootPath);
-    fs.mkdirSync(path.join(rootPath, 'app'));
-
-    expect(getIntTestOutputPath(rootPath)).toBe(
-      path.join(rootPath, 'app', 'src', 'generateIntegrationTest')
-    );
-  });
-
-  it('falls back to src when app directory is missing', () => {
-    const rootPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-src-')
-    );
-    tempDirs.push(rootPath);
-
-    expect(getIntTestOutputPath(rootPath)).toBe(
-      path.join(rootPath, 'src', 'generateIntegrationTest')
-    );
-  });
-
-  it('detects app from project root even when output path is different', () => {
-    const projectRootPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-project-root-')
-    );
-    const outputPath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-output-custom-')
-    );
-    tempDirs.push(projectRootPath, outputPath);
-    fs.mkdirSync(path.join(projectRootPath, 'app'));
-
-    expect(getIntTestOutputPath(outputPath, projectRootPath)).toBe(
-      path.join(outputPath, 'app', 'src', 'generateIntegrationTest')
-    );
-  });
-});
-
-describe('runTemplateItems', () => {
-  it('skips empty array items', async () => {
-    const writeSource = jest.fn();
-
-    await runTemplateItems([[]], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(writeSource).not.toHaveBeenCalled();
-  });
-
-  it('validates items before writing', async () => {
-    const writeSource = jest.fn()
-      .mockResolvedValueOnce([true, {}])
-      .mockResolvedValueOnce([true, {}]);
-
-    await runTemplateItems([
-      {
-        templatePath: '/tmp/template.ejs',
-        templateData: { ok: true },
-        setting: { savePath: '/tmp/out' }
-      }
-    ], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(writeSource).toHaveBeenNthCalledWith(1, expect.any(Object), {
-      checkCreateSourcePass: true
-    });
-    expect(writeSource).toHaveBeenNthCalledWith(2, expect.any(Object), {
-      checkCreateSourcePass: false
-    });
-  });
-
-  it('preserves configured files when clearing a save path', async () => {
-    const savePath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-preserve-save-path-')
-    );
-    tempDirs.push(savePath);
-    fs.writeFileSync(path.join(savePath, 'saveConfig.js'), 'keep');
-    fs.writeFileSync(path.join(savePath, 'old.js'), 'remove');
-    fs.mkdirSync(path.join(savePath, 'nested'));
-    fs.writeFileSync(path.join(savePath, 'nested', 'stale.json'), '{}');
-
-    const writeSource = jest.fn()
-      .mockResolvedValueOnce([true, {}])
-      .mockImplementationOnce(async ({ setting }) => {
-        fs.writeFileSync(path.join(setting.savePath, 'IntTestPath.js'), 'new');
-        return [true, {}];
-      });
-
-    await runTemplateItems([
-      {
-        templatePath: '/tmp/template.ejs',
-        templateData: { ok: true },
-        setting: {
-          savePath,
-          preserveFileNames: ['saveConfig.js']
-        }
-      }
-    ], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(fs.existsSync(path.join(savePath, 'saveConfig.js'))).toBe(true);
-    expect(fs.readFileSync(path.join(savePath, 'saveConfig.js'), 'utf8')).toBe('keep');
-    expect(fs.existsSync(path.join(savePath, 'old.js'))).toBe(false);
-    expect(fs.existsSync(path.join(savePath, 'nested'))).toBe(false);
-    expect(fs.existsSync(path.join(savePath, 'IntTestPath.js'))).toBe(true);
-  });
-
-  it('does not clear save path when cleanSavePath is false', async () => {
-    const savePath = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'int-test-no-clean-save-path-')
-    );
-    tempDirs.push(savePath);
-    fs.writeFileSync(path.join(savePath, 'config.json'), 'keep');
-    fs.mkdirSync(path.join(savePath, 'nested-dir'));
-    fs.writeFileSync(path.join(savePath, 'nested-dir', 'file.json'), '{}');
-
-    const writeSource = jest.fn()
-      .mockResolvedValueOnce([true, {}])
-      .mockImplementationOnce(async ({ setting }) => {
-        fs.writeFileSync(path.join(setting.savePath, 'IntTestPath.js'), 'new');
-        return [true, {}];
-      });
-
-    await runTemplateItems([
-      {
-        templatePath: '/tmp/template.ejs',
-        templateData: { ok: true },
-        setting: {
-          savePath,
-          cleanSavePath: false
-        }
-      }
-    ], {
-      writeSource,
-      errorPrefix: 'IntTest resource'
-    });
-
-    expect(fs.existsSync(path.join(savePath, 'config.json'))).toBe(true);
-    expect(fs.existsSync(path.join(savePath, 'nested-dir'))).toBe(true);
-    expect(fs.existsSync(path.join(savePath, 'IntTestPath.js'))).toBe(true);
-  });
-});