@izara_project/izara-core-generate-service-code 1.0.98 → 1.0.100

package/src/generate.js

@@ -1,10 +1,12 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
 import { buildGenerationPlan } from './plan/buildGenerationPlan.js';
 import { resolveEmissionGroups } from './plan/domainRegistry.js';
 import { commitArtifacts } from './output/commitArtifacts.js';
 import { compileProject } from './compile/compileProject.js';
 import {
   loadLocalSchemaDirectory,
-  loadGenerateDirectives,
   resolveExtendedObjectSchemas,
   resolveGraphServiceTags
 } from './compile/loadSchemas.js';
@@ -14,34 +16,32 @@ export async function generate(rootPath, options = {}) {
   console.log(`[INFO] [Generate] STATUS=STARTED | rootPath=${rootPath}`);
   try {
     const project = compileProject({ ...options, rootPath });
+    await mkdir(join(project.schemaRoot, 'ErrorSchemas'), {
+      recursive: true
+    });
     const schemaLoadOptions = {
       skipValidation: options.skipValidation
     };
-    const [
-      rawObjects,
-      relationships,
-      flows,
-      notifications,
-      errors,
-      directives
-    ] = await Promise.all([
-      loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(
-        project,
-        'RelationshipSchemas',
-        schemaLoadOptions
-      ),
-      loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(
-        project,
-        'NotificationSchemas',
-        schemaLoadOptions
-      ),
-      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions),
-      loadGenerateDirectives(project, schemaLoadOptions)
-    ]);
+    const [rawObjects, relationships, flows, notifications, errors] =
+      await Promise.all([
+        loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
+        loadLocalSchemaDirectory(
+          project,
+          'RelationshipSchemas',
+          schemaLoadOptions
+        ),
+        loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
+        loadLocalSchemaDirectory(
+          project,
+          'NotificationSchemas',
+          schemaLoadOptions
+        ),
+        loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
+      ]);
     const schemaBucketName =
-      options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
+      options.schemaBucketName ||
+      project.schemaBucketName ||
+      process.env.iz_serviceSchemaBucketName;
     const objects = await resolveExtendedObjectSchemas(
       rawObjects,
       schemaBucketName
@@ -61,17 +61,17 @@ export async function generate(rootPath, options = {}) {
     }
     console.log(
       `[INFO] [Generate] STATUS=SCHEMAS_LOADED | ` +
-      `objects=${objects.length}${objectSummary} ` +
-      `relationships=${relationships.length} flows=${flows.length} ` +
-      `notifications=${notifications.length} ` +
-      `errors=${errors.length}`
+        `objects=${objects.length}${objectSummary} ` +
+        `relationships=${relationships.length} flows=${flows.length} ` +
+        `notifications=${notifications.length} ` +
+        `errors=${errors.length}`
     );
     if (options.verbose || process.env.GENERATE_VERBOSE) {
       for (const objectSchema of objects) {
         const objectType = objectSchema.objectType || 'unknown';
         console.log(
           `[DEBUG] [Generate] OBJECT_SCHEMA | objectType=${objectType}\n` +
-          JSON.stringify(objectSchema, null, 2)
+            JSON.stringify(objectSchema, null, 2)
         );
       }
     }
@@ -82,7 +82,6 @@ export async function generate(rootPath, options = {}) {
       flows,
       notifications,
       errors,
-      directives,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger
@@ -111,17 +110,16 @@ export async function generate(rootPath, options = {}) {
     const durationMs = Date.now() - startedAt;
     console.log(
       `[INFO] [Generate] STATUS=FINISHED | ` +
-      `files=${files.length} durationMs=${durationMs}`
+        `files=${files.length} durationMs=${durationMs}`
     );
 
     return { project, durationMs, files };
   } catch (error) {
     console.log(
       `[ERROR] [Generate] STATUS=FAILED | ` +
-      `durationMs=${Date.now() - startedAt}`,
+        `durationMs=${Date.now() - startedAt}`,
       error
     );
     throw error;
   }
 }
-

package/src/output/mergeHooks.js

@@ -40,6 +40,14 @@ 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,
@@ -60,13 +68,105 @@ async function mergeHook(outputRoot, artifact) {
       }
       const hookBlock = matches[count];
       if (hookBlock !== null && hookBlock !== undefined) {
-        return hookBlock;
+        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;
@@ -85,8 +185,8 @@ function hookMatchers(filePath) {
     lower.endsWith('.cjs')
   ) {
     const jsP1 =
-      '\\/\\/\\s*\\(<\\s*([\\w.-]+)\\s*>\\)([\\s\\S]*?)' +
-      '\\/\\/\\s*\\(<\\/\\s*\\1\\s*>\\)';
+      '\\/\\/\\s*\\(<\\s*([\\w.-]+)\\s*>?\\s*\\)([\\s\\S]*?)' +
+      '\\/\\/\\s*\\(<\\/\\s*\\1\\s*>?\\s*\\)';
     const jsP2 =
       '\\/\\/\\s*<#\\s*([\\w.-]+)\\s*#>([\\s\\S]*?)' +
       '\\/\\/\\s*<#\\/\\s*\\3\\s*#>';
@@ -95,8 +195,8 @@ function hookMatchers(filePath) {
       tagPattern: (name) => {
         const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const p1 =
-          `\\/\\/\\s*\\(<\\s*${esc}\\s*>\\)([\\s\\S]*?)` +
-          `\\/\\/\\s*\\(<\\/\\s*${esc}\\s*>\\)`;
+          `\\/\\/\\s*\\(<\\s*${esc}\\s*>?\\s*\\)([\\s\\S]*?)` +
+          `\\/\\/\\s*\\(<\\/\\s*${esc}\\s*>?\\s*\\)`;
         const p2 =
           `\\/\\/\\s*<#\\s*${esc}\\s*#>([\\s\\S]*?)` +
           `\\/\\/\\s*<#\\/\\s*${esc}\\s*#>`;

package/src/plan/domainRegistry.js

@@ -52,10 +52,6 @@ import {
   attributeTreeObjectSchemaManagedPaths,
   attributeTreeRelationshipSchemaManagedPaths
 } from '../emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
-import {
-  emitAttributeTreeTargetValueStandard,
-  attributeTreeTargetValueStandardManagedPaths
-} from '../emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js';
 import {
   emitLedgerObjectSchemas,
   emitLedgerRelationshipSchemas,
@@ -81,7 +77,6 @@ export async function resolveEmissionGroups(context) {
     flows,
     notifications,
     errors,
-    directives = [],
     objectGraphServiceTags,
     relationshipGraphServiceTags,
     logger
@@ -206,11 +201,6 @@ export async function resolveEmissionGroups(context) {
       managedPaths: rbacFlowSchemaManagedPaths(objects),
       artifacts: rbacFlowArtifacts
     },
-    {
-      scope: 'attribute-tree-target-value-standard',
-      managedPaths: attributeTreeTargetValueStandardManagedPaths(directives),
-      artifacts: emitAttributeTreeTargetValueStandard({ directives })
-    },
     {
       scope: 'attribute-tree-object-schemas',
       managedPaths: attributeTreeObjectSchemaManagedPaths(objects),

package/task.md

@@ -1,132 +1,76 @@
-# Task Checklist: Attribute Tree Per-Repo Code Generation Refactoring
+# 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**: **Option C (`GenerateDirectives/`)** + **Style 1 (`generatedCode/<domain>/`)**  
+> **Selected Design**: **Single Main Service (Self-Repo Consolidation)** + **Style 1 (`generatedCode/<domain>/`)**  
 > **Repository**: `IzaraCore-SupportServices-GenerateServiceCode-Seagame`
 
 ---
 
-## 🎯 Target Architecture: Style 1 (`generatedCode/<domain>/`)
+## 🎯 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:
 
-### Target Service (e.g. `SellOfferTermValueStandard`)
 ```text
 app/src/schemas/
-├── GenerateDirectives/
-│   └── sellOfferTermValueStandard.js                       <-- [Directive] Developer creates this
-│
 ├── ObjectSchemas/
+│   ├── sellOffer.js                                        <-- Source ObjectSchema
 │   └── generatedCode/
 │       ├── attributeTree/
-│       │   └── sellOfferTermValueStandard.js               <-- [Emitted by TASK-02]
-│       └── propertyValue/
-│           ├── sellOfferTermValueStandardPropertyLabel.js   <-- [Emitted by PropertyValue addOn]
-│           └── sellOfferTermValueStandardPropertyValue.js   <-- [Emitted by PropertyValue addOn]
+│       │   ├── 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
 ```
 
-### Source Service (Self-Repo)
-```text
-app/src/schemas/
-├── ObjectSchemas/
-│   ├── sellOffer.js                                        <-- Source ObjectSchema
-│   └── generatedCode/
-│       └── attributeTree/
-│           ├── sellOfferTermLink.js
-│           ├── sellOfferTermValue.js
-│           └── sellOfferTermLabel.js
-│
-└── RelationshipSchemas/
-    └── generatedCode/
-        └── attributeTree/
-            ├── hasSellOfferTermLink.js
-            ├── disabledSellOfferTermLink.js
-            ├── isSellOfferTerm.js
-            └── isSellOfferTermLabel.js
-```
-
 ---
 
 ## 📋 Implementation Checklist
 
 - [x] **TASK-01: Recursive Schema Loading & Directives Loader**
   - **File**: `src/compile/loadSchemas.js`
-  - **Action**:
-    1. Update `loadLocalSchemaDirectory(project, directoryName, options)` to recursively find all `.js` files within subdirectories (supporting `ObjectSchemas/generatedCode/**` and `RelationshipSchemas/generatedCode/**`).
-    2. Export `loadGenerateDirectives(project, options)` calling `loadLocalSchemaDirectory(project, 'GenerateDirectives', options)`.
-  - **Acceptance Criteria**: `loadLocalSchemaDirectory(project, 'ObjectSchemas')` discovers and validates schemas nested inside `generatedCode/attributeTree/` and `generatedCode/propertyValue/`. Returns `[]` when `GenerateDirectives` folder is missing.
+  - **Acceptance Criteria**: `loadLocalSchemaDirectory(project, 'ObjectSchemas')` discovers and validates schemas nested inside `generatedCode/**`.
 
-- [x] **TASK-02: Target ValueStandard Schema Emitter**
-  - **File**: `src/emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js` (NEW)
-  - **Action**:
-    1. Filter `directives` for `directive.type === 'attributeTreeTarget'`.
-    2. Emit `{tag}ValueStandard.js` to `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}ValueStandard.js`.
-    3. Include preservation hook `//(<addOnDataStructure${tag}ValueStandard>)` with commented `propertyValue` addOn template.
-    4. Export `attributeTreeTargetValueStandardManagedPaths(directives)`.
-  - **Acceptance Criteria**: Emitted file adheres strictly to Izara backend syntax rules and matches Style 1 output path.
-
-- [x] **TASK-03: Align AttributeTree Self-Repo Emitter to Style 1**
+- [x] **TASK-02: Consolidate ValueStandard into `emitAttributeTreeSchemas.js`**
   - **File**: `src/emit/schemas/attributeTree/emitAttributeTreeSchemas.js`
   - **Action**:
-    1. Update ObjectSchema emission paths from `generatedAttributeTree/` to `generatedCode/attributeTree/`.
-    2. Update RelationshipSchema emission paths from `generatedAttributeTree/` to `generatedCode/attributeTree/`.
-    3. Update `attributeTreeObjectSchemaManagedPaths` and `attributeTreeRelationshipSchemaManagedPaths`.
-  - **Acceptance Criteria**: Self-repo attributeTree schemas output cleanly into `generatedCode/attributeTree/`.
-
-- [x] **TASK-04: Align PropertyValue Emitter to Style 1**
-  - **File**: `src/emit/schemas/propertyValue/emitPropertyValueSchemas.js`
-  - **Action**:
-    1. Update ObjectSchema emission paths from `generatedPropertyValue/` to `generatedCode/propertyValue/`.
-    2. Update RelationshipSchema emission paths from `generatedPropertyValue/` to `generatedCode/propertyValue/`.
-    3. Update `propertyValueObjectSchemaManagedPaths` and `propertyValueRelationshipSchemaManagedPaths`.
-  - **Acceptance Criteria**: PropertyValue schemas output cleanly into `generatedCode/propertyValue/`.
-
-- [x] **TASK-05: Register Managed Scopes in Domain Registry**
-  - **File**: `src/plan/domainRegistry.js`
-  - **Action**:
-    1. Import `emitAttributeTreeTargetValueStandard` and `attributeTreeTargetValueStandardManagedPaths`.
-    2. Register new scope `attribute-tree-target-value-standard`.
-    3. Pass `directives` into `resolveEmissionGroups(context)`.
-  - **Acceptance Criteria**: All 5 dynamic schema scopes registered and tracked in `.generate-service-code-v2-managed.json`.
-
-- [x] **TASK-06: Decouple Generation Pipeline in `src/generate.js`**
-  - **File**: `src/generate.js`
-  - **Action**:
-    1. Load directives: `const directives = await loadGenerateDirectives(project, schemaLoadOptions);`.
-    2. Pass `directives` to `resolveEmissionGroups`.
-    3. Delete lines 104-111 (`targetFiles = await _emitTargetServiceAttributeTreeSchemas(...)`).
-    4. Delete lines 129-186 (`_emitTargetServiceAttributeTreeSchemas` function definition).
-  - **Acceptance Criteria**: Zero cross-repo filesystem writes. Generator operates strictly within `workspaceOutputRoot`.
-
-- [x] **TASK-07: Delete Legacy Cross-Repo Files**
-  - **Files to Delete**:
-    - `src/emit/schemas/attributeTree/resolveTargetServicePath.js`
-    - `src/emit/schemas/attributeTree/emitAttributeTreeTargetSchemas.js`
-  - **Action**: Remove dead files and any unused imports.
-  - **Acceptance Criteria**: `git status` shows clean file deletions.
+    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-08: Unit & Integration Test Verification**
+- [x] **TASK-03: Remove Target Directive Scope & Dead Code**
   - **Files**:
-    - `test/unit/schemas/attributeTreeDirectives.test.js` (NEW)
-    - `test/unit/schemas/attributeTreeSchemas.test.js` (Update paths)
-    - `test/unit/schemas/propertyValueSchemas.test.js` (Update paths)
-  - **Verification Command**: `npm test`
-  - **Acceptance Criteria**: All 198+ tests pass with zero regression.
-
-- [x] **TASK-09: End-to-End Cascading Verification**
-  - **Action**: Verify two-phase generation locally:
-    1. Target service with directive -> generates `sellOfferTermValueStandard.js`.
-    2. Target service uncomments `propertyValue` -> generates PropertyLabel, PropertyValue, and 3 Relationship schemas.
-  - **Acceptance Criteria**: Zero cross-repo dependency required.
-
-- [x] **TASK-10: Synchronize Vault & Taiga Documentation**
+    - `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`
-  - **Taiga Wiki**: Update `generatecode` wiki page.

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

@@ -23,7 +23,7 @@ test('generate commits schemas, application artifacts, and resources in one publ
   const rootPath = await createCrudProject();
   const result = await generate(rootPath);
 
-  assert.strictEqual(result.files.length, 74);
+  assert.strictEqual(result.files.length, 59);
   assert.equal(result.project.rootPath, rootPath);
   assert.match(
     await readFile(
@@ -366,7 +366,7 @@ test('generate removes stale CRUD schemas and application artifacts', async () =
 
   const result = await generate(rootPath);
 
-  assert.equal(result.files.length, 38);
+  assert.equal(result.files.length, 23);
   await assert.rejects(
     readFile(
       join(
@@ -448,36 +448,45 @@ async function createTriggerCacheProject() {
 }
 
 test(
-  'emits ignoreExternalServices hooks in UploadSchema_Main.js and ' +
-    'commands/uploadSchema.js',
+  'emits ignoreExternalServices hooks in commands/uploadSchema.js',
   async () => {
     const rootPath = await createCrudProject();
     await generate(rootPath);
 
-    const uploadSchemaMain = await readFile(
+    // const uploadSchemaMain = await readFile(
+    //   join(
+    //     rootPath,
+    //     'app/src/generatedCode/CoreFunctions/UploadSchema_Main.js'
+    //   ),
+    //   'utf8'
+    // );
+    // assert.match(uploadSchemaMain, /\/\/\(<ignoreExternalServices>\)/);
+    // assert.match(uploadSchemaMain, /\/\/\(<\/ignoreExternalServices>\)/);
+
+    // const coreResource = await readFile(
+    //   join(
+    //     rootPath,
+    //     'app/sls_yaml/generatedCode/source/core-resource.yml'
+    //   ),
+    //   'utf8'
+    // );
+    // assert.match(
+    //   coreResource,
+    //   /UserAccount\$\{self:custom\.iz_stage\}AddLinkCreateByRelHdrInv/
+    // );
+    // assert.match(
+    //   coreResource,
+    //   /UserAccount\$\{self:custom\.iz_stage\}AddLinkBelongToHdrInv/
+    // );
+
+    const uploadSchemaCommand = await readFile(
       join(
         rootPath,
-        'app/src/generatedCode/CoreFunctions/UploadSchema_Main.js'
+        'app/initial_setup/generatedCode/source/commands/uploadSchema.js'
       ),
       'utf8'
     );
-    assert.match(uploadSchemaMain, /\/\/\(<ignoreExternalServices>\)/);
-    assert.match(uploadSchemaMain, /\/\/\(<\/ignoreExternalServices>\)/);
-
-    const coreResource = await readFile(
-      join(
-        rootPath,
-        'app/sls_yaml/generatedCode/source/core-resource.yml'
-      ),
-      'utf8'
-    );
-    assert.match(
-      coreResource,
-      /UserAccount\$\{self:custom\.iz_stage\}AddLinkCreateByRelHdrInv/
-    );
-    assert.match(
-      coreResource,
-      /UserAccount\$\{self:custom\.iz_stage\}AddLinkBelongToHdrInv/
-    );
+    assert.match(uploadSchemaCommand, /\/\/\(<ignoreExternalServices>\)/);
+    assert.match(uploadSchemaCommand, /\/\/\(<\/ignoreExternalServices>\)/);
   }
 );