@izara_project/izara-core-generate-service-code 1.0.97 → 1.0.99

package/src/generate.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { buildGenerationPlan } from './plan/buildGenerationPlan.js';
 import { resolveEmissionGroups } from './plan/domainRegistry.js';
 import { commitArtifacts } from './output/commitArtifacts.js';
@@ -8,10 +7,6 @@ import {
   resolveExtendedObjectSchemas,
   resolveGraphServiceTags
 } from './compile/loadSchemas.js';
-import {
-  resolveTargetServicePath,
-  emitAttributeTreeTargetSchemas
-} from './emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -29,9 +24,17 @@ export async function generate(rootPath, options = {}) {
       errors
     ] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'RelationshipSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(
+        project,
+        'RelationshipSchemas',
+        schemaLoadOptions
+      ),
       loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(
+        project,
+        'NotificationSchemas',
+        schemaLoadOptions
+      ),
       loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
     ]);
     const schemaBucketName =
@@ -101,14 +104,6 @@ export async function generate(rootPath, options = {}) {
         )
       );
     }
-    const targetFiles = await _emitTargetServiceAttributeTreeSchemas({
-      project,
-      objects,
-      logger: options.logger
-    });
-    for (const targetFile of targetFiles) {
-      files.push(targetFile);
-    }
     const durationMs = Date.now() - startedAt;
     console.log(
       `[INFO] [Generate] STATUS=FINISHED | ` +
@@ -126,61 +121,3 @@ export async function generate(rootPath, options = {}) {
   }
 }
 
-async function _emitTargetServiceAttributeTreeSchemas({
-  project,
-  objects,
-  logger
-}) {
-  if (!Array.isArray(objects)) {
-    return [];
-  }
-  const committedFiles = [];
-  for (const object of objects) {
-    if (!Array.isArray(object?.addOnDataStructure)) {
-      continue;
-    }
-    for (const addOn of object.addOnDataStructure) {
-      if (addOn?.type === 'attributeTree' && addOn?.attributeTreeTag) {
-        const attributeTag = addOn.attributeTreeTag;
-        const targetServiceRoot = resolveTargetServicePath({
-          currentServiceRoot: project.rootPath,
-          attributeTag
-        });
-        if (targetServiceRoot) {
-          const artifacts = emitAttributeTreeTargetSchemas({
-            attributeTag,
-            targetServiceRoot
-          });
-          const relativeArtifacts = artifacts.map((artifact) => {
-            return {
-              path: path.relative(targetServiceRoot, artifact.path),
-              content: artifact.content
-            };
-          });
-          const targetPlan = buildGenerationPlan(
-            { outputPath: targetServiceRoot },
-            relativeArtifacts,
-            {
-              managedScopes: {
-                'attribute-tree-target-schemas': relativeArtifacts.map(
-                  (a) => a.path
-                )
-              }
-            }
-          );
-          const targetFiles = await commitArtifacts(targetPlan);
-          for (const targetFile of targetFiles) {
-            committedFiles.push(targetFile);
-          }
-          if (logger && typeof logger.info === 'function') {
-            logger.info(
-              `[INFO] [AttributeTree] Target schemas emitted for ` +
-                `tag=${attributeTag} to ${targetServiceRoot}`
-            );
-          }
-        }
-      }
-    }
-  }
-  return committedFiles;
-}

package/src/output/mergeHooks.js

@@ -24,7 +24,10 @@ async function mergeHook(outputRoot, artifact) {
     }
   }
 
