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

package/src/schemaGenerators/app/src/schemas/FlowSchemas/RelationshipFlowSchemaGenerator.js

@@ -0,0 +1,89 @@
+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);
+
+/**
+ * Dynamic Relationship Flow Schema Generator
+ * Creates Service-Level Dynamic CRUD FlowSchemas that handle ANY relationship.
+ */
+export async function generateRelationshipFlowSchemas(
+  relationshipData,
+  options
+) {
+  console.log(
+    '  [RelationshipFlowSchemaGenerator] Generating dynamic Service-Level Relationship FlowSchemas...'
+  );
+
+  // If there are no relationships defined, skip generation
+  if (
+    !relationshipData ||
+    !relationshipData.relationships ||
+    relationshipData.relationships.length === 0
+  ) {
+    console.log(
+      '  [RelationshipFlowSchemaGenerator] No Relationship objects found. Forcing generation for testing.'
+    );
+    // return;
+  }
+
+  const schemasOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'schemas',
+    'FlowSchemas',
+    'generateCode'
+  );
+
+  await fs.mkdir(schemasOutputDir, { recursive: true });
+
+  let generatedCount = 0;
+  const actions = [
+    'CreateRelationship',
+    'UpdateRelationship',
+    'DeleteRelationship',
+    'GetRelationship',
+    'ChangeRelationship',
+    'MoveRelationship'
+  ];
+
+  const templatePath = path.join(
+    __dirname,
+    'templates',
+    'RelationshipFlowSchemaTemplate.ejs'
+  );
+  const templateString = await fs.readFile(templatePath, 'utf-8');
+
+  for (const action of actions) {
+    const filePath = path.join(schemasOutputDir, `${action}.js`);
+
+    let events = "['ownTopic']";
+    let outputTopic = true;
+    let hasCompleteStep = true;
+
+    if (action === 'getRelationship') {
+      events = "['lambdaSyncInv', 'lambdaSyncApi']";
+      outputTopic = false;
+      hasCompleteStep = false;
+    }
+
+    const fileContent = ejs.render(templateString, {
+      action: action,
+      flowTag: action,
+      events: events,
+      outputTopic: outputTopic,
+      hasCompleteStep: hasCompleteStep
+    });
+
+    await fs.writeFile(filePath, fileContent, 'utf-8');
+    generatedCount++;
+  }
+
+  console.log(
+    `  [RelationshipFlowSchemaGenerator] Wrote ${generatedCount} dynamic Relationship FlowSchemas to ${schemasOutputDir}`
+  );
+}

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/DynamicFlowSchemaTemplate.ejs

@@ -0,0 +1,39 @@
+/**
+ * GENERATED DYNAMIC FLOW SCHEMA
+ * Action: <%= action %>
+ * Description: Handles dynamic CRUD for all allowed ObjectTypes via SQS/DSQ
+ */
+export default {
+  flowTag: '<%= flowTag %>',
+  isDynamicObjectType: true,
+  initiateBy: 'system',
+  handleObj: 'one',
+  statusType: 'none',
+  event: <%- events %>,
+  outputTopic: <%= outputTopic %>,
+  stepMessageAttributes: {
+    userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
+    correlationId: { propertyName: 'x-correlation-id', type: 'string' }
+  },
+  flowSteps: [
+    {
+      stepName: 'InTag',
+      properties: [],
+      messageAttributes: ['userId', 'correlationId']
+    },
+    <% if (hasBeforeLogicalStep) { %>
+    {
+      stepName: 'beforeLogical',
+      properties: [],
+      messageAttributes: ['userId', 'correlationId']
+    },
+    <% } %>
+    <% if (['Create', 'Update', 'Delete'].includes(action)) { %>
+    {
+      stepName: 'Complete',
+      properties: [],
+      messageAttributes: ['userId', 'correlationId']
+    }
+    <% } %>
+  ]
+};

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/DynamicRbacFlowSchemaTemplate.ejs

