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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.83",
+  "version": "1.0.84",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@izara_project/izara-attribute-tree": "^1.0.15",
-    "@izara_project/izara-core-library-core": "^1.0.32",
+    "@izara_project/izara-core-library-core": "^1.0.35",
     "@izara_project/izara-property-nodes": "^1.0.16",
     "@izara_project/izara-shared-core": "^1.0.13",
     "ejs": "^6.0.1",
@@ -31,8 +31,8 @@
   },
   "devDependencies": {
     "@izara_project/izara-core-library-logger": "^1.0.11",
-    "@izara_project/izara-core-library-service-schemas": "1.0.162",
-    "@izara_project/izara-shared-service-schemas": "^1.0.71",
+    "@izara_project/izara-core-library-service-schemas": "1.0.166",
+    "@izara_project/izara-shared-service-schemas": "^1.0.74",
     "jest": "^30.4.2",
     "prettier": "^3.9.6",
     "prettier-plugin-ejs": "^1.0.3"

package/src/compile/flowValidator.js

@@ -6,9 +6,8 @@ export function validateFlowSchema(flowSchema) {
   if (flowSchema.initiateBy !== undefined) {
     const validInitiateBy = [
       'user',
-      'systemWithNoUser',
       'systemWithUser',
-      'system'
+      'systemNoUser'
     ];
     if (!validInitiateBy.includes(flowSchema.initiateBy)) {
       throw new Error(
@@ -68,6 +67,18 @@ export function validateFlowSchema(flowSchema) {
       );
     }
 
+    if (typeof step.stepName !== 'string' || step.stepName.trim() === '') {
+      throw new Error(
+        `FlowSchema validation error: flowSteps[${idx}] requires a non-empty 'stepName'`
+      );
+    }
+
+    if (step.stepName[0] !== step.stepName[0].toUpperCase()) {
+      throw new Error(
+        `FlowSchema validation error: flowSteps[${idx}].stepName '${step.stepName}' must start with an uppercase letter`
+      );
+    }
+
     if (Array.isArray(step.nextSteps) && step.nextSteps.length > 0) {
       for (let nIdx = 0; nIdx < step.nextSteps.length; nIdx++) {
         const item = step.nextSteps[nIdx];

package/src/compile/loadSchemas.js

@@ -5,12 +5,68 @@ import {
   getObjectSchema,
   utils
 } from '@izara_project/izara-core-library-service-schemas';
+import { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
 import { s3 } from '@izara_project/izara-core-library-s3';
 import Logger from '@izara_project/izara-core-library-logger';
 import { validateFlowSchema } from './flowValidator.js';
 
-export async function loadLocalSchemaDirectory(project, directoryName) {
+const VALID_INITIATE_BY_ENUM = [
+  'user',
+  'systemWithUser',
+  'systemNoUser'
+];
+
+if (basicValidatorSchema?.basicFlowSchema?.properties?.initiateBy) {
+  basicValidatorSchema.basicFlowSchema.properties.initiateBy.enum =
+    VALID_INITIATE_BY_ENUM;
+}
+
+const VALID_GENERATED_BY_ENUM = [
+  'user',
+  'systemWithUser',
+  'systemNoUser',
+  'searchResultGenerated'
+];
+
+if (basicValidatorSchema?.basicObjectSchema?.properties?.generatedBy) {
+  basicValidatorSchema.basicObjectSchema.properties.generatedBy.enum =
+    VALID_GENERATED_BY_ENUM;
+}
+
+if (basicValidatorSchema?.basicExtendObjectSchema?.properties?.generatedBy) {
+  basicValidatorSchema.basicExtendObjectSchema.properties.generatedBy.enum =
+    VALID_GENERATED_BY_ENUM;
+}
+
+const objectSchemasToPatch = [
+  basicValidatorSchema?.basicObjectSchema,
+  basicValidatorSchema?.basicExtendObjectSchema
+];
+
+for (const objSchema of objectSchemasToPatch) {
+  const addOnItems = objSchema?.properties?.addOnDataStructure?.items?.anyOf;
+  if (Array.isArray(addOnItems)) {
+    for (const item of addOnItems) {
+      if (item?.properties?.type?.enum?.includes('rbac')) {
+        if (item.properties.billalble) {
+          delete item.properties.billalble;
+        }
+        item.properties.billable = { type: 'boolean' };
+        if (Array.isArray(item.required)) {
+          item.required = item.required.filter((r) => r !== 'billalble');
+        }
+      }
+    }
+  }
+}
+
+export async function loadLocalSchemaDirectory(
+  project,
+  directoryName,
+  options = {}
+) {
   const directoryPath = join(project.schemaRoot, directoryName);
+  const logger = options.logger || Logger;
   let entries;
   try {
     entries = await readdir(directoryPath, { withFileTypes: true });
@@ -58,41 +114,85 @@ export async function loadLocalSchemaDirectory(project, directoryName) {
       }
     }
 
-    if (process.env.NODE_ENV && process.env.NODE_ENV !== 'test') {
+    const shouldValidate =
+      options.validateSchemas ??
+      (!options.skipValidation && !_isTestEnvironment());
+    if (shouldValidate) {
       for (const schema of loadedSchemas) {
         let status = true;
         let errors = [];
 
         if (directoryName === 'ObjectSchemas') {
           [status, errors] = utils.validateObjectSchema(
-            { logger: Logger },
+            { logger },
             schema
           );
+          if (!status && Array.isArray(errors)) {
+            errors = errors.filter(
+              (err) => !err.includes('billalble')
+            );
+            if (VALID_GENERATED_BY_ENUM.includes(schema?.generatedBy)) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('generatedBy') &&
+                  !err.includes('must be equal to one of the allowed values (enum)') &&
+                  !(err.includes('should be one of enum') && err.includes(schema?.generatedBy))
+              );
+            }
+            if (errors.length === 0) {
+              status = true;
+            }
+          }
         } else if (directoryName === 'RelationshipSchemas') {
           if (entry.name.toLowerCase() === 'refobjectrelationships.js') {
             [status, errors] = utils.validateRefRelationshipSchema(
-              { logger: Logger },
+              { logger },
               schema
             );
           } else {
             [status, errors] = utils.validateRelationshipSchema(
-              { logger: Logger },
+              { logger },
               schema
             );
           }
+          if (!status && Array.isArray(errors) && VALID_GENERATED_BY_ENUM.includes(schema?.generatedBy)) {
+            errors = errors.filter(
+              (err) =>
+                !err.includes('generatedBy') &&
+                !err.includes('must be equal to one of the allowed values (enum)') &&
+                !(err.includes('should be one of enum') && err.includes(schema?.generatedBy))
+            );
+            if (errors.length === 0) {
+              status = true;
+            }
+          }
         } else if (directoryName === 'FlowSchemas') {
           [status, errors] = utils.validateBasicFlowSchema(
-            { logger: Logger },
+            { logger },
             schema
           );
+          if (!status && Array.isArray(errors) && VALID_INITIATE_BY_ENUM.includes(schema?.initiateBy)) {
+            errors = errors.filter(
+              (err) =>
+                !err.includes('initiateBy') &&
+                !err.includes('must be equal to one of the allowed values (enum)') &&
+                !(err.includes('should be one of enum') && err.includes(schema?.initiateBy))
+            );
+            if (errors.length === 0) {
+              status = true;
+            }
+          }
           if (status) {
             validateFlowSchema(schema);
           }
         }
 
         if (!status) {
+          const formattedErrors = (errors || [])
+            .map((err) => `  - ${err}`)
+            .join('\n');
           throw new Error(
-            `Schema validation failed for ${entry.name}:\n${errors.join('\n')}`
+            `[SCHEMA_VALIDATION_ERROR] Schema validation failed for ${directoryName}/${entry.name}:\n${formattedErrors}`
           );
         }
       }
@@ -285,3 +385,12 @@ export async function resolveGraphServiceTags(
 
   return Array.from(resolvedTags);
 }
+
+function _isTestEnvironment() {
+  return (
+    process.env.NODE_ENV === 'test' ||
+    process.env.npm_lifecycle_event === 'test' ||
+    Boolean(process.execArgv?.includes('--test')) ||
+    Boolean(process.argv?.includes('--test'))
+  );
+}

package/src/emit/attributeTree/emitAttributeTreeSchemas.js

@@ -0,0 +1,388 @@
+/**
+ * Emits dynamic ObjectSchemas and RelationshipSchemas for attributeTree add-ons
+ */
+
+function _capitalize(str) {
+  if (!str || typeof str !== 'string') {
+    return '';
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function _extractAttributeTrees(objects = []) {
+  if (!Array.isArray(objects)) {
+    return [];
+  }
+  const results = [];
+
+  for (const object of objects) {
+    if (!Array.isArray(object?.addOnDataStructure)) {
+      continue;
+    }
+    for (const addOn of object.addOnDataStructure) {
+      if (addOn?.type === 'attributeTree' && addOn?.attributeTreeTag) {
+        results.push({
+          parentObject: object,
+          attributeTreeTag: addOn.attributeTreeTag
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+function _extractGraphStorageResources(object) {
+  const result = {};
+  if (object?.storageResources) {
+    for (const [tag, res] of Object.entries(object.storageResources)) {
+      if (res?.storageType === 'graph') {
+        result[tag] = {
+          storageType: 'graph',
+          graphServerTag: res.graphServerTag || 'GraphHandler'
+        };
+      }
+    }
+  }
+  if (Object.keys(result).length === 0) {
+    result.myGraph = {
+      storageType: 'graph',
+      graphServerTag: 'GraphHandler'
+    };
+  }
+  return result;
+}
+
+function _renderObjectSchema(schema) {
+  return `export default [\n  ${JSON.stringify(schema, null, 2).replace(/\n/g, '\n  ')}\n];\n`;
+}
+
+function _renderRelationshipSchema(relationshipTag, content) {
+  const wrapper = [{ [relationshipTag]: content }];
+  return `export default ${JSON.stringify(wrapper, null, 2)};\n`;
+}
+
+export function attributeTreeObjectSchemaManagedPaths(objects = []) {
+  const trees = _extractAttributeTrees(objects);
+  const paths = [];
+
+  for (const { attributeTreeTag } of trees) {
+    const tag = attributeTreeTag;
+    const tagCap = _capitalize(tag);
+    paths.push(
+      `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Link.js`,
+      `app/src/schemas/ObjectSchemas/generatedAttributeTree/attribute${tagCap}Value.js`,
+      `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Label.js`,
+      `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}ValueStandard.js`
+    );
+  }
+
+  return paths;
+}
+
+export function attributeTreeRelationshipSchemaManagedPaths(objects = []) {
+  const trees = _extractAttributeTrees(objects);
+  const paths = [];
+
+  for (const { attributeTreeTag } of trees) {
+    const tag = attributeTreeTag;
+    const tagCap = _capitalize(tag);
+    paths.push(
+      `app/src/schemas/RelationshipSchemas/generatedAttributeTree/has${tagCap}Link.js`,
+      `app/src/schemas/RelationshipSchemas/generatedAttributeTree/disabled${tagCap}Link.js`,
+      `app/src/schemas/RelationshipSchemas/generatedAttributeTree/is${tagCap}.js`,
+      `app/src/schemas/RelationshipSchemas/generatedAttributeTree/is${tagCap}Label.js`
+    );
+  }
+
+  return paths;
+}
+
+export function emitAttributeTreeObjectSchemas({ objects = [] } = {}) {
+  const trees = _extractAttributeTrees(objects);
+  if (trees.length === 0) {
+    return [];
+  }
+
+  const artifacts = [];
+
+  for (const { parentObject, attributeTreeTag } of trees) {
+    const tag = attributeTreeTag;
+    const tagCap = _capitalize(tag);
+    const graphStorageResources = _extractGraphStorageResources(parentObject);
+    const storageResourceTags = Object.keys(graphStorageResources);
+
+    // 1. {tag}Link.js
+    const linkSchema = {
+      objectType: `${tag}Link`,
+      canDelete: true,
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [`${tag}LinkId`]: {
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          storageResourceTags
+        },
+        order: {
+          type: 'integer',
+          optionalOnCreate: true,
+          canUpdate: true,
+          storageResourceTags
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: `${tag}LinkId`
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Link.js`,
+      content: _renderObjectSchema(linkSchema)
+    });
+
+    // 2. attribute{Tag}Value.js
+    const valueSchema = {
+      objectType: `attribute${tagCap}Value`,
+      canDelete: true,
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [`attribute${tagCap}ValueId`]: {
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          storageResourceTags
+        },
+        value: {
+          type: 'string',
+          requiredOnCreate: true,
+          canUpdate: true,
+          storageResourceTags
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: `attribute${tagCap}ValueId`
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/attribute${tagCap}Value.js`,
+      content: _renderObjectSchema(valueSchema)
+    });
+
+    // 3. {tag}Label.js
+    const labelSchema = {
+      objectType: `${tag}Label`,
+      canDelete: true,
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [`${tag}LabelId`]: {
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          storageResourceTags
+        },
+        label: {
+          type: 'string',
+          requiredOnCreate: true,
+          canUpdate: true,
+          storageResourceTags
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: `${tag}LabelId`
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Label.js`,
+      content: _renderObjectSchema(labelSchema)
+    });
+
+    // 4. {tag}ValueStandard.js
+    const standardValueSchema = {
+      objectType: `${tag}ValueStandard`,
+      canDelete: true,
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [`${tag}ValueStandardId`]: {
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          storageResourceTags
+        },
+        value: {
+          type: 'string',
+          requiredOnCreate: true,
+          canUpdate: true,
+          storageResourceTags
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: `${tag}ValueStandardId`
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}ValueStandard.js`,
+      content: _renderObjectSchema(standardValueSchema)
+    });
+  }
+
+  return artifacts;
+}
+
+export function emitAttributeTreeRelationshipSchemas({
+  objects = [],
+  serviceTag = ''
+} = {}) {
+  const trees = _extractAttributeTrees(objects);
+  if (trees.length === 0) {
+    return [];
+  }
+
+  const artifacts = [];
+
+  for (const { parentObject, attributeTreeTag } of trees) {
+    const tag = attributeTreeTag;
+    const tagCap = _capitalize(tag);
+    const parentObjectType = parentObject?.objectType;
+    const effectiveServiceTag =
+      parentObject?.serviceTag || serviceTag || 'CurrentService';
+    const graphStorageResources = _extractGraphStorageResources(parentObject);
+    const storageResourceTags = Object.keys(graphStorageResources);
+
+    // 1. has{Tag}Link.js
+    const hasLinkRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: parentObjectType
+            },
+            linkType: 'one'
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: `${tag}Link`
+            },
+            linkType: 'many'
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/has${tagCap}Link.js`,
+      content: _renderRelationshipSchema(`has${tagCap}Link`, hasLinkRel)
+    });
+
+    // 2. disabled{Tag}Link.js
+    const disabledLinkRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: parentObjectType
+            },
+            linkType: 'one'
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: `${tag}Link`
+            },
+            linkType: 'many'
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/disabled${tagCap}Link.js`,
+      content: _renderRelationshipSchema(
+        `disabled${tagCap}Link`,
+        disabledLinkRel
+      )
+    });
+
+    // 3. is{Tag}.js
+    const isRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: `${tag}Link`
+            },
+            linkType: 'one'
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: `attribute${tagCap}Value`
+            },
+            linkType: 'many'
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/is${tagCap}.js`,
+      content: _renderRelationshipSchema(`is${tagCap}`, isRel)
+    });
+
+    // 4. is{Tag}Label.js
+    const isLabelRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: `${tag}Link`
+            },
+            linkType: 'one'
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: `${tag}Label`
+            },
+            linkType: 'many'
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/is${tagCap}Label.js`,
+      content: _renderRelationshipSchema(`is${tagCap}Label`, isLabelRel)
+    });
+  }
+
+  return artifacts;
+}

package/src/emit/coreFunction/emitCoreFunctionArtifacts.js

@@ -1,7 +1,7 @@
 import ejsLib from 'ejs';
 import { readFile } from 'node:fs/promises';
 
-import { customFlowNextSteps } from '../custom/customFlows.js';
+import { customFlowNextSteps, flowHasRbac, upperFirst } from '../custom/customFlows.js';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 const APP_ROOT = 'app/sls_yaml/generatedCode/source';
@@ -99,6 +99,9 @@ function _extractDynamoTableNames({
     dynamoTableNames.add('RoleUsers');
     dynamoTableNames.add('UserRoles');
     dynamoTableNames.add('RbacPermissionCaches');
+    dynamoTableNames.add('RoleLimit');
+    dynamoTableNames.add('RunningTotalUsage');
+    dynamoTableNames.add('RunningTotalReservedUsage');
   }
   if ((s3Flows || []).length > 0) {
     dynamoTableNames.add('ReservedDataMain');
@@ -213,12 +216,37 @@ export async function emitCoreFunctionArtifacts({ project, objects = [], relatio
     (objects || []).filter(o => o.belongTo?.serviceTag && o.belongTo.serviceTag !== 'Rbac').map(o => o.belongTo.serviceTag)
   )).sort();
 
+  const customRbacFlows = (flows || []).filter((f) => flowHasRbac(f, objects));
+  const customRbacFlowTags = customRbacFlows.map((f) => f.flowTag);
+  const customRbacFlowsWithTags = customRbacFlows.map((f) => {
+    const roleName = upperFirst(f.flowTag);
+    const matched = objects.find((o) => o.objectType === f.objType?.objectType);
+    const targetServiceTags = [];
+    const belongTo = matched?.belongTo;
+    if (belongTo) {
+      if (Array.isArray(belongTo)) {
+        for (const b of belongTo) {
+          if (b?.serviceTag) targetServiceTags.push(b.serviceTag);
+        }
+      } else if (belongTo.serviceTag) {
+        targetServiceTags.push(belongTo.serviceTag);
+      }
+    }
+    return {
+      roleName,
+      flowTag: f.flowTag,
+      targetServiceTags: Array.from(new Set(targetServiceTags))
+    };
+  });
+
   const state = { 
     project, 
     objects, 
     relationships,
     flows,
     customFlowNextSteps: customFlowNextSteps(flows),
+    customRbacFlowTags,
+    customRbacFlowsWithTags,
     objectGraphServiceTags,
     relationshipGraphServiceTags,
     crud,