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

package/src/emit/{attributeTree → schemas/attributeTree}/emitAttributeTreeSchemas.js

@@ -1,6 +1,3 @@
-import { resolveTargetServicePath } from './resolveTargetServicePath.js';
-import { emitAttributeTreeTargetSchemas } from './emitAttributeTreeTargetSchemas.js';
-
 /**
  * Emits dynamic ObjectSchemas and RelationshipSchemas for attributeTree add-ons
  */
@@ -72,9 +69,9 @@ export function attributeTreeObjectSchemaManagedPaths(objects = []) {
   for (const { attributeTreeTag } of trees) {
     const tag = attributeTreeTag;
     paths.push(
-      `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Link.js`,
-      `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Value.js`,
-      `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Label.js`
+      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Link.js`,
+      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Value.js`,
+      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Label.js`
     );
   }
 
@@ -89,10 +86,10 @@ export function attributeTreeRelationshipSchemaManagedPaths(objects = []) {
     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`
+      `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/has${tagCap}Link.js`,
+      `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/disabled${tagCap}Link.js`,
+      `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/is${tagCap}.js`,
+      `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/is${tagCap}Label.js`
     );
   }
 
@@ -141,7 +138,7 @@ export function emitAttributeTreeObjectSchemas({ objects = [] } = {}) {
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Link.js`,
+      path: `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Link.js`,
       content: _renderObjectSchema(linkSchema)
     });
 
@@ -173,7 +170,7 @@ export function emitAttributeTreeObjectSchemas({ objects = [] } = {}) {
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Value.js`,
+      path: `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Value.js`,
       content: _renderObjectSchema(valueSchema)
     });
 
