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

package/src/emit/resource/emitResourceArtifacts.js

@@ -0,0 +1,300 @@
+import ejs from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+import { customFlowRoleName, flowExtTopicSteps, generatedOwnTopicFlows, supportedCustomFlows, triggerCacheFlows, triggerCacheQueueNames } from '../custom/customFlows.js';
+import { hasSystemWebSocket } from '../system/emitSystemWebSocketArtifacts.js';
+
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+const RESOURCE_ROOT = 'resource/sls_yaml/generatedCode/source';
+const APP_ROOT = 'app/sls_yaml/generatedCode/source';
+const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const RELATIONSHIP_ACTIONS = ['CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'GetRelationship', 'ChangeRelationship', 'MoveRelationship'];
+const RBAC_ACTIONS = ['CreateTargetRole', 'ListTargetRole', 'DeleteTargetRole', 'CreateRolePermissions', 'ListRolePermissions', 'DeleteRolePermissions', 'CreateUserRole', 'ListUserInRoles', 'DeleteUserFromRole'];
+const SYSTEM_TABLES = ['WebSocketTask', 'UserUploadRecords', 'RegisterRecords', 'AwaitingMultipleSteps', 'AwaitingMultipleStepByPending', 'FindDataMain', 'LogicalResultsMain', 'LogicalResultsData', 'AwaitingStep', 'TargetRoles', 'RolePermissions', 'RoleUsers', 'UserRoles'];
+const RBAC_TABLES = ['TargetRoles', 'RolePermissions', 'RoleUsers', 'UserRoles', 'WebSocketTask'];
+const LEGACY_PROCESS_QUEUES = ['FindDataHdrSqs', 'ProcessLogicalHdrSqs', 'PaginateProcessLogicalHdrDsq', 'PaginateProcessLogicalHdrSqs'];
+const DYNAMO_ACTIONS = ['dynamodb:DeleteItem', 'dynamodb:GetItem', 'dynamodb:PutItem', 'dynamodb:Query', 'dynamodb:UpdateItem'];
+const SQS_CONSUMER_ACTIONS = ['sqs:DeleteMessage', 'sqs:GetQueueAttributes', 'sqs:ReceiveMessage'];
+
+export async function emitResourceArtifacts({ objects, relationships, flows = [] }) {
+  if (![objects, relationships, flows].every(Array.isArray)) {
+    throw new TypeError('objects, relationships, and flows must be arrays');
+  }
+  const state = createResourceState({ objects, relationships, flows });
+  const [inSqs, out, dynamo, iam] = await Promise.all([
+    renderInSqs(state),
+    renderOut(state),
+    renderDynamo(state),
+    renderIam(state)
+  ]);
+  return [
+    { path: `${RESOURCE_ROOT}/generated-sns-in-sqs.yml`, content: normalizeYaml(inSqs) },
+    { path: `${RESOURCE_ROOT}/generated-sns-out.yml`, content: normalizeYaml(out) },
+    { path: `${RESOURCE_ROOT}/generated-dynamoDB-table.yml`, content: normalizeYaml(dynamo) },
+    { path: `${APP_ROOT}/generate-shared-resource.yml`, content: normalizeYaml(iam) }
+  ];
+}
+
+export const resourceArtifactPaths = [
+  `${RESOURCE_ROOT}/generated-sns-in-sqs.yml`,
+  `${RESOURCE_ROOT}/generated-sns-out.yml`,
+  `${RESOURCE_ROOT}/generated-dynamoDB-table.yml`,
+  `${APP_ROOT}/generate-shared-resource.yml`
+];
+
+function createResourceState({ objects, relationships, flows }) {
+  const crud = objects.some(isCrudObject);
+  const rbac = objects.some(hasRbacAddOn);
+  const ownTopics = new Set(flows.filter(flow => includesEvent(flow, 'ownTopic')).map(flow => upperFirst(flow.flowTag)));
+  const sqsQueues = new Set([
+    ...LEGACY_PROCESS_QUEUES,
+    ...flows.filter(flow => includesEvent(flow, 'extTopic')).map(flow => `Process${upperFirst(flow.flowTag)}HdrSqs`)
+  ]);
+  const triggerCache = triggerCacheFlows(flows);
+  const triggerCacheQueues = [...new Set(triggerCache.flatMap(triggerCacheQueueNames))].map(queueName => ({
+    queueName,
+    resourceQueueName: queueName.replaceAll('_', '')
+  }));
+  flowExtTopicSteps(flows).forEach(({ flowTag, stepName }) => sqsQueues.add(`${flowTag}${stepName}HdrSqs`));
+  flows.filter(flow => includesEvent(flow, 's3')).forEach(flow => {
+    const tag = upperFirst(flow.flowTag);
+    sqsQueues.add(`${tag}CreatePreSignUrlHdrSqs`);
+    sqsQueues.add(`${tag}ReservedLimitHdrSqs`);
+    sqsQueues.add(`${tag}ConfirmAfterUploadHdrSqs`);
+  });
+  const dsqQueues = new Set(flows.filter(flow => includesEvent(flow, 'dsq')).map(flow => `Process${upperFirst(flow.flowTag)}HdrDsq`));
+  if (crud) {
+    CRUD_ACTIONS.forEach(action => ownTopics.add(action));
+    ['Create', 'Update', 'Delete'].forEach(action => sqsQueues.add(`${action}CompleteHdrSqs`));
+  }
+  if (relationships.length > 0) {
+    RELATIONSHIP_ACTIONS.forEach(action => {
+      ownTopics.add(action);
+      sqsQueues.add(`${action}CompleteHdrSqs`);
+    });
+    dsqQueues.add('GetRelationshipHdrDsq');
+  }
+  if (rbac) {
+    RBAC_ACTIONS.forEach(action => {
+      ownTopics.add(action);
+      sqsQueues.add(`Process${action}HdrSqs`);
+    });
+    objects.filter(hasRbacAddOn).forEach(object => sqsQueues.add(`Process${upperFirst(object.objectType)}RbacFlowHdrInv`));
+  }
+  const beforeLogicalByAction = new Map();
+  for (const flow of flows.filter(flow => flow?.generatedCodeConfig?.codeHookTag === 'beforeLogical')) {
+    const action = upperFirst(flow.generatedCodeConfig.generatedCodeTag);
+    if (!action || !flow.flowTag) continue;
+    const flowTags = beforeLogicalByAction.get(action) ?? new Set();
+    flowTags.add(flow.flowTag);
+    beforeLogicalByAction.set(action, flowTags);
+  }
+  const beforeLogical = [...beforeLogicalByAction].map(([action, flowTags]) => ({ action, flowTags: [...flowTags].sort() }));
+  const customRoles = [...new Set([
+    ...supportedCustomFlows(flows).map(flow => customFlowRoleName(flow.flowTag)),
+    ...generatedOwnTopicFlows(flows).map(flow => customFlowRoleName(flow.flowTag)),
+    ...flowExtTopicSteps(flows).map(({ flow }) => customFlowRoleName(flow.flowTag)),
+    ...triggerCache.map(flow => customFlowRoleName(flow.flowTag))
+  ])];
+  const websocket = hasSystemWebSocket(flows, { includeRelationshipOwnTopic: relationships.length > 0 });
+  const webSocketRoles = new Set(websocket ? ['WebSocketMainRole'] : []);
+  if (crud) webSocketRoles.add('FlowObjectsRole');
+  if (relationships.length > 0) webSocketRoles.add('FlowRelationshipRole');
+  if (rbac) webSocketRoles.add('FlowRbacRole');
+  [...supportedCustomFlows(flows), ...generatedOwnTopicFlows(flows)]
+    .filter(flow => includesEvent(flow, 'ownTopic') || includesEvent(flow, 's3'))
+    .forEach(flow => webSocketRoles.add(customFlowRoleName(flow.flowTag)));
+  const outTopics = new Set([
+    ...ownTopics,
+    ...beforeLogical.map(({ action }) => action),
+    ...flows.filter(flow => flow?.outputTopic && upperFirst(flow.flowTag)).map(flow => upperFirst(flow.flowTag))
+  ]);
+  const objectTableNames = [...collectTables(objects).keys()];
+  const relationshipTableNames = [...collectTables(relationships).keys()];
+  const tableMap = new Map([...collectTables(objects), ...collectTables(relationships)]);
+  return {
+    crud,
+    rbac,
+    relationships: relationships.length > 0,
+    ownTopics: [...ownTopics].filter(Boolean).sort(),
+    sqsQueues: [...sqsQueues].filter(Boolean).sort(),
+    triggerCacheQueues,
+    dsqQueues: [...dsqQueues].filter(Boolean).sort(),
+    beforeLogical,
+    customRoles,
+    websocket,
+    webSocketRoles,
+    webSocketSubscriptions: websocket
+      ? [...outTopics].filter(topic => (
+        flows.some(flow => flow?.outputTopic && upperFirst(flow.flowTag) === topic) ||
+        (relationships.length > 0 && topic !== 'GetRelationship' && RELATIONSHIP_ACTIONS.includes(topic))
+      )).sort()
+      : [],
+    outTopics: [...outTopics].filter(Boolean).sort(),
+    tables: [...tableMap.entries()].map(([tableName, keys]) => ({ tableName, ...keys })),
+    allTableNames: [...new Set([...SYSTEM_TABLES, ...tableMap.keys()])].sort(),
+    objectTableNames,
+    relationshipTableNames,
+    objectTablesByType: new Map(objects.map(object => [object.objectType, Object.values(object.storageResources ?? {}).find(resource => resource?.storageType === 'dynamoDB')?.tableName]).filter(([, tableName]) => tableName)),
+    flows
+  };
+}
+
+async function renderInSqs(state) {
+  const chunks = await Promise.all([
+    ...state.ownTopics.map(queueName => render('ResourceYaml.ejs', { queueName })),
+    ...state.sqsQueues.map(queueName => render('ResourceSqsYaml.ejs', { queueName })),
+    ...state.triggerCacheQueues.map(queue => render('ResourceSqsYaml.ejs', queue)),
+    ...state.dsqQueues.map(queueName => render('ResourceSqsYaml.ejs', { queueName })),
+    ...state.beforeLogical.map(({ action, flowTags }) => render('ResourceBeforeLogicalYaml.ejs', { queueName: `${action}BeforeLogical`, flowTags })),
+    ...(state.websocket ? [render('ResourceSqsYaml.ejs', { queueName: 'WebSocketCompleteHdrSqs' })] : [])
+  ]);
+  return `Resources:\n${chunks.join('\n')}\n${state.webSocketSubscriptions.map(renderWebSocketSubscription).join('\n')}`;
+}
+
+async function renderOut(state) {
+  return `Resources:\n${(await Promise.all(state.outTopics.map(topicName => render('FlowOut_Yaml.ejs', { topicName })))).join('\n')}`;
+}
+
+async function renderDynamo(state) {
+  const [system, ...tables] = await Promise.all([
+    render('SystemDynamoDB_Yaml.ejs', {}),
+    ...state.tables.map(table => render('DynamoDBTable_Yaml.ejs', table))
+  ]);
+  return `${system}\n${tables.join('\n')}`;
+}
+
+async function renderIam(state) {
+  const roles = ['ProcFindDataRole', 'RegisterRole'];
+  if (state.crud) roles.push('FlowObjectsRole');
+  if (state.relationships) roles.push('FlowRelationshipRole');
+  if (state.rbac) roles.push('FlowRbacRole');
+  if (state.websocket) roles.push('WebSocketMainRole');
+  roles.push(...state.customRoles);
+  return render('SharedResource_Yaml.ejs', { roles: roles.sort().map(roleName => ({ roleName, statements: roleStatements(state, roleName) })) });
+}
+
+function roleStatements(state, roleName) {
+  const statements = [];
+  if (roleNeedsSchemaRead(state, roleName)) {
+    statements.push({ action: ['s3:GetObject'], resource: ['arn:aws:s3:::${self:custom.iz_serviceSchemaBucketName}/perServiceSchemas/*'] });
+  }
+  addStatement(statements, dynamoActionsForRole(roleName), dynamoArns(roleTableNames(state, roleName)));
+  addStatement(statements, SQS_CONSUMER_ACTIONS, queueArns(roleQueueNames(state, roleName)));
+  addStatement(statements, ['sns:Publish'], topicArns(roleTopicNames(state, roleName)));
+  if (state.webSocketRoles.has(roleName)) {
+    statements.push({ action: ['execute-api:ManageConnections'], resource: ['arn:aws:execute-api:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_webSocketHostId}/*'] });
+  }
+  return statements;
+}
+
+function addStatement(statements, action, resource) {
+  if (resource.length > 0) statements.push({ action, resource });
+}
+
+function roleNeedsSchemaRead(state, roleName) {
+  if (!roleName.endsWith('Role') || !roleName) return false;
+  return roleName !== 'FlowRbacRole' || state.rbac;
+}
+
+function roleTableNames(state, roleName) {
+  if (roleName === 'RegisterRole') return [];
+  if (roleName === 'WebSocketMainRole') return ['UserUploadRecords', 'WebSocketTask'];
+  if (roleName === 'FlowObjectsRole') return [...state.objectTableNames, 'WebSocketTask'];
+  if (roleName === 'FlowRelationshipRole') return [...state.objectTableNames, ...state.relationshipTableNames, 'AwaitingMultipleSteps', 'WebSocketTask'];
+  if (roleName === 'FlowRbacRole') return RBAC_TABLES;
+  if (roleName === 'ProcFindDataRole') return [...state.objectTableNames, ...state.relationshipTableNames, 'FindDataMain', 'LogicalResultsMain', 'LogicalResultsData'];
+  const flow = state.flows.find(candidate => customFlowRoleName(candidate?.flowTag ?? '') === roleName);
+  if (!flow) return [];
+  const tables = [];
+  if (includesEvent(flow, 'ownTopic') || includesEvent(flow, 's3')) tables.push('WebSocketTask');
+  if (includesEvent(flow, 's3')) tables.push('UserUploadRecords');
+  if (flow.statusType === 'storedCache') {
+    const object = state.objectTablesByType.get(flow.objType?.objectType);
+    if (object) tables.push(object);
+  }
+  return [...new Set(tables)];
+}
+
+function dynamoActionsForRole(roleName) {
+  if (roleName === 'ProcFindDataRole') return ['dynamodb:GetItem', 'dynamodb:Query'];
+  if (roleName === 'WebSocketMainRole') return ['dynamodb:DeleteItem', 'dynamodb:PutItem', 'dynamodb:Query'];
+  if (roleName === 'FlowRbacRole') return [...DYNAMO_ACTIONS, 'dynamodb:TransactWriteItems'];
+  return DYNAMO_ACTIONS;
+}
+
+function roleQueueNames(state, roleName) {
+  if (roleName === 'ProcFindDataRole') return LEGACY_PROCESS_QUEUES;
+  if (roleName === 'WebSocketMainRole') return state.websocket ? ['WebSocketCompleteHdrSqs'] : [];
+  if (roleName === 'FlowObjectsRole') return [
+    ...CRUD_ACTIONS.map(action => `${action}HdrSqs`),
+    ...CRUD_ACTIONS.filter(action => action !== 'Get').map(action => `${action}CompleteHdrSqs`),
+    ...state.beforeLogical.filter(({ action }) => CRUD_ACTIONS.includes(action)).map(({ action }) => `${action}BeforeLogicalHdrSqs`)
+  ];
+  if (roleName === 'FlowRelationshipRole') return [
+    ...RELATIONSHIP_ACTIONS.flatMap(action => [`${action}HdrSqs`, `${action}CompleteHdrSqs`]),
+    'GetRelationshipHdrDsq'
+  ];
+  if (roleName === 'FlowRbacRole') return RBAC_ACTIONS.flatMap(action => [`${action}HdrSqs`, `Process${action}HdrSqs`]);
+  const flow = state.flows.find(candidate => customFlowRoleName(candidate?.flowTag ?? '') === roleName);
+  if (!flow) return [];
+  const tag = upperFirst(flow.flowTag);
+  return [
+    ...(includesEvent(flow, 'extTopic') ? [`Process${tag}HdrSqs`] : []),
+    ...(includesEvent(flow, 'ownTopic') ? [`${tag}HdrSqs`] : []),
+    ...flowExtTopicSteps([flow]).map(({ flowTag, stepName }) => `${flowTag}${stepName}HdrSqs`),
+    ...state.sqsQueues.filter(queueName => includesEvent(flow, 's3') && queueName.startsWith(tag)),
+    ...(flow.statusType === 'triggerCache' ? triggerCacheQueueNames(flow) : [])
+  ];
+}
+
+function roleTopicNames(state, roleName) {
+  if (roleName === 'ProcFindDataRole') return [];
+  if (roleName === 'FlowObjectsRole') return state.outTopics.filter(topic => CRUD_ACTIONS.includes(topic));
+  if (roleName === 'FlowRelationshipRole') return state.outTopics.filter(topic => RELATIONSHIP_ACTIONS.includes(topic));
+  if (roleName === 'FlowRbacRole') return state.outTopics.filter(topic => RBAC_ACTIONS.includes(topic));
+  const flow = state.flows.find(candidate => customFlowRoleName(candidate?.flowTag ?? '') === roleName);
+  return flow ? state.outTopics.filter(topic => topic === upperFirst(flow.flowTag)) : [];
+}
+
+function dynamoArns(tableNames) {
+  return [...new Set(tableNames)].sort().map(tableName => `arn:aws:dynamodb:${'${self:custom.iz_region}'}:${'${self:custom.iz_accountId}'}:table/${'${self:custom.iz_resourcePrefix}'}${tableName}`);
+}
+
+function queueArns(queueNames) {
+  return [...new Set(queueNames)].sort().map(queueName => `arn:aws:sqs:${'${self:custom.iz_region}'}:${'${self:custom.iz_accountId}'}:${'${self:custom.iz_resourcePrefix}'}${queueName}`);
+}
+
+function topicArns(topicNames) {
+  return [...new Set(topicNames)].sort().map(topic => `arn:aws:sns:${'${self:custom.iz_region}'}:${'${self:custom.iz_accountId}'}:${'${self:custom.iz_serviceTag}'}_${'${self:custom.iz_stage}'}_${topic}_Out`);
+}
+
+function renderWebSocketSubscription(topicName) {
+  return `##===== WebSocket completion subscription\n  SubscriptionToOut${topicName}WebSocketComplete:\n    Type: AWS::SNS::Subscription\n    Properties:\n      TopicArn: !Ref Out${topicName}\n      Endpoint: "arn:aws:sqs:${'${self:custom.iz_region}'}:${'${self:custom.iz_accountId}'}:${'${self:custom.iz_resourcePrefix}'}WebSocketCompleteHdrSqs"\n      Protocol: "sqs"`;
+}
+
+function collectTables(schemas) {
+  const tables = new Map();
+  for (const schema of schemas) {
+    if (!schema?.storageResources) continue;
+    const identifiers = Array.isArray(schema.identifiers) ? schema.identifiers : [];
+    const pk = keyName(identifiers.find(identifier => identifier.type === 'partitionKey' || identifier.type === 'identifier')) ?? 'PK';
+    const sk = keyName(identifiers.find(identifier => identifier.type === 'sortKey'));
+    for (const resource of Object.values(schema.storageResources)) {
+      if (resource?.storageType === 'dynamoDB' && resource.tableName && !tables.has(resource.tableName)) tables.set(resource.tableName, { pk, sk });
+    }
+  }
+  return tables;
+}
+
+function keyName(identifier) {
+  if (!identifier) return undefined;
+  return identifier.name ?? identifier.fieldName ?? (Array.isArray(identifier.fieldNames) ? identifier.fieldNames.join(identifier.deliminator ?? '_') : undefined);
+}
+
+function isCrudObject(object) { return object?.generatedBy === 'userGenerated' || object?.generatedBy === 'systemGenerated'; }
+function hasRbacAddOn(object) { return Array.isArray(object?.addOnDataStructure) && object.addOnDataStructure.some(addOn => addOn?.type === 'rbac'); }
+function includesEvent(flow, event) { return Array.isArray(flow?.event) && flow.event.includes(event); }
+function upperFirst(value) { return typeof value === 'string' && value ? value[0].toUpperCase() + value.slice(1) : ''; }
+function normalizeYaml(content) { return `${content.trimEnd()}\n`; }
+async function render(templateName, data) { return ejs.render(await readFile(new URL(templateName, TEMPLATE_URL), 'utf8'), { resourceQueueName: data.queueName, ...data }); }

package/src/emit/resource/generateResourceArtifacts.js

@@ -0,0 +1,20 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { emitResourceArtifacts, resourceArtifactPaths } from './emitResourceArtifacts.js';
+
+export async function generateResourceArtifacts(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const [objects, relationships, flows] = await Promise.all([
+    loadLocalSchemaDirectory(project, 'ObjectSchemas'),
+    loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
+    loadLocalSchemaDirectory(project, 'FlowSchemas')
+  ]);
+  const artifacts = await emitResourceArtifacts({ objects, relationships, flows });
+  const files = await commitArtifacts(buildGenerationPlan(project, artifacts, {
+    managedPaths: resourceArtifactPaths,
+    managedScope: 'shared-resources'
+  }));
+  return { project, files };
+}

package/src/{codeGenerators/resource/sls_yaml/templates/crud → emit/resource/templates}/ResourceBeforeLogicalYaml.ejs

@@ -44,4 +44,4 @@
         - Ref: <%- queueName %>HdrSqs
 
   #<#<%- queueName %>QueueSetting#>
-  #<#/<%- queueName %>QueueSetting#>
+  #<#/<%- queueName %>QueueSetting#>

package/src/{codeGenerators/resource/sls_yaml/templates/crud → emit/resource/templates}/ResourceSqsYaml.ejs

@@ -1,24 +1,24 @@
   ##===== [Queue]
-  <%- queueName %>:
+  <%- resourceQueueName || queueName %>:
     Type: "AWS::SQS::Queue"
     Properties:
       QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>
       RedrivePolicy:
         deadLetterTargetArn:
           Fn::GetAtt:
-            - <%- queueName %>DLQ
+            - <%- resourceQueueName || queueName %>DLQ
             - Arn
         maxReceiveCount: 3
       VisibilityTimeout: 120
 
   ##===== [Queue DLQ]
-  <%- queueName %>DLQ:
+  <%- resourceQueueName || queueName %>DLQ:
     Type: AWS::SQS::Queue
     Properties:
       QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>DLQ
 
   ##===== [Queue Policy]
-  <%- queueName %>Policy:
+  <%- resourceQueueName || queueName %>Policy:
     Type: AWS::SQS::QueuePolicy
     Properties:
       PolicyDocument:
@@ -29,11 +29,11 @@
             Principal: "*"
             Resource:
               Fn::GetAtt:
-                - <%- queueName %>
+                - <%- resourceQueueName || queueName %>
                 - Arn
             Action: "SQS:SendMessage"
       Queues:
-        - Ref: <%- queueName %>
+        - Ref: <%- resourceQueueName || queueName %>
 
   #<#<%- queueName %>QueueSetting#>
   #<#/<%- queueName %>QueueSetting#>

package/src/{codeGenerators/app/sls_yaml → emit/resource}/templates/SharedResource_Yaml.ejs

@@ -1,5 +1,5 @@
 Resources:
-<% roles.forEach(({ roleName, statements }) => { %>
+<% roles.forEach(({ roleName, statements }) => { -%>
   <%- roleName %>:
     Type: AWS::IAM::Role
     Properties:
@@ -22,18 +22,18 @@ Resources:
           PolicyDocument:
             Version: "2012-10-17"
             Statement:
-<% statements.forEach((stmt) => { %>
+<% statements.forEach((stmt) => { -%>
               - Effect: Allow
                 Action:
-<% stmt.action.forEach((a) => { %>
+<% stmt.action.forEach((a) => { -%>
                   - <%- a %>
-<% }) %>
+<% }) -%>
                 Resource:
-<% stmt.resource.forEach((r) => { %>
+<% stmt.resource.forEach((r) => { -%>
                   - "<%- r %>"
-<% }) %>
-<% }) %>
+<% }) -%>
+<% }) -%>
               #<#<%- roleName %>StatementHookCode#>
               #<#/<%- roleName %>StatementHookCode#>
 
-<% }) %>
+<% }) -%>

package/src/emit/system/emitSystemWebSocketArtifacts.js

@@ -0,0 +1,182 @@
+const SOURCE = 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source';
+
+export async function emitSystemWebSocketArtifacts(flows, { includeRelationshipOwnTopic = false } = {}) {
+  if (!hasSystemWebSocket(flows, { includeRelationshipOwnTopic })) return { artifacts: [], functions: [] };
+
+  return {
+    artifacts: [
+      { path: `${SOURCE}/WebSocketConnect.js`, content: webSocketConnect() },
+      { path: `${SOURCE}/WebSocketComplete_Main.js`, content: webSocketCompleteMain() },
+      { path: `${SOURCE}/WebSocketComplete_HdrSqs.js`, content: webSocketCompleteHandler() }
+    ],
+    functions: [
+      renderWebSocketConnectYaml(),
+      renderWebSocketCompleteYaml()
+    ]
+  };
+}
+
+export function systemWebSocketManagedPaths() {
+  return [
+    `${SOURCE}/WebSocketConnect.js`,
+    `${SOURCE}/WebSocketComplete_Main.js`,
+    `${SOURCE}/WebSocketComplete_HdrSqs.js`
+  ];
+}
+
+export function hasSystemWebSocket(flows, { includeRelationshipOwnTopic = false } = {}) {
+  return includeRelationshipOwnTopic || (Array.isArray(flows) && flows.some(flow => Array.isArray(flow?.event) && flow.event.includes('ownTopic')));
+}
+
+function renderWebSocketConnectYaml() {
+  return `WebSocketConnect:
+  handler: src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketConnect.main
+  name: \${self:custom.iz_resourcePrefix}WebSocketConnect
+  role: WebSocketMainRole
+  events:
+    - websocket:
+        route: $connect
+    - websocket:
+        route: $disconnect
+    - websocket:
+        route: $default
+`;
+}
+
+function renderWebSocketCompleteYaml() {
+  return `WebSocketCompleteHdrSqs:
+  handler: src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.main
+  name: \${self:custom.iz_resourcePrefix}WebSocketCompleteHdrSqs
+  role: WebSocketMainRole
+  events:
+    - sqs:
+        arn: arn:aws:sqs:\${self:custom.iz_region}:\${self:custom.iz_accountId}:\${self:custom.iz_resourcePrefix}WebSocketCompleteHdrSqs
+        batchSize: 10
+        filterPatterns:
+          - body:
+              MessageAttributes:
+                callingFlow:
+                  Value:
+                    - \${self:custom.iz_resourcePrefix}WebSocketCompleteHdrSqs
+          - body:
+              MessageAttributes:
+                callingFlow:
+                  Value:
+                    - exists: false
+`;
+}
+
+function webSocketConnect() {
+  return `import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import { middlewareHandler as middleware, response } from '@izara_project/izara-middleware';
+
+export const main = middleware.wrap(async event => {
+  const { eventType, connectionId } = event.requestContext ?? {};
+  try {
+    event._izContext.logger.debug('Event:', event);
+    if (eventType === 'CONNECT') {
+      const { userId, submittedByUserId } = event.queryStringParameters ?? {};
+      await dynamodbSharedLib.putItem(event._izContext, await dynamodbSharedLib.tableName(event._izContext, 'UserUploadRecords'), {
+        connectionId, userId, submittedByUserId, expirationTime: Math.floor(Date.now() / 1000) + 7200
+      });
+      //(<webSocketConnect>)
+      //(</webSocketConnect>)
+    } else if (eventType === 'DISCONNECT') {
+      await dynamodbSharedLib.deleteItem(event._izContext, await dynamodbSharedLib.tableName(event._izContext, 'UserUploadRecords'), { connectionId });
+      //(<webSocketDisconnect>)
+      //(</webSocketDisconnect>)
+    }
+    return response.webSocketSuccess();
+  } catch (error) {
+    event._izContext.logger.error('Error, WebSocketConnect: ', error);
+    return response.failure(error);
+  }
+});
+`;
+}
+
+function webSocketCompleteMain() {
+  return `import { NoRetryError } from '@izara_project/izara-core-library-core';
+import { consts } from '@izara_project/izara-middleware';
+import { getObjectSchema, utils } from '@izara_project/izara-core-library-service-schemas';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import { webSocket } from '@izara_project/izara-core-library-external-request';
+
+const { createFlowTypeConcat } = utils;
+const { postToConnection } = webSocket;
+
+export default async function WebSocketComplete(_izContext, topicArn, requestParams, callingFlowConfig = {}) {
+  try {
+    _izContext.logger.debug('WebSocketComplete _izContext', _izContext);
+    _izContext.logger.debug('WebSocketComplete requestParams', requestParams);
+    _izContext.logger.debug('WebSocketComplete callingFlowConfig', callingFlowConfig);
+    const correlationId = _izContext.correlationIds.get(consts.X_CORRELATION_ID);
+    if (!topicArn) throw new NoRetryError('not have TopicArn for get FlowSchemas');
+    const topicName = topicArn.split(':')[5].split('_');
+    let flowTag = topicName[2];
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, { flowTag, serviceTag: topicName[0] });
+    if (!flowSchema) {
+      if (!requestParams?.hasOwnProperty('flowTag')) throw new NoRetryError('Could not find flowSchema from topicArn or requestParams.flowTag');
+      flowTag = requestParams.flowTag;
+      flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, { flowTag, serviceTag: process.env.iz_serviceTag });
+    }
+    //(<createIdentifiersFlow>)
+    let identifiers;
+    //(</createIdentifiersFlow>)
+    let taskKey;
+    if (flowSchema.statusType === 'statusField' || flowSchema.statusType === 'storedCache' || flowSchema.statusType === 'triggerCache') {
+      taskKey = createFlowTypeConcat(_izContext, { flowTag, serviceTag: topicName[0] }) + identifiers;
+    } else if (flowSchema.statusType === 'none') {
+      taskKey = createFlowTypeConcat(_izContext, { flowTag, serviceTag: topicName[0] }) + correlationId;
+    }
+    if (!taskKey) return;
+    const tasks = await dynamodbSharedLib.query(_izContext, await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'), { taskKey });
+    await Promise.all((tasks.Items ?? []).map(async task => {
+      //(<beforePostMessage>)
+      //(</beforePostMessage>)
+      await postToConnection({ message: requestParams }, task.connectionId);
+      await dynamodbSharedLib.deleteItem(_izContext, await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'), { taskKey: task.taskKey, connectionId: task.connectionId });
+    }));
+  } catch (error) {
+    _izContext.logger.error('error WebSocketInvoke: ', error);
+    throw error;
+  }
+}
+`;
+}
+
+function webSocketCompleteHandler() {
+  return `import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
+import Logger from '@izara_project/izara-core-library-logger';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import WebSocketComplete from './WebSocketComplete_Main.js';
+
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+const perRecordsValidatorSchema = {};
+export const main = middleware.wrap(async (event, context, callback) => {
+  try {
+    const recordPromises = [];
+    await Promise.all(event.Records.map(async record => {
+      record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+      await recordHandlerSharedLib.validateRecord(record, 'WebSocketCompleteHdrSqs', perRecordsValidatorSchema);
+      recordPromises.push(recordHandlerSharedLib.recordHandler(
+        record,
+        WebSocketComplete,
+        'WebSocketCompleteHdrSqs',
+        [record.body.TopicArn, record.body.Message, callingFlowSharedLib.addCallingFlowToPassOnProperties(record.body.Message)]
+      ));
+    }));
+    try {
+      await Promise.all(recordPromises);
+      return event.Records;
+    } catch {
+      Logger.debug('Promise.all(recordPromises) in handler threw error (at least one record did no resolve)');
+    }
+  } catch (error) {
+    Logger.error('Unhandled Error, WebSocketComplete_HdrSqs: ', error);
+    throw error;
+  }
+});
+`;
+}