@@ -0,0 +1,19 @@
+/**
+ * GENERATED RBAC FLOW SCHEMA
+ * ObjectType: <%= objectType %>
+ * Action: <%= flowTag %>
+ */
+export default {
+  flowTag: '<%= flowTag %>',
+  initiateBy: 'system',
+  statusType: 'none',
+  event: <%- events %>,
+  outputTopic: true,
+  flowSteps: [
+    {
+      stepName: 'InTag',
+      properties: [],
+      messageAttributes: []
+    }
+  ]
+};

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/RelationshipFlowSchemaTemplate.ejs

@@ -0,0 +1,32 @@
+/**
+ * GENERATED DYNAMIC RELATIONSHIP FLOW SCHEMA
+ * Action: <%= action %>
+ * Description: Handles dynamic relationship actions for all allowed RelationshipTypes via SQS/DSQ
+ */
+export default {
+  flowTag: '<%= flowTag %>',
+  isDynamicRelationshipType: true,
+  initiateBy: 'system',
+  handleObj: 'one',
+  statusType: 'none',
+  event: <%- events %>,
+  outputTopic: <%= outputTopic %>,
+  stepMessageAttributes: {
+    userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
+    correlationId: { propertyName: 'x-correlation-id', type: 'string' }
+  },
+  flowSteps: [
+    {
+      stepName: 'InTag',
+      properties: [],
+      messageAttributes: ['userId', 'correlationId']
+    }
+    <% if (hasCompleteStep) { %>,
+    {
+      stepName: 'Complete',
+      properties: [],
+      messageAttributes: ['userId', 'correlationId']
+    }
+    <% } %>
+  ]
+};

package/src/schemaGenerators/app/src/schemas/ObjectSchemas/AttributeTreeSchemaGenerator.js

