@izara_project/izara-core-generate-service-code 1.0.52 → 1.0.54

package/src/{generators/fromFlowSchema/shared/template.ejs → codeGenerators/app/src/generatedCode/libs/templates/GenerateCodeLibs.ejs}

@@ -15,34 +15,42 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-
 import { lambda } from '@izara_project/izara-core-library-external-request';
-import { ApiGatewayManagementApiClient, PostToConnectionCommand } from "@aws-sdk/client-apigatewaymanagementapi";
+import {
+  ApiGatewayManagementApiClient,
+  PostToConnectionCommand
+} from '@aws-sdk/client-apigatewaymanagementapi';
 import { objectHash as hash } from '@izara_project/izara-shared-core';
 
-import { NoRetryError, inMemoryCacheLib } from '@izara_project/izara-core-library-core';
+import {
+  NoRetryError,
+  inMemoryCacheLib
+} from '@izara_project/izara-core-library-core';
 
 const client = new ApiGatewayManagementApiClient({
   endpoint: `https://${process.env.iz_webSocketEndpoint}`
-})
+});
 
 async function postToConnection(message, connectionId) {
   try {
-    const messageParams = JSON.stringify(message)
+    const messageParams = JSON.stringify(message);
     const command = new PostToConnectionCommand({
       ConnectionId: connectionId,
       Data: Buffer.from(messageParams)
-    })
+    });
     // console.log("command::", command)
     // console.log("client::", client)
     await client.send(command);
-    console.log(`send Message: ${JSON.stringify(message)} to ${connectionId} 1`)
+    console.log(
+      `send Message: ${JSON.stringify(message)} to ${connectionId} 1`
+    );
   } catch (err) {
-    if (err.name === "GoneException") {
-      console.log(`message send to connectionIds ${connectionId} is no longer connect`)
+    if (err.name === 'GoneException') {
+      console.log(
+        `message send to connectionIds ${connectionId} is no longer connect`
+      );
     } else {
-      console.error(`Error post message: ${err}`)
+      console.error(`Error post message: ${err}`);
     }
   }
 }
