@izara_project/izara-core-generate-service-code 1.0.51 → 1.0.53

package/src/codeGenerators/app/sls_yaml/_policy/PolicyRegistry.js

@@ -0,0 +1,94 @@
+// src/codeGenerators/app/sls_yaml/_policy/PolicyRegistry.js
+//
+// In-memory IAM permission registry. Decoupled generators register
+// (roleName, action, resource) tuples at any point during generation.
+// PolicyEmitter reads the registry after all generators have run and
+// emits one AWS::IAM::ManagedPolicy per role with deduplicated statements.
+//
+// Internal shape:
+//   Map<roleName, Map<action, Set<resource>>>
+// The action→resource-set grouping means adding the same resource twice
+// is a no-op (Set semantics), and multiple resources for one action get
+// rendered as a Resource: [ ... ] array (required by IAM policy syntax).
+
+export class PolicyRegistry {
+  constructor() {
+    /** @type {Map<string, Map<string, Set<string>>>} */
+    this._roles = new Map();
+    /** @type {Set<string>} Roles whose entries have been fully replaced via .set() */
+    this._replaced = new Set();
+  }
+
+  add(roleName, action, resource) {
+    if (this._replaced.has(roleName)) {
+      throw new Error(
+        `PolicyRegistry.add("${roleName}", ...): role was previously replaced via .set(); ` +
+        `use .set() again or call .resetRole() first.`
+      );
+    }
+    if (!this._roles.has(roleName)) this._roles.set(roleName, new Map());
+    const actions = this._roles.get(roleName);
+    if (!actions.has(action)) actions.set(action, new Set());
+    actions.get(action).add(resource);
+  }
+
+  addMany(roleName, perms) {
+    for (const p of perms) this.add(roleName, p.action, p.resource);
+  }
+
+  /** Fully replace a role's permission set (discards anything previously added). */
+  set(roleName, perms) {
+    this._roles.set(roleName, new Map());
+    this._replaced.add(roleName);
+    for (const p of perms) {
+      const actions = this._roles.get(roleName);
+      if (!actions.has(p.action)) actions.set(p.action, new Set());
+      actions.get(p.action).add(p.resource);
+    }
+  }
+
+  /** Forget all registrations for a role (allows re-add). */
+  resetRole(roleName) {
+    this._roles.delete(roleName);
+    this._replaced.delete(roleName);
+  }
+
+  /** Forget every role. Used between test cases or if a caller wants a clean slate. */
+  clear() {
+    this._roles.clear();
+    this._replaced.clear();
+  }
+
+  /**
+   * Return a serializable view of the registry grouped by role, with each role's
+   * permissions rendered as IAM-style statements (action + resource arrays).
+   * @returns {Record<string, { statements: Array<{ action: string[], resource: string[] }> }>}
+   */
+  toGroupedByRole() {
+    const out = {};
+    for (const [roleName, actions] of this._roles.entries()) {
+      const statements = [];
+      for (const [action, resources] of actions.entries()) {
+        if (resources.size === 0) continue;
+        statements.push({
+          action: [action],
+          resource: [...resources]
+        });
+      }
+      if (statements.length > 0) out[roleName] = { statements };
+    }
+    return out;
+  }
+
+  /** List of role names currently registered (useful for the emitter to iterate). */
+  registeredRoles() {
+    return [...this._roles.keys()];
+  }
+}
+
+/**
+ * Module-level singleton — most callers want the shared registry across
+ * the whole generation run. Tests instantiate PolicyRegistry directly
+ * to avoid cross-test pollution.
+ */
+export const policyRegistry = new PolicyRegistry();

