@izara_project/izara-core-generate-service-code 1.0.96 → 1.0.98

package/src/generate.js

@@ -1,74 +1,13 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { buildGenerationPlan } from './plan/buildGenerationPlan.js';
+import { resolveEmissionGroups } from './plan/domainRegistry.js';
 import { commitArtifacts } from './output/commitArtifacts.js';
 import { compileProject } from './compile/compileProject.js';
-import {
-  crudApplicationManagedPaths,
-  emitCrudApplicationArtifacts
-} from './emit/crud/emitCrudApplicationArtifacts.js';
-import {
-  dynamicCrudFlowSchemaPaths,
-  emitDynamicCrudFlowSchemas
-} from './emit/crud/emitDynamicCrudFlowSchemas.js';
-import {
-  customFlowApplicationManagedPaths,
-  emitCustomFlowApplicationArtifacts
-} from './emit/custom/emitCustomFlowApplicationArtifacts.js';
-import {
-  emitDynamicRbacFlowSchemas,
-  rbacFlowSchemaManagedPaths
-} from './emit/rbac/emitDynamicRbacFlowSchemas.js';
-import {
-  emitRbacApplicationArtifacts,
-  rbacApplicationManagedPaths
-} from './emit/rbac/emitRbacApplicationArtifacts.js';
-import {
-  dynamicRelationshipFlowSchemaManagedPaths,
-  emitDynamicRelationshipFlowSchemas
-} from './emit/relationship/emitDynamicRelationshipFlowSchemas.js';
-import {
-  emitRelationshipApplicationArtifacts,
-  relationshipApplicationManagedPaths
-} from './emit/relationship/emitRelationshipApplicationArtifacts.js';
-import {
-  emitResourceArtifacts,
-  resourceArtifactPaths
-} from './emit/resource/emitResourceArtifacts.js';
 import {
   loadLocalSchemaDirectory,
+  loadGenerateDirectives,
   resolveExtendedObjectSchemas,
   resolveGraphServiceTags
 } from './compile/loadSchemas.js';
-import {
-  emitSystemWebSocketArtifacts,
-  hasSystemWebSocket,
-  systemWebSocketManagedPaths
-} from './emit/system/emitSystemWebSocketArtifacts.js';
-import {
-  emitSystemFindDataArtifacts,
-  findDataManagedPaths
-} from './emit/system/emitSystemFindDataArtifacts.js';
-import {
-  emitCoreFunctionArtifacts,
-  coreFunctionManagedPaths
-} from './emit/coreFunction/emitCoreFunctionArtifacts.js';
-import {
-  emitSystemTextSchemas,
-  systemTextSchemaManagedPaths
-} from './emit/systemText/emitSystemTextSchemas.js';
-import {
-  emitAttributeTreeObjectSchemas,
-  emitAttributeTreeRelationshipSchemas,
-  attributeTreeObjectSchemaManagedPaths,
-  attributeTreeRelationshipSchemaManagedPaths,
-  resolveTargetServicePath,
-  emitAttributeTreeTargetSchemas
-} from './emit/attributeTree/emitAttributeTreeSchemas.js';
-import {
-  emitErrorSchemas,
-  errorSchemaManagedPaths
-} from './emit/error/emitErrorSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -83,13 +22,23 @@ export async function generate(rootPath, options = {}) {
       relationships,
       flows,
       notifications,
-      errors
+      errors,
+      directives
     ] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'RelationshipSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(
+        project,
+        'RelationshipSchemas',
+        schemaLoadOptions
+      ),
       loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
+      loadLocalSchemaDirectory(
+        project,
+        'NotificationSchemas',
+        schemaLoadOptions
+      ),
+      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions),
+      loadGenerateDirectives(project, schemaLoadOptions)
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -105,27 +54,35 @@ export async function generate(rootPath, options = {}) {
       relationships,
       schemaBucketName
     );
+    const objectNames = objects.map((obj) => obj.objectType).filter(Boolean);
+    let objectSummary = '';
+    if (objectNames.length > 0) {
+      objectSummary = ` (${objectNames.join(', ')})`;
+    }
     console.log(
-      `[DEBUG] [Generate] STATUS=SCHEMAS_LOADED | ` +
-      `objects=${objects.length} ` +
+      `[INFO] [Generate] STATUS=SCHEMAS_LOADED | ` +
+      `objects=${objects.length}${objectSummary} ` +
       `relationships=${relationships.length} flows=${flows.length} ` +
       `notifications=${notifications.length} ` +
       `errors=${errors.length}`
     );
