@izara_project/izara-core-generate-service-code 1.0.64 → 1.0.66

package/README.md

@@ -1,15 +1,77 @@
-# izara-izara-core-generate-service-code
+# IzaraCore-SupportServices-GenerateServiceCodeV2
 
-# update version
-- commit code first
-npm version patch || npm version minor || npm version major
+New implementation of the schema-driven service generator. The legacy
+GenerateServiceCode repository remains the behavior oracle during migration.
 
-# can also push to repo ..
-git push
-# make sure commits look correct
+The first V2 seam is deliberately small:
 
-# push to npm
-npm publish
+```text
+GenerationRequest -> ProjectModel -> GenerationPlan -> Artifact[] -> committed files
+```
 
-# update project that uses this package
-npm update @izara_project/izara-core-generate-service-code
+`test-lib-generateCode` now points its local dependency at this checkout. Its
+V2 acceptance suites use only `generate(rootPath, options)`. Legacy golden
+comparison remains an oracle review: generation and artifact paths pass, while
+content differences are not accepted automatically.
+
+## Current Slice
+
+`generate(rootPath, options)` is the only public entrypoint. It loads
+the three schema directories once, emits every currently migrated schema,
+application, and resource slice, then commits all artifacts in one transaction
+and returns one `GenerationResult`. Managed artifacts retain their existing
+slice ownership, so stale files are cleaned without deleting legacy-owned
+output.
+
+`generate()` rejects invalid project/schema/artifact input before it commits.
+If staging or replacing an output target fails (including a directory or
+symlink where a generated file belongs), it restores every affected artifact
+and manifest from the same transaction; callers receive the original error.
+
+## Current Cutover Boundary
+
+V2 is generator-only for the current migration. `test-lib-generateCode` is
+the approved V2 consumer and calls the supported `generate()` API. Deployed
+services continue to use the legacy 1.x package for runtime imports; V2 does
+not provide legacy runtime exports such as `generateCode`, `utils`, `consts`,
+or `libs`.
+
+Do not replace the legacy package in a deployed service with V2 until a
+separate runtime migration removes those generated-code imports and verifies
+the resulting service behavior. The legacy repository is read-only and
+non-runtime now. After the first successful V2 production deployment, 90 days
+and two release cycles must both complete before it is archived as a protected,
+read-only Git repository. Archive retains its tags, history, and fixtures; it
+does not delete the repository.
+
+Generated function YAML preserves `FunctionSetting` hook blocks across
+regeneration and rollback. Completion SQS handlers retain the established
+`callingFlow` filter contract.
+
+Internally, the custom-flow emitter owns fixture-level application artifacts
+for `eventBridge`, `ownTopic`, `extTopic`, `lambdaSyncInv`, `lambdaSyncApi`,
+and S3's five entry handlers. The Phase 7 contract is artifact-level (paths,
+JavaScript syntax, YAML and resource/IAM wiring), not an end-to-end invocation
+contract.
+
+## Architecture Status
+
+The implemented V2 layout makes the pipeline ownership explicit:
+
+```text
+src/compile/  request and local schema loading
+src/plan/     GenerationPlan construction
+src/emit/     schema, application, function, resource, and system emitters
+src/output/   artifact validation, hook merge, and transaction commit
+```
+
+`src/generate.js` remains the high-level orchestration entrypoint. Emitter
+domains and their templates stay together beneath `src/emit/`; no pass-through
+modules were added only to mirror the proposed diagram. Internal modules are
+not part of the package API.
+
+## Development
+
+```bash
+npm test
+```

package/index.js