package/src/codeGenerators/app/sls_yaml/_policy/__tests__/PolicyEmitter.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { PolicyRegistry } from '../PolicyRegistry.js';
+import { emitManagedPolicies } from '../PolicyEmitter.js';
+
+describe('emitManagedPolicies', () => {
+  let tmpDir, reg;
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'iz-policy-emitter-'));
+    reg = new PolicyRegistry();
+  });
+  afterEach(async () => { await fs.rm(tmpDir, { recursive: true, force: true }); });
+
+  it('emits one .yml file per registered role', async () => {
+    reg.add('FindDataRole', 's3:GetObject', 'arn:aws:s3:::a/*');
+    reg.add('RegisterRole', 'dynamodb:GetItem', 'arn:aws:dynamodb:*:*:table/x');
+    await emitManagedPolicies(reg, { outputPath: tmpDir });
+    const files = await fs.readdir(path.join(tmpDir, 'app', 'sls_yaml', 'generatedCode', 'source', 'iam-managed-policies'));
+    expect(files.sort()).toEqual(['FindDataRolePolicy.yml', 'RegisterRolePolicy.yml']);
+  });
+
+  it('emits empty dir + no files when registry is empty', async () => {
+    await emitManagedPolicies(reg, { outputPath: tmpDir });
+    const outDir = path.join(tmpDir, 'app', 'sls_yaml', 'generatedCode', 'source', 'iam-managed-policies');
+    const stat = await fs.stat(outDir);
+    expect(stat.isDirectory()).toBe(true);
+    const files = await fs.readdir(outDir);
+    expect(files).toEqual([]);
+  });
+
+  it('writes YAML that references the role via !Ref', async () => {
+    reg.add('FindDataRole', 's3:GetObject', 'arn:aws:s3:::a/*');
+    await emitManagedPolicies(reg, { outputPath: tmpDir });
+    const content = await fs.readFile(
+      path.join(tmpDir, 'app', 'sls_yaml', 'generatedCode', 'source', 'iam-managed-policies', 'FindDataRolePolicy.yml'),
+      'utf8'
+    );
+    expect(content).toContain('Type: AWS::IAM::ManagedPolicy');
+    expect(content).toContain('Roles:');
+    expect(content).toContain('!Ref FindDataRole');
+    expect(content).toContain('s3:GetObject');
+  });
+
+  it('does NOT crash on roles with statements containing Serverless CFN variables', async () => {
+    reg.add('FindDataRole', 's3:GetObject', 'arn:aws:s3:::${self:custom.iz_serviceSchemaBucketName}/*');
+    await emitManagedPolicies(reg, { outputPath: tmpDir });
+    const content = await fs.readFile(
+      path.join(tmpDir, 'app', 'sls_yaml', 'generatedCode', 'source', 'iam-managed-policies', 'FindDataRolePolicy.yml'),
+      'utf8'
+    );
+    expect(content).toContain('${self:custom.iz_serviceSchemaBucketName}');
+  });
+});

