@izara_project/izara-core-generate-service-code 1.0.91 → 1.0.92

package/src/emit/resource/sqsResourceArtifacts.js

@@ -0,0 +1,113 @@
+import { indentYaml, renderResourceTemplate } from './resourceTemplate.js';
+
+export async function renderResourceGroup({
+  ownTopics = [],
+  sqsQueues = [],
+  dsqQueues = [],
+  webSocketSubscriptions = [],
+  s3Subscriptions = []
+}) {
+  const hasResources =
+    ownTopics.length > 0 ||
+    sqsQueues.length > 0 ||
+    dsqQueues.length > 0 ||
+    webSocketSubscriptions.length > 0 ||
+    s3Subscriptions.length > 0;
+  if (!hasResources) {
+    return '';
+  }
+
+  const chunks = await Promise.all([
+    ...ownTopics.map((queueName) =>
+      renderResourceTemplate('ResourceYaml.ejs', { queueName })
+    ),
+    ...sqsQueues.map((queueName) =>
+      renderResourceTemplate('ResourceSqsYaml.ejs', { queueName })
+    ),
+    ...dsqQueues.map((queueName) =>
+      renderResourceTemplate('ResourceSqsYaml.ejs', { queueName })
+    )
+  ]);
+  const wsSubs = await Promise.all(
+    webSocketSubscriptions.map((topicName) =>
+      renderWebSocketSubscription(topicName)
+    )
+  );
+  const s3Subs = await Promise.all(
+    s3Subscriptions.map(({ subscriptionName, topicName, queueName }) =>
+      renderResourceTemplate('S3Subscription_Yaml.ejs', {
+        subscriptionName,
+        topicName,
+        queueName
+      })
+    )
+  );
+  const parts = [chunks.join('\n')];
+  if (wsSubs.length > 0) {
+    parts.push(wsSubs.join('\n'));
+  }
+  if (s3Subs.length > 0) {
+    parts.push(s3Subs.join('\n'));
+  }
+  const body = parts.filter(Boolean).join('\n');
+  if (!body.trim()) {
+    return '';
+  }
+  return `Resources:\n${indentYaml(body, 2)}`;
+}
+
+export async function renderCrudInSqs(state) {
+  return renderResourceGroup({
+    ownTopics: state.crudOwnTopics,
+    sqsQueues: state.crudSqsQueues
+  });
+}
+
+export async function renderRelationshipInSqs(state) {
+  return renderResourceGroup({
+    ownTopics: state.relationshipOwnTopics,
+    sqsQueues: state.relationshipSqsQueues,
+    dsqQueues: state.relationshipDsqQueues
+  });
+}
+
+export async function renderRbacInSqs(state) {
+  return renderResourceGroup({
+    ownTopics: state.rbacOwnTopics,
+    sqsQueues: state.rbacSqsQueues
+  });
+}
+
+export async function renderCustomFlowInSqs(state) {
+  return renderResourceGroup({
+    ownTopics: state.customOwnTopics,
+    sqsQueues: state.customSqsQueues,
+    dsqQueues: state.customDsqQueues,
+    s3Subscriptions: state.s3Subscriptions
+  });
+}
+
+export async function renderSystemInSqs(state) {
+  return renderResourceGroup({
+    ownTopics: state.systemOwnTopics,
+    sqsQueues: state.systemSqsQueues,
+    dsqQueues: state.systemDsqQueues,
+    webSocketSubscriptions: state.webSocketSubscriptions
+  });
+}
+
+export async function renderOut(state) {
+  const renderedTopics = await Promise.all(
+    state.outTopics.map((topicName) =>
+      renderResourceTemplate('FlowOut_Yaml.ejs', { topicName })
+    )
+  );
+  const body = renderedTopics.join('\n');
+  return `Resources:\n${indentYaml(body, 2)}`;
+}
+
+export function renderWebSocketSubscription(topicName) {
+  return renderResourceTemplate('WebSocketSubscription_Yaml.ejs', {
+    topicName
+  });
+}

package/src/emit/shared/runSubsystemGeneration.js

