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

package/src/emit/schemas/ledger/emitLedgerSchemas.js

@@ -1,3 +1,8 @@
+import { readFile } from 'node:fs/promises';
+import ejsLib from 'ejs';
+
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+
 /**
  * Emits dynamic ObjectSchemas and RelationshipSchemas for ledger add-ons
  */
@@ -92,13 +97,17 @@ function _extractGraphStorageResources(object, storageResourceTag) {
   return result;
 }
 
-function _renderObjectSchema(schema) {
-  return `export default [\n  ${JSON.stringify(schema, null, 2).replace(/\n/g, '\n  ')}\n];\n`;
+function _renderObjectSchema(template, schema) {
+  return ejsLib.render(template, { schema });
 }
 
-function _renderRelationshipSchema(relationshipTag, content) {
+function _renderRelationshipSchema(template, relationshipTag, content) {
   const wrapper = [{ [relationshipTag]: content }];
-  return `export default ${JSON.stringify(wrapper, null, 2)};\n`;
+  return ejsLib.render(template, {
+    relationshipTag,
+    content,
+    wrapper
+  });
 }
 
 function _buildParentToEntryLinks({
@@ -117,7 +126,7 @@ function _buildParentToEntryLinks({
           objectType: parentObjectType
         },
         linkType: 'many',
-        requiredOnCreate: true,
+        requiredOnCreate: false,
         belongTo: true
       },
       to: {
@@ -176,12 +185,16 @@ export function ledgerRelationshipSchemaManagedPaths(objects = []) {
   return paths;
 }
 
-export function emitLedgerObjectSchemas({ objects = [] } = {}) {
+export async function emitLedgerObjectSchemas({ objects = [] } = {}) {
   const ledgers = _extractLedgers(objects);
   if (ledgers.length === 0) {
     return [];
   }
 
+  const template = await readFile(
+    new URL('LedgerObjectSchema.ejs', TEMPLATE_URL),
+    'utf8'
+  );
   const artifacts = [];
 
   for (const { parentObject, addOn, component } of ledgers) {
@@ -217,14 +230,14 @@ export function emitLedgerObjectSchemas({ objects = [] } = {}) {
 
     artifacts.push({
       path: `app/src/schemas/ObjectSchemas/generatedLedger/${objectType}.js`,
-      content: _renderObjectSchema(schema)
+      content: _renderObjectSchema(template, schema)
     });
   }
 
   return artifacts;
 }
 
-export function emitLedgerRelationshipSchemas({
+export async function emitLedgerRelationshipSchemas({
   objects = [],
   serviceTag = ''
 } = {}) {
@@ -233,6 +246,10 @@ export function emitLedgerRelationshipSchemas({
     return [];
   }
 
+  const template = await readFile(
+    new URL('LedgerRelationshipSchema.ejs', TEMPLATE_URL),
+    'utf8'
+  );
   const artifacts = [];
 
   for (const { parentObject, addOn, component } of ledgers) {
@@ -281,6 +298,7 @@ export function emitLedgerRelationshipSchemas({
     artifacts.push({
       path: `app/src/schemas/RelationshipSchemas/generatedLedger/${component.newRelationshipTag}.js`,
       content: _renderRelationshipSchema(
+        template,
         component.newRelationshipTag,
         currentRel
       )
@@ -306,7 +324,11 @@ export function emitLedgerRelationshipSchemas({
     };
     artifacts.push({
       path: `app/src/schemas/RelationshipSchemas/generatedLedger/${component.oldRelationshipTag}.js`,
-      content: _renderRelationshipSchema(component.oldRelationshipTag, oldRel)
+      content: _renderRelationshipSchema(
+        template,
+        component.oldRelationshipTag,
+        oldRel
+      )
     });
 
     // 3. is<Prefix>Entry.js (if targetObjType or moveToTargetObjTypes is present)
@@ -341,7 +363,7 @@ export function emitLedgerRelationshipSchemas({
               objectType: component.objectType
             },
             linkType: 'many',
-            requiredOnCreate: true
+            requiredOnCreate: false
           },
           to: {
             objType: {
@@ -361,7 +383,7 @@ export function emitLedgerRelationshipSchemas({
       };
       artifacts.push({
         path: `app/src/schemas/RelationshipSchemas/generatedLedger/${isRelTag}.js`,
-        content: _renderRelationshipSchema(isRelTag, isRel)
+        content: _renderRelationshipSchema(template, isRelTag, isRel)
       });
     }
   }

package/src/emit/schemas/ledger/templates/LedgerObjectSchema.ejs

@@ -0,0 +1,3 @@
+export default [
+  <%- JSON.stringify(schema, null, 2).replace(/\n/g, '\n  ') %>
+];

package/src/emit/schemas/ledger/templates/LedgerRelationshipSchema.ejs

@@ -0,0 +1 @@
+export default <%- JSON.stringify(wrapper, null, 2) %>;

package/src/emit/schemas/propertyValue/emitPropertyValueSchemas.js

@@ -0,0 +1,329 @@
+import propertyNode from '@izara_project/izara-property-nodes';
+
+/**
+ * Emits dynamic ObjectSchemas and RelationshipSchemas for propertyValue add-ons
+ */
+
+function _capitalize(str) {
+  if (!str) {
+    return '';
+  }
+  if (typeof str !== 'string') {
+    return '';
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function _extractPropertyValues(objects = []) {
+  if (!Array.isArray(objects)) {
+    return [];
+  }
+  const results = [];
+  const seenTags = new Set();
+
+  for (const object of objects) {
+    if (!Array.isArray(object?.addOnDataStructure)) {
+      continue;
+    }
+    for (const addOn of object.addOnDataStructure) {
+      if (addOn?.type === 'propertyValue') {
+        let tag = object.objectType;
+        if (addOn.propertyValuePrefix) {
+          tag = addOn.propertyValuePrefix;
+        }
+        if (!tag) {
+          continue;
+        }
+        if (seenTags.has(tag)) {
+          continue;
+        }
+        seenTags.add(tag);
+        results.push({
+          parentObject: object,
+          addOn,
+          tag
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+function _extractGraphStorageResources(object) {
+  const result = {};
+  if (object?.storageResources) {
+    for (const [tag, res] of Object.entries(object.storageResources)) {
+      if (res?.storageType === 'graph') {
+        let graphServerTag = 'GraphHandler';
+        if (res.graphServerTag) {
+          graphServerTag = res.graphServerTag;
+        }
+        result[tag] = {
+          storageType: 'graph',
+          graphServerTag
+        };
+      }
+    }
+  }
+  if (Object.keys(result).length === 0) {
+    result.myGraph = {
+      storageType: 'graph',
+      graphServerTag: 'GraphHandler'
+    };
+  }
+  return result;
+}
+
+function _renderObjectSchema(schema) {
+  const json = JSON.stringify(schema, null, 2).replace(/\n/g, '\n  ');
+  return `export default [\n  ${json}\n];\n`;
+}
+
+function _renderRelationshipSchema(relationshipTag, content) {
+  const wrapper = [{ [relationshipTag]: content }];
+  return `export default ${JSON.stringify(wrapper, null, 2)};\n`;
+}
+
+export function propertyValueObjectSchemaManagedPaths(objects = []) {
+  const items = _extractPropertyValues(objects);
+  const paths = [];
+
+  for (const { tag } of items) {
+    const labelType = propertyNode.createPropertyLabelGraphNodeLabel(tag);
+    const valueType = propertyNode.createPropertyValueGraphNodeLabel(tag);
+    paths.push(
+      `app/src/schemas/ObjectSchemas/generatedCode/propertyValue/${labelType}.js`,
+      `app/src/schemas/ObjectSchemas/generatedCode/propertyValue/${valueType}.js`
+    );
+  }
+
+  return paths;
+}
+
+export function propertyValueRelationshipSchemaManagedPaths(objects = []) {
+  const items = _extractPropertyValues(objects);
+  const paths = [];
+
+  for (const { tag } of items) {
+    const tagCap = _capitalize(tag);
+    const hasRel = propertyNode.createHasPropertyGraphRelationshipType(tagCap);
+    const disabledRel =
+      propertyNode.createDisabledPropertyGraphRelationshipType(tagCap);
+    const isRel =
+      propertyNode.createIsPropertyLabelGraphRelationshipType(tagCap);
+    paths.push(
+      `app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/${hasRel}.js`,
+      `app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/${disabledRel}.js`,
+      `app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/${isRel}.js`
+    );
+  }
+
+  return paths;
+}
+
+export function emitPropertyValueObjectSchemas({ objects = [] } = {}) {
+  const items = _extractPropertyValues(objects);
+  if (items.length === 0) {
+    return [];
+  }
+
+  const artifacts = [];
+
+  for (const { parentObject, tag } of items) {
+    const graphStorageResources = _extractGraphStorageResources(parentObject);
+    const storageResourceTags = Object.keys(graphStorageResources);
+
+    const labelIdSuffix = _capitalize(
+      propertyNode.consts.PROPERTY_LABEL_GRAPH_IDENTIFIER_ID
+    );
+    const labelType = propertyNode.createPropertyLabelGraphNodeLabel(tag);
+    const labelIdField = `${tag}${labelIdSuffix}`;
+
+    const labelSchema = {
+      objectType: labelType,
+      canDelete: true,
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [labelIdField]: {
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          storageResourceTags
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: labelIdField
+        }
+      ]
+    };
+
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedCode/propertyValue/${labelType}.js`,
+      content: _renderObjectSchema(labelSchema)
+    });
+
+    const valueIdSuffix = _capitalize(
+      propertyNode.consts.PROPERTY_VALUE_GRAPH_IDENTIFIERS_ID
+    );
+    const valueType = propertyNode.createPropertyValueGraphNodeLabel(tag);
+    const valueIdField = `${tag}${valueIdSuffix}`;
+
+    const valueSchema = {
+      objectType: valueType,
+      canDelete: true,
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [valueIdField]: {
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          storageResourceTags
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: valueIdField
+        }
+      ]
+    };
+
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedCode/propertyValue/${valueType}.js`,
+      content: _renderObjectSchema(valueSchema)
+    });
+  }
+
+  return artifacts;
+}
+
+export function emitPropertyValueRelationshipSchemas({
+  objects = [],
+  serviceTag = ''
+} = {}) {
+  const items = _extractPropertyValues(objects);
+  if (items.length === 0) {
+    return [];
+  }
+
+  const artifacts = [];
+
+  for (const { parentObject, tag } of items) {
+    const tagCap = _capitalize(tag);
+    const parentObjectType = parentObject.objectType;
+    let effectiveServiceTag = 'CurrentService';
+    if (parentObject?.serviceTag) {
+      effectiveServiceTag = parentObject.serviceTag;
+    } else if (serviceTag) {
+      effectiveServiceTag = serviceTag;
+    }
+
+    const graphStorageResources = _extractGraphStorageResources(parentObject);
+    const storageResourceTags = Object.keys(graphStorageResources);
+
+    const labelType = propertyNode.createPropertyLabelGraphNodeLabel(tag);
+    const valueType = propertyNode.createPropertyValueGraphNodeLabel(tag);
+
+    const hasRelTag =
+      propertyNode.createHasPropertyGraphRelationshipType(tagCap);
+    const hasRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      generatedBy: 'user',
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: parentObjectType
+            },
+            linkType: 'one'
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: valueType
+            },
+            linkType: 'many',
+            requiredOnCreate: true
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/${hasRelTag}.js`,
+      content: _renderRelationshipSchema(hasRelTag, hasRel)
+    });
+
+    const disabledRelTag =
+      propertyNode.createDisabledPropertyGraphRelationshipType(tagCap);
+    const disabledRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      generatedBy: 'user',
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: parentObjectType
+            },
+            linkType: 'one'
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: valueType
+            },
+            linkType: 'many'
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/${disabledRelTag}.js`,
+      content: _renderRelationshipSchema(disabledRelTag, disabledRel)
+    });
+
+    const isRelTag =
+      propertyNode.createIsPropertyLabelGraphRelationshipType(tagCap);
+    const isRel = {
+      fieldNames: {},
+      storageResources: graphStorageResources,
+      generatedBy: 'systemNoUser',
+      links: [
+        {
+          storageResourceTags,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: valueType
+            },
+            linkType: 'many',
+            requiredOnCreate: true
+          },
+          to: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: labelType
+            },
+            linkType: 'one'
+          }
+        }
+      ]
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/propertyValue/${isRelTag}.js`,
+      content: _renderRelationshipSchema(isRelTag, isRel)
+    });
+  }
+
+  return artifacts;
+}

package/src/generate.js

@@ -1,17 +1,13 @@
-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 {
   loadLocalSchemaDirectory,
+  loadGenerateDirectives,
   resolveExtendedObjectSchemas,
   resolveGraphServiceTags
 } from './compile/loadSchemas.js';
-import {
-  resolveTargetServicePath,
-  emitAttributeTreeTargetSchemas
-} from './emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -26,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;
@@ -76,6 +82,7 @@ export async function generate(rootPath, options = {}) {
       flows,
       notifications,
       errors,
+      directives,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger
@@ -101,14 +108,6 @@ export async function generate(rootPath, options = {}) {
         )
       );
     }
-    const targetFiles = await _emitTargetServiceAttributeTreeSchemas({
-      project,
-      objects,
-      logger: options.logger
-    });
-    for (const targetFile of targetFiles) {
-      files.push(targetFile);
-    }
     const durationMs = Date.now() - startedAt;
     console.log(
       `[INFO] [Generate] STATUS=FINISHED | ` +
@@ -126,61 +125,3 @@ export async function generate(rootPath, options = {}) {
   }
 }
 
-async function _emitTargetServiceAttributeTreeSchemas({
-  project,
-  objects,
-  logger
-}) {
-  if (!Array.isArray(objects)) {
-    return [];
-  }
-  const committedFiles = [];
-  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
-          });
-          const relativeArtifacts = artifacts.map((artifact) => {
-            return {
-              path: path.relative(targetServiceRoot, artifact.path),
-              content: artifact.content
-            };
-          });
-          const targetPlan = buildGenerationPlan(
-            { outputPath: targetServiceRoot },
-            relativeArtifacts,
-            {
-              managedScopes: {
-                'attribute-tree-target-schemas': relativeArtifacts.map(
-                  (a) => a.path
-                )
-              }
-            }
-          );
-          const targetFiles = await commitArtifacts(targetPlan);
-          for (const targetFile of targetFiles) {
-            committedFiles.push(targetFile);
-          }
-          if (logger && typeof logger.info === 'function') {
-            logger.info(
-              `[INFO] [AttributeTree] Target schemas emitted for ` +
-                `tag=${attributeTag} to ${targetServiceRoot}`
-            );
-          }
-        }
-      }
-    }
-  }
-  return committedFiles;
-}

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;