package/src/codeGenerators/app/sls_yaml/_policy/__tests__/PolicyRegistry.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { policyRegistry, PolicyRegistry } from '../PolicyRegistry.js';
+
+describe('PolicyRegistry', () => {
+  let reg;
+  beforeEach(() => { reg = new PolicyRegistry(); });
+
+  it('add() dedupes identical (role, action, resource) tuples', () => {
+    reg.add('Role1', 's3:GetObject', 'arn:aws:s3:::bucket/*');
+    reg.add('Role1', 's3:GetObject', 'arn:aws:s3:::bucket/*');
+    expect(reg.toGroupedByRole().Role1.statements).toHaveLength(1);
+  });
+
+  it('add() groups multiple resources under one (role, action)', () => {
+    reg.add('Role1', 's3:GetObject', 'arn:aws:s3:::a/*');
+    reg.add('Role1', 's3:GetObject', 'arn:aws:s3:::b/*');
+    const stmt = reg.toGroupedByRole().Role1.statements[0];
+    expect(stmt.action).toEqual(['s3:GetObject']);
+    expect(stmt.resource).toEqual(['arn:aws:s3:::a/*', 'arn:aws:s3:::b/*']);
+  });
+
+  it('addMany() inserts batch in one call', () => {
+    reg.addMany('Role1', [
+      { action: 's3:GetObject', resource: 'arn:aws:s3:::a/*' },
+      { action: 's3:ListBucket', resource: 'arn:aws:s3:::a' }
+    ]);
+    expect(reg.toGroupedByRole().Role1.statements).toHaveLength(2);
+  });
+
+  it('set() replaces baseline for a role (full override)', () => {
+    reg.add('Role1', 's3:GetObject', 'arn:aws:s3:::a/*');  // baseline
+    reg.set('Role1', [{ action: 'dynamodb:GetItem', resource: 'arn:aws:dynamodb:*:*:table/x' }]);
+    expect(reg.toGroupedByRole().Role1.statements).toHaveLength(1);
+    expect(reg.toGroupedByRole().Role1.statements[0].action).toEqual(['dynamodb:GetItem']);
+  });
+
+  it('toGroupedByRole() returns empty object when nothing registered', () => {
+    expect(reg.toGroupedByRole()).toEqual({});
+  });
+
+  it('toGroupedByRole() preserves insertion order within a role', () => {
+    reg.add('Role1', 's3:GetObject', 'arn:aws:s3:::a/*');
+    reg.add('Role1', 'dynamodb:GetItem', 'arn:aws:dynamodb:*:*:table/x');
+    reg.add('Role1', 's3:ListBucket', 'arn:aws:s3:::a');
+    const stmts = reg.toGroupedByRole().Role1.statements;
+    expect(stmts.map(s => s.action[0])).toEqual(['s3:GetObject', 'dynamodb:GetItem', 's3:ListBucket']);
+  });
+});

package/src/codeGenerators/app/sls_yaml/_policy/templates/ManagedPolicy_Yaml.ejs

@@ -0,0 +1,22 @@
+Resources:
+  <%- roleName %>Policy:
+    Type: AWS::IAM::ManagedPolicy
+    Properties:
+      ManagedPolicyName: ${self:custom.iz_resourcePrefix}<%- roleName %>Policy
+      Description: "Managed policy for <%- roleName %> (auto-generated by PolicyEmitter)"
+      PolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+<% statements.forEach((stmt) => { -%>
+          - Effect: Allow
+            Action:
+<% stmt.action.forEach((a) => { -%>
+              - <%- a %>
+<% }) -%>
+            Resource:
+<% stmt.resource.forEach((r) => { -%>
+              - "<%- r %>"
+<% }) -%>
+<% }) -%>
+      Roles:
+        - !Ref <%- roleName %>

package/src/codeGenerators/app/sls_yaml/templates/FunctionYaml_Api.ejs

@@ -0,0 +1,21 @@
+<%- functionNameConfig %>:
+  handler: <%- handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%- functionNameConfig %>
+  role: <%- roleName %>
+  #<#<%- functionNameConfig %>FunctionSetting#>
+  #<#/<%- functionNameConfig %>FunctionSetting#>
+  events:
+<% for (const route of apiRoutes) { -%>
+    - httpApi:
+        path: <%- route.path %>
+        method: post
+        #<#<%- route.upperName %>AppLevelAuthorizer#>
+        # authorizer: authorizerServiceSchema
+        #<#/<%- route.upperName %>AppLevelAuthorizer#>
+    - httpApi:
+        path: <%- route.path %>/{targetUserId}
+        method: post
+        #<#<%- route.upperName %>UserLevelAuthorizer#>
+        # authorizer: authorizerIdentifiers
+        #<#/<%- route.upperName %>UserLevelAuthorizer#>
+<% } -%>

package/src/codeGenerators/app/sls_yaml/templates/FunctionYaml_EventBridge.ejs

@@ -0,0 +1,14 @@
+  ${self:custom.iz_resourcePrefix}<%= functionNameConfig %>:
+    handler: <%= handlerPath %>
+    role: <%= roleName %>
+    description: <%= flowTag %> (EventBridge Schedule)
+<% if (locals.schedules && schedules.length > 0) { -%>
+    events:
+<% schedules.forEach(function(sched) { -%>
+      - schedule:
+          name: ${self:custom.iz_resourcePrefix}<%= sched.name %>
+          description: '<%= sched.description %>'
+          rate: <%= sched.rate[0] %>
+          enabled: true
+<% }); -%>
+<% } -%>