@@ -54,21 +62,18 @@ async function postToConnection(message, connectionId) {
  * @param {Object} payload
  */
 async function processStaticLimit(_izContext, functionName, payload) {
-  return await lambda.invokeSync(_izContext, functionName, payload)
+  return await lambda.invokeSync(_izContext, functionName, payload);
 }
 
-const processStaticLimitWithCache = inMemoryCacheLib(
-  processStaticLimit,
-  {
-    max: 100,
-    maxAge: 86400000,
-    promise: true,
-    profileName: "processStaticLimit",
-    normalizer: function (args) {
-      return hash(args[1], args[2])
-    }
+const processStaticLimitWithCache = inMemoryCacheLib(processStaticLimit, {
+  max: 100,
+  maxAge: 86400000,
+  promise: true,
+  profileName: 'processStaticLimit',
+  normalizer: function (args) {
+    return hash(args[1], args[2]);
   }
-)
+});
 
 /**
  *
@@ -77,13 +82,17 @@ const processStaticLimitWithCache = inMemoryCacheLib(
  * @param {String[]} paths - path to get value
  */
 function getNestObject(_izContext, nestedObj, paths) {
-  _izContext.logger.debug("function getNestObject", { nestedObj, paths });
+  _izContext.logger.debug('function getNestObject', { nestedObj, paths });
   let data;
 
-  if (typeof nestedObj === "object" && Array.isArray(paths)) {
-    data = paths.reduce((obj, key) => obj && typeof obj[key] !== 'undefined' ? obj[key] : undefined, nestedObj);
+  if (typeof nestedObj === 'object' && Array.isArray(paths)) {
+    data = paths.reduce(
+      (obj, key) =>
+        obj && typeof obj[key] !== 'undefined' ? obj[key] : undefined,
+      nestedObj
+    );
   } else {
-    throw new NoRetryError("Type error: Invalid type in getNestObject")
+    throw new NoRetryError('Type error: Invalid type in getNestObject');
   }
 
   return data;
@@ -101,7 +110,7 @@ function getResourcePart(arnString, index) {
     const parts = resourceId.split('_');
     return parts[index] || null;
   } catch (error) {
-    console.error("Invalid ARN format", error);
+    console.error('Invalid ARN format', error);
     return null;
   }
 }
@@ -112,4 +121,4 @@ export {
   processStaticLimitWithCache,
   getNestObject,
   getResourcePart
-}
+};

package/src/codeGenerators/resource/sls_yaml/DynamoDBGenerator.js

@@ -0,0 +1,96 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function appendToFile(filePath, content) {
+    try {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.appendFile(filePath, content + '\n', 'utf-8');
+    } catch (error) {
+        console.error(`[Error] Failed to append to file: ${filePath}`, error);
+    }
+}
+
+export async function generateDynamoDBTables(allSchemas, options) {
+    console.log('  [DynamoDBGenerator] Generating DynamoDB Tables...');
+
+    const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    const yamlTplPath = path.join(__dirname, 'templates', 'DynamoDBTable_Yaml.ejs');
+    const yamlTpl = await fs.readFile(yamlTplPath, 'utf-8');
+
+    // Collect all unique table names and their key schemas
+    const tables = new Map(); // key: tableName, value: { pk, sk }
+
+    const extractKeyName = (identifier) => {
+        if (identifier.name) return identifier.name;
+        if (identifier.fieldName) return identifier.fieldName;
+        if (identifier.fieldNames) return identifier.fieldNames.join(identifier.deliminator || '_');
+        return null;
+    };
+
+    const processSchemaForTables = (schema) => {
+        if (!schema.storageResources) return;
+        
+        // Find pk and sk from identifiers
+        let pk = 'PK';
+        let sk = null;
+        if (schema.identifiers && Array.isArray(schema.identifiers)) {
+            const pkId = schema.identifiers.find(i => i.type === 'partitionKey' || i.type === 'identifier');
+            if (pkId) pk = extractKeyName(pkId) || 'PK';
+            
+            const skId = schema.identifiers.find(i => i.type === 'sortKey');
+            if (skId) sk = extractKeyName(skId);
+        }
+
+        for (const key of Object.keys(schema.storageResources)) {
+            const resource = schema.storageResources[key];
+            if (resource.storageType === 'dynamoDB' && resource.tableName) {
+                if (!tables.has(resource.tableName)) {
+                    tables.set(resource.tableName, { pk, sk });
+                }
+            }
+        }
+    };
+
+    // From objects
+    if (allSchemas.objects) {
+        for (const obj of allSchemas.objects) {
+            processSchemaForTables(obj);
+        }
+    }
+
+    // From relationships
+    if (allSchemas.relationships) {
+        for (const rel of allSchemas.relationships) {
+            processSchemaForTables(rel);
+        }
+    }
+
+    let generatedCount = 0;
+    const yamlOutputPath = path.join(resourceYamlDir, 'generated-dynamoDB-table.yml');
+
+    // Generate system tables first
+    const systemYamlTplPath = path.join(__dirname, 'templates', 'SystemDynamoDB_Yaml.ejs');
+    const systemYamlTpl = await fs.readFile(systemYamlTplPath, 'utf-8');
+    const systemYamlContent = ejs.render(systemYamlTpl, {});
+    await appendToFile(yamlOutputPath, systemYamlContent);
+    generatedCount += 8; // 8 system tables
+
+    for (const [tableName, keys] of tables.entries()) {
+        const yamlContent = ejs.render(yamlTpl, {
+            tableName: tableName,
+            pk: keys.pk,
+            sk: keys.sk
+        });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+    }
+
+    console.log(`  [DynamoDBGenerator] Generated ${generatedCount} DynamoDB Tables (including system tables).`);
+}

package/src/codeGenerators/resource/sls_yaml/FlowOutGenerator.js

@@ -0,0 +1,73 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/shared/flowSelection.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function appendToFile(filePath, content) {
+    try {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.appendFile(filePath, content + '\n', 'utf-8');
+    } catch (error) {
+        console.error(`[Error] Failed to append to file: ${filePath}`, error);
+    }
+}
+
+export async function generateFlowOut(allSchemas, options) {
+    console.log('  [FlowOutGenerator] Generating Flow Out nodes (SNS Topics)...');
+    
+    const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    const yamlTplPath = path.join(__dirname, 'templates', 'FlowOut_Yaml.ejs');
+    const yamlTpl = await fs.readFile(yamlTplPath, 'utf-8');
+
+    let generatedCount = 0;
+    const yamlOutputPath = path.join(resourceYamlDir, 'generated-sns-out.yml');
+
+    const flows = getFlowsForGeneration(allSchemas);
+    for (const flow of flows) {
+        if (flow.outputTopic === true) {
+            const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+            const topicName = upperCase(flow.flowTag);
+
+            const yamlContent = ejs.render(yamlTpl, {
+                topicName: topicName
+            });
+
+            await appendToFile(yamlOutputPath, yamlContent);
+            generatedCount++;
+        }
+    }
+
+    const systemTopics = [
+        'CreateObjectComplete',
+        'DeleteNodeComplete',
+        'UpdateNodeComplete',
+        'GetNodeComplete',
+        'ProcessLogicalComplete',
+        'FindDataComplete',
+        // CRUD Async Topics
+        'Create', 'Update', 'Delete',
+        // Relationship Topics
+        'CreateRelationship', 'UpdateRelationship', 'DeleteRelationship',
+        'GetRelationship', 'ChangeRelationship', 'MoveRelationship',
+        // RBAC Topics
+        'CreateTargetRole', 'ListTargetRole', 'DeleteTargetRole',
+        'CreateRolePermissions', 'ListRolePermissions', 'DeleteRolePermissions',
+        'CreateUserRole', 'ListUserInRoles', 'DeleteUserFromRole'
+    ];
+
+    for (const topic of systemTopics) {
+        const yamlContent = ejs.render(yamlTpl, {
+            topicName: topic
+        });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+    }
+
+    console.log(`  [FlowOutGenerator] Generated ${generatedCount} SNS Topics for Flow Out nodes.`);
+}

package/src/codeGenerators/resource/sls_yaml/FlowResourceYamlGenerator.js

@@ -0,0 +1,199 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/shared/flowSelection.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function appendToFile(filePath, content) {
+    try {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.appendFile(filePath, content + '\n', 'utf-8');
+    } catch (error) {
+        console.error(`[Error] Failed to append to file: ${filePath}`, error);
+    }
+}
+
+export async function generateFlowResourceYaml(allSchemas, options) {
+    console.log('  [FlowResourceYamlGenerator] Generating SQS/SNS YAML resources for flows...');
+    
+    const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    const resourceYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceYaml.ejs');
+    const resourceBeforeLogicalYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceBeforeLogicalYaml.ejs');
+    
+    const resourceYamlTpl = await fs.readFile(resourceYamlTplPath, 'utf-8');
+    const resourceBeforeLogicalYamlTpl = await fs.readFile(resourceBeforeLogicalYamlTplPath, 'utf-8');
+
+    let generatedCount = 0;
+    const yamlOutputPath = path.join(resourceYamlDir, 'generated-sns-in-sqs.yml');
+
+    const flows = getFlowsForGeneration(allSchemas);
+    for (const flow of flows) {
+        const flowTag = flow.flowTag;
+        
+        // Generate In-Queue resources for any flow that listens on its own topic
+        if (flow.event && flow.event.includes('ownTopic')) {
+            // Render main ResourceYaml.ejs (e.g., InCreate, CreateHdrSqs)
+            const yamlContent = ejs.render(resourceYamlTpl, {
+                queueName: flowTag
+            });
+            await appendToFile(yamlOutputPath, yamlContent);
+            generatedCount++;
+
+            // Check if there are beforeLogical configs for this flow
+            const generateCodeConfigs = flows
+                .filter(f => f.generatedCodeConfig && f.generatedCodeConfig.generatedCodeTag.toLowerCase() === flowTag.toLowerCase())
+                .map(f => ({
+                    ...f.generatedCodeConfig,
+                    flowTag: f.flowTag
+                }));
+
+            const beforeLogicalConfigs = generateCodeConfigs.filter(c => c.codeHookTag === 'beforeLogical');
+
+            if (beforeLogicalConfigs.length > 0) {
+                // Collect unique flowTags (like ValidateUnitTrackedProperty) from the beforeLogical configs
+                const uniqueFlowTags = [...new Set(beforeLogicalConfigs.map(c => c.flowTag))];
+                
+                const beforeLogicalYamlContent = ejs.render(resourceBeforeLogicalYamlTpl, {
+                    queueName: `${flowTag}BeforeLogical`,
+                    flowTags: uniqueFlowTags
+                });
+
+                await appendToFile(yamlOutputPath, beforeLogicalYamlContent);
+                generatedCount++;
+            }
+        } else if (flow.event && flow.event.includes('extTopic')) {
+            // Custom flows using extTopic do not have ownTopic, but need an entry queue
+            const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+            const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+            const yamlContent = ejs.render(resourceSqsYamlTpl, {
+                queueName: `Process${flowTag}Sqs`
+            });
+            await appendToFile(yamlOutputPath, yamlContent);
+            generatedCount++;
+        }
+        
+        // Generate Complete queues for custom FlowSchema
+        // Also generate queues for any flowStep that uses sqs, dsq, or extTopic
+        if (flow.flowSteps && Array.isArray(flow.flowSteps)) {
+            for (const stepConfig of flow.flowSteps) {
+                const stepName = stepConfig.stepName;
+                if (stepName === 'InTag') continue;
+                
+                const events = stepConfig.event || ['sqs'];
+                for (const ev of events) {
+                    let queueName = flowTag + stepName;
+                    if (stepName === 'Complete') {
+                        queueName = flowTag + 'Complete';
+                    }
+
+                    if (ev === 'sqs' || ev === 'ownTopic') {
+                        // sqs and ownTopic create SNS Topic + Subscription + SQS Queue
+                        const yamlContent = ejs.render(resourceYamlTpl, {
+                            queueName: queueName
+                        });
+                        await appendToFile(yamlOutputPath, yamlContent);
+                        generatedCount++;
+                    } else if (ev === 'dsq' || ev === 'extTopic') {
+                        // extTopic and dsq create ONLY SQS Queue
+                        const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+                        const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+                        const yamlContent = ejs.render(resourceSqsYamlTpl, {
+                            queueName: queueName
+                        });
+                        await appendToFile(yamlOutputPath, yamlContent);
+                        generatedCount++;
+                    }
+                }
+            }
+        }
+
+        // Generate SQS queues for S3 Event flows
+        if (flow.event && flow.event.includes('s3')) {
+            const queueNames = [
+                `${flowTag}CreatePreSignUrlSqs`,
+                `${flowTag}ReservedLimitSqs`
+            ];
+            
+            for (const qName of queueNames) {
+                const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+                const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+                const yamlContent = ejs.render(resourceSqsYamlTpl, {
+                    queueName: qName
+                });
+                await appendToFile(yamlOutputPath, yamlContent);
+                generatedCount++;
+            }
+        }
+
+        // Generate Dsq queues for Relationship
+        if (flow.isDynamicRelationshipType) {
+            // Usually Relationship has dead-letter queue processing
+            const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+            const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+            const queueName = flowTag + 'Dsq';
+            const yamlContent = ejs.render(resourceSqsYamlTpl, {
+                queueName: queueName
+            });
+            await appendToFile(yamlOutputPath, yamlContent);
+            generatedCount++;
+        }
+    }
+
+    // Add hardcoded ownTopic flows for CRUD, RBAC, Relationship
+    const systemOwnTopicFlows = [
+        'Create', 'Update', 'Delete', // CRUD
+        'CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'ChangeRelationship', 'MoveRelationship', // Relationship
+        'CreateTargetRole', 'DeleteTargetRole', 'CreateRolePermissions', 'DeleteRolePermissions', 'CreateUserRole', 'DeleteUserFromRole' // RBAC
+    ];
+    for (const flowTag of systemOwnTopicFlows) {
+        const yamlContent = ejs.render(resourceYamlTpl, { queueName: flowTag });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+        
+        // BeforeLogical queues for CRUD
+        if (['Create', 'Update', 'Delete'].includes(flowTag)) {
+            // Since we don't have beforeLogical configs here, we assume we might need them or we can just generate a generic one?
+            // For now, only custom flows generate beforeLogical dynamically above.
+        }
+    }
+
+    // Generate Dsq queues for Relationship
+    const relationshipActions = ['CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'GetRelationship', 'ChangeRelationship', 'MoveRelationship'];
+    const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+    const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+    for (const action of relationshipActions) {
+        const yamlContent = ejs.render(resourceSqsYamlTpl, { queueName: action + 'Dsq' });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+    }
+
+    // Add System Queues
+    const systemQueues = [
+        'ProcessLogical',
+        'PaginateProcessLogical',
+        'FindData',
+        'Register',
+        'WebSocket',
+        'CreateObjectComplete',
+        'UpdateNodeComplete',
+        'DeleteNodeComplete',
+        'GetNodeComplete'
+    ];
+
+    const resourceSqsYamlTplGlobal = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+
+    for (const sysQueue of systemQueues) {
+        const yamlContent = ejs.render(resourceSqsYamlTplGlobal, {
+            queueName: sysQueue
+        });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+    }
+
+    console.log(`  [FlowResourceYamlGenerator] Appended ${generatedCount} sections to generated-sns-in-sqs.yml.`);
+}

package/src/codeGenerators/resource/sls_yaml/templates/DynamoDBTable_Yaml.ejs

@@ -0,0 +1,20 @@
+##===== [DynamoDB Table: <%- tableName %>]
+  <%- tableName %>Table:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      TableName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_<%- tableName %>
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+        - AttributeName: "<%- pk %>"
+          AttributeType: "S"
+<% if (sk) { %>
+        - AttributeName: "<%- sk %>"
+          AttributeType: "S"
+<% } %>
+      KeySchema:
+        - AttributeName: "<%- pk %>"
+          KeyType: "HASH"
+<% if (sk) { %>
+        - AttributeName: "<%- sk %>"
+          KeyType: "RANGE"
+<% } %>

package/src/{generators/fromObjectSchema/relationship/create/complete/sns-out/template.ejs → codeGenerators/resource/sls_yaml/templates/FlowOut_Yaml.ejs}

@@ -1,8 +1,6 @@
-##--------- [Create Topic Out]
-  Out<%- queueName %>:
+##===== [Topic Out]
+  Out<%- topicName %>:
     Type: AWS::SNS::Topic
     Properties:
       DisplayName: "SNS Message out"
-      TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_<%- queueName %>_Out
-
-  
+      TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_<%- topicName %>_Out

package/src/codeGenerators/resource/sls_yaml/templates/SystemDynamoDB_Yaml.ejs

@@ -0,0 +1,138 @@
+Resources:
+  WebSocketTaskTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}WebSocketTask
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: taskKey
+        AttributeType: S
+      - AttributeName: connectionId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: taskKey
+        KeyType: HASH
+      - AttributeName: connectionId
+        KeyType: RANGE
+      TimeToLiveSpecification:
+        AttributeName: expirationTime
+        Enabled: true
+
+  UserUploadRecordsTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}UserUploadRecords
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: connectionId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: connectionId
+        KeyType: HASH
+      TimeToLiveSpecification:
+        AttributeName: expirationTime
+        Enabled: true
+
+  RegisterRecordsTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}RegisterRecords
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: identifiersTask
+        AttributeType: S
+      - AttributeName: connectionId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: identifiersTask
+        KeyType: HASH
+      - AttributeName: connectionId
+        KeyType: RANGE
+
+  AwaitingMultipleStepsTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}AwaitingMultipleSteps
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: awaitingStepId
+        AttributeType: S
+      - AttributeName: pendingStepId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: awaitingStepId
+        KeyType: HASH
+      - AttributeName: pendingStepId
+        KeyType: RANGE
+
+  AwaitingMultipleStepByPendingTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}AwaitingMultipleStepByPending
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: pendingStepId
+        AttributeType: S
+      - AttributeName: awaitingStepId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: pendingStepId
+        KeyType: HASH
+      - AttributeName: awaitingStepId
+        KeyType: RANGE
+
+  FindDataMainTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}FindDataMain
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: findDataId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: findDataId
+        KeyType: HASH
+
+  LogicalResultsMainTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}LogicalResultsMain
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: logicalResultId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: logicalResultId
+        KeyType: HASH
+
+  LogicalResultsDataTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}LogicalResultsData
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: logicalResultId
+        AttributeType: S
+      - AttributeName: identifiersId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: logicalResultId
+        KeyType: HASH
+      - AttributeName: identifiersId
+        KeyType: RANGE
+
+  AwaitingStepTable:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}AwaitingStep
+      BillingMode: PAY_PER_REQUEST
+      AttributeDefinitions:
+      - AttributeName: awaitingStepId
+        AttributeType: S
+      - AttributeName: pendingStepId
+        AttributeType: S
+      KeySchema:
+      - AttributeName: awaitingStepId
+        KeyType: HASH
+      - AttributeName: pendingStepId
+        KeyType: RANGE