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

package/test/unit/infrastructure/functionYamlArtifact.test.js

@@ -83,14 +83,16 @@ test('filters all SQS functions by their calling flow', () => {
     /#<#CreateCompleteHdrSqsFilterPatterns#>[\s\S]*filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateCompleteHdrSqs/
   );
   assert.match(completion, /#<#\/CreateCompleteHdrSqsFilterPatterns#>/);
-  assert.match(completion, /callingFlow:\s*\n\s*- exists: false/);
-  assert.match(completion, /MessageAttributes:\s*\n\s*- exists: false/);
+  assert.match(completion, /callingFlow:\s*\n\s*StringValue:/);
+  assert.doesNotMatch(completion, /callingFlow:\s*\n\s*- exists: false/);
+  assert.doesNotMatch(completion, /MessageAttributes:\s*\n\s*- exists: false/);
   assert.match(
     ordinary,
     /#<#CreateHdrSqsFilterPatterns#>[\s\S]*filterPatterns:[\s\S]*\$\{self:custom\.iz_resourcePrefix\}CreateHdrSqs/
   );
   assert.match(ordinary, /#<#\/CreateHdrSqsFilterPatterns#>/);
-  assert.match(ordinary, /callingFlow:\s*\n\s*- exists: false/);
-  assert.match(ordinary, /MessageAttributes:\s*\n\s*- exists: false/);
+  assert.match(ordinary, /callingFlow:\s*\n\s*StringValue:/);
+  assert.doesNotMatch(ordinary, /callingFlow:\s*\n\s*- exists: false/);
+  assert.doesNotMatch(ordinary, /MessageAttributes:\s*\n\s*- exists: false/);
 });
 

package/test/unit/infrastructure/resourceArtifacts.test.js

@@ -7,6 +7,10 @@ import test, { after } from 'node:test';
 process.env.NODE_ENV = 'test';
 
 import { generateResourceArtifacts } from '../../../src/emit/infrastructure/resources/generateResourceArtifacts.js';
+import {
+  renderS3,
+  toAlphanumericPascalCase
+} from '../../../src/emit/infrastructure/resources/s3ResourceArtifacts.js';
 
 const roots = new Set();
 after(() =>
@@ -909,3 +913,50 @@ async function createProject() {
   );
   return rootPath;
 }
+
+test('toAlphanumericPascalCase converts non-alphanumeric strings to PascalCase', () => {
+  assert.equal(
+    toAlphanumericPascalCase('video-record-temp-test'),
+    'VideoRecordTempTest'
+  );
+  assert.equal(
+    toAlphanumericPascalCase('video.record_temp-test'),
+    'VideoRecordTempTest'
+  );
+  assert.equal(toAlphanumericPascalCase('AlreadyPascal'), 'AlreadyPascal');
+  assert.equal(toAlphanumericPascalCase(''), '');
+});
+
+test('renderS3 generates alphanumeric PascalCase Logical ID for CloudFormation', async () => {
+  const yaml = await renderS3({
+    s3Buckets: ['video-record-temp-test']
+  });
+  assert.ok(
+    yaml.includes('VideoRecordTempTestS3Bucket:'),
+    'Logical ID must be alphanumeric PascalCase without hyphens'
+  );
+  assert.ok(
+    !yaml.includes('video-record-temp-testS3Bucket:'),
+    'Logical ID must not contain hyphens'
+  );
+  assert.ok(
+    yaml.includes('BucketName: video-record-temp-test'),
+    'BucketName property must preserve original bucket name'
+  );
+});
+
+test('roleStatements emits s3:GetObject for custom S3 flow bucket', async () => {
+  const rootPath = await createProject();
+  await generateResourceArtifacts(rootPath);
+  const iam = await readFile(
+    join(
+      rootPath,
+      'app/sls_yaml/generatedCode/source/generate-shared-resource.yml'
+    ),
+    'utf8'
+  );
+  const uploadRole = roleBlock(iam, 'UploadRole');
+  assert.match(uploadRole, /s3:GetObject/);
+  assert.match(uploadRole, /arn:aws:s3:::UploadBucket\/\*/);
+});
+

package/test/unit/schemas/dynamicRbacFlowSchemas.test.js

@@ -26,7 +26,8 @@ const STATIC_RBAC_ACTIONS = [
 const STATIC_LIMIT_ACTIONS = [
   'ReservedDynamicUsage',
   'ConfirmUsage',
-  'CancelUsage'
+  'CancelUsage',
+  'ReservedUsageTtlExpired'
 ];
 
 after(async () => {
@@ -113,11 +114,12 @@ test('generates shared and object-specific RBAC flow schemas', async () => {
     'lambdaSyncInv',
     'lambdaSyncApi'
   ]);
-  assert.deepEqual(cancelUsage.event, [
-    'ownTopic',
-    'lambdaSyncInv',
-    'lambdaSyncApi'
-  ]);
+  const reservedUsageTtlExpired = await readGeneratedFlow(
+    rootPath,
+    'ReservedUsageTtlExpired',
+    'FlowLimit'
+  );
+  assert.deepEqual(reservedUsageTtlExpired.event, ['dss']);
 });
 
 test('removes RBAC schemas when the last RBAC object is removed', async () => {

package/test/unit/schemas/dynamicRelationshipFlowSchemas.test.js

@@ -6,6 +6,7 @@ import test, { after } from 'node:test';
 import { pathToFileURL } from 'node:url';
 
 import { generateDynamicRelationshipFlowSchemas } from '../../../src/emit/application/relationship/generateDynamicRelationshipFlowSchemas.js';
+import { loadLocalSchemaDirectory } from '../../../src/compile/loadSchemas.js';
 
 const RELATIONSHIP_ACTIONS = [
   'CreateRelationship',
@@ -136,6 +137,56 @@ test('does not allow options to override the rootPath argument', async () => {
   );
 });
 
+test('validates relationship schemas with systemNoUser and systemWithUser generatedBy', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-rel-val-')
+  );
+  projectRoots.add(rootPath);
+  const relationshipDirectory = join(
+    rootPath,
+    'app/src/schemas/RelationshipSchemas'
+  );
+  await mkdir(relationshipDirectory, { recursive: true });
+  const relSchema = [
+    {
+      isItemLabel: {
+        fieldNames: {},
+        storageResources: {
+          myGraph: { storageType: 'graph', graphServerTag: 'GraphHandler' }
+        },
+        generatedBy: 'systemNoUser',
+        links: [
+          {
+            storageResourceTags: ['myGraph'],
+            from: {
+              objType: { serviceTag: 'ItemSvc', objectType: 'itemValue' },
+              linkType: 'many',
+              requiredOnCreate: true
+            },
+            to: {
+              objType: { serviceTag: 'ItemSvc', objectType: 'itemLabel' },
+              linkType: 'one'
+            }
+          }
+        ]
+      }
+    }
+  ];
+  await writeFile(
+    join(relationshipDirectory, 'isItemLabel.js'),
+    `export default ${JSON.stringify(relSchema, null, 2)};\n`
+  );
+
+  const schemas = await loadLocalSchemaDirectory(
+    { schemaRoot: join(rootPath, 'app/src/schemas') },
+    'RelationshipSchemas',
+    { validateSchemas: true }
+  );
+
+  assert.equal(schemas.length, 1);
+  assert.equal(schemas[0].isItemLabel.generatedBy, 'systemNoUser');
+});
+
 async function createProject({ singletonExport = false } = {}) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-relationship-')

package/test/unit/schemas/errorSchemas.test.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { readFile, rm, writeFile, mkdir } from 'node:fs/promises';
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import test, { after } from 'node:test';
@@ -7,7 +7,10 @@ import test, { after } from 'node:test';
 import {
   emitErrorSchemas,
   errorSchemaManagedPaths,
-  ERROR_SCHEMA_PATH
+  ERROR_SCHEMA_PATH,
+  SHARED_ERROR_PACKAGE_PATH,
+  SHARED_ERROR_INDEX_PATH,
+  SHARED_ERROR_CONSTS_PATH
 } from '../../../src/emit/schemas/error/emitErrorSchemas.js';
 import { generate } from '../../../src/generate.js';
 
@@ -49,7 +52,7 @@ test('emitErrorSchemas produces expected ERROR_TYPES for graph and general error
     ]
   });
 