@@ -16,17 +16,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { generate } from './src/generate.js';
-import { generateCode } from './src/generateCode.js';
-import { generateSchema } from './src/generateSchema.js';
 import { generateIntTest } from './src/generateIntTest.js';
 import { generateResourceIntTest } from './src/generateResourceIntTest.js';
 
 export {
   // High-level API (recommended for consumers) — wires legacy Logger+validateLocalSchema
   generate,
-  // Main generators (low-level)
-  generateCode,
-  generateSchema,
   // IntTest generators (Result-Driven: no createSource/libs dependencies)
   generateIntTest,
   generateResourceIntTest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {
@@ -11,6 +11,7 @@
   "author": "Sven Mason <thebarbariansven@gmail.com>",
   "type": "module",
   "main": "index.js",
+  "exports": "./index.js",
   "scripts": {
     "test": "jest"
   },
@@ -19,9 +20,9 @@
   },
   "dependencies": {
     "@izara_project/izara-core-library-core": "^1.0.32",
-    "@izara_project/izara-core-library-logger": "^1.0.9",
-    "@izara_project/izara-shared-core": "^1.0.12",
-    "ejs": "^5.0.1",
+    "@izara_project/izara-core-library-logger": "^1.0.11",
+    "@izara_project/izara-shared-core": "^1.0.13",
+    "ejs": "^6.0.1",
     "js-beautify": "^2.0.3",
     "yaml": "^2.9.0",
     "@izara_project/izara-property-nodes": "^1.0.16",
@@ -32,8 +33,8 @@
     "@izara_project/izara-shared-service-schemas": "^1.0.65"
   },
   "devDependencies": {
-    "@izara_project/izara-core-library-service-schemas": "^1.0.157",
-    "@izara_project/izara-shared-service-schemas": "^1.0.65",
+    "@izara_project/izara-core-library-service-schemas": "^1.0.158",
+    "@izara_project/izara-shared-service-schemas": "^1.0.66",
     "jest": "^30.4.2"
   }
 }

package/src/compile/compileProject.js

@@ -0,0 +1,26 @@
+import { join, resolve } from 'node:path';
+
+export function compileProject(request = {}) {
+  if (!isNonEmptyString(request.rootPath)) {
+    throw new TypeError('GenerationRequest.rootPath must be a non-empty string');
+  }
+
+  const rootPath = resolve(request.rootPath);
+  const outputPath = resolve(request.outputPath ?? rootPath);
+  const configPath = resolve(
+    request.configPath ?? join(rootPath, 'config', 'serverless.config.yml')
+  );
+
+  return Object.freeze({
+    rootPath,
+    outputPath,
+    configPath,
+    schemaRoot: join(rootPath, 'app', 'src', 'schemas'),
+    serviceTag: request.serviceTag,
+    schemaTemplateConfig: request.schemaTemplateConfig ?? []
+  });
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '';
+}

package/src/compile/loadSchemas.js

