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

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/src/generate.js

@@ -61,6 +61,10 @@ import {
   attributeTreeObjectSchemaManagedPaths,
   attributeTreeRelationshipSchemaManagedPaths
 } from './emit/attributeTree/emitAttributeTreeSchemas.js';
+import {
+  emitErrorSchemas,
+  errorSchemaManagedPaths
+} from './emit/error/emitErrorSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -70,11 +74,18 @@ export async function generate(rootPath, options = {}) {
     const schemaLoadOptions = {
       skipValidation: options.skipValidation
     };
-    const [rawObjects, relationships, flows, notifications] = await Promise.all([
+    const [
+      rawObjects,
+      relationships,
+      flows,
+      notifications,
+      errors
+    ] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(project, 'RelationshipSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions)
+      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -93,14 +104,24 @@ export async function generate(rootPath, options = {}) {
     console.log(
       `[DEBUG] [Generate] STATUS=SCHEMAS_LOADED | ` +
       `objects=${objects.length} ` +
-      `relationships=${relationships.length} flows=${flows.length}`
+      `relationships=${relationships.length} flows=${flows.length} ` +
+      `notifications=${notifications.length} ` +
+      `errors=${errors.length}`
     );
+    for (const objectSchema of objects) {
+      const objectType = objectSchema.objectType || 'unknown';
+      console.log(
+        `[DEBUG] [Generate] OBJECT_SCHEMA | objectType=${objectType}\n` +
+        JSON.stringify(objectSchema, null, 2)
+      );
+    }
     const groups = await _emitGroups({
       project,
       objects,
       relationships,
       flows,
       notifications,
+      errors,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger
@@ -149,6 +170,7 @@ async function _emitGroups({
   relationships,
   flows,
   notifications,
+  errors,
   objectGraphServiceTags,
   relationshipGraphServiceTags,
   logger
@@ -161,7 +183,8 @@ async function _emitGroups({
     findData,
     resource,
     coreFunction,
-    systemText
+    systemText,
+    errorSchemas
   ] = await Promise.all([
     emitCrudApplicationArtifacts({
       objects,
@@ -196,6 +219,11 @@ async function _emitGroups({
       relationships,
       flows,
       notifications
+    }),
+    emitErrorSchemas({
+      project,
+      errors,
+      objectGraphServiceTags
     })
   ]);
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
@@ -307,6 +335,11 @@ async function _emitGroups({
       scope: 'system-text-schemas',
       managedPaths: systemTextSchemaManagedPaths(),
       artifacts: systemText
+    },
+    {
+      scope: 'error-schemas',
+      managedPaths: errorSchemaManagedPaths(errors),
+      artifacts: errorSchemas
     }
   ];
 }

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/errorSchemas.test.js

@@ -0,0 +1,154 @@
+import assert from 'node:assert/strict';
+import { readFile, rm, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import test, { after } from 'node:test';
+
+import {
+  emitErrorSchemas,
+  errorSchemaManagedPaths,
+  ERROR_SCHEMA_PATH
+} from '../src/emit/error/emitErrorSchemas.js';
+import { generate } from '../src/generate.js';
+
+const roots = new Set();
+after(() =>
+  Promise.all(
+    [...roots].map((root) => rm(root, { recursive: true, force: true }))
+  )
+);
+
+test('emitErrorSchemas produces expected ERROR_TYPES for graph and general errors', async () => {
+  const artifacts = await emitErrorSchemas({
+    project: { serviceTag: 'MyService' },
+    objectGraphServiceTags: ['GraphHandler'],
+    errors: [
+      {
+        errorTag: 'NOT_FOUND_SCHEMA',
+        errorAction: 'throw',
+        sharedLibrary: true,
+        _sourceFile: 'errorgraph.js'
+      },
+      {
+        errorTag: 'INVALID_GENERATED_BY',
+        errorAction: 'throw',
+        sharedLibrary: true,
+        _sourceFile: 'errorgraph.js'
+      },
+      {
+        errorTag: 'CUSTOM_INTERNAL_ERROR',
+        errorAction: 'return',
+        _sourceFile: 'errors.js'
+      },
+      {
+        errorTag: 'EXPLICIT_SERVICE_ERROR',
+        errorAction: 'throw',
+        serviceTag: 'CustomService',
+        _sourceFile: 'custom.js'
+      }
+    ]
+  });
+
+  assert.equal(artifacts.length, 1);
+  assert.equal(artifacts[0].path, ERROR_SCHEMA_PATH);
+
+  const content = artifacts[0].content;
+  assert.match(content, /^export const ERROR_TYPES = {/m);
+  assert.doesNotMatch(content, /export default/);
+
+  // Errors without explicit serviceTag resolve to project.serviceTag
+  assert.match(
+    content,
+    /NOT_FOUND_SCHEMA:\s*{\s*errorTag:\s*'NOT_FOUND_SCHEMA',\s*serviceTag:\s*'MyService'\s*}/
+  );
+  assert.match(
+    content,
+    /INVALID_GENERATED_BY:\s*{\s*errorTag:\s*'INVALID_GENERATED_BY',\s*serviceTag:\s*'MyService'\s*}/
+  );
+
+  // General error resolved to project.serviceTag
+  assert.match(
+    content,
+    /CUSTOM_INTERNAL_ERROR:\s*{\s*errorTag:\s*'CUSTOM_INTERNAL_ERROR',\s*serviceTag:\s*'MyService'\s*}/
+  );
+
+  // Explicit serviceTag respected
+  assert.match(
+    content,
+    /EXPLICIT_SERVICE_ERROR:\s*{\s*errorTag:\s*'EXPLICIT_SERVICE_ERROR',\s*serviceTag:\s*'CustomService'\s*}/
+  );
+
+  // Keys sorted alphabetically
+  const customIdx = content.indexOf('CUSTOM_INTERNAL_ERROR');
+  const explicitIdx = content.indexOf('EXPLICIT_SERVICE_ERROR');
+  const invalidIdx = content.indexOf('INVALID_GENERATED_BY');
+  const notFoundIdx = content.indexOf('NOT_FOUND_SCHEMA');
+  assert.ok(customIdx < explicitIdx);
+  assert.ok(explicitIdx < invalidIdx);
+  assert.ok(invalidIdx < notFoundIdx);
+});
+
+test('emitErrorSchemas returns empty array when no errors provided', async () => {
+  const artifacts = await emitErrorSchemas({
+    project: { serviceTag: 'MyService' },
+    errors: []
+  });
+
+  assert.deepEqual(artifacts, []);
+  assert.deepEqual(errorSchemaManagedPaths([]), []);
+  assert.deepEqual(errorSchemaManagedPaths(['someError']), [ERROR_SCHEMA_PATH]);
+});
+
+test('generate creates errorSchema.js when ErrorSchemas directory exists', async () => {
+  const rootPath = join(
+    tmpdir(),
+    `error-schema-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  roots.add(rootPath);
+  await mkdir(join(rootPath, 'app/src/schemas/ErrorSchemas'), {
+    recursive: true
+  });
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    'main_config:\n  iz_serviceTag: CategoryTreeStandard\n'
+  );
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ErrorSchemas/errorgraph.js'),
+    `export default [
+  {
+    errorTag: 'NOT_FOUND_SCHEMA',
+    errorAction: 'throw',
+    sharedLibrary: true
+  },
+  {
+    errorTag: 'INVALID_GENERATED_BY',
+    errorAction: 'throw',
+    sharedLibrary: true
+  },
+  {
+    errorTag: 'MISSING_USER_NODE',
+    errorAction: 'throw',
+    sharedLibrary: true
+  }
+];
+`
+  );
+
+  // Run generate
+  await generate(rootPath);
+
+  const targetFile = join(
+    rootPath,
+    'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js'
+  );
+  const content = await readFile(targetFile, 'utf8');
+
+  assert.match(content, /export const ERROR_TYPES = {/);
+  assert.match(content, /NOT_FOUND_SCHEMA:/);
+  assert.match(content, /INVALID_GENERATED_BY:/);
+  assert.match(content, /MISSING_USER_NODE:/);
+  assert.match(content, /serviceTag:\s*'CategoryTreeStandard'/);
+  assert.doesNotMatch(content, /export default/);
+});

package/test/publicApi.test.js

@@ -70,7 +70,7 @@ test('generate logs its lifecycle through console.log', async () => {
 
     assert.match(messages[0], /STATUS=STARTED/);
     assert.ok(messages.some((message) => {
-      return /STATUS=SCHEMAS_LOADED/.test(message);
+      return /STATUS=SCHEMAS_LOADED.*notifications=/.test(message);
     }));
     assert.ok(messages.some((message) => {
       return /STATUS=ARTIFACTS_EMITTED/.test(message);