@@ -0,0 +1,124 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import { attributeTreeLib } from '@izara_project/izara-attribute-tree';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function fieldNameSetting(type) {
+  const stringValidation = '^[a-zA-Z0-9-_]+$';
+  if (type === 'randomOnCreateFieldName') {
+    return {
+      type: 'string',
+      requiredOnCreate: false,
+      optionalOnCreate: false,
+      canUpdate: false,
+      randomOnCreate: true,
+      validation: { pattern: stringValidation }
+    };
+  }
+  return {};
+}
+
+export async function generateAttributeTreeObjectSchemas(hydratedObjectData, options) {
+  console.log('  [AttributeTreeSchemaGenerator] Generating dynamic AttributeTree ObjectSchemas...');
+  const schemasOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'schemas',
+    'ObjectSchemas',
+    'generatedAttributeTree'
+  );
+
+  let generatedCount = 0;
+
+  const managerTemplatePath = path.join(__dirname, 'templates', 'DynamicAttributeTreeManagerSchemaTemplate.ejs');
+  const standardTemplatePath = path.join(__dirname, 'templates', 'DynamicAttributeTreeStandardSchemaTemplate.ejs');
+  const managerTemplateStr = await fs.readFile(managerTemplatePath, 'utf-8');
+  const standardTemplateStr = await fs.readFile(standardTemplatePath, 'utf-8');
+
+  for (const obj of hydratedObjectData.objects) {
+    if (obj.addOnDataStructure && Array.isArray(obj.addOnDataStructure)) {
+      const attrTreeSchema = obj.addOnDataStructure.find(addOn => addOn.type === 'attributeTree');
+      
+      if (attrTreeSchema) {
+        const attributeTreeTag = attrTreeSchema.attributeTreeTag;
+        
+        let cloneDeepStorageResources = JSON.parse(JSON.stringify(obj.storageResources || {}));
+        for (const [tag, res] of Object.entries(cloneDeepStorageResources)) {
+          if (res.storageType === 'dynamoDB') {
+            delete cloneDeepStorageResources[tag];
+          } else if (res.storageType === 'graph') {
+            delete cloneDeepStorageResources[tag].additionalGraphIndexes;
+          }
+        }
+
+        const storageResourceTags = Object.keys(cloneDeepStorageResources);
+
+        // 1. Manager schemas
+        const managerSchemasToGenerate = [
+          {
+            objectType: attributeTreeLib.createAttributeLinkNodeLabel(attributeTreeTag),
+            fieldNames: {
+              [attributeTreeLib.createAttributeLinkIdentifierPropertyName(attributeTreeTag)]: Object.assign(fieldNameSetting('randomOnCreateFieldName'), { storageResourceTags })
+            },
+            identifiers: [{ type: 'identifier', fieldName: attributeTreeLib.createAttributeLinkIdentifierPropertyName(attributeTreeTag) }]
+          },
+          {
+            objectType: attributeTreeLib.createAttributeValue(attributeTreeTag),
+            fieldNames: {
+              [attributeTreeLib.createAttributeValueIdentifierPropertyName(attributeTreeTag)]: Object.assign(fieldNameSetting('randomOnCreateFieldName'), { storageResourceTags })
+            },
+            identifiers: [{ type: 'identifier', fieldName: attributeTreeLib.createAttributeValueIdentifierPropertyName(attributeTreeTag) }]
+          },
+          {
+            objectType: attributeTreeLib.createAttributeLabelNodeLabel(attributeTreeTag),
+            fieldNames: {
+              [attributeTreeLib.createAttributeLabelIdentifierPropertyName(attributeTreeTag)]: Object.assign(fieldNameSetting('randomOnCreateFieldName'), { storageResourceTags })
+            },
+            identifiers: [{ type: 'identifier', fieldName: attributeTreeLib.createAttributeLabelIdentifierPropertyName(attributeTreeTag) }]
+          }
+        ];
+
+        await fs.mkdir(schemasOutputDir, { recursive: true });
+
+        for (const schemaDef of managerSchemasToGenerate) {
+          const filePath = path.join(schemasOutputDir, `${schemaDef.objectType}.js`);
+          const fileContent = ejs.render(managerTemplateStr, {
+            objectType: schemaDef.objectType,
+            storageResources: JSON.stringify(cloneDeepStorageResources, null, 4),
+            fieldNames: JSON.stringify(schemaDef.fieldNames, null, 4),
+            identifiers: JSON.stringify(schemaDef.identifiers, null, 4)
+          });
+          await fs.writeFile(filePath, fileContent, 'utf-8');
+          generatedCount++;
+        }
+
+        // 2. Standard schema
+        const standardObjectType = attributeTreeLib.createAttributeValueStandard(attributeTreeTag);
+        const extendObjType = {
+          objectType: attributeTreeLib.createAttributeValue(attributeTreeTag),
+          serviceTag: options.serviceTag // Uses local service tag for simplicity
+        };
+        
+        const standardFilePath = path.join(schemasOutputDir, `${standardObjectType}.js`);
+        const standardFileContent = ejs.render(standardTemplateStr, {
+          objectType: standardObjectType,
+          storageResources: JSON.stringify(cloneDeepStorageResources, null, 4),
+          extendObjType: JSON.stringify(extendObjType, null, 4)
+        });
+        await fs.writeFile(standardFilePath, standardFileContent, 'utf-8');
+        generatedCount++;
+      }
+    }
+  }
+
+  if (generatedCount > 0) {
+    console.log(`  [AttributeTreeSchemaGenerator] Wrote ${generatedCount} dynamic AttributeTree ObjectSchemas to ${schemasOutputDir}`);
+  } else {
+    console.log('  [AttributeTreeSchemaGenerator] No AttributeTree objects found.');
+  }
+}

package/src/schemaGenerators/app/src/schemas/ObjectSchemas/PropertyValueSchemaGenerator.js

