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

package/src/emit/application/rbac/templates/ReservedDynamicUsage_Main.ejs

@@ -161,7 +161,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     let passStatus = false;
     if (currentTotal + value <= maxLimit) {
       passStatus = true;
-      const ttlTimestamp = Math.floor(Date.now() / 1000) + 3600;
+      const expirationTime = Math.floor(Date.now() / 1000) + 3600;
 
       await dynamodbSharedLib.putItem(
         _izContext,
@@ -173,7 +173,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
           flowTypeConcat,
           usageCount: value,
           runningTotalUsageStatus: 'reserved',
-          ttlTimestamp
+          expirationTime
         }
       );
 
@@ -196,13 +196,31 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
       identifiersConcat
     };
 
-    await sns.publishMessage(_izContext, {
-      message: { returnResult },
-      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-        _izContext,
-        'ReservedDynamicUsage_Out'
-      )
-    });
+    const eventSourceTag =
+      _izContext.izEventSource?.eventSourceTag ||
+      requestParams?.izEventSource?.eventSourceTag;
+
+    let isSync = false;
+    if (
+      eventSourceTag === 'DirectInvoke' ||
+      eventSourceTag === 'ApiGateway' ||
+      eventSourceTag === 'ApiGatewayV2' ||
+      requestParams?.hasOwnProperty('__context__')
+    ) {
+      isSync = true;
+    }
+
+    if (!isSync) {
+      await sns.publishMessage(_izContext, {
+        message: { returnResult },
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          'ReservedDynamicUsage_Out'
+        )
+      });
+    }
+
+    return returnResult;
   } catch (error) {
     _izContext.logger.error(`[${process.env.iz_serviceTag}:ReservedDynamicUsage] error:`, error);
     throw error;

package/src/emit/application/rbac/templates/UserRbacFlow_Main.ejs

@@ -55,7 +55,8 @@ async function _getL2Cache(_izContext, submittedByUserId, cacheSubKey) {
       userId: submittedByUserId,
       cacheKey: cacheSubKey
     });
