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

package/src/generateCode.js

@@ -1,358 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import yaml from 'yaml';
-
-import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
-import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
-import { parseFlowSchemas } from './parsers/flowSchemaParser.js';
-
-import { generateFlowEntryPoint } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowEntryPointBase.js';
-import { generateFlowMainFunction } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowMainFunctionBase.js';
-import { generateFlowSteps } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepBase.js';
-import { normalizeUnifiedFlows } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepNormalizer.js';
-
-import { generateEndpointsFlow } from './codeGenerators/app/src/generatedCode/Flow/FlowObjects/EndpointsGenerator.js';
-import { generateFlowOut } from './codeGenerators/resource/sls_yaml/FlowOutGenerator.js';
-import { generateFlowResourceYaml } from './codeGenerators/resource/sls_yaml/FlowResourceYamlGenerator.js';
-import { generateRbacFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRbac/RbacFlowGenerator.js';
-import { generateRelationshipFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRelationships/RelationshipFlowGenerator.js';
-import { generateWebSocket } from './codeGenerators/app/src/generatedCode/Flow/FlowSchemas/WebSocketGenerator.js';
-import { validateFlowsForGeneration } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowValidator.js';
-import { generateRegisterFlow } from './codeGenerators/app/src/generatedCode/SystemFlowSchemas/RegisterGenerator.js';
-import { generateDynamoDBTables } from './codeGenerators/resource/sls_yaml/DynamoDBGenerator.js';
-import { generateFindData } from './codeGenerators/app/src/generatedCode/FindData/FindDataGenerator.js';
-import { generateRoleNameConfig } from './codeGenerators/app/sls_yaml/RoleNameConfigGenerator.js';
-import { generateFunctionYaml } from './codeGenerators/app/sls_yaml/FunctionYamlGenerator.js';
-import { generateInitialSetup } from './codeGenerators/app/initial_setup/InitialSetupGenerator.js';
-import { generateCodeLibs } from './codeGenerators/app/src/generatedCode/libs/GenerateCodeLibsGenerator.js';
-import { generateConsts } from './codeGenerators/app/src/generatedCode/libs/ConstsGenerator.js';
-import { generateProcessLogical } from './codeGenerators/app/src/generatedCode/ProcessLogical/ProcessLogicalGenerator.js';
-import { generateProcessLogicalYaml } from './codeGenerators/app/sls_yaml/ProcessLogicalYamlGenerator.js';
-import { generateSharedResourceYaml } from './codeGenerators/app/sls_yaml/SharedResourceYamlGenerator.js';
-import { generateFindDataYaml } from './codeGenerators/app/sls_yaml/FindDataYamlGenerator.js';
-import { policyRegistry } from './codeGenerators/app/sls_yaml/_policy/PolicyRegistry.js';
-import { emitManagedPolicies } from './codeGenerators/app/sls_yaml/_policy/PolicyEmitter.js';
-
-function createGeneratorOptions(rootPath, options = {}) {
-  return {
-    outputPath: options.outputPath || rootPath
-  };
-}
-
-/**
- * Low-level generator to generate application code files from all schemas.
- *
- * @param {string} rootPath - The root path of the project.
- * @param {object} [options={}] - Configuration options.
- * @param {string} [options.outputPath] - Output directory path.
- * @returns {Promise<void>}
- */
-export async function generateCode(rootPath, options = {}) {
-  console.log(
-    '[INFO] [generateCode] STATUS=STARTING | Generating code files from all schemas...'
-  );
-
-  const generatorOptions = createGeneratorOptions(rootPath, options);
-  const { outputPath } = generatorOptions;
-
-  let serviceName;
-  try {
-    const configPath = options.configPath || path.join(rootPath, 'config', 'serverless.config.yml');
-    if (!fs.existsSync(configPath)) {
-      throw new Error(`serverless.config.yml not found at path: ${configPath}`);
-    }
-    const configStr = fs.readFileSync(configPath, 'utf8');
-    const config = yaml.parse(configStr);
-    serviceName = config?.main_config?.iz_serviceName || config?.main_config?.iz_serviceTag;
-    
-    if (!serviceName) {
-      throw new Error('main_config.iz_serviceName or main_config.iz_serviceTag is missing in serverless.config.yml');
-    }
-    
-    console.log(`[INFO] [generateCode] Loaded config - serviceName: '${serviceName}' from ${configPath}`);
-  } catch (e) {
-    throw new Error(`[Developer Error] Failed to read service name from config: ${e.message}`);
-  }
-  generatorOptions.serviceName = serviceName;
-
-  // Clean workspace
-  const generatedCodePath = path.join(
-    outputPath,
-    'app',
-    'src',
-    'generatedCode'
-  );
-
-  // Backup existing hook files to prevent them from being wiped out
-  const hookBackups = [];
-  const hookDirs = new Set();
-
-  function getHookTagMatchers(filePath) {
-    if (filePath.endsWith('.js')) {
-      return {
-        anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
-        tagPattern: name =>
-          new RegExp(
-            `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
-            'gm'
-          )
-      };
-    }
-
-    if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
-      return {
-        anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
-        tagPattern: name =>
-          new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
-      };
-    }
-
-    return null;
-  }
-
-  function mergeHookIntoSource(sourceContent, hookContent, filePath) {
-    const matchers = getHookTagMatchers(filePath);
-    if (!matchers) return hookContent;
-
-    return sourceContent.replace(
-      matchers.anyTag,
-      (match, tagName) =>
-        hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
-    );
-  }
-
-  function collectHookBackups(currentDir) {
-    if (!fs.existsSync(currentDir)) return;
-
-    const items = fs.readdirSync(currentDir, { withFileTypes: true });
-    const hasSource = items.some(
-      item => item.isDirectory() && item.name === 'source'
-    );
-    const hasHook = items.some(
-      item => item.isDirectory() && item.name === 'hook'
-    );
-
-    if (hasSource && hasHook) {
-      const hookPath = path.join(currentDir, 'hook');
-      hookDirs.add(path.relative(outputPath, hookPath));
-      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
-
-      for (const hookItem of hookItems) {
-        if (!hookItem.isFile()) continue;
-        const hookFilePath = path.join(hookPath, hookItem.name);
-        hookBackups.push({
-          relativePath: path.relative(outputPath, hookPath),
-          name: hookItem.name,
-          content: fs.readFileSync(hookFilePath)
-        });
-      }
-    }
-
-    for (const item of items) {
-      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
-        continue;
-      collectHookBackups(path.join(currentDir, item.name));
-    }
-  }
-
-  console.log(
-    '[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...'
-  );
-  collectHookBackups(outputPath);
-
-  function processSourceHooks(currentDir) {
-    if (!fs.existsSync(currentDir)) return;
-
-    const items = fs.readdirSync(currentDir, { withFileTypes: true });
-    const hasSource = items.some(
-      item => item.isDirectory() && item.name === 'source'
-    );
-    const hasHook = items.some(
-      item => item.isDirectory() && item.name === 'hook'
-    );
-
-    if (hasSource && hasHook) {
-      const sourcePath = path.join(currentDir, 'source');
-      const hookPath = path.join(currentDir, 'hook');
-      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
-
-      for (const hookItem of hookItems) {
-        if (!hookItem.isFile()) continue;
-
-        const hookFile = path.join(hookPath, hookItem.name);
-        const sourceFile = path.join(sourcePath, hookItem.name);
-
-        if (!fs.existsSync(sourceFile)) {
-          fs.copyFileSync(hookFile, sourceFile);
-          console.log(
-            `[INFO] [generateCode] HOOK APPLIED: Created ${hookItem.name} from hook.`
-          );
-          continue;
-        }
-
-        const mergedContent = mergeHookIntoSource(
-          fs.readFileSync(sourceFile, 'utf8'),
-          fs.readFileSync(hookFile, 'utf8'),
-          sourceFile
-        );
-        fs.writeFileSync(sourceFile, mergedContent);
-        console.log(
-          `[INFO] [generateCode] HOOK APPLIED: Merged ${hookItem.name} into source.`
-        );
-      }
-    } else if (hasSource) {
-      fs.mkdirSync(path.join(currentDir, 'hook'), { recursive: true });
-    }
-
-    for (const item of items) {
-      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
-        continue;
-      processSourceHooks(path.join(currentDir, item.name));
-    }
-  }
-
-  let cleanupStarted = false;
-  let generationSucceeded = false;
-  const backedUpDirs = new Set();
-  const dirsToBackup = [
-    generatedCodePath,
-    path.join(outputPath, 'app', 'sls_yaml', 'generatedCode'),
-    path.join(outputPath, 'resource', 'sls_yaml', 'generatedCode')
-  ];
-
-  // ponytail: ensure hooks are restored even if generation fails
-  try {
-    policyRegistry.clear();
-
-
-  // 1. Parsing & Hydration Pipeline
-  console.log('[INFO] [generateCode] STATUS=PARSING | ObjectSchemas...');
-  const objectData = await parseObjectSchemas(rootPath);
-
-  console.log('[INFO] [generateCode] STATUS=PARSING | RelationshipSchemas...');
-  const relationshipData = await parseRelationshipSchemas(rootPath, objectData);
-
-  console.log('[INFO] [generateCode] STATUS=PARSING | FlowSchemas...');
-  const flowData = await parseFlowSchemas(rootPath, objectData, options);
-
-  // The 'allSchemas' object contains the fully hydrated Memory Objects
-  const allSchemas = {
-    objects: objectData.objects,
-    relationships: relationshipData.relationships,
-    flows: flowData.flows,
-    flowsForGeneration: flowData.flows || []
-  };
-
-  console.log('[INFO] [generateCode] STATUS=NORMALIZING | Adapting Unified Flows...');
-  normalizeUnifiedFlows(allSchemas.flowsForGeneration);
-
-  console.log('[INFO] [generateCode] STATUS=VALIDATING | Validating Flows...');
-  validateFlowsForGeneration(allSchemas.flowsForGeneration);
-
-  console.log(
-    '[INFO] [generateCode] STATUS=BACKUP_DIRS | Backing up old generatedCode directories...'
-  );
-  for (const dir of dirsToBackup) {
-    if (fs.existsSync(dir)) {
-      if (fs.existsSync(`${dir}.bak`)) {
-        await fs.promises.rm(`${dir}.bak`, { recursive: true, force: true });
-      }
-      await fs.promises.rename(dir, `${dir}.bak`);
-      backedUpDirs.add(dir);
-    }
-  }
-
-  cleanupStarted = true;
-
-  console.log(
-    '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode directories before generating new files...'
-  );
-  for (const dir of dirsToBackup) {
-    await fs.promises.rm(dir, { recursive: true, force: true });
-  }
-
-  // 2. Generation Pipeline
-  await generateEndpointsFlow(allSchemas, generatorOptions);
-  await generateFlowMainFunction(allSchemas, generatorOptions);
-  await generateFlowEntryPoint(allSchemas, generatorOptions);
-  await generateFlowSteps(allSchemas, generatorOptions);
-  await generateFlowOut(allSchemas, generatorOptions);
-  await generateFlowResourceYaml(allSchemas, generatorOptions);
-  await generateRbacFlows(allSchemas, generatorOptions);
-  await generateRelationshipFlows(allSchemas, generatorOptions);
-  await generateWebSocket(
-    allSchemas.flowsForGeneration,
-    '',
-    generatorOptions.outputPath
-  );
-  await generateRegisterFlow(
-    allSchemas.flowsForGeneration,
-    '',
-    generatorOptions.outputPath
-  );
-
-  // Call FunctionYamlGenerator after all Handlers have been generated
-  await generateFunctionYaml(allSchemas, generatorOptions);
-  await generateDynamoDBTables(allSchemas, generatorOptions);
-  await generateFindData(allSchemas, generatorOptions);
-  await generateCodeLibs(generatorOptions);
-  await generateConsts(generatorOptions);
-  await generateProcessLogical(generatorOptions);
-  await generateRoleNameConfig(allSchemas, generatorOptions);
-  await generateProcessLogicalYaml(allSchemas, generatorOptions);
-  await generateFindDataYaml(generatorOptions);
-  await generateSharedResourceYaml(allSchemas, generatorOptions);
-  await generateInitialSetup(allSchemas, generatorOptions);
-
-  generationSucceeded = true;
-
-  } finally {
-    if (generationSucceeded) {
-      console.log('[INFO] [generateCode] STATUS=CLEANUP_BAK | Generation successful, removing .bak directories...');
-      for (const dir of dirsToBackup) {
-        if (fs.existsSync(`${dir}.bak`)) {
-          await fs.promises.rm(`${dir}.bak`, { recursive: true, force: true });
-        }
-      }
-    } else if (cleanupStarted) {
-      console.log('[INFO] [generateCode] STATUS=FAILED | Generation failed, rolling back directories...');
-      for (const dir of dirsToBackup) {
-        if (fs.existsSync(dir)) {
-          await fs.promises.rm(dir, { recursive: true, force: true });
-        }
-        if (backedUpDirs.has(dir) && fs.existsSync(`${dir}.bak`)) {
-          await fs.promises.rename(`${dir}.bak`, dir);
-        }
-      }
-    }
-
-    // Restore backed-up hooks
-    if (hookDirs.size > 0 || hookBackups.length > 0) {
-      console.log(
-        `[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`
-      );
-      for (const relativeHookDir of hookDirs) {
-        fs.mkdirSync(path.join(outputPath, relativeHookDir), { recursive: true });
-      }
-      for (const backup of hookBackups) {
-        const hookDir = path.join(outputPath, backup.relativePath);
-        fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
-      }
-    }
-
-    if (generationSucceeded) {
-      console.log(
-        '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
-      );
-      processSourceHooks(generatorOptions.outputPath);
-
-      console.log(
-        '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'
-      );
-    } else {
-      console.log(
-        '[INFO] [generateCode] STATUS=FAILED | Code generation failed. Hook files were restored, but processSourceHooks was skipped.'
-      );
-    }
-  }
-}

package/src/generateSchema.js

@@ -1,123 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import yaml from 'yaml';
-
-import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
-import { parseFlowSchemas } from './parsers/flowSchemaParser.js';
-import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
-
-import { generateRelationshipFlowSchemas } from './schemaGenerators/app/src/schemas/FlowSchemas/RelationshipFlowSchemaGenerator.js';
-import { generateDynamicFlowSchemas } from './schemaGenerators/app/src/schemas/FlowSchemas/FlowSchemaGenerator.js';
-import { generateRbacFlowSchemas } from './schemaGenerators/app/src/schemas/FlowSchemas/RbacFlowSchemaGenerator.js';
-import { generateSystemTextSchemas } from './schemaGenerators/app/src/schemas/SystemTextSchemas/SystemTextGenerator.js';
-import { generatePropertyValueObjectSchemas } from './schemaGenerators/app/src/schemas/ObjectSchemas/PropertyValueSchemaGenerator.js';
-import { generatePropertyValueRelationshipSchemas } from './schemaGenerators/app/src/schemas/RelationshipSchemas/PropertyValueRelationshipSchemaGenerator.js';
-import { generateAttributeTreeObjectSchemas } from './schemaGenerators/app/src/schemas/ObjectSchemas/AttributeTreeSchemaGenerator.js';
-import { generateAttributeTreeRelationshipSchemas } from './schemaGenerators/app/src/schemas/RelationshipSchemas/AttributeTreeRelationshipSchemaGenerator.js';
-
-/**
- * Low-level generator to generate dynamic schemas (FlowSchema, etc.).
- *
- * @param {string} rootPath - The root path of the project.
- * @param {object} [options={}] - Configuration options.
- * @param {string} [options.configPath] - Path to the serverless configuration file.
- * @param {string} [options.outputPath] - Output directory path.
- * @param {Array} [options.schemaTemplateConfig] - Schema template configuration.
- * @returns {Promise<void>}
- */
-export async function generateSchema(rootPath, options = {}) {
-  console.log(
-    '[INFO] [generateSchema] STATUS=STARTING | Generating dynamic schemas (FlowSchema, etc.)...'
-  );
-
-  const configPath =
-    options.configPath || path.join(rootPath, 'config', 'serverless.config.yml');
-  const serviceTag = readServiceTag(configPath);
-
-  const objectData = await parseObjectSchemas(rootPath);
-  applySchemaTemplateConfig(objectData, options.schemaTemplateConfig, serviceTag);
-
-  const flowData = await parseFlowSchemas(rootPath, objectData);
-  const relationshipData = await parseRelationshipSchemas(rootPath, objectData);
-
-  const generatorOptions = {
-    outputPath: options.outputPath || rootPath,
-    serviceTag
-  };
-
-  await generateSystemTextSchemas(
-    objectData,
-    relationshipData,
-    flowData,
-    generatorOptions
-  );
-  await generateRelationshipFlowSchemas(relationshipData, generatorOptions);
-  await generateDynamicFlowSchemas(objectData, flowData, generatorOptions);
-  await generateRbacFlowSchemas(objectData, generatorOptions);
-  await generatePropertyValueObjectSchemas(objectData, generatorOptions);
-  await generatePropertyValueRelationshipSchemas(objectData, generatorOptions);
-  await generateAttributeTreeObjectSchemas(objectData, generatorOptions);
-  await generateAttributeTreeRelationshipSchemas(objectData, generatorOptions);
-}
-
-function readServiceTag(configPath) {
-  try {
-    const serviceConfigStr = fs.readFileSync(configPath, 'utf8');
-    const serviceConfig = yaml.parse(serviceConfigStr);
-    return serviceConfig?.main_config?.iz_serviceTag || 'unknownService';
-  } catch {
-    console.warn(
-      `[WARNING] Could not read service config at ${configPath}. Using default serviceTag.`
-    );
-    return 'unknownService';
-  }
-}
-
-function applySchemaTemplateConfig(objectData, schemaTemplateConfig, defaultServiceTag) {
-  const templates = Array.isArray(schemaTemplateConfig)
-    ? schemaTemplateConfig
-    : [];
-
-  for (const template of templates) {
-    if (template?.generateName !== 'mainAttributeTree') {
-      continue;
-    }
-
-    const objectType = template?.objType?.objectType;
-    const serviceTag = template?.objType?.serviceTag || defaultServiceTag;
-    const attributeTag = template?.attributeTag;
-
-    if (!objectType || !attributeTag) {
-      continue;
-    }
-
-    const objectSchema = objectData.objects.find(
-      obj =>
-        obj.objectType === objectType &&
-        (obj.serviceTag || defaultServiceTag) === serviceTag
-    );
-
-    if (!objectSchema) {
-      console.warn(
-        `[WARNING] [generateSchema] Template target not found for ${serviceTag}.${objectType}`
-      );
-      continue;
-    }
-
-    objectSchema.addOnDataStructure ||= [];
-
-    const hasAttributeTree = objectSchema.addOnDataStructure.some(
-      addOn =>
-        addOn?.type === 'attributeTree' &&
-        addOn?.attributeTreeTag === attributeTag
-    );
-
-    if (!hasAttributeTree) {
-      // ponytail: inject the same addon shape the existing generators already understand
-      objectSchema.addOnDataStructure.push({
-        type: 'attributeTree',
-        attributeTreeTag: attributeTag
-      });
-    }
-  }
-}

package/src/parsers/flowSchemaParser.js

@@ -1,112 +0,0 @@
-import { consts, getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-import path from 'path';
-
-function buildObjectSchemaAllS3DebugParam(objType) {
-    return {
-        Bucket: process.env.iz_serviceSchemaBucketName || consts.OBJECT_SCHEMA_BUCKET_NAME,
-        Key: consts.UPLOAD_PATH_S3.objectSchemaAll({}, objType)
-    };
-}
-
-/**
- * Parses FlowSchemas into a memory-resident data structure.
- * Implements Hydration Strategy 3: Binding related flows directly to their owning ObjectSchema.
- */
-export async function parseFlowSchemas(rootPath, hydratedObjectData, options = {}) {
-    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
-    const _izContext = { reqId: 'generate-sandbox', logger: console };
-
-    // 1. Read FlowSchemas using existing library
-    const flowsResponse = await getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath);
-    let flows = flowsResponse.records || [];
-
-    const seenFlowTags = new Set(flows.map(f => f.flowTag));
-
-    // Also read dynamic flows from generateCode directory in the output path
-    const targetSchemasDir = options.outputPath ? path.join(options.outputPath, 'app', 'src', 'schemas') : schemasPath;
-    const dynamicSchemasPath = path.join(targetSchemasDir, 'FlowSchemas', 'generateCode');
-    try {
-        const fs = await import('fs/promises');
-        const { pathToFileURL } = await import('url');
-        const files = await fs.readdir(dynamicSchemasPath);
-        for (const file of files) {
-            if (file.endsWith('.js')) {
-                const filePath = path.join(dynamicSchemasPath, file);
-                const mod = await import(pathToFileURL(filePath).href);
-                if (mod.default) {
-                    if (seenFlowTags.has(mod.default.flowTag)) {
-                        continue;
-                    }
-                    console.log(`[flowSchemaParser] Loaded dynamic flow: ${mod.default.flowTag}`);
-                    flows.push(mod.default);
-                    seenFlowTags.add(mod.default.flowTag);
-                } else {
-                    console.log(`[flowSchemaParser] No default export in ${file}`);
-                }
-            }
-        }
-    } catch (err) {
-        if (err.code !== 'ENOENT') {
-            console.error(`[flowSchemaParser] Failed to load dynamic schemas from ${dynamicSchemasPath}:`, err);
-        }
-    }
-
-    // 2. Hydration: Link flows to their parent ObjectSchema
-    for (const flow of flows) {
-        // If the flow explicitly defines an objType it handles (e.g. Validation, Search)
-        if (flow.objType && flow.objType.objectType) {
-            const targetObj = flow.objType.objectType;
-            if (hydratedObjectData.objectMap.has(targetObj)) {
-                hydratedObjectData.objectMap.get(targetObj).relatedFlows.push({
-                    flowTag: flow.flowTag,
-                    initiateBy: flow.initiateBy,
-                    type: 'explicit'
-                });
-            }
-
-            // --- RBAC Check ---
-            try {
-                let objSchema = hydratedObjectData.objectMap.get(targetObj);
-                if (!objSchema && flow.objType.serviceTag) {
-                    console.log(`[flowSchemaParser] Fetching objSchema from S3 for targetObj: ${targetObj}`);
-                    console.log(`[flowSchemaParser] getObjSchemaS3WithHierarchy param:`, {
-                        objType: flow.objType,
-                        s3: buildObjectSchemaAllS3DebugParam(flow.objType)
-                    });
-                    objSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, flow.objType);
-                }
-
-                console.log(`[flowSchemaParser] targetObj: ${targetObj}, objSchema.belongTo:`, objSchema?.belongTo);
-
-                if (objSchema && objSchema.belongTo) {
-                    console.log(`[flowSchemaParser] Fetching belongToSchema from S3:`, objSchema.belongTo);
-                    console.log(`[flowSchemaParser] getObjSchemaS3WithHierarchy param:`, {
-                        objType: objSchema.belongTo,
-                        s3: buildObjectSchemaAllS3DebugParam(objSchema.belongTo)
-                    });
-                    const belongToSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, objSchema.belongTo);
-                    console.log(`[flowSchemaParser] belongToSchema.addOnDataStructure:`, belongToSchema?.addOnDataStructure);
-                    if (belongToSchema && belongToSchema.addOnDataStructure) {
-                        const hasRbac = belongToSchema.addOnDataStructure.some(addOn => addOn.type === 'rbac');
-                        console.log(`[flowSchemaParser] flowTag: ${flow.flowTag}, hasRbac: ${hasRbac}`);
-                        if (hasRbac) {
-                            flow.isRbac = true;
-                        }
-                    }
-                }
-            } catch (err) {
-                console.error(`[flowSchemaParser] Failed to check RBAC for flow ${flow.flowTag}:`, err.message);
-            }
-        }
-
-        // Also check triggerFlowTypes if this flow triggers others
-        if (flow.triggerFlowTypes && Array.isArray(flow.triggerFlowTypes)) {
-            // Further hydration logic if needed...
-        }
-    }
-
-    return {
-        flows: flows,
-        flowMap: new Map(flows.map(f => [f.flowTag, f]))
-    };
-}

package/src/parsers/objectSchemaParser.js

@@ -1,39 +0,0 @@
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-import path from 'path';
-
-/**
- * Parses ObjectSchemas into a memory-resident data structure.
- * Implements Hydration Strategy 1: Merging fieldNames and identifiers from extendObjType
- */
-export async function parseObjectSchemas(rootPath) {
-    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
-    // Dummy izContext for local parsing
-    const _izContext = { reqId: 'generate-sandbox', logger: console };
-
-    // 1. Fetch raw schemas using the existing library
-    const schemasResponse = await getObjectSchema.getAllLocalObjectSchemasWithoutHierarchy(_izContext, schemasPath);
-    const schemas = schemasResponse.records || [];
-    
-    // 2. Hydration: Merge extended objects
-    const schemaMap = new Map();
-    schemas.forEach(s => schemaMap.set(s.objectType, s));
-
-    const hydratedObjects = schemas.map(obj => {
-        const hydrated = { ...obj, relationships: {}, relatedFlows: [] };
-        
-        // If it extends another object, merge its fields
-        if (obj.extendObjType && obj.extendObjType.objectType) {
-            const parent = schemaMap.get(obj.extendObjType.objectType);
-            if (parent) {
-                hydrated.fieldNames = { ...parent.fieldNames, ...hydrated.fieldNames };
-                hydrated.identifiers = [ ...(parent.identifiers || []), ...(hydrated.identifiers || []) ];
-            }
-        }
-        return hydrated;
-    });
-
-    return {
-        objects: hydratedObjects,
-        objectMap: new Map(hydratedObjects.map(s => [s.objectType, s]))
-    };
-}

package/src/parsers/relationshipSchemaParser.js

@@ -1,51 +0,0 @@
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-import path from 'path';
-
-/**
- * Parses RelationshipSchemas into a memory-resident data structure.
- * Implements Hydration Strategy 2: Two-way binding for links array.
- */
-export async function parseRelationshipSchemas(rootPath, hydratedObjectData) {
-    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
-    const _izContext = { reqId: 'generate-sandbox', logger: console };
-
-    // 1. Read from schemas/RelationshipSchemas
-    const relationships = await getObjectSchema.getAllLocalRelationshipSchema(_izContext, schemasPath);
-    
-    // 2. Hydrate ObjectSchemas with two-way bindings
-    relationships.forEach(rel => {
-        if (rel.links && Array.isArray(rel.links)) {
-            rel.links.forEach(link => {
-                const fromObj = link.from?.objType?.objectType;
-                const toObj = link.to?.objType?.objectType;
-
-                // Bind to "from" object
-                if (fromObj && hydratedObjectData.objectMap.has(fromObj)) {
-                    const obj = hydratedObjectData.objectMap.get(fromObj);
-                    obj.relationships[rel.relationshipTag] = {
-                        relationshipTag: rel.relationshipTag,
-                        direction: 'from',
-                        linkType: link.from.linkType,
-                        target: toObj
-                    };
-                }
-
-                // Bind to "to" object
-                if (toObj && hydratedObjectData.objectMap.has(toObj)) {
-                    const obj = hydratedObjectData.objectMap.get(toObj);
-                    obj.relationships[rel.relationshipTag] = {
-                        relationshipTag: rel.relationshipTag,
-                        direction: 'to',
-                        linkType: link.to.linkType,
-                        target: fromObj
-                    };
-                }
-            });
-        }
-    });
-
-    return {
-        relationships: relationships,
-        relationshipMap: new Map(relationships.map(r => [r.relationshipTag, r]))
-    };
-}