@@ -0,0 +1,119 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import propertyNode from '@izara_project/izara-property-nodes';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Helper function equivalent to fieldNameSetting
+function fieldNameSetting(type) {
+  const stringValidation = '^[a-zA-Z0-9-_]+$';
+  if (type === 'randomOnCreateFieldName') {
+    return {
+      type: 'string',
+      requiredOnCreate: false,
+      optionalOnCreate: false,
+      canUpdate: false,
+      randomOnCreate: true,
+      validation: { pattern: stringValidation }
+    };
+  }
+  return {};
+}
+
+function upperCase(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export async function generatePropertyValueObjectSchemas(hydratedObjectData, options) {
+  console.log('  [PropertyValueSchemaGenerator] Generating dynamic PropertyValue ObjectSchemas...');
+  const schemasOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'schemas',
+    'ObjectSchemas',
+    'generatedPropertyValue'
+  );
+
+  let generatedCount = 0;
+
+  // Read the EJS template
+  const templatePath = path.join(__dirname, 'templates', 'DynamicPropertyValueSchemaTemplate.ejs');
+  const templateString = await fs.readFile(templatePath, 'utf-8');
+
+  for (const obj of hydratedObjectData.objects) {
+    if (obj.addOnDataStructure && Array.isArray(obj.addOnDataStructure)) {
+      const pvSchema = obj.addOnDataStructure.find(addOn => addOn.type === 'propertyValue');
+
+      if (pvSchema) {
+        const propertyValueTag = pvSchema.propertyValuePrefix;
+
+        // Clone and filter storageResources (remove dynamoDB, keep graph)
+        let cloneDeepStorageResources = JSON.parse(JSON.stringify(obj.storageResources || {}));
+        for (const [tag, res] of Object.entries(cloneDeepStorageResources)) {
+          if (res.storageType === 'dynamoDB') {
+            delete cloneDeepStorageResources[tag];
+          } else if (res.storageType === 'graph') {
+            delete cloneDeepStorageResources[tag].additionalGraphIndexes;
+          }
+        }
+
+        const storageResourceTags = Object.keys(cloneDeepStorageResources);
+        const compositeKeyDeliminator = obj.compositeKeyDeliminator ? `"${obj.compositeKeyDeliminator}"` : 'undefined';
+
+        // 1. {subject}property
+        const propertyObjectType = propertyNode.createPropertyLabelGraphNodeLabel(propertyValueTag);
+        const propertyIdField = propertyValueTag + upperCase(propertyNode.consts.PROPERTY_LABEL_GRAPH_IDENTIFIER_ID);
+
+        // 2. {subject}propertyLabel
+        const propertyLabelObjectType = propertyNode.createPropertyValueGraphNodeLabel(propertyValueTag);
+        const propertyLabelIdField = propertyValueTag + upperCase(propertyNode.consts.PROPERTY_VALUE_GRAPH_IDENTIFIERS_ID);
+
+        const schemasToGenerate = [
+          {
+            objectType: propertyObjectType,
+            fieldNames: {
+              [propertyIdField]: Object.assign(fieldNameSetting('randomOnCreateFieldName'), { storageResourceTags })
+            },
+            identifiers: [{ type: 'identifier', fieldName: propertyIdField }]
+          },
+          {
+            objectType: propertyLabelObjectType,
+            fieldNames: {
+              [propertyLabelIdField]: Object.assign(fieldNameSetting('randomOnCreateFieldName'), { storageResourceTags })
+            },
+            identifiers: [{ type: 'identifier', fieldName: propertyLabelIdField }]
+          }
+        ];
+
+        // Ensure directory exists for this specific object
+        await fs.mkdir(schemasOutputDir, { recursive: true });
+
+        for (const schemaDef of schemasToGenerate) {
+          const filePath = path.join(schemasOutputDir, `${schemaDef.objectType}.js`);
+
+          const fileContent = ejs.render(templateString, {
+            objectType: schemaDef.objectType,
+            storageResources: JSON.stringify(cloneDeepStorageResources, null, 4),
+            fieldNames: JSON.stringify(schemaDef.fieldNames, null, 4),
+            identifiers: JSON.stringify(schemaDef.identifiers, null, 4),
+            compositeKeyDeliminator: compositeKeyDeliminator
+          });
+
+          await fs.writeFile(filePath, fileContent, 'utf-8');
+          generatedCount++;
+        }
+      }
+    }
+  }
+
+  if (generatedCount > 0) {
+    console.log(`  [PropertyValueSchemaGenerator] Wrote ${generatedCount} dynamic PropertyValue ObjectSchemas to ${schemasOutputDir}`);
+  } else {
+    console.log('  [PropertyValueSchemaGenerator] No PropertyValue objects found.');
+  }
+}