package/src/codeGenerators/app/sls_yaml/templates/FunctionYaml_Inv.ejs

@@ -0,0 +1,6 @@
+<%- functionNameConfig %>:
+  handler: <%- handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%- functionNameConfig %>
+  role: <%- roleName %>
+  #<#<%- functionNameConfig %>FunctionSetting#>
+  #<#/<%- functionNameConfig %>FunctionSetting#>

package/src/codeGenerators/app/sls_yaml/templates/FunctionYaml_Sqs.ejs

@@ -0,0 +1,11 @@
+<%- functionNameConfig %>:
+  handler: <%- handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%- functionNameConfig %>
+  role: <%- roleName %>
+  #<#<%- functionNameConfig %>FunctionSetting#>
+  #<#/<%- functionNameConfig %>FunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>
+        batchSize: 10
+<%- filterPatterns %>

package/src/codeGenerators/app/sls_yaml/templates/FunctionYaml_Wbs.ejs

@@ -0,0 +1,11 @@
+<%- functionNameConfig %>:
+  handler: <%- handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%- functionNameConfig %>
+  role: <%- roleName %>
+  #<#<%- functionNameConfig %>FunctionSetting#>
+  #<#/<%- functionNameConfig %>FunctionSetting#>
+  events:
+    - websocket:
+        route: <%- routeName %>
+        # authorizer: ${self:custom.iz_authorizerAppLevel}
+        # identifierResource: 'route.request.header.Auth'

package/src/codeGenerators/app/sls_yaml/templates/ProcessLogical_Yaml.ejs

@@ -0,0 +1,32 @@
+ProcessLogicalSqs:
+  handler: src/generatedCode/ProcessLogical/source/ProcessLogical_HdrSqs.main
+  name: ${self:custom.iz_resourcePrefix}ProcessLogicalHdrSqs
+  role: ProcFindDataRole
+  #<#ProcessLogicalhdrSqsFunctionSetting#>
+  #<#/ProcessLogicalhdrSqsFunctionSetting#>
+  events:
+  - sqs:
+      arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}ProcessLogicalHdrSqs
+      batchSize: 10
+
+PaginateProLogicalDsq:
+  handler: src/generatedCode/ProcessLogical/source/PaginateProcessLogical_HdrDsq.main
+  name: ${self:custom.iz_resourcePrefix}PaginateProcessLogicalHdrDsq
+  role: ProcFindDataRole
+  #<#PaginateProcessLogicalhdrDsqFunctionSetting#>
+  #<#/PaginateProcessLogicalhdrDsqFunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}PaginateProcessLogicalHdrDsq
+        batchSize: 10
+
+PaginateProLogicalSqs:
+  handler: src/generatedCode/ProcessLogical/source/PaginateProcessLogical_HdrSqs.main
+  name: ${self:custom.iz_resourcePrefix}PaginateProcessLogicalHdrSqs
+  role: ProcFindDataRole
+  #<#PaginateProcessLogicalHdrSqsFunctionSetting#>
+  #<#/PaginateProcessLogicalHdrSqsFunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}PaginateProcessLogicalHdrSqs
+        batchSize: 10

package/src/{generators/fromObjectSchema/roleNameConfig/templateYaml.ejs → codeGenerators/app/sls_yaml/templates/RoleNameConfig_Yaml.ejs}

@@ -2,4 +2,4 @@
 
 <% roleNameConfigs.forEach(roleNameConfig => { _%>
 - arn:aws:iam::${self:custom.iz_accountId}:role/${self:custom.iz_resourcePrefix}<%- roleNameConfig %>
-<% }) _%>
+<% }) _%>

