@izara_project/izara-core-generate-service-code 1.0.78 → 1.0.79

package/src/emit/crud/crudActionPlan.js

@@ -0,0 +1,82 @@
+export const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+
+export function createCrudActionPlans(objects = []) {
+  const hasGraph = hasGraphStorageResource(objects);
+  const hasRbac = objects.some(
+    (object) => isCrudObject(object) && hasRbacObject(object, objects)
+  );
+
+  return Object.fromEntries(
+    CRUD_ACTIONS.map((action) => [
+      action,
+      createCrudActionPlan(action, { hasGraph, hasRbac })
+    ])
+  );
+}
+
+export function createCrudActionPlan(
+  action,
+  { hasGraph = false, hasRbac = false } = {}
+) {
+  const actionHasRbac = action !== 'Create' && action !== 'Get' && hasRbac;
+  const outputTopic = action !== 'Get';
+
+  return {
+    action,
+    outputTopic,
+    hasGraph: outputTopic && hasGraph,
+    hasRbac: actionHasRbac,
+    hasComplete: outputTopic && (actionHasRbac || hasGraph),
+    hasRbacCallback: outputTopic && actionHasRbac && hasGraph
+  };
+}
+
+export function isCrudObject(object) {
+  return (
+    object?.generatedBy === 'userGenerated' ||
+    object?.generatedBy === 'systemGenerated'
+  );
+}
+
+export function hasGraphStorageResource(objects = []) {
+  return objects.some((object) =>
+    Object.values(object?.storageResources ?? {}).some(
+      (resource) =>
+        resource?.storageType === 'graph' ||
+        resource?.resourceType === 'graph' ||
+        resource?.dbType === 'neo4j' ||
+        resource?.storageTag?.toLowerCase().includes('graph')
+    )
+  );
+}
+
+function hasRbacObject(object, objects = []) {
+  return (
+    hasSelfRbac(object) ||
+    Array.isArray(object?.belongToSchema?.addOnDataStructure) &&
+      object.belongToSchema.addOnDataStructure.some(
+        (addOn) => addOn?.type === 'rbac'
+      ) ||
+    normalizeBelongTo(object).some((target) => {
+      if (target?.serviceTag === 'UserAccount') return true;
+      const matched = objects.find(
+        (candidate) =>
+          candidate?.serviceTag === target?.serviceTag &&
+          candidate?.objectType === target?.objectType
+      );
+      return hasSelfRbac(matched);
+    })
+  );
+}
+
+function hasSelfRbac(object) {
+  return (
+    Array.isArray(object?.addOnDataStructure) &&
+    object.addOnDataStructure.some((addOn) => addOn?.type === 'rbac')
+  );
+}
+
+function normalizeBelongTo(object) {
+  if (!object?.belongTo) return [];
+  return Array.isArray(object.belongTo) ? object.belongTo : [object.belongTo];
+}

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -8,7 +8,13 @@ import {
   renderWbsFunctionYaml
 } from '../function/functionYamlArtifact.js';
 