package/src/schemaGenerators/app/src/schemas/ObjectSchemas/templates/DynamicAttributeTreeManagerSchemaTemplate.ejs

@@ -0,0 +1,14 @@
+/**
+ * GENERATED ATTRIBUTE TREE MANAGER OBJECT SCHEMA
+ * ObjectType: <%= objectType %>
+ */
+export default [
+  {
+    objectType: '<%= objectType %>',
+    addOnDataStructure: [],
+    canDelete: true,
+    storageResources: <%- storageResources %>,
+    fieldNames: <%- fieldNames %>,
+    identifiers: <%- identifiers %>
+  }
+];

package/src/schemaGenerators/app/src/schemas/ObjectSchemas/templates/DynamicAttributeTreeStandardSchemaTemplate.ejs

@@ -0,0 +1,13 @@
+/**
+ * GENERATED ATTRIBUTE TREE STANDARD OBJECT SCHEMA
+ * ObjectType: <%= objectType %>
+ */
+export default [
+  {
+    objectType: '<%= objectType %>',
+    addOnDataStructure: [],
+    canDelete: true,
+    storageResources: <%- storageResources %>,
+    extendObjType: <%- extendObjType %>
+  }
+];

package/src/schemaGenerators/app/src/schemas/ObjectSchemas/templates/DynamicPropertyValueSchemaTemplate.ejs

@@ -0,0 +1,15 @@
+/**
+ * GENERATED PROPERTY VALUE OBJECT SCHEMA
+ * ObjectType: <%= objectType %>
+ */
+export default [
+  {
+    objectType: '<%= objectType %>',
+    addOnDataStructure: [],
+    canDelete: true,
+    storageResources: <%- storageResources %>,
+    fieldNames: <%- fieldNames %>,
+    identifiers: <%- identifiers %>,
+    compositeKeyDeliminator: <%- compositeKeyDeliminator %>
+  }
+];

package/src/schemaGenerators/app/src/schemas/RelationshipSchemas/AttributeTreeRelationshipSchemaGenerator.js