-  if (sourceContent !== null && (artifact.writeWhenFileExist === false || artifact.writeWhenFileExists === false)) {
+  const skipWrite =
+    artifact.writeWhenFileExist === false ||
+    artifact.writeWhenFileExists === false;
+  if (sourceContent !== null && skipWrite) {
     return sourceContent;
   }
 
@@ -37,32 +40,183 @@ async function mergeHook(outputRoot, artifact) {
     return artifact.content;
   }
 
+  _validateHookIntegrity(artifact.path, sourceContent);
+  _warnOrphanedHooks(
+    artifact.path,
+    sourceContent,
+    artifact.content,
+    matchers
+  );
+
+  const tagOccurrences = new Map();
   return artifact.content.replace(
     matchers.anyTag,
     (_match, p1, _body1, p2) => {
-      const tagName = p1 || p2;
-      const hookBlock = sourceContent.match(matchers.tagPattern(tagName))?.[0];
-      return hookBlock ?? _match;
+      const tagName = _extractTagName(p1, p2);
+      if (!tagName) {
+        return _match;
+      }
+      let count = 0;
+      if (tagOccurrences.has(tagName)) {
+        count = tagOccurrences.get(tagName);
+      }
+      tagOccurrences.set(tagName, count + 1);
+
+      const matches = sourceContent.match(matchers.tagPattern(tagName));
+      if (!matches || count >= matches.length) {
+        return _match;
+      }
+      const hookBlock = matches[count];
+      if (hookBlock !== null && hookBlock !== undefined) {
+        return _normalizeHookBlock(hookBlock, tagName);
+      }
+      return _match;
     }
   );
 }
 