-    if (result && result.ttlTimestamp && result.ttlTimestamp > Math.floor(Date.now() / 1000)) {
+    const expTime = result && (result.expirationTime || result.ttlTimestamp);
+    if (expTime && expTime > Math.floor(Date.now() / 1000)) {
       return {
         returnValue: {
           permission: Boolean(result.permission),
@@ -75,14 +76,14 @@ async function _getL2Cache(_izContext, submittedByUserId, cacheSubKey) {
 async function _setL2Cache(_izContext, submittedByUserId, cacheSubKey, value) {
   try {
     const tableName = dynamodbSharedLib.tableName(_izContext, 'RbacPermissionCaches');
-    const ttlTimestamp = Math.floor(Date.now() / 1000) + L2_TTL_SECONDS;
+    const expirationTime = Math.floor(Date.now() / 1000) + L2_TTL_SECONDS;
     await dynamodbSharedLib.putItem(_izContext, tableName, {
       userId: submittedByUserId,
       cacheKey: cacheSubKey,
       permission: value.returnValue ? value.returnValue.permission : value.permission,
       roleIdKey: value.returnValue ? value.returnValue.roleIdKey : value.roleIdKey,
       rbacType: 'target',
-      ttlTimestamp
+      expirationTime
     });
   } catch (error) {
     // Safely ignore L2 write errors if table is not configured

package/src/emit/application/system/templates/Register_HdrWbs.ejs

@@ -27,7 +27,8 @@ export const main = middleware.wrap(async (event, context) => {
             await dynamodbSharedLib.tableName(event._izContext, 'WebSocketTask'),
             {
               taskKey: correlationId,
-              connectionId: connectionId
+              connectionId: connectionId,
+              expirationTime: Math.floor(Date.now() / 1000) + 7200
             }
           );
 

package/src/emit/infrastructure/functions/functionYamlArtifact.js

@@ -181,6 +181,7 @@ export function renderS3FunctionYaml({
   handlerPath,
   roleName,
   bucketName,
+  s3KeyPrefix,
   flowTag,
   flowStepName
 }) {
@@ -189,6 +190,7 @@ export function renderS3FunctionYaml({
     handlerPath,
     roleName,
     bucketName,
+    s3KeyPrefix,
     environmentSetting: _environmentSetting(
       functionName,
       flowTag,
@@ -342,15 +344,8 @@ function _sqsFilterPatterns(
           - body:
               MessageAttributes:
                 callingFlow:
-                  Value:
+                  StringValue:
                     - \${self:custom.iz_resourcePrefix}${callingFlowName}
-          - body:
-              MessageAttributes:
-                callingFlow:
-                  - exists: false
-          - body:
-              MessageAttributes:
-                - exists: false
         #<#/${hookFunctionName}FilterPatterns#>
 `;
 }

package/src/emit/infrastructure/functions/templates/S3Function_Yaml.ejs

@@ -8,9 +8,8 @@
         bucket: <%= bucketName %>
         event: s3:ObjectCreated:*
         existing: true
-        rules:
+        rules:<% if (s3KeyPrefix) { %>
+          - prefix: <%- s3KeyPrefix %><% } %>
         #<#<%= functionName %>rules#>
         #<#/<%= functionName %>rules#>
-          - prefix: uploads/
-          - suffix: .csv
         forceDeploy: true

package/src/emit/infrastructure/resources/iamResourceArtifacts.js

@@ -139,6 +139,25 @@ export function roleStatements(state, roleName) {
       resource: ['arn:aws:s3:::${self:custom.iz_serviceSchemaBucketName}']
     });
   }
+  const s3FlowsForRole = (state.flows || []).filter((candidate) => {
+    const roleCandidate = customFlowRoleName(candidate?.flowTag ?? '');
+    return (
+      roleCandidate === roleName &&
+      includesEvent(candidate, 's3') &&
+      Boolean(candidate.bucketName)
+    );
+  });
+  if (s3FlowsForRole.length > 0) {
+    const bucketResources = [
+      ...new Set(
+        s3FlowsForRole.map((flow) => `arn:aws:s3:::${flow.bucketName}/*`)
+      )
+    ].sort();
+    statements.push({
+      action: ['s3:GetObject'],
+      resource: bucketResources
+    });
+  }
   addStatement(statements, dynamoActionsForRole(roleName), [
     ...dynamoArns(roleTableNames(state, roleName)),
     ...externalDynamoArns(roleExternalDynamoTables(state, roleName))
@@ -479,6 +498,9 @@ export function roleTopicNames(state, roleName) {
     if (flowHasOwnTopic(flow)) {
       topics.push(`${name}_In`);
     }
+    if (includesEvent(flow, 's3')) {
+      topics.push('Create_In');
+    }
     return topics;
   }
   return [];

package/src/emit/infrastructure/resources/resourceState.js

@@ -4,7 +4,8 @@ import {
   flowExtTopicSteps,
   generatedDsqFlows,
   generatedOwnTopicFlows,
-  supportedCustomFlows
+  supportedCustomFlows,
+  resolveS3Parts
 } from '../../application/custom/customFlows.js';
 import { hasSystemWebSocket } from '../../application/system/emitSystemWebSocketArtifacts.js';
 import { rbacFlowTag } from '../../application/rbac/rbacFlowTag.js';
@@ -161,9 +162,12 @@ export function createResourceState({ objects, relationships, flows }) {
 
   for (const flow of flows.filter((flow) => includesEvent(flow, 's3'))) {
     const tag = upperFirst(flow.flowTag);
-    customSqsQueues.push(`${tag}CreatePreSignUrlHdrSqs`);
-    customSqsQueues.push(`${tag}ReservedLimitHdrSqs`);
-    customSqsQueues.push(`${tag}ConfirmAfterUploadHdrSqs`);
+    const parts = resolveS3Parts(flow);
+    for (const part of parts) {
+      if (part.type === 'sqs') {
+        customSqsQueues.push(`${tag}${part.action}HdrSqs`);
+      }
+    }
   }
 
   const customDsqQueues = flows
@@ -281,8 +285,14 @@ export function createResourceState({ objects, relationships, flows }) {
           topicName = `Out${upperFirst(flow.outputTopic)}`;
         }
       }
+      let targetAction = 'ReservedLimit';
+      const parts = resolveS3Parts(flow);
+      const firstSqsPart = parts.find((p) => p.type === 'sqs');
+      if (firstSqsPart && firstSqsPart.action) {
+        targetAction = firstSqsPart.action;
+      }
       const queueName =
-        flow.s3Subscription?.queueName || `${tag}ReservedLimitHdrSqs`;
+        flow.s3Subscription?.queueName || `${tag}${targetAction}HdrSqs`;
       const subscriptionName =
         flow.s3Subscription?.subscriptionName ||
         `Subscription${topicName}To${queueName}`;

package/src/emit/infrastructure/resources/s3ResourceArtifacts.js

@@ -1,13 +1,29 @@
 import { indentYaml, renderResourceTemplate } from './resourceTemplate.js';
 
+export function toAlphanumericPascalCase(str) {
+  if (!str) {
+    return '';
+  }
+  const parts = str.split(/[^a-zA-Z0-9]+/);
+  const validParts = parts.filter(Boolean);
+  const capitalizedParts = validParts.map((word) => {
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  });
+  return capitalizedParts.join('');
+}
+
 export async function renderS3(state) {
   if (state.s3Buckets.length === 0) {
     return '';
   }
   const renderedBuckets = await Promise.all(
-    state.s3Buckets.map((bucketName) =>
-      renderResourceTemplate('S3Bucket_Yaml.ejs', { bucketName })
-    )
+    state.s3Buckets.map((bucketName) => {
+      const bucketLogicalId = `${toAlphanumericPascalCase(bucketName)}S3Bucket`;
+      return renderResourceTemplate('S3Bucket_Yaml.ejs', {
+        bucketName,
+        bucketLogicalId
+      });
+    })
   );
   const body = renderedBuckets.join('\n');
   return `Resources:\n${indentYaml(body, 2)}`;

package/src/emit/infrastructure/resources/templates/S3Bucket_Yaml.ejs

@@ -1,5 +1,5 @@
 ##===== [S3 Bucket: <%- bucketName %>]
-<%- bucketName %>S3Bucket:
+<%- bucketLogicalId %>:
   Type: AWS::S3::Bucket
   Properties:
     BucketName: <%- bucketName %>

package/src/emit/infrastructure/resources/templates/SystemDynamoDB_Yaml.ejs

@@ -230,7 +230,7 @@ Resources:
         - AttributeName: cacheKey
           KeyType: RANGE
       TimeToLiveSpecification:
-        AttributeName: ttlTimestamp
+        AttributeName: expirationTime
         Enabled: true
 
   RunningTotalUsageTable:
@@ -265,7 +265,7 @@ Resources:
         - AttributeName: usedTimestampId
           KeyType: RANGE
       TimeToLiveSpecification:
-        AttributeName: ttlTimestamp
+        AttributeName: expirationTime
         Enabled: true
       StreamSpecification:
         StreamViewType: NEW_AND_OLD_IMAGES

package/src/emit/schemas/error/emitErrorSchemas.js

@@ -1,19 +1,43 @@
+import { existsSync, readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import ejsLib from 'ejs';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 export const ERROR_SCHEMA_PATH =
-  'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js';
+  'app/src/schemas/ErrorSchemas/generateCode/errorConsts.js';
+export const ERROR_CONSTS_PATH = ERROR_SCHEMA_PATH;
+
+export const SHARED_ERROR_PACKAGE_PATH = 'libs/errorLib/package.json';
+export const SHARED_ERROR_INDEX_PATH = 'libs/errorLib/index.js';
+export const SHARED_ERROR_CONSTS_PATH = 'libs/errorLib/src/errorConsts.js';
 
 export function errorSchemaManagedPaths(errors = []) {
   if (!errors || errors.length === 0) {
     return [];
   }
-  return [ERROR_SCHEMA_PATH];
+  const paths = [ERROR_SCHEMA_PATH];
+  const safeErrors = Array.isArray(errors) ? errors : [];
+  let hasShared = false;
+  for (const item of safeErrors) {
+    if (item && item.sharedLibrary === true) {
+      hasShared = true;
+      break;
+    }
+  }
+  if (hasShared) {
+    paths.push(
+      SHARED_ERROR_PACKAGE_PATH,
+      SHARED_ERROR_INDEX_PATH,
+      SHARED_ERROR_CONSTS_PATH
+    );
+  }
+  return paths;
 }
 
 /**
- * Emits errorSchema.js artifact based on loaded ErrorSchemas
+ * Emits errorConsts.js artifact and shared library artifacts based on
+ * loaded ErrorSchemas
  *
  * @param {Object} params
  * @param {Object} params.project
@@ -31,21 +55,28 @@ export async function emitErrorSchemas({
     return [];
   }
 
-  const defaultGraphServiceTag =
-    objectGraphServiceTags[0] || 'GraphHandler';
   const defaultServiceTag = project?.serviceTag || '';
 
   const errorTypes = {};
+  const sharedErrorTypes = {};
+
   for (const item of safeErrors) {
     if (!item || typeof item !== 'object' || !item.errorTag) {
       continue;
     }
     const errorTag = item.errorTag;
-    const serviceTag = item.serviceTag || defaultServiceTag;
-    errorTypes[errorTag] = {
+    let serviceTag = item.serviceTag;
+    if (!serviceTag) {
+      serviceTag = defaultServiceTag;
+    }
+    const errorEntry = {
       errorTag,
       serviceTag
     };
+    errorTypes[errorTag] = errorEntry;
+    if (item.sharedLibrary === true) {
+      sharedErrorTypes[errorTag] = errorEntry;
+    }
   }
 
   const sortedKeys = Object.keys(errorTypes).sort();
@@ -58,16 +89,95 @@ export async function emitErrorSchemas({
     sortedErrorTypes[key] = errorTypes[key];
   }
 
-  const templatePath = new URL('errorSchema.ejs', TEMPLATE_URL);
+  const templatePath = new URL('errorConsts.ejs', TEMPLATE_URL);
   const template = await readFile(templatePath, 'utf8');
   const content = ejsLib.render(template, {
-    errorTypes: sortedErrorTypes
+    errorTypes: sortedErrorTypes,
+    headerComment: null
   });
 
-  return [
+  const artifacts = [
     {
       path: ERROR_SCHEMA_PATH,
       content
     }
   ];
+
+  const sortedSharedKeys = Object.keys(sharedErrorTypes).sort();
+  if (sortedSharedKeys.length > 0) {
+    const sortedSharedErrorTypes = {};
+    for (const key of sortedSharedKeys) {
+      sortedSharedErrorTypes[key] = sharedErrorTypes[key];
+    }
+
+    const sharedContent = ejsLib.render(template, {
+      errorTypes: sortedSharedErrorTypes,
+      headerComment: '// only generate error that sharedLibrary: true'
+    });
+
+    let serviceName = 'service';
+    if (project?.serviceTag) {
+      serviceName = project.serviceTag.toLowerCase();
+    }
+    const packageName = `@izara_project/izara-${serviceName}-library-errorlib`;
+
+    let packageJson = {
+      name: packageName,
+      version: '1.0.0',
+      description: '',
+      type: 'module',
+      main: 'index.js',
+      scripts: {},
+      keywords: [],
+      author: '',
+      license: 'ISC',
+      devDependencies: {},
+      dependencies: {}
+    };
+
+    let targetDir = project?.outputPath;
+    if (!targetDir) {
+      targetDir = project?.rootPath;
+    }
+    if (targetDir) {
+      const existingPkgPath = join(targetDir, SHARED_ERROR_PACKAGE_PATH);
+      if (existsSync(existingPkgPath)) {
+        try {
+          const raw = readFileSync(existingPkgPath, 'utf8');
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === 'object') {
+            packageJson = {
+              ...parsed,
+              name: packageName,
+              type: 'module',
+              main: 'index.js'
+            };
+          }
+        } catch {
+          // If parsing fails (e.g. comments in JSON), use default packageJson
+        }
+      }
+    }
+
+    const packageJsonContent = `${JSON.stringify(packageJson, null, 2)}\n`;
+    const indexContent =
+      "import * as errorLib from './src/errorConsts.js';\n\nexport { errorLib };\n";
+
+    artifacts.push(
+      {
+        path: SHARED_ERROR_PACKAGE_PATH,
+        content: packageJsonContent
+      },
+      {
+        path: SHARED_ERROR_INDEX_PATH,
+        content: indexContent
+      },
+      {
+        path: SHARED_ERROR_CONSTS_PATH,
+        content: sharedContent
+      }
+    );
+  }
+
+  return artifacts;
 }

package/src/emit/schemas/error/templates/errorConsts.ejs

@@ -0,0 +1,12 @@
+<% if (locals.headerComment) { -%>
+<%- headerComment %>
+<% } -%>
+export const ERROR_TYPES = {
+<% const keys = Object.keys(errorTypes); -%>
+<% keys.forEach((key, index) => { -%>
+  <%- key %>: {
+    errorTag: '<%- errorTypes[key].errorTag %>',
+    serviceTag: '<%- errorTypes[key].serviceTag %>'
+  }<%- index < keys.length - 1 ? ',' : '' %>
+<% }); -%>
+};

package/src/generate.js

@@ -1,3 +1,6 @@
+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';
@@ -13,32 +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
-    ] = await Promise.all([
-      loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(
-        project,
-        'RelationshipSchemas',
-        schemaLoadOptions
-      ),
-      loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(
-        project,
-        'NotificationSchemas',
-        schemaLoadOptions
-      ),
-      loadLocalSchemaDirectory(project, 'ErrorSchemas', 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
@@ -58,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)
         );
       }
     }
@@ -107,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/plan/domainRegistry.js

@@ -145,7 +145,8 @@ export async function resolveEmissionGroups(context) {
   ]);
 
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
-    objects
+    objects,
+    relationships
   });
 
   let systemFunctions = [];

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>\)/);
   }
 );