package/src/codeGenerators/app/sls_yaml/templates/SharedResource_Yaml.ejs

@@ -0,0 +1,35 @@
+Resources:
+<% roles.forEach(({ roleName, statements }) => { %>
+  <%- roleName %>:
+    Type: AWS::IAM::Role
+    Properties:
+      RoleName: ${self:custom.iz_resourcePrefix}<%- roleName %>
+      AssumeRolePolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: "lambda.amazonaws.com"
+            Action: sts:AssumeRole
+      ManagedPolicyArns:
+        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+        //(<<%- roleName %>ManagedPolicyArns>)
+        //(</<%- roleName %>ManagedPolicyArns>)
+      Policies:
+        - PolicyName: ${self:custom.iz_resourcePrefix}<%- roleName %>Policy
+          PolicyDocument:
+            Version: "2012-10-17"
+            Statement:
+<% statements.forEach((stmt) => { %>
+              - Effect: Allow
+                Action:
+<% stmt.action.forEach((a) => { %>
+                  - <%- a %>
+<% }) %>
+                Resource:
+<% stmt.resource.forEach((r) => { %>
+                  - "<%- r %>"
+<% }) %>
+<% }) %>
+
+<% }) %>

package/src/codeGenerators/app/src/generatedCode/FindData/FindDataGenerator.js

