@izara_project/izara-core-generate-service-code 1.0.83 → 1.0.84

package/src/emit/system/emitSystemWebSocketArtifacts.js

@@ -14,9 +14,9 @@ async function _renderSystemTemplate(templateName, data = {}) {
 
 export async function emitSystemWebSocketArtifacts(
   flows,
-  { includeRelationshipOwnTopic = false } = {}
+  { includeRelationshipOwnTopic = false, objects = [], relationships = [] } = {}
 ) {
-  if (!hasSystemWebSocket(flows, { includeRelationshipOwnTopic })) {
+  if (!hasSystemWebSocket(flows, { includeRelationshipOwnTopic, objects, relationships })) {
     return { artifacts: [], functions: [] };
   }
 
@@ -115,8 +115,10 @@ export function systemWebSocketManagedPaths() {
 
 export function hasSystemWebSocket(
   flows,
-  { includeRelationshipOwnTopic = false } = {}
+  { includeRelationshipOwnTopic = false, objects = [], relationships = [] } = {}
 ) {
+  if (Array.isArray(objects) && objects.length > 0) return true;
+  if (Array.isArray(relationships) && relationships.length > 0) return true;
   return (
     Array.isArray(flows) &&
     flows.some(
@@ -125,8 +127,7 @@ export function hasSystemWebSocket(
         (flow.event.includes('s3') ||
           (includeRelationshipOwnTopic &&
             flow.event.includes('ownTopic') &&
-            (flow.initiateBy === 'user' ||
-              flow.initiateBy === 'systemWithUser')))
+            (flow.initiateBy === 'user' || flow.initiateBy === 'systemWithUser')))
     )
   );
 }

package/src/emit/system/templates/WebSocketConnect.ejs

@@ -1,45 +1,104 @@
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 import {
   middlewareHandler as middleware,
+  consts,
   response
 } from '@izara_project/izara-middleware';
 
 export const main = middleware.wrap(async (event) => {
   const { eventType, connectionId } = event.requestContext ?? {};
   try {
-    event._izContext.logger.debug('Event:', event);
+    event._izContext.logger.debug('[Lib:WebSocketMain:webSocketConnect] Event:', event);
     if (eventType === 'CONNECT') {
-      const { userId, submittedByUserId } = event.queryStringParameters ?? {};
+      const fromCorrelationIds =
+        event._izContext?.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+      const fromAuthorizerSubmittedBy =
+        event.requestContext?.authorizer?.submittedByUserId;
+      const fromAuthorizerPrincipal =
+        event.requestContext?.authorizer?.principalId;
+      const fromQueryString =
+        event.queryStringParameters?.submittedByUserId;
+
+      const submittedByUserId =
+        fromCorrelationIds ||
+        fromAuthorizerSubmittedBy ||
+        fromAuthorizerPrincipal ||
+        fromQueryString;
+
+      event._izContext.logger.debug(
+        '[Lib:WebSocketMain:webSocketConnect] submittedByUserId sources:',
+        {
+          connectionId,
+          fromCorrelationIds,
+          fromAuthorizerSubmittedBy,
+          fromAuthorizerPrincipal,
+          fromQueryString,
+          resolvedSubmittedByUserId: submittedByUserId,
+          authorizer: event.requestContext?.authorizer
+        }
+      );
+
+      const tableName = await dynamodbSharedLib.tableName(
+        event._izContext,
+        'UserUploadRecords'
+      );
+      event._izContext.logger.debug(
+        '[Lib:WebSocketMain:webSocketConnect] Saving connection to table:',
+        {
+          tableName,
+          connectionId,
+          submittedByUserId
+        }
+      );
+
       await dynamodbSharedLib.putItem(
         event._izContext,
-        await dynamodbSharedLib.tableName(
-          event._izContext,
-          'UserUploadRecords'
-        ),
+        tableName,
         {
           connectionId,
-          userId,
           submittedByUserId,
           expirationTime: Math.floor(Date.now() / 1000) + 7200
         }
       );
+      event._izContext.logger.debug(
+        '[Lib:WebSocketMain:webSocketConnect] Successfully stored connection record'
+      );
       //(<webSocketConnect>)
       //(</webSocketConnect>)
     } else if (eventType === 'DISCONNECT') {
+      const tableName = await dynamodbSharedLib.tableName(
+        event._izContext,
+        'UserUploadRecords'
+      );
+      event._izContext.logger.debug(
+        '[Lib:WebSocketMain:webSocketConnect] WebSocket DISCONNECT:',
+        {
+          tableName,
+          connectionId
+        }
+      );
+
       await dynamodbSharedLib.deleteItem(
         event._izContext,
-        await dynamodbSharedLib.tableName(
-          event._izContext,
-          'UserUploadRecords'
-        ),
+        tableName,
         { connectionId }
       );
+      event._izContext.logger.debug(
+        '[Lib:WebSocketMain:webSocketConnect] Successfully deleted connection record'
+      );
       //(<webSocketDisconnect>)
       //(</webSocketDisconnect>)
     }
+
+    event._izContext.logger.debug(
+      '[Lib:WebSocketMain:webSocketConnect] WebSocket event processed successfully'
+    );
     return response.webSocketSuccess();
   } catch (error) {
-    event._izContext.logger.error('Error, WebSocketConnect: ', error);
+    event._izContext.logger.error(
+      '[Lib:WebSocketMain:webSocketConnect] Error: ',
+      error
+    );
     return response.failure(error);
   }
 });

package/src/emit/system/templates/WebSocketConnect_Yaml.ejs

@@ -5,6 +5,13 @@ WebSocketConnect:
   events:
     - websocket:
         route: $connect
+        #<#WebSocketConnectAuthorizer#>
+        authorizer:
+          arn: arn:aws:lambda:${self:custom.iz_region}:${self:custom.iz_accountId}:function:UserAccount${self:custom.iz_stage}UserIdentityAuthorizer
+          identitySource:
+            - 'route.request.header.Authorization'
+            - 'route.request.querystring.access_token'
+        #<#/WebSocketConnectAuthorizer#>
     - websocket:
         route: $disconnect
     - websocket:

package/src/emit/systemText/emitSystemTextSchemas.js

@@ -179,7 +179,7 @@ export async function emitSystemTextSchemas({
     (object) =>
       object?.generatedBy === 'user' ||
       object?.generatedBy === 'systemWithUser' ||
-      object?.generatedBy === 'systemWithNoUser'
+      object?.generatedBy === 'systemNoUser'
   );
   if (hasCrudObjects) {
     for (const action of CRUD_ACTIONS) {

package/src/generate.js

@@ -55,6 +55,12 @@ import {
   emitSystemTextSchemas,
   systemTextSchemaManagedPaths
 } from './emit/systemText/emitSystemTextSchemas.js';
+import {
+  emitAttributeTreeObjectSchemas,
+  emitAttributeTreeRelationshipSchemas,
+  attributeTreeObjectSchemaManagedPaths,
+  attributeTreeRelationshipSchemaManagedPaths
+} from './emit/attributeTree/emitAttributeTreeSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -62,11 +68,15 @@ export async function generate(rootPath, options = {}) {
   logger?.info?.(`[INFO] [Generate] STATUS=STARTED | rootPath=${rootPath}`);
   try {
     const project = compileProject({ ...options, rootPath });
+    const schemaLoadOptions = {
+      logger,
+      skipValidation: options.skipValidation
+    };
     const [rawObjects, relationships, flows, notifications] = await Promise.all([
-      loadLocalSchemaDirectory(project, 'ObjectSchemas'),
-      loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
-      loadLocalSchemaDirectory(project, 'FlowSchemas'),
-      loadLocalSchemaDirectory(project, 'NotificationSchemas')
+      loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(project, 'RelationshipSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions)
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -92,7 +102,8 @@ export async function generate(rootPath, options = {}) {
       flows,
       notifications,
       objectGraphServiceTags,
-      relationshipGraphServiceTags
+      relationshipGraphServiceTags,
+      logger
     });
     logger?.debug?.(
       `[DEBUG] [Generate] STATUS=ARTIFACTS_EMITTED | ${groups.map((group) => `${group.scope}=${group.artifacts.length}`).join(' ')}`
@@ -133,7 +144,8 @@ async function _emitGroups({
   flows,
   notifications,
   objectGraphServiceTags,
-  relationshipGraphServiceTags
+  relationshipGraphServiceTags,
+  logger
 }) {
   const [
     crud,
@@ -148,7 +160,8 @@ async function _emitGroups({
     emitCrudApplicationArtifacts({
       objects,
       flows,
-      serviceTag: project.serviceTag
+      serviceTag: project.serviceTag,
+      logger
     }),
     emitRelationshipApplicationArtifacts({
       relationships,
@@ -157,7 +170,9 @@ async function _emitGroups({
     }),
     emitRbacApplicationArtifacts(objects),
     emitSystemWebSocketArtifacts(flows, {
-      includeRelationshipOwnTopic: true
+      includeRelationshipOwnTopic: true,
+      objects,
+      relationships
     }),
     emitSystemFindDataArtifacts(objects),
     emitResourceArtifacts({ objects, relationships, flows }),
@@ -211,7 +226,7 @@ async function _emitGroups({
     {
       scope: 'crud-flow-schemas',
       managedPaths: dynamicCrudFlowSchemaPaths,
-      artifacts: emitDynamicCrudFlowSchemas({ objects, flows })
+      artifacts: emitDynamicCrudFlowSchemas({ objects, flows, logger })
     },
     {
       scope: 'relationship-flow-schemas',
@@ -226,6 +241,22 @@ async function _emitGroups({
         serviceTag: project.serviceTag
       })
     },
+    {
+      scope: 'attribute-tree-object-schemas',
+      managedPaths: attributeTreeObjectSchemaManagedPaths(objects),
+      artifacts: emitAttributeTreeObjectSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      })
+    },
+    {
+      scope: 'attribute-tree-relationship-schemas',
+      managedPaths: attributeTreeRelationshipSchemaManagedPaths(objects),
+      artifacts: emitAttributeTreeRelationshipSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      })
+    },
     {
       scope: 'crud-application',
       managedPaths: crudApplicationManagedPaths(),
@@ -253,7 +284,7 @@ async function _emitGroups({
     },
     {
       scope: 'custom-flow-application',
-      managedPaths: customFlowApplicationManagedPaths(flows),
+      managedPaths: customFlowApplicationManagedPaths(flows, { objects }),
       artifacts: custom
     },
     {

package/test/attributeTreeSchemas.test.js

@@ -0,0 +1,219 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import {
+  emitAttributeTreeObjectSchemas,
+  emitAttributeTreeRelationshipSchemas,
+  attributeTreeObjectSchemaManagedPaths,
+  attributeTreeRelationshipSchemaManagedPaths
+} from '../src/emit/attributeTree/emitAttributeTreeSchemas.js';
+import { generate } from '../src/generate.js';
+
+const projectRoots = new Set();
+
+after(async () => {
+  await Promise.all(
+    [...projectRoots].map((rootPath) =>
+      rm(rootPath, { recursive: true, force: true })
+    )
+  );
+});
+
+test('emitAttributeTreeObjectSchemas returns 4 object schemas per attributeTree tag', () => {
+  const objects = [
+    {
+      objectType: 'sellOffer',
+      serviceTag: 'SellOfferManager',
+      storageResources: {
+        dynamoDB: {
+          storageType: 'dynamoDB',
+          tableName: 'SellOfferRecords'
+        },
+        myGraph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'attributeTree',
+          attributeTreeTag: 'sellOfferTerm'
+        }
+      ]
+    }
+  ];
+
+  const artifacts = emitAttributeTreeObjectSchemas({ objects });
+  assert.equal(artifacts.length, 4);
+
+  const paths = artifacts.map((a) => a.path);
+  assert.deepEqual(paths, [
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js',
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/attributeSellOfferTermValue.js',
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLabel.js',
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermValueStandard.js'
+  ]);
+
+  for (const artifact of artifacts) {
+    assert.doesNotMatch(artifact.content, /dynamoDB/);
+    assert.match(artifact.content, /GraphHandler/);
+  }
+});
+
+test('emitAttributeTreeRelationshipSchemas returns 4 relationship schemas per attributeTree tag', () => {
+  const objects = [
+    {
+      objectType: 'sellOffer',
+      serviceTag: 'SellOfferManager',
+      storageResources: {
+        dynamoDB: {
+          storageType: 'dynamoDB',
+          tableName: 'SellOfferRecords'
+        },
+        myGraph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'attributeTree',
+          attributeTreeTag: 'sellOfferTerm'
+        }
+      ]
+    }
+  ];
+
+  const artifacts = emitAttributeTreeRelationshipSchemas({
+    objects,
+    serviceTag: 'SellOfferManager'
+  });
+  assert.equal(artifacts.length, 4);
+
+  const paths = artifacts.map((a) => a.path);
+  assert.deepEqual(paths, [
+    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/hasSellOfferTermLink.js',
+    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/disabledSellOfferTermLink.js',
+    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/isSellOfferTerm.js',
+    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/isSellOfferTermLabel.js'
+  ]);
+
+  for (const artifact of artifacts) {
+    assert.doesNotMatch(artifact.content, /dynamoDB/);
+    assert.match(artifact.content, /GraphHandler/);
+  }
+});
+
+test('managed paths return empty array when no attributeTree is present', () => {
+  const objects = [{ objectType: 'user', addOnDataStructure: [] }];
+  assert.deepEqual(attributeTreeObjectSchemaManagedPaths(objects), []);
+  assert.deepEqual(attributeTreeRelationshipSchemaManagedPaths(objects), []);
+  assert.deepEqual(emitAttributeTreeObjectSchemas({ objects }), []);
+  assert.deepEqual(emitAttributeTreeRelationshipSchemas({ objects }), []);
+});
+
+test('generate commits and cleans up attributeTree dynamic schemas', async () => {
+  const rootPath = await createProjectWithAttributeTree({ hasAddOn: true });
+  const result = await generate(rootPath);
+
+  const expectedObjectPath = join(
+    rootPath,
+    'app/src/schemas/ObjectSchemas/generatedAttributeTree/sellOfferTermLink.js'
+  );
+  const expectedRelPath = join(
+    rootPath,
+    'app/src/schemas/RelationshipSchemas/generatedAttributeTree/hasSellOfferTermLink.js'
+  );
+
+  const objectContent = await readFile(expectedObjectPath, 'utf8');
+  assert.match(objectContent, /sellOfferTermLink/);
+  assert.match(objectContent, /GraphHandler/);
+  assert.doesNotMatch(objectContent, /dynamoDB/);
+
+  const relContent = await readFile(expectedRelPath, 'utf8');
+  assert.match(relContent, /hasSellOfferTermLink/);
+  assert.match(relContent, /sellOfferTermLink/);
+
+  // Re-run without addOn to verify stale file cleanup
+  await createProjectWithAttributeTree({ rootPath, hasAddOn: false });
+  await generate(rootPath);
+
+  await assert.rejects(readFile(expectedObjectPath, 'utf8'), {
+    code: 'ENOENT'
+  });
+  await assert.rejects(readFile(expectedRelPath, 'utf8'), {
+    code: 'ENOENT'
+  });
+});
+
+async function createProjectWithAttributeTree({
+  rootPath: existingRoot,
+  hasAddOn = true
+} = {}) {
+  const rootPath =
+    existingRoot || (await mkdtemp(join(tmpdir(), 'izara-attr-tree-test-')));
+  projectRoots.add(rootPath);
+
+  const schemaRoot = join(rootPath, 'app/src/schemas');
+  await mkdir(join(schemaRoot, 'ObjectSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'RelationshipSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'FlowSchemas'), { recursive: true });
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    'service: SellOfferManager\ncustom:\n  serviceTag: SellOfferManager\n'
+  );
+
+  const addOnContent = hasAddOn
+    ? `
+    addOnDataStructure: [
+      {
+        type: 'attributeTree',
+        attributeTreeTag: 'sellOfferTerm'
+      }
+    ],`
+    : '    addOnDataStructure: [],';
+
+  await writeFile(
+    join(schemaRoot, 'ObjectSchemas/SellOffer.js'),
+    `export default [
+  {
+    objectType: 'sellOffer',
+    canDelete: false,
+    generatedBy: 'user',${addOnContent}
+    storageResources: {
+      dynamoDB: {
+        storageType: 'dynamoDB',
+        tableName: 'SellOfferRecords',
+        serviceTag: 'SellOfferManager'
+      },
+      myGraph: {
+        storageType: 'graph',
+        graphServerTag: 'GraphHandler'
+      }
+    },
+    fieldNames: {
+      sellOfferId: {
+        type: 'string',
+        randomOnCreate: true,
+        canUpdate: false,
+        storageResourceTags: ['dynamoDB', 'myGraph']
+      }
+    },
+    identifiers: [
+      {
+        type: 'partitionKey',
+        fieldName: 'sellOfferId'
+      }
+    ]
+  }
+];
+`
+  );
+
+  return rootPath;
+}

package/test/createTargetRoleHandler.test.js

@@ -13,8 +13,22 @@ const OWN_TOPIC_FLOWS = [
   'DeleteRolePermissions',
   'DeleteTargetRole',
   'CreateUserRole',
-  'DeleteUserFromRole'
+  'DeleteUserFromRole',
+  'CreateRoleLimit',
+  'DeleteRoleLimit',
+  'ReservedDynamicUsage',
+  'ConfirmUsage',
+  'CancelUsage'
 ];
+
+const LIMIT_FLOWS = [
+  'CreateRoleLimit',
+  'DeleteRoleLimit',
+  'ReservedDynamicUsage',
+  'ConfirmUsage',
+  'CancelUsage'
+];
+
 after(() =>
   Promise.all(
     [...roots].map((root) => rm(root, { recursive: true, force: true }))
@@ -25,11 +39,15 @@ test('generates RBAC own-topic WebSocket entries alongside their SQS handlers',
   const rootPath = await createProject(true);
   const result = await generateCreateTargetRoleHandler(rootPath);
 
-  assert.equal(result.files.length, 36);
+  assert.equal(result.files.length, 60);
   assert.match(
     await readFile(join(rootPath, result.files[0].path), 'utf8'),
     /CreateTargetRole/
   );
+  assert.match(
+    await readFile(join(rootPath, result.files[0].path), 'utf8'),
+    /roleName = 'owner'/
+  );
   assert.match(
     await readFile(join(rootPath, result.files[1].path), 'utf8'),
     /CreateTargetRoleHdrSqs/
@@ -51,16 +69,53 @@ test('generates RBAC own-topic WebSocket entries alongside their SQS handlers',
     ),
     /ListTargetRole/
   );
-  const yaml = await readFile(
+  assert.match(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowRbac/ValidatorRbac/source/ValidatorRbac_Main.js'
+      ),
+      'utf8'
+    ),
+    /Fast-path triggered: user self-action/
+  );
+  assert.match(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowLimit/ReservedDynamicUsage/source/ReservedDynamicUsage_Main.js'
+      ),
+      'utf8'
+    ),
+    /Math\.min\(maxIncrease, minDecrease\)/
+  );
+  assert.match(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowLimit/CreateRoleLimit/source/CreateRoleLimit_Main.js'
+      ),
+      'utf8'
+    ),
+    /actionType/
+  );
+  const rbacYaml = await readFile(
     join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'),
     'utf8'
   );
+  const limitYaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-limits.yml'),
+    'utf8'
+  );
   for (const flowTag of OWN_TOPIC_FLOWS) {
+    const isLimit = LIMIT_FLOWS.includes(flowTag);
+    const folder = isLimit ? 'FlowLimit' : 'FlowRbac';
+    const yaml = isLimit ? limitYaml : rbacYaml;
     assert.match(
       await readFile(
         join(
           rootPath,
-          `app/src/generatedCode/FlowRbac/${flowTag}/source/${flowTag}_HdrWbs.js`
+          `app/src/generatedCode/${folder}/${flowTag}/source/${flowTag}_HdrWbs.js`
         ),
         'utf8'
       ),

package/test/crudApplicationArtifacts.test.js

@@ -184,7 +184,7 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   assert.equal(await readFile(yamlPath, 'utf8'), yaml);
 });
 
-test('does not add RBAC handlers to Create', async () => {
+test('emits a single Complete RBAC handler for Create without Graph', async () => {
   const rootPath = await createRbacProject();
   const result = await generateCrudApplicationArtifacts(rootPath, {
     serviceTag: 'orders'
@@ -196,13 +196,13 @@ test('does not add RBAC handlers to Create', async () => {
   assert.ok(createPaths.includes(
     'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
   ));
-  assert.ok(!createPaths.includes(
+  assert.ok(createPaths.includes(
     'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'
   ));
   assert.ok(
     !createPaths.some((path) => path.includes('CreateRbacCallback'))
   );
-  assert.doesNotMatch(
+  assert.match(
     await readFile(
       join(
         rootPath,
@@ -341,6 +341,23 @@ test('removes managed CRUD artifacts when no applicable object remains', async (
   );
 });
 
+test('logs warning when ObjectSchema has invalid or non-CRUD generatedBy in crudApplicationArtifacts', async () => {
+  const rootPath = await createProject(false);
+  const warnings = [];
+  const logger = {
+    warn: (msg) => warnings.push(msg)
+  };
+
+  const result = await generateCrudApplicationArtifacts(rootPath, { logger });
+  assert.deepEqual(result.files, []);
+  assert.equal(warnings.length, 1);
+  assert.match(
+    warnings[0],
+    /\[WARN\] \[CRUD Application\] Skipped FlowObjects application artifacts generation/
+  );
+});
+
+
 async function createProject(withCrudObject) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-application-')