@@ -0,0 +1,55 @@
+import { compileProject } from '../../compile/compileProject.js';
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+
+/**
+ * Common pipeline runner for emitting and committing subsystem artifacts.
+ *
+ * @param {Object} params
+ * @param {string} params.rootPath Root path of the service project.
+ * @param {Object} [params.options={}] Options passed to compile and load.
+ * @param {Function} [params.loadInputs] Function to load schemas or inputs.
+ * @param {Function} params.emitArtifacts Function to emit artifacts.
+ * @param {string} params.managedScope Scope identifier for generation plan.
+ * @param {Array<string>|Function} params.resolveManagedPaths Managed paths.
+ * @returns {Promise<{ project: Object, files: Array<string> }>}
+ */
+export async function runSubsystemGeneration({
+  rootPath,
+  options = {},
+  loadInputs,
+  emitArtifacts,
+  managedScope,
+  resolveManagedPaths
+}) {
+  const project = compileProject({ ...options, rootPath });
+
+  let inputs = {};
+  if (typeof loadInputs === 'function') {
+    inputs = await loadInputs(project, options);
+  }
+
+  const artifacts = await emitArtifacts({
+    project,
+    options,
+    ...inputs
+  });
+
+  let managedPaths = resolveManagedPaths;
+  if (typeof resolveManagedPaths === 'function') {
+    managedPaths = await resolveManagedPaths({
+      project,
+      options,
+      artifacts,
+      ...inputs
+    });
+  }
+
+  const plan = buildGenerationPlan(project, artifacts, {
+    managedPaths,
+    managedScope
+  });
+  const files = await commitArtifacts(plan);
+
+  return { project, files };
+}

package/src/emit/system/emitSystemWebSocketArtifacts.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import ejsLib from 'ejs';
+import { flowHasOwnTopic } from '../custom/customFlows.js';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 const SOURCE = 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source';
@@ -126,7 +127,7 @@ export function hasSystemWebSocket(
         Array.isArray(flow?.event) &&
         (flow.event.includes('s3') ||
           (includeRelationshipOwnTopic &&
-            flow.event.includes('ownTopic') &&
+            flowHasOwnTopic(flow) &&
             (flow.initiateBy === 'user' || flow.initiateBy === 'systemWithUser')))
     )
   );

package/test/crudApplicationArtifacts.test.js

@@ -1388,6 +1388,78 @@ test('emits autoProvisionOwnerTargetRole in CreateNodeCallback when service has
   );
 });
 
+test('emits synchronous before-hook invocation in Create_Main when event is generateCode and invocationType is lambdaSyncInv', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeCreateSync.js'),
+    "export default { flowTag: 'validateBeforeCreateSync', event: ['generateCode'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(
+    createMain,
+    /lambda\.invokeSync\(\s*_izContext,\s*await lambdaSharedLib\.lambdaFunctionName\(\s*_izContext,\s*'validateBeforeCreateSync'\s*\)/
+  );
+  assert.match(createMain, /Hook validateBeforeCreateSync failed/);
+
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('emits async before-hook callback and SNS publish in Create_Main when event is generateCode and invocationType is ownTopic', async () => {
+  const rootPath = await createProject(true);
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/ValidateBeforeCreateAsync.js'),
+    "export default { flowTag: 'validateBeforeCreateAsync', event: ['generateCode'], generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  const createMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(createMain, /sns\.publishAsync\(_izContext,/);
+  assert.match(
+    createMain,
+    /snsTopicArnByFlowSchema\(\s*_izContext,\s*'validateBeforeCreateAsync_In'\s*\)/
+  );
+  assert.match(createMain, /CreateBeforeHookCallbackHdrSqs/);
+
+  const callbackHandler = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Create/source/CreateBeforeHookCallback_HdrSqs.js'
+    ),
+    'utf8'
+  );
+  assert.match(callbackHandler, /CreateBeforeHookCallback_Main/);
+});
+
 async function createProject(withCrudObject) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-application-')

package/test/customFlowApplicationArtifacts.test.js

@@ -1173,3 +1173,101 @@ test('renders previousSteps extTopic subscriptions in InitialSetupConfig', async
     /sqsEndpoint: 'OrderBuildOrderSellOfferLinkAndReserveOrderDataHdrSqs'/
   );
 });
