@izara_project/izara-core-generate-service-code 1.0.68 → 1.0.70

package/test/dynamicCrudFlowSchemas.test.js

@@ -14,18 +14,27 @@ test('generates dynamic CRUD schemas from local schema modules', async () => {
   });
 
   const result = await generateDynamicCrudFlowSchemas(rootPath);
-  assert.deepEqual(result.files.map(file => file.path), [
-    'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Create.js',
-    'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Update.js',
-    'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Delete.js',
-    'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Get.js'
-  ]);
+  assert.deepEqual(
+    result.files.map((file) => file.path),
+    [
+      'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Create.js',
+      'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Update.js',
+      'app/src/schemas/FlowSchemas/generateCode/FlowObjects/Delete.js',
+      'app/src/schemas/FlowSchemas/generateCode/FlowObjects/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.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);
@@ -41,11 +50,12 @@ test('accepts singleton object exports used by existing schema files', async ()
   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'
-  ]);
+  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 () => {
@@ -66,17 +76,24 @@ 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 });
+  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 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 writeFile(
+    join(objectDirectory, 'Invalid.js'),
+    "export default 'not-a-schema';\n"
+  );
 
   await assert.rejects(
     generateDynamicCrudFlowSchemas(rootPath),
@@ -94,22 +111,40 @@ test('reloads changed local flow schemas instead of reusing module cache', async
   await generateDynamicCrudFlowSchemas(rootPath);
   assert.match(await readGeneratedFile(rootPath, 'Create'), /BeforeLogical/);
 
-  await writeFile(flowPath, `export default [${JSON.stringify(createHookFlow([]))}];\n`);
+  await writeFile(
+    flowPath,
+    `export default [${JSON.stringify(createHookFlow([]))}];\n`
+  );
   await generateDynamicCrudFlowSchemas(rootPath);
-  assert.doesNotMatch(await readGeneratedFile(rootPath, 'Create'), /BeforeLogical/);
+  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 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 });
+  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`);
+  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`);
+    await writeFile(
+      flowPath,
+      `export default ${singletonExports ? flowSource : `[${flowSource}]`};\n`
+    );
   }
   return rootPath;
 }
@@ -127,10 +162,23 @@ function createHookFlow(event) {
 }
 
 async function readGeneratedFlow(rootPath, action) {
-  const filePath = join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/FlowObjects', `${action}.js`);
-  return import(`${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`).then(module => module.default);
+  const filePath = join(
+    rootPath,
+    'app/src/schemas/FlowSchemas/generateCode/FlowObjects',
+    `${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/FlowObjects', `${action}.js`), 'utf8');
+  return readFile(
+    join(
+      rootPath,
+      'app/src/schemas/FlowSchemas/generateCode/FlowObjects',
+      `${action}.js`
+    ),
+    'utf8'
+  );
 }

package/test/dynamicRbacFlowSchemas.test.js

@@ -21,19 +21,34 @@ const STATIC_ACTIONS = [
 ];
 
 after(async () => {
-  await Promise.all([...projectRoots].map(rootPath => rm(rootPath, { recursive: true, force: true })));
+  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' });
+  const result = await generateDynamicRbacFlowSchemas(rootPath, {
+    serviceTag: 'UserAccount'
+  });
 
-  assert.deepEqual(result.files.map(file => file.path), [
-    ...STATIC_ACTIONS.map(action => `app/src/schemas/FlowSchemas/generateCode/FlowRbac/${action}.js`),
-    'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js'
-  ]);
-  const createTargetRole = await readGeneratedFlow(rootPath, 'CreateTargetRole');
+  assert.deepEqual(
+    result.files.map((file) => file.path),
+    [
+      ...STATIC_ACTIONS.map(
+        (action) =>
+          `app/src/schemas/FlowSchemas/generateCode/FlowRbac/${action}.js`
+      ),
+      'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js'
+    ]
+  );
+  const createTargetRole = await readGeneratedFlow(
+    rootPath,
+    'CreateTargetRole'
+  );
   const user = await readGeneratedFlow(rootPath, 'UserRbacFlow');
   assert.deepEqual(createTargetRole.flowSteps[0].returnValues, {
     properties: ['returnResult'],
@@ -47,13 +62,30 @@ 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");
+  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/FlowRbac/CreateTargetRole.js')));
-  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js')));
+  await assert.rejects(
+    readFile(
+      join(
+        rootPath,
+        'app/src/schemas/FlowSchemas/generateCode/FlowRbac/CreateTargetRole.js'
+      )
+    )
+  );
+  await assert.rejects(
+    readFile(
+      join(
+        rootPath,
+        'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js'
+      )
+    )
+  );
 });
 
 test('requires a serviceTag only when RBAC schemas are needed', async () => {
@@ -75,11 +107,20 @@ test('removes object-specific RBAC schemas when the ObjectSchema file is deleted
 
   await generateDynamicRbacFlowSchemas(rootPath);
 
-  await assert.rejects(readFile(join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js')));
+  await assert.rejects(
+    readFile(
+      join(
+        rootPath,
+        'app/src/schemas/FlowSchemas/generateCode/FlowRbac/UserRbacFlow.js'
+      )
+    )
+  );
 });
 
 async function createProject({ hasRbac = false } = {}) {
-  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-rbac-'));
+  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 });
@@ -91,7 +132,13 @@ async function createProject({ hasRbac = false } = {}) {
 }
 
 async function readGeneratedFlow(rootPath, flowTag) {
-  const filePath = join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/FlowRbac', `${flowTag}.js`);
-  const module = await import(`${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`);
+  const filePath = join(
+    rootPath,
+    'app/src/schemas/FlowSchemas/generateCode/FlowRbac',
+    `${flowTag}.js`
+  );
+  const module = await import(
+    `${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`
+  );
   return module.default;
 }

package/test/dynamicRelationshipFlowSchemas.test.js

@@ -18,9 +18,11 @@ const RELATIONSHIP_ACTIONS = [
 const projectRoots = new Set();
 
 after(async () => {
-  await Promise.all([...projectRoots].map(rootPath =>
-    rm(rootPath, { recursive: true, force: true })
-  ));
+  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 () => {
@@ -29,32 +31,58 @@ test('generates dynamic relationship schemas even without declared relationships
   const result = await generateDynamicRelationshipFlowSchemas(rootPath);
 
   assert.deepEqual(
-    result.files.map(file => file.path),
-    RELATIONSHIP_ACTIONS.map(action => `app/src/schemas/FlowSchemas/generateCode/FlowRelationship/${action}.js`)
+    result.files.map((file) => file.path),
+    RELATIONSHIP_ACTIONS.map(
+      (action) =>
+        `app/src/schemas/FlowSchemas/generateCode/FlowRelationship/${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.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);
+  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);
+  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');
+  const relationshipPath = join(
+    rootPath,
+    'app/src/schemas/RelationshipSchemas/OrderCustomer.js'
+  );
 
   await generateDynamicRelationshipFlowSchemas(rootPath);
   await writeFile(relationshipPath, "export default 'not-a-schema';\n");
@@ -69,20 +97,33 @@ 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 });
+  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/FlowRelationship/CreateRelationship.js'), 'utf8'),
+    await readFile(
+      join(
+        rootPath,
+        'app/src/schemas/FlowSchemas/generateCode/FlowRelationship/CreateRelationship.js'
+      ),
+      'utf8'
+    ),
     /export default/
   );
 });
 
 async function createProject({ singletonExport = false } = {}) {
-  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-relationship-'));
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-relationship-')
+  );
   projectRoots.add(rootPath);