-    for (const objectSchema of objects) {
-      const objectType = objectSchema.objectType || 'unknown';
-      console.log(
-        `[DEBUG] [Generate] OBJECT_SCHEMA | objectType=${objectType}\n` +
-        JSON.stringify(objectSchema, null, 2)
-      );
+    if (options.verbose || process.env.GENERATE_VERBOSE) {
+      for (const objectSchema of objects) {
+        const objectType = objectSchema.objectType || 'unknown';
+        console.log(
+          `[DEBUG] [Generate] OBJECT_SCHEMA | objectType=${objectType}\n` +
+          JSON.stringify(objectSchema, null, 2)
+        );
+      }
     }
-    const groups = await _emitGroups({
+    const groups = await resolveEmissionGroups({
       project,
       objects,
       relationships,
       flows,
       notifications,
       errors,
+      directives,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger
@@ -135,7 +92,7 @@ export async function generate(rootPath, options = {}) {
     });
     const emittedScopeSummary = scopeCounts.join(' ');
     console.log(
-      `[DEBUG] [Generate] STATUS=ARTIFACTS_EMITTED | ${emittedScopeSummary}`
+      `[INFO] [Generate] STATUS=ARTIFACTS_EMITTED | ${emittedScopeSummary}`
     );
     let files = [];
     if (groups.length > 0) {
@@ -151,11 +108,6 @@ export async function generate(rootPath, options = {}) {
         )
       );
     }
-    await _emitTargetServiceAttributeTreeSchemas({
-      project,
-      objects,
-      logger: options.logger
-    });
     const durationMs = Date.now() - startedAt;
     console.log(
       `[INFO] [Generate] STATUS=FINISHED | ` +
@@ -173,229 +125,3 @@ export async function generate(rootPath, options = {}) {
   }
 }
 
-async function _emitGroups({
-  project,
-  objects,
-  relationships,
-  flows,
-  notifications,
-  errors,
-  objectGraphServiceTags,
-  relationshipGraphServiceTags,
-  logger
-}) {
-  const [
-    crud,
-    relationship,
-    rbac,
-    system,
-    findData,
-    resource,
-    coreFunction,
-    systemText,
-    errorSchemas
-  ] = await Promise.all([
-    emitCrudApplicationArtifacts({
-      objects,
-      flows,
-      serviceTag: project.serviceTag,
-      logger
-    }),
-    emitRelationshipApplicationArtifacts({
-      relationships,
-      flows,
-      serviceTag: project.serviceTag
-    }),
-    emitRbacApplicationArtifacts(objects),
-    emitSystemWebSocketArtifacts(flows, {
-      includeRelationshipOwnTopic: true,
-      objects,
-      relationships
-    }),
-    emitSystemFindDataArtifacts(objects),
-    emitResourceArtifacts({ objects, relationships, flows }),
-    emitCoreFunctionArtifacts({
-      project,
-      objects,
-      relationships,
-      flows,
-      objectGraphServiceTags,
-      relationshipGraphServiceTags
-    }),
-    emitSystemTextSchemas({
-      project,
-      objects,
-      relationships,
-      flows,
-      notifications
-    }),
-    emitErrorSchemas({
-      project,
-      errors,
-      objectGraphServiceTags
-    })
-  ]);
-  const custom = await emitCustomFlowApplicationArtifacts(flows, {
-    objects
-  });
-
-  const systemFunctions = [
-    ...(system.functions ?? []),
-    ...(findData.functions ?? [])
-  ].filter(Boolean);
-
-  const findDataArtifacts = [...(findData.artifacts ?? [])];
-
-  if (systemFunctions.length > 0) {
-    findDataArtifacts.push({
-      path: 'app/sls_yaml/generatedCode/source/flow-system.yml',
-      content: systemFunctions.join('\n\n')
-    });
-  }
-
-  let resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths;
-  if (typeof coreFunctionManagedPaths === 'function') {
-    resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths({
-      project,
-      objects,
-      relationships,
-      flows,
-      objectGraphServiceTags,
-      relationshipGraphServiceTags
-    });
-  }
-
-  return [
-    {
-      scope: 'crud-flow-schemas',
-      managedPaths: dynamicCrudFlowSchemaPaths,
-      artifacts: emitDynamicCrudFlowSchemas({ objects, flows, logger })
-    },
-    {
-      scope: 'relationship-flow-schemas',
-      managedPaths: dynamicRelationshipFlowSchemaManagedPaths(relationships),
-      artifacts: emitDynamicRelationshipFlowSchemas({ relationships })
-    },
-    {
-      scope: 'rbac-flow-schemas',
-      managedPaths: rbacFlowSchemaManagedPaths(objects),
-      artifacts: await emitDynamicRbacFlowSchemas({
-        objects,
-        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(),
-      artifacts: crud
-    },
-    {
-      scope: 'relationship-application',
-      managedPaths: relationshipApplicationManagedPaths(),
-      artifacts: relationship
-    },
-    {
-      scope: 'rbac-application',
-      managedPaths: rbacApplicationManagedPaths(objects),
-      artifacts: rbac
-    },
-    {
-      scope: 'system-websocket',
-      managedPaths: systemWebSocketManagedPaths(),
-      artifacts: system.artifacts
-    },
-    {
-      scope: 'system-find-data',
-      managedPaths: findDataManagedPaths(),
-      artifacts: findDataArtifacts
-    },
-    {
-      scope: 'custom-flow-application',
-      managedPaths: customFlowApplicationManagedPaths(flows, { objects }),
-      artifacts: custom
-    },
-    {
-      scope: 'shared-resources',
-      managedPaths: resourceArtifactPaths,
-      artifacts: resource
-    },
-    {
-      scope: 'core-function',
-      managedPaths: resolvedCoreFunctionManagedPaths,
-      artifacts: coreFunction
-    },
-    {
-      scope: 'system-text-schemas',
-      managedPaths: systemTextSchemaManagedPaths(),
-      artifacts: systemText
-    },
-    {
-      scope: 'error-schemas',
-      managedPaths: errorSchemaManagedPaths(errors),
-      artifacts: errorSchemas
-    }
-  ];
-}
-
-async function _emitTargetServiceAttributeTreeSchemas({
-  project,
-  objects,
-  logger
-}) {
-  if (!Array.isArray(objects)) {
-    return;
-  }
-  for (const object of objects) {
-    if (!Array.isArray(object?.addOnDataStructure)) {
-      continue;
-    }
-    for (const addOn of object.addOnDataStructure) {
-      if (addOn?.type === 'attributeTree' && addOn?.attributeTreeTag) {
-        const attributeTag = addOn.attributeTreeTag;
-        const targetServiceRoot = resolveTargetServicePath({
-          currentServiceRoot: project.rootPath,
-          attributeTag
-        });
-        if (targetServiceRoot) {
-          const artifacts = emitAttributeTreeTargetSchemas({
-            attributeTag,
-            targetServiceRoot
-          });
-          for (const artifact of artifacts) {
-            await fs.promises.mkdir(path.dirname(artifact.path), {
-              recursive: true
-            });
-            await fs.promises.writeFile(
-              artifact.path,
-              artifact.content,
-              'utf8'
-            );
-          }
-          if (logger && typeof logger.info === 'function') {
-            logger.info(
-              `[INFO] [AttributeTree] Target schemas emitted for ` +
-                `tag=${attributeTag} to ${targetServiceRoot}`
-            );
-          }
-        }
-      }
-    }
-  }
-}
-

package/src/{generateIntTest.js → intTest/generateIntTest.js}

@@ -25,11 +25,11 @@ import { join } from 'path';
 import ejsLib from 'ejs';
 import beautify from 'js-beautify/js/index.js';
 
-import generateTestTemplate from './generateResources/IntTest/generateTests/generateTemplate.js';
+import generateTestTemplate from './generators/generateTests/generateTemplate.js';
 import {
   DEFAULT_BUCKET,
   uploadToS3
-} from './generateResources/IntTest/upload/uploadIntTest.js';
+} from './generators/upload/uploadIntTest.js';
 import {
   getIntTestOutputPath,
   getServiceTag,

package/src/{generateResourceIntTest.js → intTest/generateResourceIntTest.js}

@@ -18,11 +18,11 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import ejsLib from 'ejs';
 
-import generateResourceTemplate from './generateResources/IntTest/generateResources/generateResources.js';
+import generateResourceTemplate from './generators/generateResources/generateResources.js';
 import {
   DEFAULT_BUCKET,
   uploadToS3
-} from './generateResources/IntTest/upload/uploadIntTest.js';
+} from './generators/upload/uploadIntTest.js';
 import {
   getIntTestOutputPath,
   getServiceTag,

package/src/output/mergeHooks.js

@@ -24,7 +24,10 @@ async function mergeHook(outputRoot, artifact) {
     }
   }
 
-  if (sourceContent !== null && (artifact.writeWhenFileExist === false || artifact.writeWhenFileExists === false)) {
+  const skipWrite =
+    artifact.writeWhenFileExist === false ||
+    artifact.writeWhenFileExists === false;
+  if (sourceContent !== null && skipWrite) {
     return sourceContent;
   }
 
@@ -37,32 +40,83 @@ async function mergeHook(outputRoot, artifact) {
     return artifact.content;
   }
 
+  const tagOccurrences = new Map();
   return artifact.content.replace(
     matchers.anyTag,
     (_match, p1, _body1, p2) => {
-      const tagName = p1 || p2;
-      const hookBlock = sourceContent.match(matchers.tagPattern(tagName))?.[0];
-      return hookBlock ?? _match;
+      const tagName = _extractTagName(p1, p2);
+      if (!tagName) {
+        return _match;
+      }
+      let count = 0;
+      if (tagOccurrences.has(tagName)) {
+        count = tagOccurrences.get(tagName);
+      }
+      tagOccurrences.set(tagName, count + 1);
+
+      const matches = sourceContent.match(matchers.tagPattern(tagName));
+      if (!matches || count >= matches.length) {
+        return _match;
+      }
+      const hookBlock = matches[count];
+      if (hookBlock !== null && hookBlock !== undefined) {
+        return hookBlock;
+      }
+      return _match;
     }
   );
 }
 
+function _extractTagName(p1, p2) {
+  if (typeof p1 === 'string' && p1.length > 0) {
+    return p1;
+  }
+  if (typeof p2 === 'string' && p2.length > 0) {
+    return p2;
+  }
+  return '';
+}
+
 function hookMatchers(filePath) {
-  if (filePath.endsWith('.js')) {
+  const lower = filePath.toLowerCase();
+  if (
+    lower.endsWith('.js') ||
+    lower.endsWith('.mjs') ||
+    lower.endsWith('.cjs')
+  ) {
+    const jsP1 =
+      '\\/\\/\\s*\\(<\\s*([\\w.-]+)\\s*>\\)([\\s\\S]*?)' +
+      '\\/\\/\\s*\\(<\\/\\s*\\1\\s*>\\)';
+    const jsP2 =
+      '\\/\\/\\s*<#\\s*([\\w.-]+)\\s*#>([\\s\\S]*?)' +
+      '\\/\\/\\s*<#\\/\\s*\\3\\s*#>';
     return {
-      anyTag: /(?:\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)|\/\/\s*<#(\w+)#>([\s\S]*?)\/\/\s*<#\/\3#>)/gm,
-      tagPattern: (name) =>
-        new RegExp(
-          `(?:\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)|\\/\\/\\s*<#${name}#>([\\s\\S]*?)\\/\\/\\s*<#\\/${name}#>)`,
-          'gm'
-        )
+      anyTag: new RegExp(`(?:${jsP1}|${jsP2})`, 'gm'),
+      tagPattern: (name) => {
+        const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const p1 =
+          `\\/\\/\\s*\\(<\\s*${esc}\\s*>\\)([\\s\\S]*?)` +
+          `\\/\\/\\s*\\(<\\/\\s*${esc}\\s*>\\)`;
+        const p2 =
+          `\\/\\/\\s*<#\\s*${esc}\\s*#>([\\s\\S]*?)` +
+          `\\/\\/\\s*<#\\/\\s*${esc}\\s*#>`;
+        return new RegExp(`(?:${p1}|${p2})`, 'gm');
+      }
     };
   }
-  if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+  if (lower.endsWith('.yml') || lower.endsWith('.yaml')) {
+    const ymlPattern =
+      '#\\s*<#\\s*([\\w.-]+)\\s*#>([\\s\\S]*?)' +
+      '#\\s*<#\\/\\s*\\1\\s*#>';
     return {
-      anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
-      tagPattern: (name) =>
-        new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
+      anyTag: new RegExp(ymlPattern, 'gm'),
+      tagPattern: (name) => {
+        const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(
+          `#\\s*<#\\s*${esc}\\s*#>([\\s\\S]*?)#\\s*<#\\/\\s*${esc}\\s*#>`,
+          'gm'
+        );
+      }
     };
   }
   return null;