@@ -0,0 +1,272 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const STORAGE_TYPES = {
+  dynamoDB: 'dynamoDB',
+  graph: 'graph'
+};
+
+export async function generateFindData(allSchemas, generatorOptions) {
+  console.log('  [FindDataGenerator] Generating FindData logic...');
+
+  const outputPath = path.join(
+    generatorOptions.outputPath,
+    'app',
+    'src',
+    'generatedCode',
+    'FindData',
+    'source'
+  );
+  const yamlOutputPath = path.join(
+    generatorOptions.outputPath,
+    'app',
+    'sls_yaml',
+    'generatedCode',
+    'source'
+  );
+
+  await fs.mkdir(outputPath, { recursive: true });
+  await fs.mkdir(yamlOutputPath, { recursive: true });
+
+  const datas = [];
+
+  // Parse allSchemas.objects to extract fields for FindData
+  if (allSchemas && allSchemas.objects) {
+    allSchemas.objects.forEach(obj => {
+      const objectType = obj.objectType;
+      let fieldNameDatas = [];
+
+      // Identify identifiers for checking 'getInIdentifiers'
+      const identifierFields = [];
+      if (obj.identifiers) {
+        obj.identifiers.forEach(id => {
+          if (id.fieldName) identifierFields.push(id.fieldName);
+          if (id.fieldNames) identifierFields.push(...id.fieldNames);
+        });
+      }
+
+      if (obj.fieldNames) {
+        Object.entries(obj.fieldNames).forEach(([field, schemas]) => {
+          if (schemas.type === 'string' || schemas.type === 'number') {
+            let collectStorageDetail = {};
+            let storageResourceTags = schemas.storageResourceTags || [];
+
+            storageResourceTags.forEach(tag => {
+              if (obj.storageResources && obj.storageResources[tag]) {
+                let storageDetail = obj.storageResources[tag];
+
+                if (storageDetail.storageType === STORAGE_TYPES.graph) {
+                  if (!collectStorageDetail[STORAGE_TYPES.graph]) {
+                    collectStorageDetail[STORAGE_TYPES.graph] = {
+                      graphServerTag: storageDetail.graphServerTag,
+                      getInIdentifiers: identifierFields.includes(field)
+                    };
+                  }
+                } else if (
+                  storageDetail.storageType === STORAGE_TYPES.dynamoDB
+                ) {
+                  if (!collectStorageDetail[STORAGE_TYPES.dynamoDB]) {
+                    collectStorageDetail[STORAGE_TYPES.dynamoDB] = {
+                      tableName: storageDetail.tableName
+                    };
+                  }
+                }
+              }
+            });
+
+            // Priority: DynamoDB over Graph
+            if (
+              collectStorageDetail[STORAGE_TYPES.graph] &&
+              collectStorageDetail[STORAGE_TYPES.dynamoDB]
+            ) {
+              delete collectStorageDetail[STORAGE_TYPES.graph];
+            }
+
+            if (Object.keys(collectStorageDetail).length > 0) {
+              fieldNameDatas.push({ [field]: collectStorageDetail });
+            }
+          }
+        });
+      }
+
+      // Parse addOnDataStructure for versionedData
+      if (obj.addOnDataStructure) {
+        obj.addOnDataStructure.forEach(versionedData => {
+          if (
+            versionedData.type === 'versionedData' &&
+            versionedData.fieldNames
+          ) {
+            let versionedStorageDetail = {};
+            let storageTag = versionedData.storageResourceTag;
+
+            if (obj.storageResources && obj.storageResources[storageTag]) {
+              let storageDetail = obj.storageResources[storageTag];
+              if (storageDetail.storageType === STORAGE_TYPES.graph) {
+                versionedStorageDetail = {
+                  [STORAGE_TYPES.graph]: {
+                    graphServerTag: storageDetail.graphServerTag,
+                    versionedDataLabel: versionedData.versionedDataLabel
+                  }
+                };
+              }
+            }
+
+            Object.entries(versionedData.fieldNames).forEach(
+              ([key, schema]) => {
+                if (schema.type === 'string' || schema.type === 'number') {
+                  if (Object.keys(versionedStorageDetail).length > 0) {
+                    fieldNameDatas.push({ [key]: versionedStorageDetail });
+                  }
+                }
+              }
+            );
+          }
+        });
+      }
+
+      if (fieldNameDatas.length > 0) {
+        datas.push({
+          objectType: objectType,
+          fieldNames: fieldNameDatas
+        });
+      }
+    });
+  }
+
+  // Pre-build the if-else-if blocks as a string, then pass to template
+  const getByDynamoTemplate = await fs.readFile(
+    path.join(__dirname, 'templates', 'GetByStorage', 'getByDynamo.ejs'),
+    'utf8'
+  );
+  const getByGraphTemplate = await fs.readFile(
+    path.join(__dirname, 'templates', 'GetByStorage', 'getByGraph.ejs'),
+    'utf8'
+  );
+  const templateViews = [path.join(__dirname, 'templates')];
+
+  // Helper: prefix every line of a block with `spaces`
+  const indent = (str, spaces) => {
+    const pad = ' '.repeat(spaces);
+    return str
+      .split('\n')
+      .map(line => (line.trim() === '' ? '' : pad + line))
+      .join('\n');
+  };
+
+  let objectTypeBlocks = '';
+  if (datas.length === 0) {
+    objectTypeBlocks = [
+      '    //(<additionalObjectType>)',
+      '    //(</additionalObjectType>)',
+      "    errorsFound.push('unrecognized objectType');",
+      '    standardErrorParams.push(errorsFound);',
+      '    await findDataSharedLib.completeFindDataMain(...standardErrorParams);',
+      "    return { returnResponse: 'Function FindData Error' };"
+    ].join('\n');
+  } else {
+    const objBlocks = datas.map((data, idx) => {
+      const objectType = data.objectType;
+      const fieldNames = data.fieldNames;
+      const keyword = idx === 0 ? 'if' : '} else if';
+
+      let fieldBlocks = '';
+      if (fieldNames && fieldNames.length > 0) {
+        const fBlocks = fieldNames.map((fieldEntry, fIdx) => {
+          const fieldObj = Object.keys(fieldEntry)[0];
+          const storageDetails = Object.values(fieldEntry)[0];
+          const fKeyword = fIdx === 0 ? 'if' : '} else if';
+
+          let storageCode = '';
+          for (const [storage, details] of Object.entries(storageDetails)) {
+            const versionedDataLabel =
+              storage === STORAGE_TYPES.graph && details.versionedDataLabel
+                ? [details.versionedDataLabel]
+                : [];
+            if (storage === STORAGE_TYPES.dynamoDB) {
+              const raw = ejs.render(
+                getByDynamoTemplate,
+                {
+                  tableName: details.tableName,
+                  fieldName: { fieldName: fieldObj },
+                  objectType
+                },
+                { views: templateViews }
+              );
+              storageCode += indent(raw.trimStart(), 8);
+            }
+            if (storage === STORAGE_TYPES.graph) {
+              const raw = ejs.render(
+                getByGraphTemplate,
+                {
+                  graphServerTag: details.graphServerTag,
+                  versionedDataLabel,
+                  fieldName: { fieldName: fieldObj },
+                  objectType,
+                  getInIdentifiers: details.getInIdentifiers
+                },
+                { views: templateViews }
+              );
+              storageCode += indent(raw.trimStart(), 8);
+            }
+          }
+
+          return `      ${fKeyword} (fieldName.fieldName == ${JSON.stringify(fieldObj)}) {\n        _izContext.logger.debug('fieldName: ', fieldName.fieldName);\n${storageCode}`;
+        });
+
+        fieldBlocks = fBlocks.join('\n');
+        fieldBlocks += `\n      }\n      //(<additional${objectType}FieldNames>)\n      //(</additional${objectType}FieldNames>)\n      else {\n        errorsFound.push('unrecognized fieldName');\n        standardErrorParams.push(errorsFound);\n        await findDataSharedLib.completeFindDataMain(...standardErrorParams);\n        return;\n      }`;
+      }
+
+      return `    ${keyword} (objType.objectType === ${JSON.stringify(objectType)}) {\n      _izContext.logger.debug('objectType: ', objType.objectType);\n\n${fieldBlocks}`;
+    });
+
+    objectTypeBlocks = objBlocks.join('\n');
+    objectTypeBlocks += `\n    }\n    //(<additionalObjectType>)\n    //(</additionalObjectType>)\n    else {\n      errorsFound.push('unrecognized objectType');\n      standardErrorParams.push(errorsFound);\n      await findDataSharedLib.completeFindDataMain(...standardErrorParams);\n      return { returnResponse: 'Function FindData Error' };\n    }`;
+  }
+
+  // Generate FindData_Main.js
+  const mainTemplatePath = path.join(
+    __dirname,
+    'templates',
+    'FindData_Main.ejs'
+  );
+  const mainTemplate = await fs.readFile(mainTemplatePath, 'utf8');
+  const mainContent = ejs.render(mainTemplate, { objectTypeBlocks });
+  await fs.writeFile(path.join(outputPath, 'FindData_Main.js'), mainContent);
+
+  // Generate FindData_HdrSqs.js
+  const sqsTemplatePath = path.join(
+    __dirname,
+    'templates',
+    'FindData_HdrSqs.ejs'
+  );
+  const sqsTemplate = await fs.readFile(sqsTemplatePath, 'utf8');
+  const sqsContent = ejs.render(sqsTemplate, {});
+  await fs.writeFile(path.join(outputPath, 'FindData_HdrSqs.js'), sqsContent);
+
+  // Generate FindData YAML
+  const yamlTemplatePath = path.join(
+    __dirname,
+    'templates',
+    'FindData_Yaml.ejs'
+  );
+  const yamlTemplate = await fs.readFile(yamlTemplatePath, 'utf8');
+  const yamlContent = ejs.render(yamlTemplate, {
+    functionName: 'FindData',
+    handlerPath: 'src/generatedCode/FindData/source/FindData_HdrSqs.main',
+    roleName: 'ProcFindData',
+    upperFunctionName: 'FINDDATA',
+    upperHandlerType: 'HDRSQS'
+  });
+  await fs.writeFile(
+    path.join(yamlOutputPath, 'find-data.yml'),
+    yamlContent
+  );
+
+  console.log('  [FindDataGenerator] Finished generating FindData logic.');
+}