+
+test('emits handlers, YAML and templates for flow with event generateCode and invocationType ownTopic', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-custom-gen-own-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'GenOwn.js'),
+    `export default {
+  flowTag: 'genOwn',
+  event: ['generateCode'],
+  generatedCodeConfig: {
+    generateCodeTag: 'create',
+    codeHookTag: 'before',
+    invocationType: 'ownTopic'
+  },
+  flowSteps: [{ stepName: 'Start', properties: ['dummyId'] }],
+  stepProperties: { dummyId: { type: 'string' } }
+};\n`
+  );
+
+  await generateCustomFlowApplicationArtifacts(rootPath);
+
+  const mainPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/GenOwn/source/GenOwn_Main.js'
+  );
+  const hdrSqsPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/GenOwn/source/GenOwn_HdrSqs.js'
+  );
+  const wbsMainPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/GenOwn/source/GenOwn_WbsMain.js'
+  );
+  const hdrWbsPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/GenOwn/source/GenOwn_HdrWbs.js'
+  );
+
+  assert.match(await readFile(mainPath, 'utf8'), /asyncFlowSharedLib/);
+  assert.match(await readFile(hdrSqsPath, 'utf8'), /GenOwn_Main/);
+  assert.match(await readFile(wbsMainPath, 'utf8'), /GenOwn_WbsMain/);
+  assert.match(await readFile(hdrWbsPath, 'utf8'), /GenOwn_WbsMain/);
+
+  const yaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'),
+    'utf8'
+  );
+  assert.match(yaml, /GenOwnHdrWbs:/);
+  assert.match(yaml, /GenOwnHdrSqs:/);
+});
+
+test('emits handler and YAML for flow with event generateCode and invocationType lambdaSyncInv', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-custom-gen-sync-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'GenSync.js'),
+    `export default {
+  flowTag: 'genSync',
+  event: ['generateCode'],
+  generatedCodeConfig: {
+    generateCodeTag: 'create',
+    codeHookTag: 'before',
+    invocationType: 'lambdaSyncInv'
+  },
+  flowSteps: [{ stepName: 'Start', properties: ['dummyId'] }],
+  stepProperties: { dummyId: { type: 'string' } }
+};\n`
+  );
+
+  await generateCustomFlowApplicationArtifacts(rootPath);
+
+  const mainPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/GenSync/source/GenSync_Main.js'
+  );
+  const hdrInvPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/GenSync/source/GenSync_HdrInv.js'
+  );
+
+  assert.match(await readFile(mainPath, 'utf8'), /export default async function GenSync/);
+  assert.match(await readFile(hdrInvPath, 'utf8'), /GenSync_Main/);
+
+  const yaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'),
+    'utf8'
+  );
+  assert.match(yaml, /GenSyncHdrInv:/);
+});
+

package/test/resourceArtifacts.test.js

@@ -672,6 +672,105 @@ test('emits SQS queues and deduplicated IAM policies when generateCodeTag is an
   assert.strictEqual(notifyTopicMatches?.length, 1);
 });
 
+test('rejects flow schema with event generateCode missing generatedCodeConfig', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'MissingConfig.js'),
+    "export default { flowTag: 'missingConfig', event: ['generateCode'] };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /flow with event 'generateCode' requires generatedCodeConfig/
+  );
+});
+
+test('rejects flow schema with event generateCode and invalid invocationType', async () => {
+  const rootPath = await createProject();
+  const flowDirectory = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await writeFile(
+    join(flowDirectory, 'InvalidInvocation.js'),
+    "export default { flowTag: 'invalidInvocation', event: ['generateCode'], " +
+      "generatedCodeConfig: { invocationType: 'invalidType' } };\n"
+  );
+
+  await assert.rejects(
+    generateResourceArtifacts(rootPath),
+    /invocationType 'invalidType' is invalid/
+  );
+});
+
+test('emits SQS resources, SNS topics, and IAM role when flow has event generateCode with invocationType ownTopic', async () => {
+  const rootPath = await createProject();
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/GenOwnHook.js'),
+    "export default { flowTag: 'genOwnHook', event: ['generateCode'], " +
+      "generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', " +
+      "invocationType: 'ownTopic' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const crudResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-crud.yml'
+    ),
+    'utf8'
+  );
+  assert.match(crudResources, /^  CreateBeforeHookCallbackHdrSqs:/m);
+
+  const customResources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-custom-flows.yml'
+    ),
+    'utf8'
+  );
+  assert.match(customResources, /^  GenOwnHookHdrSqs:/m);
+  assert.match(customResources, /^  InGenOwnHook:/m);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const flowRole = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(flowRole, /CreateBeforeHookCallbackHdrSqs/);
+  assert.match(flowRole, /GenOwnHook_In/);
+
+  const customRole = roleBlock(iam, 'GenOwnHookRole');
+  assert.match(customRole, /GenOwnHookHdrSqs/);
+  assert.match(customRole, /GenOwnHook_In/);
+});
+
+test('emits lambda:InvokeFunction in FlowObjectsRole when flow has event generateCode with invocationType lambdaSyncInv', async () => {
+  const rootPath = await createProject();
+  const schemas = join(rootPath, 'app/src/schemas');
+  await writeFile(
+    join(schemas, 'FlowSchemas/GenSyncHook.js'),
+    "export default { flowTag: 'genSyncHook', event: ['generateCode'], " +
+      "generatedCodeConfig: { generateCodeTag: 'create', codeHookTag: 'before', " +
+      "invocationType: 'lambdaSyncInv' }, objType: { objectType: 'order' } };\n"
+  );
+  await generateResourceArtifacts(rootPath);
+
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const role = roleBlock(iam, 'FlowObjectsRole');
+  assert.match(role, /lambda:InvokeFunction/);
+  assert.match(role, /GenSyncHook/);
+});
+
+
 function roleBlock(iam, roleName) {
   const match = iam.match(
     new RegExp(