+function _validateHookIntegrity(filePath, content) {
+  const lower = filePath.toLowerCase();
+  let openCount = 0;
+  let closeCount = 0;
+
+  if (
+    lower.endsWith('.js') ||
+    lower.endsWith('.mjs') ||
+    lower.endsWith('.cjs')
+  ) {
+    const openP1 = content.match(/\/\/\s*\(<\s*[\w.-]+/g);
+    const closeP1 = content.match(/\/\/\s*\(<\/\s*[\w.-]+/g);
+    const openP2 = content.match(/\/\/\s*<#\s*[\w.-]+/g);
+    const closeP2 = content.match(/\/\/\s*<#\/\s*[\w.-]+/g);
+
+    if (openP1) {
+      openCount += openP1.length;
+    }
+    if (closeP1) {
+      closeCount += closeP1.length;
+    }
+    if (openP2) {
+      openCount += openP2.length;
+    }
+    if (closeP2) {
+      closeCount += closeP2.length;
+    }
+  } else if (lower.endsWith('.yml') || lower.endsWith('.yaml')) {
+    const openYml = content.match(/#\s*<#\s*[\w.-]+/g);
+    const closeYml = content.match(/#\s*<#\/\s*[\w.-]+/g);
+
+    if (openYml) {
+      openCount += openYml.length;
+    }
+    if (closeYml) {
+      closeCount += closeYml.length;
+    }
+  }
+
+  if (openCount !== closeCount) {
+    throw new Error(
+      `[mergeHooks] Malformed hook tags in '${filePath}': found ` +
+      `${openCount} open tag(s) but ${closeCount} close tag(s). ` +
+      `Aborting to prevent code loss.`
+    );
+  }
+}
+
+function _warnOrphanedHooks(
+  filePath,
+  sourceContent,
+  artifactContent,
+  matchers
+) {
+  const anyTagRegex = new RegExp(matchers.anyTag.source, 'gm');
+  let match = anyTagRegex.exec(sourceContent);
+
+  while (match !== null) {
+    const tagName = _extractTagName(match[1], match[3]);
+    let body = '';
+    if (typeof match[2] === 'string') {
+      body = match[2];
+    } else if (typeof match[4] === 'string') {
+      body = match[4];
+    }
+
+    if (tagName && body.trim().length > 0) {
+      const templatePattern = matchers.tagPattern(tagName);
+      const existsInTemplate = templatePattern.test(artifactContent);
+      if (!existsInTemplate) {
+        console.warn(
+          `[WARN] [mergeHooks] Hook '${tagName}' in '${filePath}' ` +
+          `contains custom code but is no longer present in template.`
+        );
+      }
+    }
+    match = anyTagRegex.exec(sourceContent);
+  }
+}
+
+function _normalizeHookBlock(hookBlock, tagName) {
+  if (typeof hookBlock !== 'string' || hookBlock.length === 0) {
+    return hookBlock;
+  }
+  const esc = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const openRegex = new RegExp(`(//\\s*\\(<\\s*${esc}\\s*)(?!>)\\)`);
+  const closeRegex = new RegExp(`(//\\s*\\(<\\/\\s*${esc}\\s*)(?!>)\\)`);
+  let normalized = hookBlock.replace(openRegex, '$1>)');
+  normalized = normalized.replace(closeRegex, '$1>)');
+  return normalized;
+}
+
+function _extractTagName(p1, p2) {
+  if (typeof p1 === 'string' && p1.length > 0) {
+    return p1;
+  }
+  if (typeof p2 === 'string' && p2.length > 0) {
+    return p2;
+  }
+  return '';
+}
+
 function hookMatchers(filePath) {
-  if (filePath.endsWith('.js')) {
+  const lower = filePath.toLowerCase();
+  if (
+    lower.endsWith('.js') ||
+    lower.endsWith('.mjs') ||
+    lower.endsWith('.cjs')
+  ) {
+    const jsP1 =
+      '\\/\\/\\s*\\(<\\s*([\\w.-]+)\\s*>?\\s*\\)([\\s\\S]*?)' +
+      '\\/\\/\\s*\\(<\\/\\s*\\1\\s*>?\\s*\\)';
+    const jsP2 =
+      '\\/\\/\\s*<#\\s*([\\w.-]+)\\s*#>([\\s\\S]*?)' +
+      '\\/\\/\\s*<#\\/\\s*\\3\\s*#>';
     return {
-      anyTag: /(?:\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)|\/\/\s*<#(\w+)#>([\s\S]*?)\/\/\s*<#\/\3#>)/gm,
-      tagPattern: (name) =>
-        new RegExp(
-          `(?:\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)|\\/\\/\\s*<#${name}#>([\\s\\S]*?)\\/\\/\\s*<#\\/${name}#>)`,
-          'gm'
-        )
+      anyTag: new RegExp(`(?:${jsP1}|${jsP2})`, 'gm'),
+      tagPattern: (name) => {
+        const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const p1 =
+          `\\/\\/\\s*\\(<\\s*${esc}\\s*>?\\s*\\)([\\s\\S]*?)` +
+          `\\/\\/\\s*\\(<\\/\\s*${esc}\\s*>?\\s*\\)`;
+        const p2 =
+          `\\/\\/\\s*<#\\s*${esc}\\s*#>([\\s\\S]*?)` +
+          `\\/\\/\\s*<#\\/\\s*${esc}\\s*#>`;
+        return new RegExp(`(?:${p1}|${p2})`, 'gm');
+      }
     };
   }
-  if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+  if (lower.endsWith('.yml') || lower.endsWith('.yaml')) {
+    const ymlPattern =
+      '#\\s*<#\\s*([\\w.-]+)\\s*#>([\\s\\S]*?)' +
+      '#\\s*<#\\/\\s*\\1\\s*#>';
     return {
-      anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
-      tagPattern: (name) =>
-        new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
+      anyTag: new RegExp(ymlPattern, 'gm'),
+      tagPattern: (name) => {
+        const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(
+          `#\\s*<#\\s*${esc}\\s*#>([\\s\\S]*?)#\\s*<#\\/\\s*${esc}\\s*#>`,
+          'gm'
+        );
+      }
     };
   }
   return null;

package/src/plan/domainRegistry.js

@@ -58,6 +58,12 @@ import {
   ledgerObjectSchemaManagedPaths,
   ledgerRelationshipSchemaManagedPaths
 } from '../emit/schemas/ledger/emitLedgerSchemas.js';
+import {
+  emitPropertyValueObjectSchemas,
+  emitPropertyValueRelationshipSchemas,
+  propertyValueObjectSchemaManagedPaths,
+  propertyValueRelationshipSchemaManagedPaths
+} from '../emit/schemas/propertyValue/emitPropertyValueSchemas.js';
 import {
   emitErrorSchemas,
   errorSchemaManagedPaths
@@ -85,7 +91,9 @@ export async function resolveEmissionGroups(context) {
     resource,
     coreFunction,
     systemText,
-    errorSchemas
+    errorSchemas,
+    ledgerObjectArtifacts,
+    ledgerRelationshipArtifacts
   ] = await Promise.all([
     emitCrudApplicationArtifacts({
       objects,
@@ -125,6 +133,14 @@ export async function resolveEmissionGroups(context) {
       project,
       errors,
       objectGraphServiceTags
+    }),
+    emitLedgerObjectSchemas({
+      objects,
+      serviceTag: project.serviceTag
+    }),
+    emitLedgerRelationshipSchemas({
+      objects,
+      serviceTag: project.serviceTag
     })
   ]);
 
@@ -204,15 +220,25 @@ export async function resolveEmissionGroups(context) {
     {
       scope: 'ledger-object-schemas',
       managedPaths: ledgerObjectSchemaManagedPaths(objects),
-      artifacts: emitLedgerObjectSchemas({
+      artifacts: ledgerObjectArtifacts
+    },
+    {
+      scope: 'ledger-relationship-schemas',
+      managedPaths: ledgerRelationshipSchemaManagedPaths(objects),
+      artifacts: ledgerRelationshipArtifacts
+    },
+    {
+      scope: 'property-value-object-schemas',
+      managedPaths: propertyValueObjectSchemaManagedPaths(objects),
+      artifacts: emitPropertyValueObjectSchemas({
         objects,
         serviceTag: project.serviceTag
       })
     },
     {
-      scope: 'ledger-relationship-schemas',
-      managedPaths: ledgerRelationshipSchemaManagedPaths(objects),
-      artifacts: emitLedgerRelationshipSchemas({
+      scope: 'property-value-relationship-schemas',
+      managedPaths: propertyValueRelationshipSchemaManagedPaths(objects),
+      artifacts: emitPropertyValueRelationshipSchemas({
         objects,
         serviceTag: project.serviceTag
       })

package/task.md

@@ -0,0 +1,76 @@
+# Task Checklist: Attribute Tree Single-Service Code Generation Consolidation
+
+> **Canonical Architecture Plan**: [[10.Systems/GenerateServiceCode/30-Generation/Task Roadmap - Attribute Tree Per-Repo Generation Refactoring|Task Roadmap in Obsidian]]  
+> **Selected Design**: **Single Main Service (Self-Repo Consolidation)** + **Style 1 (`generatedCode/<domain>/`)**  
+> **Repository**: `IzaraCore-SupportServices-GenerateServiceCode-Seagame`
+
+---
+
+## 🎯 Target Architecture: Single Unified Service (Self-Repo)
+
+All schemas for an `attributeTree` (Tree nodes, Standard Value Handler node, and cascading PropertyValue nodes) are emitted directly inside the **Main Service** workspace:
+
+```text
+app/src/schemas/
+├── ObjectSchemas/
+│   ├── sellOffer.js                                        <-- Source ObjectSchema
+│   └── generatedCode/
+│       ├── attributeTree/
+│       │   ├── sellOfferTermLink.js                        <-- Link Node
+│       │   ├── sellOfferTermValue.js                       <-- Value Node
+│       │   ├── sellOfferTermLabel.js                       <-- Label Node
+│       │   └── sellOfferTermValueStandard.js               <-- Handler Node (Self-Repo)
+│       │
+│       └── propertyValue/                                  <-- Cascading from ValueStandard
+│           ├── sellOfferTermValueStandardPropertyLabel.js
+│           └── sellOfferTermValueStandardPropertyValue.js
+│
+└── RelationshipSchemas/
+    └── generatedCode/
+        ├── attributeTree/
+        │   ├── hasSellOfferTermLink.js
+        │   ├── disabledSellOfferTermLink.js
+        │   ├── isSellOfferTerm.js
+        │   └── isSellOfferTermLabel.js
+        │
+        └── propertyValue/
+            ├── hasSellOfferTermValueStandardPropertyValue.js
+            ├── disabledSellOfferTermValueStandardPropertyValue.js
+            └── isSellOfferTermValueStandardPropertyLabel.js
+```
+
+---
+
+## 📋 Implementation Checklist
+
+- [x] **TASK-01: Recursive Schema Loading & Directives Loader**
+  - **File**: `src/compile/loadSchemas.js`
+  - **Acceptance Criteria**: `loadLocalSchemaDirectory(project, 'ObjectSchemas')` discovers and validates schemas nested inside `generatedCode/**`.
+
+- [x] **TASK-02: Consolidate ValueStandard into `emitAttributeTreeSchemas.js`**
+  - **File**: `src/emit/schemas/attributeTree/emitAttributeTreeSchemas.js`
+  - **Action**:
+    1. Emit `${tag}ValueStandard.js` directly within `emitAttributeTreeObjectSchemas`.
+    2. Add `${tag}ValueStandard.js` to `attributeTreeObjectSchemaManagedPaths`.
+    3. Include preservation hook `//(<addOnDataStructure${tag}ValueStandard>)` with commented `propertyValue` addOn template.
+  - **Acceptance Criteria**: Single-service attributeTree generates all 4 ObjectSchemas (`Link`, `Value`, `Label`, `ValueStandard`).
+
+- [x] **TASK-03: Remove Target Directive Scope & Dead Code**
+  - **Files**:
+    - `src/plan/domainRegistry.js` (Removed `attribute-tree-target-value-standard` scope & unused `directives` param)
+    - `src/emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js` (Deleted dead file)
+    - `src/compile/loadSchemas.js` (Removed obsolete `loadGenerateDirectives`)
+    - `src/generate.js` (Removed `loadGenerateDirectives` call & `directives` passing)
+    - `test/unit/schemas/attributeTreeSingleService.test.js` (Removed obsolete directive loader tests)
+  - **Acceptance Criteria**: Clean scope tracking under `attribute-tree-object-schemas` with zero dead directive loading.
+
+- [x] **TASK-04: Single-Service & Cascading Integration Verification**
+  - **File**: `test/unit/schemas/attributeTreeSingleService.test.js`
+  - **Action**: Verifies single-service generation and cascading generation to `propertyValue` within the same repository.
+  - **Acceptance Criteria**: 100% passing tests with zero cross-repo write or external directive needed.
+
+- [x] **TASK-05: Synchronize Vault & Documentation**
+  - **Vault Files**:
+    - `10.Systems/GenerateServiceCode/20-Schema/Dynamic Schema.md`
+    - `40.Vault/Operations/timeline-log.md`
+    - `40.Vault/Memory/active-context.md`

package/test/integration/graphDrivenFlowSchema.test.js

@@ -544,6 +544,64 @@ test('validateFlowSchema passes for s3 event with valid bucketName', () => {
   );
 });
 
+test('validateFlowSchema passes for s3 event with explicit S3 flowSteps', () => {
+  assert.equal(
+    validateFlowSchema({
+      flowTag: 'uploadFlow',
+      event: ['s3'],
+      bucketName: 'MyUploadBucket',
+      flowSteps: [
+        { stepName: 'CreateObject', event: ['wbs'] },
+        { stepName: 'ReservedLimit', event: ['sqs'] },
+        { stepName: 'CreatePreSignUrl', event: ['sqs'] },
+        { stepName: 'ProcessAfterUpload', event: ['s3'] },
+        { stepName: 'ConfirmAfterUpload', event: ['sqs'] }
+      ]
+    }),
+    true
+  );
+});
+
+test('validateFlowSchema passes for s3 event without flowSteps', () => {
+  assert.equal(
+    validateFlowSchema({
+      flowTag: 'uploadFlow',
+      event: ['s3'],
+      bucketName: 'MyUploadBucket'
+    }),
+    true
+  );
+});
+
+test('validateFlowSchema rejects s3 event with invalid entry stepName', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'uploadFlow',
+        event: ['s3'],
+        bucketName: 'MyUploadBucket',
+        flowSteps: [{ stepName: 'InvalidEntry' }]
+      }),
+    /Entry step flowSteps\[0\] for s3 flow must have stepName 'CreateObject' or 'Start'/
+  );
+});
+
+test('validateFlowSchema rejects s3 event with invalid non-entry stepName', () => {
+  assert.throws(
+    () =>
+      validateFlowSchema({
+        flowTag: 'uploadFlow',
+        event: ['s3'],
+        bucketName: 'MyUploadBucket',
+        flowSteps: [
+          { stepName: 'CreateObject' },
+          { stepName: 'InvalidStep' }
+        ]
+      }),
+    /is invalid for s3 flow/
+  );
+});
+
 test('validateFlowSchema rejects event with storedCache or triggerCache as invalid event', () => {
   assert.throws(
     () =>

package/test/integration/publicApi.test.js

@@ -208,7 +208,7 @@ test('generate commits the system WebSocket completion path for own-topic flows'
   assert.match(webSocketComplete, /\(\<createIdentifiersFlow\>\)/);
   assert.match(webSocketComplete, /\(\<beforePostMessage\>\)/);
   assert.match(webSocketComplete, /postToConnection\(_izContext,/);
-  const webSocketHandler = await readFile(
+    const webSocketHandler = await readFile(
     join(
       rootPath,
       'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source/WebSocketComplete_HdrSqs.js'
@@ -217,6 +217,49 @@ test('generate commits the system WebSocket completion path for own-topic flows'
   );
   assert.match(webSocketHandler, /record\.body\.TopicArn/);
   assert.match(webSocketHandler, /addCallingFlowToPassOnProperties/);
+
+  const registerComplete = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/SystemFlowSchemas/Register/source/RegisterComplete_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(registerComplete, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(registerComplete, /getObjectSchema\.getFlowSchemaS3WithCache/);
+
+  const registerMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/SystemFlowSchemas/Register/source/Register_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(registerMain, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(registerMain, /getObjectSchema\.getFlowSchemaS3WithCache/);
+
+  assert.match(webSocketComplete, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(webSocketComplete, /getObjectSchema\.getFlowSchemaS3WithCache/);
+
+  const trackHdrWbs = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/Track/source/Track_HdrWbs.js'
+    ),
+    'utf8'
+  );
+  assert.match(trackHdrWbs, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(trackHdrWbs, /getObjectSchema\.getFlowSchemaS3WithCache/);
+
+  const trackWbsMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/Track/source/Track_WbsMain.js'
+    ),
+    'utf8'
+  );
+  assert.match(trackWbsMain, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(trackWbsMain, /getObjectSchema\.getFlowSchemaS3WithCache/);
 });
 
 test('generate commits the trigger-cache suite with its queues when triggerFlowTypes is set', async () => {
@@ -245,6 +288,16 @@ test('generate commits the trigger-cache suite with its queues when triggerFlowT
     ),
     /CartCheckTriggerFlowsHdrSqs/
   );
+
+  const cartCheckTrigger = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowSchemas/Cart/source/CartCheckTriggerFlows_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(cartCheckTrigger, /getFlowSchema\.getFlowSchemaS3WithCache/);
+  assert.doesNotMatch(cartCheckTrigger, /getObjectSchema\.getFlowSchemaS3WithCache/);
 });
 
 test('generate removes the system WebSocket path when the last own-topic flow is removed', async () => {