@@ -0,0 +1,149 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import { attributeTreeLib } from '@izara_project/izara-attribute-tree';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function createBasicRelationshipsProperties(from, to, storageResources, baseDirection) {
+  const otherDirection = baseDirection === 'to' ? 'from' : 'to';
+  return {
+    fieldNames: {
+      originTimeStamp: {
+        type: 'number',
+        requiredOnCreate: true,
+        canUpdate: false,
+        validation: {
+          minimum: 1111111111111,
+          maximum: 9999999999999
+        }
+      }
+    },
+    storageResources: storageResources,
+    links: [
+      {
+        storageResourceTags: Object.keys(storageResources),
+        from: {
+          objType: {
+            objectType: from.objectType,
+            serviceTag: from.serviceTag
+          },
+          linkType: from.linkType,
+          direction: baseDirection,
+          requiredOnCreate: from.requiredOnCreate
+        },
+        to: {
+          objType: {
+            objectType: to.objectType,
+            serviceTag: to.serviceTag
+          },
+          linkType: to.linkType,
+          direction: otherDirection,
+          requiredOnCreate: to.requiredOnCreate
+        }
+      }
+    ]
+  };
+}
+
+export async function generateAttributeTreeRelationshipSchemas(hydratedObjectData, options) {
+  console.log('  [AttributeTreeRelSchemaGenerator] Generating dynamic AttributeTree RelationshipSchemas...');
+  const schemasOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'schemas',
+    'RelationshipSchemas',
+    'generatedAttributeTree'
+  );
+
+  let generatedCount = 0;
+
+  const templatePath = path.join(__dirname, 'templates', 'DynamicAttributeTreeRelationshipSchemaTemplate.ejs');
+  const templateString = await fs.readFile(templatePath, 'utf-8');
+
+  const serviceTag = options.serviceTag;
+
+  for (const obj of hydratedObjectData.objects) {
+    if (obj.addOnDataStructure && Array.isArray(obj.addOnDataStructure)) {
+      const attrTreeSchema = obj.addOnDataStructure.find(addOn => addOn.type === 'attributeTree');
+      
+      if (attrTreeSchema) {
+        const attributeTreeTag = attrTreeSchema.attributeTreeTag;
+        
+        let cloneDeepStorageResources = JSON.parse(JSON.stringify(obj.storageResources || {}));
+        for (const [tag, res] of Object.entries(cloneDeepStorageResources)) {
+          if (res.storageType === 'dynamoDB') {
+            delete cloneDeepStorageResources[tag];
+          }
+        }
+
+        const schemasToGenerate = [
+          {
+            relationshipTag: attributeTreeLib.createHasAttributeLinkRelationshipType(upperCase(attributeTreeTag)),
+            relationshipProperties: createBasicRelationshipsProperties(
+              { serviceTag, objectType: obj.objectType, linkType: 'one', requiredOnCreate: false },
+              { serviceTag, objectType: attributeTreeLib.createAttributeLinkNodeLabel(attributeTreeTag), linkType: 'many', requiredOnCreate: true },
+              cloneDeepStorageResources,
+              'from'
+            )
+          },
+          {
+            relationshipTag: attributeTreeLib.createDisabledAttributeLinkRelationshipType(upperCase(attributeTreeTag)),
+            relationshipProperties: createBasicRelationshipsProperties(
+              { serviceTag, objectType: obj.objectType, linkType: 'one', requiredOnCreate: false },
+              { serviceTag, objectType: attributeTreeLib.createAttributeLinkNodeLabel(attributeTreeTag), linkType: 'many', requiredOnCreate: false },
+              cloneDeepStorageResources,
+              'from'
+            )
+          },
+          {
+            relationshipTag: attributeTreeLib.createIsAttributeRelationshipType(upperCase(attributeTreeTag)),
+            relationshipProperties: createBasicRelationshipsProperties(
+              { serviceTag, objectType: attributeTreeLib.createAttributeLinkNodeLabel(attributeTreeTag), linkType: 'many', requiredOnCreate: true },
+              { serviceTag, objectType: attributeTreeLib.createAttributeValue(attributeTreeTag), linkType: 'one', requiredOnCreate: false },
+              cloneDeepStorageResources,
+              'from'
+            )
+          },
+          {
+            relationshipTag: attributeTreeLib.createIsAttributeLabelRelationshipType(upperCase(attributeTreeTag)),
+            relationshipProperties: createBasicRelationshipsProperties(
+              { serviceTag, objectType: attributeTreeLib.createAttributeValue(attributeTreeTag), linkType: 'many', requiredOnCreate: true },
+              { serviceTag, objectType: attributeTreeLib.createAttributeLabelNodeLabel(attributeTreeTag), linkType: 'one', requiredOnCreate: false },
+              cloneDeepStorageResources,
+              'from'
+            )
+          }
+        ];
+
+        await fs.mkdir(schemasOutputDir, { recursive: true });
+
+        for (const schemaDef of schemasToGenerate) {
+          const filePath = path.join(schemasOutputDir, `${schemaDef.relationshipTag}.js`);
+
+          const fileContent = ejs.render(templateString, {
+            relationshipTag: schemaDef.relationshipTag,
+            relationshipProperties: JSON.stringify(schemaDef.relationshipProperties, null, 4)
+          });
+
+          await fs.writeFile(filePath, fileContent, 'utf-8');
+          generatedCount++;
+        }
+      }
+    }
+  }
+
+  if (generatedCount > 0) {
+    console.log(`  [AttributeTreeRelSchemaGenerator] Wrote ${generatedCount} dynamic AttributeTree RelationshipSchemas to ${schemasOutputDir}`);
+  } else {
+    console.log('  [AttributeTreeRelSchemaGenerator] No AttributeTree objects found.');
+  }
+}