@@ -205,7 +202,7 @@ export function emitAttributeTreeObjectSchemas({ objects = [] } = {}) {
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/ObjectSchemas/generatedAttributeTree/${tag}Label.js`,
+      path: `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Label.js`,
       content: _renderObjectSchema(labelSchema)
     });
   }
@@ -260,7 +257,7 @@ export function emitAttributeTreeRelationshipSchemas({
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/has${tagCap}Link.js`,
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/has${tagCap}Link.js`,
       content: _renderRelationshipSchema(`has${tagCap}Link`, hasLinkRel)
     });
 
@@ -290,7 +287,7 @@ export function emitAttributeTreeRelationshipSchemas({
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/disabled${tagCap}Link.js`,
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/disabled${tagCap}Link.js`,
       content: _renderRelationshipSchema(
         `disabled${tagCap}Link`,
         disabledLinkRel
@@ -324,7 +321,7 @@ export function emitAttributeTreeRelationshipSchemas({
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/is${tagCap}.js`,
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/is${tagCap}.js`,
       content: _renderRelationshipSchema(`is${tagCap}`, isRel)
     });
 
@@ -355,15 +352,10 @@ export function emitAttributeTreeRelationshipSchemas({
       ]
     };
     artifacts.push({
-      path: `app/src/schemas/RelationshipSchemas/generatedAttributeTree/is${tagCap}Label.js`,
+      path: `app/src/schemas/RelationshipSchemas/generatedCode/attributeTree/is${tagCap}Label.js`,
       content: _renderRelationshipSchema(`is${tagCap}Label`, isLabelRel)
     });
   }
 
   return artifacts;
 }
-
-export {
-  resolveTargetServicePath,
-  emitAttributeTreeTargetSchemas
-};

package/src/emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js

@@ -0,0 +1,132 @@
+/**
+ * Emits target ValueStandard ObjectSchema for attributeTreeTarget directives
+ */
+
+function _extractTargetDirectives(directives = []) {
+  if (!Array.isArray(directives)) {
+    return [];
+  }
+  const results = [];
+  const seenTags = new Set();
+
+  for (const directive of directives) {
+    if (
+      directive?.type === 'attributeTreeTarget' &&
+      directive?.attributeTreeTag
+    ) {
+      const tag = directive.attributeTreeTag;
+      if (seenTags.has(tag)) {
+        continue;
+      }
+      seenTags.add(tag);
+      results.push(directive);
+    }
+  }
+
+  return results;
+}
+
+function _extractStorageResources(directive) {
+  if (directive?.storageResources) {
+    return directive.storageResources;
+  }
+  return {
+    myGraph: {
+      storageType: 'graph',
+      graphServerTag: 'GraphHandler'
+    }
+  };
+}
+
+function _renderTargetValueStandardSchema(tag, storageResources) {
+  const storageResourceTags = Object.keys(storageResources);
+  if (storageResourceTags.length === 0) {
+    storageResourceTags.push('myGraph');
+  }
+
+  const storageJson = JSON.stringify(storageResources, null, 2)
+    .replace(/\n/g, '\n    ');
+  const tagsJson = JSON.stringify(storageResourceTags);
+
+  return `export default [
+  {
+    objectType: '${tag}ValueStandard',
+    canDelete: true,
+    generatedBy: 'user',
+    storageResources: ${storageJson},
+    addOnDataStructure: [
+      //(<addOnDataStructure${tag}ValueStandard>)
+      // {
+      //   type: 'propertyValue',
+      //   propertyValuePrefix: '${tag}ValueStandard'
+      // }
+      //(</addOnDataStructure${tag}ValueStandard>)
+    ],
+    fieldNames: {
+      ${tag}ValueStandardId: {
+        type: 'string',
+        randomOnCreate: true,
+        canUpdate: false,
+        storageResourceTags: ${tagsJson}
+      },
+      label: {
+        type: 'string',
+        canUpdate: true,
+        storageResourceTags: ${tagsJson}
+      },
+      value: {
+        type: 'string',
+        requiredOnCreate: true,
+        canUpdate: true,
+        storageResourceTags: ${tagsJson}
+      }
+    },
+    identifiers: [
+      {
+        type: 'identifier',
+        fieldName: '${tag}ValueStandardId'
+      }
+    ]
+  }
+];
+`;
+}
+
+export function attributeTreeTargetValueStandardManagedPaths(directives = []) {
+  const targets = _extractTargetDirectives(directives);
+  const paths = [];
+
+  for (const directive of targets) {
+    const tag = directive.attributeTreeTag;
+    paths.push(
+      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/` +
+        `${tag}ValueStandard.js`
+    );
+  }
+
+  return paths;
+}
+
+export function emitAttributeTreeTargetValueStandard({
+  directives = []
+} = {}) {
+  const targets = _extractTargetDirectives(directives);
+  if (targets.length === 0) {
+    return [];
+  }
+
+  const artifacts = [];
+
+  for (const directive of targets) {
+    const tag = directive.attributeTreeTag;
+    const storageResources = _extractStorageResources(directive);
+    artifacts.push({
+      path:
+        `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/` +
+        `${tag}ValueStandard.js`,
+      content: _renderTargetValueStandardSchema(tag, storageResources)
+    });
+  }
+
+  return artifacts;
+}

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