-  assert.equal(artifacts.length, 1);
+  assert.equal(artifacts.length, 4);
   assert.equal(artifacts[0].path, ERROR_SCHEMA_PATH);
 
   const content = artifacts[0].content;
@@ -86,6 +89,31 @@ test('emitErrorSchemas produces expected ERROR_TYPES for graph and general error
   assert.ok(customIdx < explicitIdx);
   assert.ok(explicitIdx < invalidIdx);
   assert.ok(invalidIdx < notFoundIdx);
+
+  // Shared library artifacts
+  assert.equal(artifacts[1].path, SHARED_ERROR_PACKAGE_PATH);
+  const parsedPkg = JSON.parse(artifacts[1].content);
+  assert.equal(
+    parsedPkg.name,
+    '@izara_project/izara-myservice-library-errorlib'
+  );
+
+  assert.equal(artifacts[2].path, SHARED_ERROR_INDEX_PATH);
+  assert.match(
+    artifacts[2].content,
+    /import \* as errorLib from '\.\/src\/errorConsts\.js';/
+  );
+
+  assert.equal(artifacts[3].path, SHARED_ERROR_CONSTS_PATH);
+  const sharedContent = artifacts[3].content;
+  assert.match(
+    sharedContent,
+    /\/\/ only generate error that sharedLibrary: true/
+  );
+  assert.match(sharedContent, /INVALID_GENERATED_BY:/);
+  assert.match(sharedContent, /NOT_FOUND_SCHEMA:/);
+  assert.doesNotMatch(sharedContent, /CUSTOM_INTERNAL_ERROR:/);
+  assert.doesNotMatch(sharedContent, /EXPLICIT_SERVICE_ERROR:/);
 });
 
 test('emitErrorSchemas returns empty array when no errors provided', async () => {
@@ -97,9 +125,18 @@ test('emitErrorSchemas returns empty array when no errors provided', async () =>
   assert.deepEqual(artifacts, []);
   assert.deepEqual(errorSchemaManagedPaths([]), []);
   assert.deepEqual(errorSchemaManagedPaths(['someError']), [ERROR_SCHEMA_PATH]);
+  assert.deepEqual(
+    errorSchemaManagedPaths([{ errorTag: 'E1', sharedLibrary: true }]),
+    [
+      ERROR_SCHEMA_PATH,
+      SHARED_ERROR_PACKAGE_PATH,
+      SHARED_ERROR_INDEX_PATH,
+      SHARED_ERROR_CONSTS_PATH
+    ]
+  );
 });
 
-test('generate creates errorSchema.js when ErrorSchemas directory exists', async () => {
+test('generate creates errorConsts.js and libs/errorLib when ErrorSchemas directory exists', async () => {
   const rootPath = join(
     tmpdir(),
     `error-schema-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
@@ -141,7 +178,7 @@ test('generate creates errorSchema.js when ErrorSchemas directory exists', async
 
   const targetFile = join(
     rootPath,
-    'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js'
+    'app/src/schemas/ErrorSchemas/generateCode/errorConsts.js'
   );
   const content = await readFile(targetFile, 'utf8');
 
@@ -151,4 +188,46 @@ test('generate creates errorSchema.js when ErrorSchemas directory exists', async
   assert.match(content, /MISSING_USER_NODE:/);
   assert.match(content, /serviceTag:\s*'CategoryTreeStandard'/);
   assert.doesNotMatch(content, /export default/);
+
+  // Verify libs/errorLib files
+  const pkgFile = join(rootPath, 'libs/errorLib/package.json');
+  const pkgContent = JSON.parse(await readFile(pkgFile, 'utf8'));
+  assert.equal(
+    pkgContent.name,
+    '@izara_project/izara-categorytreestandard-library-errorlib'
+  );
+
+  const indexFile = join(rootPath, 'libs/errorLib/index.js');
+  const indexContent = await readFile(indexFile, 'utf8');
+  assert.match(indexContent, /export { errorLib };/);
+
+  const sharedConstsFile = join(rootPath, 'libs/errorLib/src/errorConsts.js');
+  const sharedConstsContent = await readFile(sharedConstsFile, 'utf8');
+  assert.match(
+    sharedConstsContent,
+    /\/\/ only generate error that sharedLibrary: true/
+  );
+  assert.match(sharedConstsContent, /NOT_FOUND_SCHEMA:/);
+  assert.match(sharedConstsContent, /INVALID_GENERATED_BY:/);
+  assert.match(sharedConstsContent, /MISSING_USER_NODE:/);
+});
+
+test('generate creates ErrorSchemas directory if it does not exist', async () => {
+  const rootPath = join(
+    tmpdir(),
+    `error-schema-dir-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  roots.add(rootPath);
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    'main_config:\n  iz_serviceTag: TestService\n'
+  );
+
+  await generate(rootPath);
+
+  const errorSchemasDir = join(rootPath, 'app/src/schemas/ErrorSchemas');
+  const dirStat = await stat(errorSchemasDir);
+  assert.ok(dirStat.isDirectory());
 });