@izara_project/izara-core-generate-service-code 1.0.91 → 1.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.91",
+  "version": "1.0.93",
   "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": {
@@ -13,28 +13,25 @@
   "exports": "./index.js",
   "main": "index.js",
   "scripts": {
-    "test": "node --test",
-    "format:ejs": "node scripts/format-ejs.js"
-  },
-  "jest": {
-    "testEnvironment": "node"
+    "format:ejs": "node scripts/format-ejs.js",
+    "test": "node --test"
   },
   "dependencies": {
     "@izara_project/izara-attribute-tree": "^1.0.15",
-    "@izara_project/izara-core-library-core": "^1.0.35",
+    "@izara_project/izara-core-library-core": "^1.0.37",
+    "@izara_project/izara-core-library-s3": "^1.0.12",
     "@izara_project/izara-property-nodes": "^1.0.16",
     "@izara_project/izara-shared-core": "^1.0.13",
     "ejs": "^6.0.1",
     "js-beautify": "^2.0.3",
     "ws": "^8.21.3",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.1"
   },
   "devDependencies": {
     "@izara_project/izara-core-library-logger": "^1.0.11",
     "@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": "^3.9.8",
     "prettier-plugin-ejs": "^1.0.3"
   },
   "peerDependencies": {

package/src/compile/flowValidator.js

@@ -44,6 +44,12 @@ export function validateFlowSchema(flowSchema) {
       break;
     }
   }
+  if (
+    flowEvents.includes('generateCode') &&
+    flowSchema?.generatedCodeConfig?.invocationType === 'lambdaSyncInv'
+  ) {
+    hasSyncEvent = true;
+  }
 
   if (hasSyncEvent && steps.length > 1) {
     let flowTag = 'unknown';

package/src/compile/loadSchemas.js

@@ -16,20 +16,31 @@ const consoleLogger = {
   error: console.error
 };
 
-const VALID_INITIATE_BY_ENUM = [
-  'user',
-  'systemWithUser',
-  'systemNoUser'
+const VALID_INITIATE_BY_ENUM = ['user', 'systemWithUser', 'systemNoUser'];
+const VALID_EVENT_ENUM = [
+  'ownTopic',
+  'extTopic',
+  's3',
+  'eventBridge',
+  'lambdaSyncInv',
+  'lambdaSyncApi',
+  'dsq',
+  'generateCode'
 ];
-
 const VALID_CODE_HOOK_TAG_ENUM = ['before', 'after'];
 const VALID_GENERATE_CODE_TAG_ENUM = ['create', 'update', 'delete'];
+const VALID_INVOCATION_TYPE_ENUM = ['ownTopic', 'lambdaSyncInv'];
 
 if (basicValidatorSchema?.basicFlowSchema?.properties?.initiateBy) {
   basicValidatorSchema.basicFlowSchema.properties.initiateBy.enum =
     VALID_INITIATE_BY_ENUM;
 }
 
+if (basicValidatorSchema?.basicFlowSchema?.properties?.event?.items) {
+  basicValidatorSchema.basicFlowSchema.properties.event.items.enum =
+    VALID_EVENT_ENUM;
+}
+
 if (
   basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
     ?.properties?.codeHookTag
@@ -38,48 +49,58 @@ if (
     VALID_CODE_HOOK_TAG_ENUM;
 }
 
+if (
+  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
+    ?.properties?.invocationType
+) {
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.invocationType.enum =
+    VALID_INVOCATION_TYPE_ENUM;
+}
+
 if (
   basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
     ?.properties?.generateCodeTag
 ) {
-  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.generateCodeTag = {
-    anyOf: [
-      {
-        type: 'array',
-        items: {
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.generateCodeTag =
+    {
+      anyOf: [
+        {
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: VALID_GENERATE_CODE_TAG_ENUM
+          }
+        },
+        {
           type: 'string',
           enum: VALID_GENERATE_CODE_TAG_ENUM
         }
-      },
-      {
-        type: 'string',
-        enum: VALID_GENERATE_CODE_TAG_ENUM
-      }
-    ]
-  };
+      ]
+    };
 }
 
 if (
   basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
     ?.properties
 ) {
-  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.objType = {
-    anyOf: [
-      { type: 'string' },
-      {
-        type: 'array',
-        items: { type: 'string' }
-      },
-      {
-        type: 'object',
-        properties: {
-          objectType: { type: 'string' },
-          serviceTag: { type: 'string' }
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.objType =
+    {
+      anyOf: [
+        { type: 'string' },
+        {
+          type: 'array',
+          items: { type: 'string' }
         },
-        required: ['objectType']
-      }
-    ]
-  };
+        {
+          type: 'object',
+          properties: {
+            objectType: { type: 'string' },
+            serviceTag: { type: 'string' }
+          },
+          required: ['objectType']
+        }
+      ]
+    };
 }
 
 const VALID_GENERATED_BY_ENUM = [
@@ -165,9 +186,60 @@ export async function loadLocalSchemaDirectory(
     );
     if (loadedSchemas.length === 0) continue;
 
+    if (directoryName === 'ErrorSchemas') {
+      for (const schema of loadedSchemas) {
+        if (!schema._sourceFile) {
+          schema._sourceFile = entry.name;
+        }
+        if (!schema.errorTag || typeof schema.errorTag !== 'string') {
+          throw new Error(
+            `Invalid ErrorSchema in ${entry.name}: errorTag is required and must be a non-empty string`
+          );
+        }
+        if (!schema.errorAction || typeof schema.errorAction !== 'string') {
+          throw new Error(
+            `Invalid ErrorSchema in ${entry.name}: errorAction is required and must be a non-empty string`
+          );
+        }
+      }
+    }
+
     if (directoryName === 'FlowSchemas') {
       for (const schema of loadedSchemas) {
-        if (Object.prototype.hasOwnProperty.call(schema?.generatedCodeConfig ?? {}, 'codeHookTag')) {
+        if (
+          Array.isArray(schema?.event) &&
+          schema.event.includes('generateCode') &&
+          !schema.generatedCodeConfig
+        ) {
+          throw new Error(
+            `Unsupported FlowHook configuration in ${entry.name}: ` +
+              `flow with event 'generateCode' requires generatedCodeConfig`
+          );
+        }
+        if (
+          Object.prototype.hasOwnProperty.call(
+            schema?.generatedCodeConfig ?? {},
+            'invocationType'
+          )
+        ) {
+          const invType = schema.generatedCodeConfig.invocationType;
+          if (
+            typeof invType !== 'string' ||
+            !VALID_INVOCATION_TYPE_ENUM.includes(invType)
+          ) {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: ` +
+                `generatedCodeConfig.invocationType '${invType}' is invalid. ` +
+                `Must be 'ownTopic' or 'lambdaSyncInv'`
+            );
+          }
+        }
+        if (
+          Object.prototype.hasOwnProperty.call(
+            schema?.generatedCodeConfig ?? {},
+            'codeHookTag'
+          )
+        ) {
           const hookTag = schema.generatedCodeConfig.codeHookTag;
           if (hookTag === 'beforeLogical') {
             throw new Error(
@@ -191,7 +263,7 @@ export async function loadLocalSchemaDirectory(
             if (codeTag.length === 0) {
               throw new Error(
                 `Unsupported FlowHook configuration in ${entry.name}: ` +
-                `generatedCodeConfig.generateCodeTag array must not be empty`
+                  `generatedCodeConfig.generateCodeTag array must not be empty`
               );
             }
             for (const tag of codeTag) {
@@ -201,8 +273,8 @@ export async function loadLocalSchemaDirectory(
               ) {
                 throw new Error(
                   `Unsupported FlowHook configuration in ${entry.name}: ` +
-                  `generatedCodeConfig.generateCodeTag contains invalid ` +
-                  `tag '${tag}'. Must be 'create', 'update', or 'delete'`
+                    `generatedCodeConfig.generateCodeTag contains invalid ` +
+                    `tag '${tag}'. Must be 'create', 'update', or 'delete'`
                 );
               }
             }
@@ -210,14 +282,14 @@ export async function loadLocalSchemaDirectory(
             if (!VALID_GENERATE_CODE_TAG_ENUM.includes(codeTag.toLowerCase())) {
               throw new Error(
                 `Unsupported FlowHook configuration in ${entry.name}: ` +
-                `generatedCodeConfig.generateCodeTag '${codeTag}' ` +
-                `is invalid. Must be 'create', 'update', or 'delete'`
+                  `generatedCodeConfig.generateCodeTag '${codeTag}' ` +
+                  `is invalid. Must be 'create', 'update', or 'delete'`
               );
             }
           } else {
             throw new Error(
               `Unsupported FlowHook configuration in ${entry.name}: ` +
-              `generatedCodeConfig.generateCodeTag must be an array or string`
+                `generatedCodeConfig.generateCodeTag must be an array or string`
             );
           }
         }
@@ -232,7 +304,7 @@ export async function loadLocalSchemaDirectory(
             if (hookObjType.length === 0) {
               throw new Error(
                 `Unsupported FlowHook configuration in ${entry.name}: ` +
-                `generatedCodeConfig.objType array must not be empty`
+                  `generatedCodeConfig.objType array must not be empty`
               );
             }
             for (const item of hookObjType) {
@@ -240,7 +312,7 @@ export async function loadLocalSchemaDirectory(
               if (!strVal || typeof strVal !== 'string') {
                 throw new Error(
                   `Unsupported FlowHook configuration in ${entry.name}: ` +
-                  `generatedCodeConfig.objType array items must be non-empty strings or objects with objectType`
+                    `generatedCodeConfig.objType array items must be non-empty strings or objects with objectType`
                 );
               }
             }
@@ -251,7 +323,7 @@ export async function loadLocalSchemaDirectory(
             ) {
               throw new Error(
                 `Unsupported FlowHook configuration in ${entry.name}: ` +
-                `generatedCodeConfig.objType object must have string property objectType`
+                  `generatedCodeConfig.objType object must have string property objectType`
               );
             }
           } else if (
@@ -260,7 +332,7 @@ export async function loadLocalSchemaDirectory(
           ) {
             throw new Error(
               `Unsupported FlowHook configuration in ${entry.name}: ` +
-              `generatedCodeConfig.objType must be a non-empty string, array, or object`
+                `generatedCodeConfig.objType must be a non-empty string, array, or object`
             );
           }
         }
@@ -276,20 +348,20 @@ export async function loadLocalSchemaDirectory(
         let errors = [];
 
         if (directoryName === 'ObjectSchemas') {
-          [status, errors] = utils.validateObjectSchema(
-            { logger },
-            schema
-          );
+          [status, errors] = utils.validateObjectSchema({ logger }, schema);
           if (!status && Array.isArray(errors)) {
-            errors = errors.filter(
-              (err) => !err.includes('billalble')
-            );
+            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))
+                  !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) {
@@ -308,29 +380,73 @@ export async function loadLocalSchemaDirectory(
               schema
             );
           }
-          if (!status && Array.isArray(errors) && VALID_GENERATED_BY_ENUM.includes(schema?.generatedBy)) {
+          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))
+                !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 },
-            schema
-          );
+          [status, errors] = utils.validateBasicFlowSchema({ logger }, schema);
           if (!status && Array.isArray(errors)) {
             if (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))
+                  !err.includes(
+                    'must be equal to one of the allowed values (enum)'
+                  ) &&
+                  !(
+                    err.includes('should be one of enum') &&
+                    err.includes(schema?.initiateBy)
+                  )
+              );
+            }
+            if (
+              Array.isArray(schema?.event) &&
+              schema.event.every((e) => VALID_EVENT_ENUM.includes(e))
+            ) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('event') &&
+                  !err.includes(
+                    'must be equal to one of the allowed values (enum)'
+                  ) &&
+                  !(
+                    err.includes('should be one of enum') &&
+                    schema.event.some((e) => err.includes(e))
+                  )
+              );
+            }
+            if (
+              VALID_INVOCATION_TYPE_ENUM.includes(
+                schema?.generatedCodeConfig?.invocationType
+              )
+            ) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('invocationType') &&
+                  !err.includes(
+                    'must be equal to one of the allowed values (enum)'
+                  ) &&
+                  !(
+                    err.includes('should be one of enum') &&
+                    err.includes(schema?.generatedCodeConfig?.invocationType)
+                  )
               );
             }
             if (
@@ -341,7 +457,9 @@ export async function loadLocalSchemaDirectory(
               errors = errors.filter(
                 (err) =>
                   !err.includes('codeHookTag') &&
-                  !err.includes('must be equal to one of the allowed values (enum)') &&
+                  !err.includes(
+                    'must be equal to one of the allowed values (enum)'
+                  ) &&
                   !(
                     err.includes('should be one of enum') &&
                     err.includes(schema?.generatedCodeConfig?.codeHookTag)
@@ -398,6 +516,14 @@ export async function loadLocalSchemaDirectory(
   return schemas;
 }
 
+export async function loadLocalSchemaArrays(project, options = {}) {
+  const [objects, flows] = await Promise.all([
+    loadLocalSchemaDirectory(project, 'ObjectSchemas', options),
+    loadLocalSchemaDirectory(project, 'FlowSchemas', options)
+  ]);
+  return { objects, flows };
+}
+
 /**
  * Resolves extendObjType for ObjectSchemas by fetching the parent schema
  * from S3 and merging its storageResources into the child schema.
@@ -426,7 +552,7 @@ export async function resolveExtendedObjectSchemas(
       try {
         console.log(
           `[DEBUG] [resolveExtendedObjectSchemas] Merging extendObjType ` +
-          `for objectType=${currentSchema.objectType}`,
+            `for objectType=${currentSchema.objectType}`,
           { extendObjType: currentSchema.extendObjType }
         );
         const initialResources = currentSchema.storageResources || {};
@@ -468,7 +594,7 @@ export async function resolveExtendedObjectSchemas(
       } catch (error) {
         console.log(
           `[ERROR] [resolveExtendedObjectSchemas] Failed to merge ` +
-          `extendObjType for objectType=${currentSchema.objectType}`,
+            `extendObjType for objectType=${currentSchema.objectType}`,
           { error }
         );
         throw error;
@@ -488,7 +614,7 @@ export async function resolveExtendedObjectSchemas(
         try {
           console.log(
             `[DEBUG] [resolveExtendedObjectSchemas] Fetching belongTo ` +
-            `schema for objectType=${currentSchema.objectType}`,
+              `schema for objectType=${currentSchema.objectType}`,
             { belongTo: belongToTarget }
           );
           const belongToObjType = {
@@ -504,13 +630,13 @@ export async function resolveExtendedObjectSchemas(
           currentSchema.belongToSchema = belongToSchema;
           console.log(
             `[DEBUG] [resolveExtendedObjectSchemas] Successfully fetched ` +
-            `belongTo schema for objectType=${currentSchema.objectType}`,
+              `belongTo schema for objectType=${currentSchema.objectType}`,
             { belongToObjectType: belongToSchema?.objectType }
           );
         } catch (error) {
           console.log(
             `[WARN] [resolveExtendedObjectSchemas] Failed to fetch ` +
-            `belongTo schema for objectType=${currentSchema.objectType}`,
+              `belongTo schema for objectType=${currentSchema.objectType}`,
             { error }
           );
         }
@@ -572,7 +698,7 @@ export async function resolveGraphServiceTags(
     } catch (error) {
       console.log(
         `[DEBUG] [resolveGraphServiceTags] Could not fetch ` +
-        `GraphServerTags.json from bucket=${bucketName}`,
+          `GraphServerTags.json from bucket=${bucketName}`,
         error
       );
     }

package/src/emit/coreFunction/templates/UploadSchema_Main.ejs

@@ -15,7 +15,7 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { uploadObjSchema } from '@izara_project/izara-core-library-service-schemas';
+import initialSetupSharedLib from '@izara_project/izara-core-library-initial-setup';
 
 const SERVICE_TAG = {
   TRANSLATIONS: 'Translations',
@@ -39,7 +39,7 @@ const uploadSchema = async (_izContext) => {
   try {
     _izContext.logger.debug('uploadSchema _izContext: ', _izContext);
 
-    await uploadObjSchema.uploadObjectSchemaByUseCase(_izContext, {
+    await initialSetupSharedLib.uploadObjectSchema(_izContext, {
       ignoreExternalServices: ignoreExternalServices
     });
     return 'upload successfully';

package/src/emit/crud/generateCrudApplicationArtifacts.js

@@ -1,25 +1,23 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
-import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
+import { loadLocalSchemaArrays } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   crudApplicationManagedPaths,
   emitCrudApplicationArtifacts
 } from './emitCrudApplicationArtifacts.js';
 
 export async function generateCrudApplicationArtifacts(rootPath, options = {}) {
-  const project = compileProject({ ...options, rootPath });
-  const schemas = await loadLocalSchemaArrays(project, options);
-  const artifacts = await emitCrudApplicationArtifacts({
-    ...schemas,
-    serviceTag: project.serviceTag,
-    logger: options.logger
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: (project, opt) => loadLocalSchemaArrays(project, opt),
+    emitArtifacts: ({ objects, flows, project, options: opt }) =>
+      emitCrudApplicationArtifacts({
+        objects,
+        flows,
+        serviceTag: project.serviceTag,
+        logger: opt.logger
+      }),
+    managedScope: 'crud-application',
+    resolveManagedPaths: () => crudApplicationManagedPaths()
   });
-  const files = await commitArtifacts(
-    buildGenerationPlan(project, artifacts, {
-      managedPaths: crudApplicationManagedPaths(),
-      managedScope: 'crud-application'
-    })
-  );
-  return { project, files };
 }

package/src/emit/crud/generateDynamicCrudFlowSchemas.js

@@ -1,28 +1,23 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaArrays } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   dynamicCrudFlowSchemaPaths,
   emitDynamicCrudFlowSchemas
 } from './emitDynamicCrudFlowSchemas.js';
-import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
 
 export async function generateDynamicCrudFlowSchemas(rootPath, options = {}) {
-  const project = compileProject({ ...options, rootPath });
-  const schemaInputs = await loadLocalSchemaArrays(project, options);
-  const plan = buildGenerationPlan(
-    project,
-    emitDynamicCrudFlowSchemas({
-      ...schemaInputs,
-      serviceTag: project.serviceTag,
-      logger: options.logger
-    }),
-    {
-      managedPaths: dynamicCrudFlowSchemaPaths,
-      managedScope: 'crud-flow-schemas'
-    }
-  );
-  const files = await commitArtifacts(plan);
-
-  return { project, files };
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: (project, opt) => loadLocalSchemaArrays(project, opt),
+    emitArtifacts: ({ objects, flows, project, options: opt }) =>
+      emitDynamicCrudFlowSchemas({
+        objects,
+        flows,
+        serviceTag: project.serviceTag,
+        logger: opt.logger
+      }),
+    managedScope: 'crud-flow-schemas',
+    resolveManagedPaths: dynamicCrudFlowSchemaPaths
+  });
 }

package/src/emit/crud/loadLocalSchemaArrays.js

@@ -1,8 +1,4 @@
-import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
-
-export async function loadLocalSchemaArrays(project, options = {}) {
-  return {
-    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas', options),
-    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas', options)
-  };
-}
+/**
+ * @deprecated Use `loadLocalSchemaArrays` from `../../compile/loadSchemas.js` instead.
+ */
+export { loadLocalSchemaArrays } from '../../compile/loadSchemas.js';