-const ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+import {
+  CRUD_ACTIONS,
+  createCrudActionPlans,
+  isCrudObject
+} from './crudActionPlan.js';
+
+const ACTIONS = CRUD_ACTIONS;
 const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-objects.yml';
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 const SHARED_TEMPLATE_URL = new URL('../shared/templates/', import.meta.url);
@@ -24,7 +30,7 @@ export async function emitCrudApplicationArtifacts({
   if (!objects.some(isCrudObject)) return [];
 
   const handlers = await Promise.all(
-    ACTIONS.map((action) => emitAction(action, objects, flows, serviceTag))
+    ACTIONS.map((action) => emitAction(action, objects, serviceTag))
   );
   return [
     ...handlers.flatMap((handler) => handler.artifacts),
@@ -43,6 +49,9 @@ export function crudApplicationManagedPaths() {
     ...ACTIONS.flatMap((action) => {
       const source = `app/src/generatedCode/FlowObjects/${action}/source`;
       const paths = [`${source}/${action}_Main.js`];
+      if (action !== 'Get') {
+        paths.unshift(`${source}/${action}LogicalLib.js`);
+      }
       if (action === 'Get') {
         paths.push(`${source}/Get_HdrInv.js`, `${source}/Get_HdrApi.js`);
         paths.push(
@@ -54,10 +63,8 @@ export function crudApplicationManagedPaths() {
           `${source}/${action}_HdrSqs.js`,
           `${source}/${action}_WbsMain.js`,
           `${source}/${action}_HdrWbs.js`,
-          `${source}/${action}BeforeLogical_Main.js`,
-          `${source}/${action}BeforeLogical_HdrSqs.js`
-        );
-        paths.push(
+          `${source}/${action}RbacCallback_Main.js`,
+          `${source}/${action}RbacCallback_HdrSqs.js`,
           `${source}/${action}Complete_Main.js`,
           `${source}/${action}Complete_HdrSqs.js`
         );
@@ -68,25 +75,21 @@ export function crudApplicationManagedPaths() {
   ];
 }
 
-async function emitAction(action, objects, flows, serviceTag) {
+async function emitAction(action, objects, serviceTag) {
   const source = `app/src/generatedCode/FlowObjects/${action}/source`;
   const handlerRoot = `src/generatedCode/FlowObjects/${action}/source`;
-  const generateCode = flows
-    .filter(
-      (flow) =>
-        flow?.generatedCodeConfig?.generatedCodeTag?.toLowerCase() ===
-        action.toLowerCase()
-    )
-    .map((flow) => ({ ...flow.generatedCodeConfig, flowTag: flow.flowTag }));
+  const plan = createCrudActionPlans(objects)[action];
   const mainFileName = `${action}_Main`;
   const shared = {
     flowTag: action,
     upperCaseFlowTag: action,
     topicArn: `${action}_In`,
-    generateCode,
     flow: null,
     flowStepName: '',
-    startConfig: null
+    startConfig: null,
+    objects: action === 'Create' ? [] : objects,
+    isCrudObject,
+    hasRbacAddOn: (object) => hasRbacAddOn(object, objects)
   };
   const artifacts = [
     {
@@ -94,6 +97,12 @@ async function emitAction(action, objects, flows, serviceTag) {
       content: await render(`${action}Endpoint_Main.ejs`, shared)
     }
   ];
+  if (action !== 'Get') {
+    artifacts.unshift({
+      path: `${source}/${action}LogicalLib.js`,
+      content: await render(`${action}LogicalLib.ejs`, shared)
+    });
+  }
 
   let targetServiceTag = '${self:custom.iz_serviceName}';
   if (serviceTag) {
@@ -118,69 +127,75 @@ async function emitAction(action, objects, flows, serviceTag) {
           functionName: 'Get',
           queueName: 'GetHdrApi'
         })
-      },
+      }
+    );
+    const functions = [
       {
-        path: `${source}/GetRange_Main.js`,
-        content: await render('GetRangeEndpoint_Main.ejs', {
-          ...shared,
-          mainFileName: 'GetRange_Main',
-          functionName: 'GetRange'
-        })
+        type: 'inv',
+        functionName: 'GetHdrInv',
+        handlerPath: `${handlerRoot}/Get_HdrInv.main`,
+        roleName: 'FlowObjectsRole',
+        flowTag: action,
+        flowStepName: ''
       },
       {
-        path: `${source}/GetRange_HdrApi.js`,
-        content: await renderShared('FlowHandler_HdrApi.ejs', {
-          ...shared,
-          mainFileName: 'GetRange_Main',
-          functionName: 'GetRange',
-          queueName: 'GetRangeHdrApi'
-        })
+        type: 'api',
+        functionName: 'GetHdrApi',
+        handlerPath: `${handlerRoot}/Get_HdrApi.main`,
+        roleName: 'FlowObjectsRole',
+        flowTag: action,
+        flowStepName: '',
+        routes: objects.filter(isCrudObject).map((object) => ({
+          path: `/${targetServiceTag}/${object.objectType}/get`,
+          upperName: upperFirst(object.objectType)
+        }))
       }
-    );
-    return {
-      artifacts,
-      functions: [
-        {
-          type: 'inv',
-          functionName: 'GetHdrInv',
-          handlerPath: `${handlerRoot}/Get_HdrInv.main`,
-          roleName: 'FlowObjectsRole',
-          flowTag: action,
-          flowStepName: ''
-        },
+    ];
+
+    const getRangeRoutes = objects
+      .filter(isCrudObject)
+      .filter(
+        (object) =>
+          object.identifiers &&
+          object.identifiers.some((i) => i.type === 'sortKey')
+      )
+      .map((object) => ({
+        path: `/${targetServiceTag}/${object.objectType}/getRange`,
+        upperName: upperFirst(object.objectType)
+      }));
+
+    if (getRangeRoutes.length > 0) {
+      artifacts.push(
         {
-          type: 'api',
-          functionName: 'GetHdrApi',
-          handlerPath: `${handlerRoot}/Get_HdrApi.main`,
-          roleName: 'FlowObjectsRole',
-          flowTag: action,
-          flowStepName: '',
-          routes: objects.filter(isCrudObject).map((object) => ({
-            path: `/${targetServiceTag}/${object.objectType}/get`,
-            upperName: upperFirst(object.objectType)
-          }))
+          path: `${source}/GetRange_Main.js`,
+          content: await render('GetRangeEndpoint_Main.ejs', {
+            ...shared,
+            mainFileName: 'GetRange_Main',
+            functionName: 'GetRange'
+          })
         },
         {
-          type: 'api',
-          functionName: 'GetRangeHdrApi',
-          handlerPath: `${handlerRoot}/GetRange_HdrApi.main`,
-          roleName: 'FlowObjectsRole',
-          flowTag: 'GetRange',
-          flowStepName: '',
-          routes: objects
-            .filter(isCrudObject)
-            .filter(
-              (object) =>
-                object.identifiers &&
-                object.identifiers.some((i) => i.type === 'sortKey')
-            )
-            .map((object) => ({
-              path: `/${targetServiceTag}/${object.objectType}/getRange`,
-              upperName: upperFirst(object.objectType)
-            }))
+          path: `${source}/GetRange_HdrApi.js`,
+          content: await renderShared('FlowHandler_HdrApi.ejs', {
+            ...shared,
+            mainFileName: 'GetRange_Main',
+            functionName: 'GetRange',
+            queueName: 'GetRangeHdrApi'
+          })
         }
-      ]
-    };
+      );
+      functions.push({
+        type: 'api',
+        functionName: 'GetRangeHdrApi',
+        handlerPath: `${handlerRoot}/GetRange_HdrApi.main`,
+        roleName: 'FlowObjectsRole',
+        flowTag: 'GetRange',
+        flowStepName: '',
+        routes: getRangeRoutes
+      });
+    }
+
+    return { artifacts, functions };
   }
 
   artifacts.push(
@@ -230,68 +245,100 @@ async function emitAction(action, objects, flows, serviceTag) {
       flowStepName: ''
     }
   ];
-  const complete = `${action}Complete`;
-  artifacts.push(
-    {
-      path: `${source}/${complete}_Main.js`,
-      content: await render(`${action}Complete_Main.ejs`, { action })
-    },
-    {
-      path: `${source}/${complete}_HdrSqs.js`,
-      content: await render(`${action}Complete_HdrSqs.ejs`, {
-        ...shared,
-        mainFileName: `${complete}_Main`,
-        functionName: complete,
-        queueName: `${action}CompleteHdrSqs`
-      })
-    }
-  );
-  functions.push({
-    type: 'sqs',
-    functionName: `${action}CompleteHdrSqs`,
-    handlerPath: `${handlerRoot}/${complete}_HdrSqs.main`,
-    roleName: 'FlowObjectsRole',
-    queueName: `${action}CompleteHdrSqs`,
-    flowTag: action,
-    flowStepName: 'Complete'
-  });
-  if (generateCode.some((config) => config.codeHookTag === 'beforeLogical')) {
-    const beforeMain = `${action}BeforeLogical_Main`;
+
+  if (plan.hasRbacCallback) {
+    const rbacCallbackMain = `${action}RbacCallback_Main`;
+    artifacts.push(
+      {
+        path: `${source}/${rbacCallbackMain}.js`,
+        content: await render('FlowEndpointRbacCallback_Main.ejs', shared)
+      },
+      {
+        path: `${source}/${rbacCallbackMain.replace('_Main', '_HdrSqs')}.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          ...shared,
+          mainFileName: rbacCallbackMain,
+          functionName: `${action}RbacCallbackMain`,
+          queueName: `${action}RbacCallbackHdrSqs`
+        })
+      }
+    );
+    functions.push({
+      type: 'sqs',
+      functionName: `${action}RbacCallbackHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}RbacCallback_HdrSqs.main`,
+      roleName: 'FlowObjectsRole',
+      queueName: `${action}RbacCallbackHdrSqs`,
+      flowTag: action,
+      flowStepName: 'RbacCallback'
+    });
+  }
+
+  if (plan.hasComplete) {
+    const completeMain = `${action}Complete_Main`;
     artifacts.push(
       {
-        path: `${source}/${beforeMain}.js`,
-        content: await render('FlowEndpointBeforeLogical_Main.ejs', shared)
+        path: `${source}/${completeMain}.js`,
+        content: await render(
+          plan.hasRbac ? 'FlowEndpointRbacCallback_Main.ejs' : `${action}Complete_Main.ejs`,
+          plan.hasRbac ? shared : { action }
+        )
       },
       {
-        path: `${source}/${action}BeforeLogical_HdrSqs.js`,
+        path: `${source}/${action}Complete_HdrSqs.js`,
         content: await renderShared('FlowHandler_HdrSqs.ejs', {
           ...shared,
-          mainFileName: beforeMain,
-          functionName: `${action}BeforeLogicalMain`,
-          queueName: `${action}BeforeLogicalHdrSqs`
+          mainFileName: completeMain,
+          functionName: `${action}CompleteMain`,
+          queueName: `${action}CompleteHdrSqs`
         })
       }
     );
     functions.push({
       type: 'sqs',
-      functionName: `${action}BeforeLogicalHdrSqs`,
-      handlerPath: `${handlerRoot}/${action}BeforeLogical_HdrSqs.main`,
+      functionName: `${action}CompleteHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}Complete_HdrSqs.main`,
       roleName: 'FlowObjectsRole',
-      queueName: `${action}BeforeLogicalHdrSqs`,
+      queueName: `${action}CompleteHdrSqs`,
       flowTag: action,
-      flowStepName: 'BeforeLogical'
+      flowStepName: 'Complete'
     });
   }
+
   return { artifacts, functions };
 }
 
-function isCrudObject(object) {
+function hasSelfRbacAddOn(object) {
   return (
-    object?.generatedBy === 'userGenerated' ||
-    object?.generatedBy === 'systemGenerated'
+    Array.isArray(object?.addOnDataStructure) &&
+    object.addOnDataStructure.some((addOn) => addOn?.type === 'rbac')
   );
 }
 
+function hasRbacAddOn(object, objects = []) {
+  const selfHasRbac = hasSelfRbacAddOn(object);
+  const belongToTargets = object?.belongTo
+    ? Array.isArray(object.belongTo)
+      ? object.belongTo
+      : [object.belongTo]
+    : [];
+  const belongToHasRbac =
+    (Array.isArray(object?.belongToSchema?.addOnDataStructure) &&
+      object.belongToSchema.addOnDataStructure.some(
+        (addOn) => addOn?.type === 'rbac'
+      )) ||
+    belongToTargets.some((target) => {
+      if (target?.serviceTag === 'UserAccount') return true;
+      const matched = objects.find(
+        (candidate) =>
+          candidate?.serviceTag === target?.serviceTag &&
+          candidate?.objectType === target?.objectType
+      );
+      return hasSelfRbacAddOn(matched);
+    });
+  return selfHasRbac || belongToHasRbac;
+}
+
 function upperFirst(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
@@ -302,7 +349,10 @@ async function render(templateName, data) {
 }
 
 async function renderShared(templateName, data) {
-  const template = await readFile(new URL(templateName, SHARED_TEMPLATE_URL), 'utf8');
+  const template = await readFile(
+    new URL(templateName, SHARED_TEMPLATE_URL),
+    'utf8'
+  );
   return ejsLib.render(template, data);
 }
 

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -1,64 +1,52 @@
 import { renderDynamicCrudFlowSchema } from './dynamicCrudFlowSchemaTemplate.js';
+import {
+  CRUD_ACTIONS,
+  createCrudActionPlans,
+  hasGraphStorageResource,
+  isCrudObject
+} from './crudActionPlan.js';
 
-const ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
 const MESSAGE_ATTRIBUTES = ['userId', 'correlationId'];
 
-export const dynamicCrudFlowSchemaPaths = ACTIONS.map(
+export const dynamicCrudFlowSchemaPaths = CRUD_ACTIONS.map(
   (action) =>
     `app/src/schemas/FlowSchemas/generateCode/FlowObjects/${action}.js`
 );
 
-export function emitDynamicCrudFlowSchemas({ objects, flows = [] }) {
+export function emitDynamicCrudFlowSchemas({ objects, flows = [], serviceTag }) {
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
-  if (
-    !objects.some(
-      (object) =>
-        object?.generatedBy === 'userGenerated' ||
-        object?.generatedBy === 'systemGenerated'
-    )
-  ) {
-    return [];
-  }
+  if (!objects.some(isCrudObject)) return [];
 
-  return ACTIONS.map((action, index) => {
-    const flow = _createDynamicFlow(
+  const plans = createCrudActionPlans(objects);
+
+  return CRUD_ACTIONS.map((action, index) => ({
+    path: dynamicCrudFlowSchemaPaths[index],
+    content: renderDynamicCrudFlowSchema(
       action,
-      _hasBeforeLogicalStep(flows, action)
-    );
-    return {
-      path: dynamicCrudFlowSchemaPaths[index],
-      content: renderDynamicCrudFlowSchema(action, flow)
-    };
-  });
+      _createDynamicFlow(action, plans[action], serviceTag)
+    )
+  }));
 }
 
-function _createDynamicFlow(action, hasBeforeLogicalStep) {
-  const outputTopic = action !== 'Get';
+function _createDynamicFlow(action, plan, serviceTag = '') {
   const flowSteps = [
     {
-      stepName: 'start',
-      ...(hasBeforeLogicalStep
-        ? {
-            nextSteps: [
-              {
-                stepName: 'BeforeLogical'
-              }
-            ]
-          }
-        : outputTopic
+      stepName: 'Start',
+      ...(plan.hasRbacCallback || plan.hasComplete
         ? {
             nextSteps: [
               {
-                stepName: 'Complete'
+                targetType: 'ownTopic',
+                stepName: plan.hasRbacCallback ? 'RbacCallback' : 'Complete'
               }
             ]
           }
         : {}),
       properties: [],
       messageAttributes: MESSAGE_ATTRIBUTES,
-      ...(outputTopic
+      ...(plan.outputTopic
         ? {
             returnValues: {
               properties: [],
@@ -69,17 +57,19 @@ function _createDynamicFlow(action, hasBeforeLogicalStep) {
     }
   ];
 
-  if (hasBeforeLogicalStep) {
+  if (plan.hasRbacCallback) {
     flowSteps.push({
-      stepName: 'BeforeLogical',
+      stepName: 'RbacCallback',
       event: ['extTopic'],
       previousSteps: [
         {
-          stepName: 'start'
+          sourceType: 'ownTopic',
+          stepName: 'Start'
         }
       ],
       nextSteps: [
         {
+          targetType: 'ownTopic',
           stepName: 'Complete'
         }
       ],
@@ -88,38 +78,36 @@ function _createDynamicFlow(action, hasBeforeLogicalStep) {
     });
   }
 
-  if (action !== 'Get') {
+  if (plan.hasComplete) {
     flowSteps.push({
       stepName: 'Complete',
       event: ['extTopic'],
       previousSteps: [
         {
-          stepName: hasBeforeLogicalStep ? 'BeforeLogical' : 'start'
+          sourceType: 'ownTopic',
+          stepName: plan.hasRbacCallback ? 'RbacCallback' : 'Start'
         }
       ],
-      properties: [
-        'returnValue',
-        'parentFlowId',
-        'status',
-        'errorsFound',
-        'graphServiceTag'
-      ],
+      properties: plan.hasGraph
+        ? [
+            'returnValue',
+            'parentFlowId',
+            'status',
+            'errorsFound',
+            'graphServiceTag'
+          ]
+        : [],
       messageAttributes: MESSAGE_ATTRIBUTES
     });
   }
 
-  let eventTypes = ['lambdaSyncInv', 'lambdaSyncApi'];
-  if (outputTopic) {
-    eventTypes = ['ownTopic'];
-  }
-
   return {
     flowTag: action,
     initiateBy: 'system',
     handleObj: 'one',
     statusType: 'none',
-    event: eventTypes,
-    outputTopic,
+    event: plan.outputTopic ? ['ownTopic'] : ['lambdaSyncInv', 'lambdaSyncApi'],
+    outputTopic: plan.outputTopic,
     stepMessageAttributes: {
       userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
       correlationId: { propertyName: 'x-correlation-id', type: 'string' }
@@ -128,14 +116,4 @@ function _createDynamicFlow(action, hasBeforeLogicalStep) {
   };
 }
 
-function _hasBeforeLogicalStep(flows, action) {
-  return flows.some((flow) => {
-    const config = flow?.generatedCodeConfig;
-    return (
-      config?.generatedCodeTag === action.toLowerCase() &&
-      config.codeHookTag === 'beforeLogical' &&
-      Array.isArray(flow.event) &&
-      flow.event.includes(config.invocationType)
-    );
-  });
-}
+export { hasGraphStorageResource };

package/src/emit/crud/generateDynamicCrudFlowSchemas.js

@@ -12,7 +12,10 @@ export async function generateDynamicCrudFlowSchemas(rootPath, options = {}) {
   const schemaInputs = await loadLocalSchemaArrays(project);
   const plan = buildGenerationPlan(
     project,
-    emitDynamicCrudFlowSchemas(schemaInputs),
+    emitDynamicCrudFlowSchemas({
+      ...schemaInputs,
+      serviceTag: project.serviceTag
+    }),
     {
       managedPaths: dynamicCrudFlowSchemaPaths,
       managedScope: 'crud-flow-schemas'