@izara_project/izara-core-generate-service-code 1.0.65 → 1.0.67

package/src/emit/resource/emitResourceArtifacts.js

@@ -0,0 +1,595 @@
+import ejs from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+import {
+  customFlowRoleName,
+  flowDsqSteps,
+  flowExtTopicSteps,
+  generatedOwnTopicFlows,
+  supportedCustomFlows
+} 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`)
+  ]);
+  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 => `${upperFirst(flow.flowTag)}HdrDsq`)
+  );
+  flowDsqSteps(flows).forEach(({ flowTag, stepName }) =>
+    dsqQueues.add(`${flowTag}${stepName}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)
+      ),
+      ...flowDsqSteps(flows).map(({ flow }) =>
+        customFlowRoleName(flow.flowTag)
+      )
+    ])
+  ];
+  const websocket = hasSystemWebSocket(flows, {
+    includeRelationshipOwnTopic: true
+  });
+  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(),
+    dsqQueues: [...dsqQueues].filter(Boolean).sort(),
+    beforeLogical,
+    customRoles,
+    websocket,
+    webSocketRoles,
+    webSocketSubscriptions: websocket
+      ? [...outTopics]
+          .filter(
+            topic =>
+              flows.some(
+                flow => (flow?.outputTopic || (includesEvent(flow, 'ownTopic') && flow.initiateBy === 'user')) && 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.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}:*/*'
+      ]
+    });
+  }
+  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,
+      'AwaitingMultipleSteps',
+      'AwaitingMultipleStepByPending',
+      'WebSocketTask'
+    ];
+  if (roleName === 'FlowRelationshipRole')
+    return [
+      ...state.objectTableNames,
+      ...state.relationshipTableNames,
+      'AwaitingMultipleSteps',
+      'AwaitingMultipleStepByPending',
+      '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') ? [`${tag}HdrSqs`] : []),
+    ...(includesEvent(flow, 'ownTopic') ? [`${tag}HdrSqs`] : []),
+    ...(includesEvent(flow, 'dsq') ? [`${tag}HdrDsq`] : []),
+    ...flowExtTopicSteps([flow]).map(
+      ({ flowTag, stepName }) => `${flowTag}${stepName}HdrSqs`
+    ),
+    ...flowDsqSteps([flow]).map(
+      ({ flowTag, stepName }) => `${flowTag}${stepName}HdrDsq`
+    ),
+    ...state.sqsQueues.filter(
+      queueName => includesEvent(flow, 's3') && queueName.startsWith(tag)
+    )
+  ];
+}
+
+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#>
 
-<% }) %>
+<% }) -%>