@@ -0,0 +1,392 @@
+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
+ */
+
+function _capitalize(str) {
+  if (!str || typeof str !== 'string') {
+    return '';
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function _createLedgerComponent(prefix) {
+  const cap = _capitalize(prefix);
+  return {
+    oldRelationshipTag: `old${cap}`,
+    newRelationshipTag: `current${cap}`,
+    objectType: `${prefix}Entry`
+  };
+}
+
+function _extractLedgers(objects = []) {
+  if (!Array.isArray(objects)) {
+    return [];
+  }
+  const results = [];
+  const seenPrefixes = new Set();
+
+  for (const object of objects) {
+    if (!Array.isArray(object?.addOnDataStructure)) {
+      continue;
+    }
+    for (const addOn of object.addOnDataStructure) {
+      if (addOn?.type === 'ledger' && addOn?.prefix) {
+        if (seenPrefixes.has(addOn.prefix)) {
+          continue;
+        }
+        seenPrefixes.add(addOn.prefix);
+        results.push({
+          parentObject: object,
+          addOn,
+          prefix: addOn.prefix,
+          component: _createLedgerComponent(addOn.prefix)
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+function _extractGraphStorageResources(object, storageResourceTag) {
+  const result = {};
+  if (object?.storageResources) {
+    if (
+      storageResourceTag &&
+      object.storageResources[storageResourceTag]?.storageType === 'graph'
+    ) {
+      let graphServerTag = 'GraphHandler';
+      if (object.storageResources[storageResourceTag].graphServerTag) {
+        graphServerTag =
+          object.storageResources[storageResourceTag].graphServerTag;
+      }
+      result[storageResourceTag] = {
+        storageType: 'graph',
+        graphServerTag
+      };
+      return result;
+    }
+    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) {
+    let defaultTag = 'graph';
+    if (storageResourceTag) {
+      defaultTag = storageResourceTag;
+    }
+    result[defaultTag] = {
+      storageType: 'graph',
+      graphServerTag: 'GraphHandler'
+    };
+  }
+  return result;
+}
+
+function _renderObjectSchema(template, schema) {
+  return ejsLib.render(template, { schema });
+}
+
+function _renderRelationshipSchema(template, relationshipTag, content) {
+  const wrapper = [{ [relationshipTag]: content }];
+  return ejsLib.render(template, {
+    relationshipTag,
+    content,
+    wrapper
+  });
+}
+
+function _buildParentToEntryLinks({
+  storageResourceTags,
+  effectiveServiceTag,
+  parentObjectType,
+  entryObjectType
+}) {
+  return [
+    {
+      storageResourceTags,
+      canDelete: true,
+      from: {
+        objType: {
+          serviceTag: effectiveServiceTag,
+          objectType: parentObjectType
+        },
+        linkType: 'many',
+        requiredOnCreate: false,
+        belongTo: true
+      },
+      to: {
+        objType: {
+          serviceTag: effectiveServiceTag,
+          objectType: entryObjectType
+        },
+        linkType: 'one',
+        requiredOnCreate: false
+      }
+    }
+  ];
+}
+
+export function ledgerObjectSchemaManagedPaths(objects = []) {
+  const ledgers = _extractLedgers(objects);
+  const paths = [];
+
+  for (const { component } of ledgers) {
+    paths.push(
+      `app/src/schemas/ObjectSchemas/generatedLedger/${component.objectType}.js`
+    );
+  }
+
+  return paths;
+}
+
+export function ledgerRelationshipSchemaManagedPaths(objects = []) {
+  const ledgers = _extractLedgers(objects);
+  const paths = [];
+
+  for (const { component, addOn } of ledgers) {
+    paths.push(
+      `app/src/schemas/RelationshipSchemas/generatedLedger/${component.newRelationshipTag}.js`,
+      `app/src/schemas/RelationshipSchemas/generatedLedger/${component.oldRelationshipTag}.js`
+    );
+
+    let hasTargets = false;
+    if (addOn?.targetObjType) {
+      hasTargets = true;
+    } else if (
+      Array.isArray(addOn?.moveToTargetObjTypes) &&
+      addOn.moveToTargetObjTypes.length > 0
+    ) {
+      hasTargets = true;
+    }
+
+    if (hasTargets) {
+      const isRelTag = `is${_capitalize(component.objectType)}`;
+      paths.push(
+        `app/src/schemas/RelationshipSchemas/generatedLedger/${isRelTag}.js`
+      );
+    }
+  }
+
+  return paths;
+}
+
+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) {
+    const objectType = component.objectType;
+    const graphStorageResources = _extractGraphStorageResources(
+      parentObject,
+      addOn.storageResourceTag
+    );
+    const storageResourceTags = Object.keys(graphStorageResources);
+
+    const schema = {
+      objectType,
+      generatedBy: 'systemNoUser',
+      canDelete: false,
+      storageResources: graphStorageResources,
+      fieldNames: {
+        [`${objectType}Id`]: {
+          storageResourceTags,
+          type: 'string',
+          randomOnCreate: true,
+          canUpdate: false,
+          requiredOnCreate: false,
+          optionalOnCreate: false
+        }
+      },
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: `${objectType}Id`
+        }
+      ]
+    };
+
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedLedger/${objectType}.js`,
+      content: _renderObjectSchema(template, schema)
+    });
+  }
+
+  return artifacts;
+}
+
+export async function emitLedgerRelationshipSchemas({
+  objects = [],
+  serviceTag = ''
+} = {}) {
+  const ledgers = _extractLedgers(objects);
+  if (ledgers.length === 0) {
+    return [];
+  }
+
+  const template = await readFile(
+    new URL('LedgerRelationshipSchema.ejs', TEMPLATE_URL),
+    'utf8'
+  );
+  const artifacts = [];
+
+  for (const { parentObject, addOn, component } of ledgers) {
+    let effectiveServiceTag = 'CurrentService';
+    if (parentObject?.serviceTag) {
+      effectiveServiceTag = parentObject.serviceTag;
+    } else if (serviceTag) {
+      effectiveServiceTag = serviceTag;
+    }
+
+    const graphStorageResources = _extractGraphStorageResources(
+      parentObject,
+      addOn.storageResourceTag
+    );
+    const storageResourceTags = Object.keys(graphStorageResources);
+
+    const parentToEntryLinks = _buildParentToEntryLinks({
+      storageResourceTags,
+      effectiveServiceTag,
+      parentObjectType: parentObject.objectType,
+      entryObjectType: component.objectType
+    });
+
+    // 1. current<Prefix>.js
+    const currentRel = {
+      generatedBy: 'user',
+      storageResources: graphStorageResources,
+      canChangeToRelTypes: [
+        {
+          relType: {
+            serviceTag: effectiveServiceTag,
+            relationshipTag: component.oldRelationshipTag
+          },
+          changeBy: 'systemWithUser'
+        }
+      ],
+      fieldNames: {
+        fromTimestamp: {
+          type: 'number',
+          requiredOnCreate: true,
+          canUpdate: false
+        }
+      },
+      links: parentToEntryLinks
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedLedger/${component.newRelationshipTag}.js`,
+      content: _renderRelationshipSchema(
+        template,
+        component.newRelationshipTag,
+        currentRel
+      )
+    });
+
+    // 2. old<Prefix>.js
+    const oldRel = {
+      generatedBy: 'systemWithUser',
+      storageResources: graphStorageResources,
+      fieldNames: {
+        fromTimestamp: {
+          type: 'number',
+          requiredOnCreate: true,
+          canUpdate: false
+        },
+        toTimestamp: {
+          type: 'number',
+          requiredOnCreate: true,
+          canUpdate: false
+        }
+      },
+      links: parentToEntryLinks
+    };
+    artifacts.push({
+      path: `app/src/schemas/RelationshipSchemas/generatedLedger/${component.oldRelationshipTag}.js`,
+      content: _renderRelationshipSchema(
+        template,
+        component.oldRelationshipTag,
+        oldRel
+      )
+    });
+
+    // 3. is<Prefix>Entry.js (if targetObjType or moveToTargetObjTypes is present)
+    const targetObjTypes = [];
+    if (addOn.targetObjType?.objectType) {
+      targetObjTypes.push(addOn.targetObjType);
+    }
+    if (Array.isArray(addOn.moveToTargetObjTypes)) {
+      for (const target of addOn.moveToTargetObjTypes) {
+        if (target?.objectType) {
+          targetObjTypes.push(target);
+        }
+      }
+    }
+
+    if (targetObjTypes.length > 0) {
+      const isRelTag = `is${_capitalize(component.objectType)}`;
+      const isLinks = [];
+
+      for (const target of targetObjTypes) {
+        let targetServiceTag = effectiveServiceTag;
+        if (target.serviceTag) {
+          targetServiceTag = target.serviceTag;
+        }
+
+        isLinks.push({
+          storageResourceTags,
+          canDelete: true,
+          from: {
+            objType: {
+              serviceTag: effectiveServiceTag,
+              objectType: component.objectType
+            },
+            linkType: 'many',
+            requiredOnCreate: false
+          },
+          to: {
+            objType: {
+              serviceTag: targetServiceTag,
+              objectType: target.objectType
+            },
+            linkType: 'one',
+            requiredOnCreate: false
+          }
+        });
+      }
+
+      const isRel = {
+        generatedBy: 'systemNoUser',
+        storageResources: graphStorageResources,
+        links: isLinks
+      };
+      artifacts.push({
+        path: `app/src/schemas/RelationshipSchemas/generatedLedger/${isRelTag}.js`,
+        content: _renderRelationshipSchema(template, isRelTag, isRel)
+      });
+    }
+  }
+
+  return artifacts;
+}

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) %>;