@@ -0,0 +1,28 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+export async function loadLocalSchemaDirectory(project, directoryName) {
+  const directoryPath = join(project.schemaRoot, directoryName);
+  let entries;
+  try {
+    entries = await readdir(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+
+  const schemas = [];
+  for (const entry of entries.filter(entry => entry.isFile() && entry.name.endsWith('.js')).sort((a, b) => a.name.localeCompare(b.name))) {
+    const filePath = join(directoryPath, entry.name);
+    const details = await stat(filePath);
+    const module = await import(`${pathToFileURL(filePath).href}?schemaVersion=${details.mtimeMs}-${details.size}`);
+    if (!module.default || typeof module.default !== 'object') {
+      throw new TypeError(`Schema module must default-export an object or array: ${filePath}`);
+    }
+    schemas.push(...(Array.isArray(module.default) ? module.default : [module.default]));
+  }
+  return schemas;
+}

package/src/emit/crud/dynamicCrudFlowSchemaTemplate.js

@@ -0,0 +1,11 @@
+export function renderDynamicCrudFlowSchema(action, flow) {
+  return [
+    '/**',
+    ' * GENERATED DYNAMIC FLOW SCHEMA',
+    ` * Action: ${action}`,
+    ' * Description: Handles dynamic CRUD for all allowed ObjectTypes via SQS/DSQ',
+    ' */',
+    `export default ${JSON.stringify(flow, null, 2)};`,
+    ''
+  ].join('\n');
+}

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -0,0 +1,157 @@
+import ejs from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+import {
+  renderApiFunctionYaml,
+  renderInvFunctionYaml,
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../function/functionYamlArtifact.js';
+
+const ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-objects.yml';
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+
+export async function emitCrudApplicationArtifacts({ objects, flows = [], serviceTag }) {
+  if (!Array.isArray(objects) || !Array.isArray(flows)) {
+    throw new TypeError('objects and flows must be arrays');
+  }
+  if (!objects.some(isCrudObject)) return [];
+
+  const handlers = await Promise.all(ACTIONS.map(action => emitAction(action, objects, flows, serviceTag)));
+  return [
+    ...handlers.flatMap(handler => handler.artifacts),
+    {
+      path: YAML_PATH,
+      content: handlers.flatMap(handler => handler.functions).map(renderFunction).join('\n')
+    }
+  ];
+}
+
+export function crudApplicationManagedPaths() {
+  return [
+    ...ACTIONS.flatMap(action => {
+      const source = `app/src/generatedCode/FlowObjects/${action}/source`;
+      const paths = [`${source}/${action}_Main.js`];
+      if (action === 'Get') {
+        paths.push(`${source}/Get_HdrInv.js`, `${source}/Get_HdrApi.js`);
+        paths.push(`${source}/GetRange_Main.js`, `${source}/GetRange_HdrApi.js`);
+      } else {
+        paths.push(
+          `${source}/${action}_HdrSqs.js`,
+          `${source}/${action}_WbsMain.js`,
+          `${source}/${action}_HdrWbs.js`,
+          `${source}/${action}BeforeLogical_Main.js`,
+          `${source}/${action}BeforeLogical_HdrSqs.js`
+        );
+        paths.push(`${source}/${action}Complete_Main.js`, `${source}/${action}Complete_HdrSqs.js`);
+      }
+      return paths;
+    }),
+    YAML_PATH
+  ];
+}
+
+async function emitAction(action, objects, flows, serviceTag) {
+  const source = `app/src/generatedCode/FlowObjects/${action}/source`;
+  const handlerRoot = `src/generatedCode/FlowObjects/${action}/source`;
+  const generateCode = flows
+    .filter(flow => flow?.generatedCodeConfig?.generatedCodeTag?.toLowerCase() === action.toLowerCase())
+    .map(flow => ({ ...flow.generatedCodeConfig, flowTag: flow.flowTag }));
+  const mainFileName = `${action}_Main`;
+  const shared = {
+    flowTag: action,
+    upperCaseFlowTag: action,
+    topicArn: `${action}_In`,
+    generateCode,
+    flow: null,
+    flowStepName: '',
+    startConfig: null
+  };
+  const artifacts = [{
+    path: `${source}/${mainFileName}.js`,
+    content: await render(`${action}Endpoint_Main.ejs`, shared)
+  }];
+
+  if (action === 'Get') {
+    artifacts.push(
+      { path: `${source}/Get_HdrInv.js`, content: await render('FlowHandler_HdrInv.ejs', { ...shared, mainFileName, functionName: 'Get', queueName: 'GetHdrInv' }) },
+      { path: `${source}/Get_HdrApi.js`, content: await render('FlowHandler_HdrApi.ejs', { ...shared, mainFileName, functionName: 'Get', queueName: 'GetHdrApi' }) },
+      { path: `${source}/GetRange_Main.js`, content: await render('GetRangeEndpoint_Main.ejs', { ...shared, mainFileName: 'GetRange_Main', functionName: 'GetRange' }) },
+      { path: `${source}/GetRange_HdrApi.js`, content: await render('FlowHandler_HdrApi.ejs', { ...shared, mainFileName: 'GetRange_Main', functionName: 'GetRange', queueName: 'GetRangeHdrApi' }) }
+    );
+    return {
+      artifacts,
+      functions: [
+        { type: 'inv', functionName: 'GetHdrInv', handlerPath: `${handlerRoot}/Get_HdrInv.main`, roleName: 'FlowObjectsRole' },
+        {
+          type: 'api',
+          functionName: 'GetHdrApi',
+          handlerPath: `${handlerRoot}/Get_HdrApi.main`,
+          roleName: 'FlowObjectsRole',
+          routes: objects.filter(isCrudObject).map(object => ({
+            path: `/${serviceTag ?? '${self:custom.iz_serviceName}'}/${object.objectType}/get`,
+            upperName: upperFirst(object.objectType)
+          }))
+        },
+        {
+          type: 'api',
+          functionName: 'GetRangeHdrApi',
+          handlerPath: `${handlerRoot}/GetRange_HdrApi.main`,
+          roleName: 'FlowObjectsRole',
+          routes: objects.filter(isCrudObject)
+            .filter(object => object.identifiers && object.identifiers.some(i => i.type === 'sortKey'))
+            .map(object => ({
+            path: `/${serviceTag ?? '${self:custom.iz_serviceName}'}/${object.objectType}/getRange`,
+            upperName: upperFirst(object.objectType)
+          }))
+        }
+      ]
+    };
+  }
+
+  artifacts.push(
+    { path: `${source}/${action}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, mainFileName, functionName: action, queueName: `${action}HdrSqs` }) },
+    { path: `${source}/${action}_WbsMain.js`, content: await render('FlowMain_Wbs.ejs', { ...shared, functionName: action }) },
+    { path: `${source}/${action}_HdrWbs.js`, content: await render('FlowEndpoint_HdrWbs.ejs', { ...shared, mainFileName: `${action}_WbsMain`, functionName: action, route: action }) }
+  );
+  const functions = [
+    { type: 'wbs', functionName: `${action}HdrWbs`, handlerPath: `${handlerRoot}/${action}_HdrWbs.main`, roleName: 'FlowObjectsRole', routeName: action },
+    { type: 'sqs', functionName: `${action}HdrSqs`, handlerPath: `${handlerRoot}/${action}_HdrSqs.main`, roleName: 'FlowObjectsRole', queueName: `${action}HdrSqs` }
+  ];
+  const complete = `${action}Complete`;
+  artifacts.push(
+    { path: `${source}/${complete}_Main.js`, content: await render('FlowEndpointComplete_Main.ejs', { action }) },
+    { path: `${source}/${complete}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, mainFileName: `${complete}_Main`, functionName: complete, queueName: `${action}CompleteHdrSqs` }) }
+  );
+  functions.push({ type: 'sqs', functionName: `${action}CompleteHdrSqs`, handlerPath: `${handlerRoot}/${complete}_HdrSqs.main`, roleName: 'FlowObjectsRole', queueName: `${action}CompleteHdrSqs` });
+  if (generateCode.some(config => config.codeHookTag === 'beforeLogical')) {
+    const beforeMain = `${action}BeforeLogical_Main`;
+    artifacts.push(
+      { path: `${source}/${beforeMain}.js`, content: await render('FlowEndpointBeforeLogical_Main.ejs', shared) },
+      { path: `${source}/${action}BeforeLogical_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, mainFileName: beforeMain, functionName: `${action}BeforeLogicalMain`, queueName: `${action}BeforeLogicalHdrSqs` }) }
+    );
+    functions.push({ type: 'sqs', functionName: `${action}BeforeLogicalHdrSqs`, handlerPath: `${handlerRoot}/${action}BeforeLogical_HdrSqs.main`, roleName: 'FlowObjectsRole', queueName: `${action}BeforeLogicalHdrSqs` });
+  }
+  return { artifacts, functions };
+}
+
+function isCrudObject(object) {
+  return object?.generatedBy === 'userGenerated' || object?.generatedBy === 'systemGenerated';
+}
+
+function upperFirst(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+async function render(templateName, data) {
+  const template = await readFile(new URL(templateName, TEMPLATE_URL), 'utf8');
+  return ejs.render(template, data);
+}
+
+function renderFunction(descriptor) {
+  if (descriptor.type === 'api') return renderApiFunctionYaml(descriptor);
+  if (descriptor.type === 'inv') return renderInvFunctionYaml(descriptor);
+  if (descriptor.type === 'wbs') return renderWbsFunctionYaml(descriptor);
+  return renderSqsFunctionYaml(descriptor);
+}

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -0,0 +1,84 @@
+import { renderDynamicCrudFlowSchema } from './dynamicCrudFlowSchemaTemplate.js';
+
+const ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const MESSAGE_ATTRIBUTES = ['userId', 'correlationId'];
+
+export const dynamicCrudFlowSchemaPaths = ACTIONS.map(
+  action => `app/src/schemas/FlowSchemas/generateCode/${action}.js`
+);
+
+export function emitDynamicCrudFlowSchemas({ objects, flows = [] }) {
+  if (!Array.isArray(objects) || !Array.isArray(flows)) {
+    throw new TypeError('objects and flows must be arrays');
+  }
+  if (!objects.some(object => object?.generatedBy === 'userGenerated' || object?.generatedBy === 'systemGenerated')) {
+    return [];
+  }
+
+  return ACTIONS.map((action, index) => {
+    const flow = createDynamicFlow(action, hasBeforeLogicalStep(flows, action));
+    return {
+      path: dynamicCrudFlowSchemaPaths[index],
+      content: renderDynamicCrudFlowSchema(action, flow)
+    };
+  });
+}
+
+function createDynamicFlow(action, hasBeforeLogicalStep) {
+  const outputTopic = action !== 'Get';
+  const flowSteps = [
+    {
+      stepName: 'start',
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES,
+      ...(outputTopic ? {
+        returnValues: {
+          properties: [],
+          messageAttributes: MESSAGE_ATTRIBUTES
+        }
+      } : {})
+    }
+  ];
+
+  if (hasBeforeLogicalStep) {
+    flowSteps.push({
+      stepName: 'BeforeLogical',
+      event: ['extTopic'],
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES
+    });
+  }
+  if (action !== 'Get') {
+    flowSteps.push({
+      stepName: 'Complete',
+      event: ['extTopic'],
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES
+    });
+  }
+
+  return {
+    flowTag: action,
+    isDynamicObjectType: true,
+    initiateBy: 'system',
+    handleObj: 'one',
+    statusType: 'none',
+    event: outputTopic ? ['ownTopic'] : ['lambdaSyncInv', 'lambdaSyncApi'],
+    outputTopic,
+    stepMessageAttributes: {
+      userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
+      correlationId: { propertyName: 'x-correlation-id', type: 'string' }
+    },
+    flowSteps
+  };
+}
+
+function hasBeforeLogicalStep(flows, action) {
+  return flows.some(flow => {
+    const config = flow?.generatedCodeConfig;
+    return config?.generatedCodeTag === action.toLowerCase()
+      && config.codeHookTag === 'beforeLogical'
+      && Array.isArray(flow.event)
+      && flow.event.includes(config.invocationType);
+  });
+}

package/src/emit/crud/generateCrudApplicationArtifacts.js

@@ -0,0 +1,16 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
+import { crudApplicationManagedPaths, emitCrudApplicationArtifacts } from './emitCrudApplicationArtifacts.js';
+
+export async function generateCrudApplicationArtifacts(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const schemas = await loadLocalSchemaArrays(project);
+  const artifacts = await emitCrudApplicationArtifacts({ ...schemas, serviceTag: project.serviceTag });
+  const files = await commitArtifacts(buildGenerationPlan(project, artifacts, {
+    managedPaths: crudApplicationManagedPaths(),
+    managedScope: 'crud-application'
+  }));
+  return { project, files };
+}

package/src/emit/crud/generateDynamicCrudFlowSchemas.js

@@ -0,0 +1,21 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import {
+  dynamicCrudFlowSchemaPaths,
+  emitDynamicCrudFlowSchemas
+} from './emitDynamicCrudFlowSchemas.js';
+import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
+
+export async function generateDynamicCrudFlowSchemas(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const schemaInputs = await loadLocalSchemaArrays(project);
+  const plan = buildGenerationPlan(
+    project,
+    emitDynamicCrudFlowSchemas(schemaInputs),
+    { managedPaths: dynamicCrudFlowSchemaPaths, managedScope: 'crud-flow-schemas' }
+  );
+  const files = await commitArtifacts(plan);
+
+  return { project, files };
+}

package/src/emit/crud/loadLocalSchemaArrays.js

@@ -0,0 +1,8 @@
+import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+
+export async function loadLocalSchemaArrays(project) {
+  return {
+    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas'),
+    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas')
+  };
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/crud → emit/crud/templates}/CreateEndpoint_Main.ejs

@@ -670,4 +670,4 @@ export default async function <%- flowTag %>(
   } catch (err) {
     throw err;
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/crud → emit/crud/templates}/DeleteEndpoint_Main.ejs

@@ -346,4 +346,4 @@ export default async function <%- flowTag %>(
   } catch (err) {
     throw err;
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/step → emit/crud/templates}/FlowEndpointBeforeLogical_Main.ejs

@@ -67,7 +67,7 @@ export default async function <%- flowTag %>BeforeLogicalMain(
       }
     }
     _izContext.logger.debug('identifiers:::: ', identifiers);
-    
+
     // build parentFlowId
     <%_ if (flowTag === 'Create') { _%>
     const parentFlowId = identifierUuid();
@@ -155,4 +155,4 @@ export default async function <%- flowTag %>BeforeLogicalMain(
   } catch (err) {
     throw err;
   }
-}
+}

package/src/emit/crud/templates/FlowEndpointComplete_Main.ejs

@@ -0,0 +1,75 @@
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts } from '@izara_project/izara-core-library-service-schemas';
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+
+const { TOPIC_NAME_GENERATE_CODE } = consts;
+const PREFIX = { ASYNC: '<%- action %>AsyncEndpoint' };
+
+function empty(value) {
+  return value == null || (typeof value === 'object' && Object.keys(value).length === 0);
+}
+
+function validateInput(returnValue, status, graphServiceTag, errorsFound) {
+  if (!returnValue?.queryResult) errorsFound.push('message is not have property queryResult, should be not happen');
+  if (!returnValue?.requestParams?.objType) errorsFound.push('message is not have property objType, should be not happen');
+  if (!returnValue?.requestParams?.objInstanceFull) errorsFound.push('message is not have property objInstance, should be not objInstance');
+  if (status === 'error' && errorsFound.length === 0) errorsFound.push('[invalid]status is error not have errorsFound form graphService');
+  if (status === 'complete' && errorsFound.length > 0) errorsFound.push('[Invalid] status is complete should be not have errorsFound');
+  if (graphServiceTag == null) errorsFound.push('[Invalid] graphServerTag is not empty string');
+}
+
+export default async function <%- action %>Complete(_izContext, requestParams, passBackProperties) {
+  try {
+    const { returnValue, status, errorsFound = [], graphServiceTag, parentFlowId } = requestParams;
+    if (empty(returnValue?.requestParams)) throw new NoRetryError('message not an object');
+    validateInput(returnValue, status, graphServiceTag, errorsFound);
+    if (errorsFound.length > 0) errorsFound.push(errorsFound.join(','));
+
+    const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(parentFlowId, PREFIX.ASYNC);
+    const pending = await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(_izContext, awaitingStepId);
+    const result = await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+      _izContext, pending.pendingStepId, awaitingStepId, errorsFound
+    );
+
+    if (result.isComplete) {
+      const node = returnValue.queryResult.return<%- action %>Node ?? {};
+      const existsNode = node.existsNode && Object.keys(node.existsNode).length
+        ? { objType: returnValue.requestParams.objType, objInstanceFull: node.existsNode.objInstanceFull }
+        : null;
+      if (status === 'complete') {
+        await Promise.all((pending.listOfRecords ?? []).flatMap(records => Object.values(records).map(async record =>
+          dynamodbSharedLib.putItem(_izContext, await dynamodbSharedLib.tableName(_izContext, record.tableName, record.serviceTag), {
+            ...record.objInstanceFull.identifiers,
+            ...record.objInstanceFull.fields
+          })
+        )));
+      }
+      const message = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        relationships: node.relationships,
+        parentFlowId: returnValue.parentFlowId,
+        existsNode,
+        status,
+        errorsFound
+      });
+      const messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {});
+      await sns.publishAsync(_izContext, {
+        Message: JSON.stringify(message),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+        TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.out<%- action %>NodeComplete)
+      });
+      //(<afterSendMessage>)
+      //(</afterSendMessage>)
+    }
+    await asyncFlowSharedLib.removeAwaitingMultipleStep(_izContext, awaitingStepId, pending.pendingStepId, errorsFound);
+    return { returnValue, status, errorsFound };
+  } catch (error) {
+    _izContext.logger.error('<%- action %>Complete error:', error);
+    throw error;
+  }
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint → emit/crud/templates}/FlowEndpoint_HdrWbs.ejs

@@ -107,4 +107,4 @@ export const main = middleware.wrap(async (event, context) => {
     await postToConnection({ message: err.message }, connId);
     return (response.failure(err));
   }
-});
+});