-  const relationshipDirectory = join(rootPath, 'app/src/schemas/RelationshipSchemas');
+  const relationshipDirectory = join(
+    rootPath,
+    'app/src/schemas/RelationshipSchemas'
+  );
   await mkdir(relationshipDirectory, { recursive: true });
   const relationship = { relationshipTag: 'orderCustomer', links: [] };
   await writeFile(
@@ -93,7 +134,13 @@ async function createProject({ singletonExport = false } = {}) {
 }
 
 async function readGeneratedFlow(rootPath, action) {
-  const filePath = join(rootPath, 'app/src/schemas/FlowSchemas/generateCode/FlowRelationship', `${action}.js`);
-  const module = await import(`${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`);
+  const filePath = join(
+    rootPath,
+    'app/src/schemas/FlowSchemas/generateCode/FlowRelationship',
+    `${action}.js`
+  );
+  const module = await import(
+    `${pathToFileURL(filePath).href}?test=${process.hrtime.bigint()}`
+  );
   return module.default;
 }

package/test/functionYamlArtifact.test.js

@@ -11,11 +11,51 @@ import {
 
 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)'] }] })]
+    [
+      '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) {
@@ -24,11 +64,28 @@ test('renders function-setting hooks for every function transport', () => {
   }
 });
 
-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' });
+test('filters all 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,
+    /filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateCompleteHdrSqs/
+  );
   assert.match(completion, /exists: false/);
-  assert.doesNotMatch(ordinary, /filterPatterns:/);
+  assert.match(
+    ordinary,
+    /filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateHdrSqs/
+  );
+  assert.match(ordinary, /exists: false/);
 });

package/test/intTestApi.test.js

@@ -4,21 +4,20 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import {
-  generateIntTest,
-  generateResourceIntTest
-} from '../index.js';
+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-'));
+  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');
+  await writeFile(
+    path.join(rootPath, 'config', 'serverless.config.yml'),
+    'main_config: {}\n'
+  );
 
   try {
-    await assert.rejects(
-      generateIntTest(rootPath),
-      /Missing iz_serviceTag/
-    );
+    await assert.rejects(generateIntTest(rootPath), /Missing iz_serviceTag/);
     await assert.rejects(
       generateResourceIntTest(rootPath),
       /Missing iz_serviceTag/