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

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

@@ -0,0 +1,370 @@
+/**
+ * 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(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`;
+}
+
+function _buildParentToEntryLinks({
+  storageResourceTags,
+  effectiveServiceTag,
+  parentObjectType,
+  entryObjectType
+}) {
+  return [
+    {
+      storageResourceTags,
+      canDelete: true,
+      from: {
+        objType: {
+          serviceTag: effectiveServiceTag,
+          objectType: parentObjectType
+        },
+        linkType: 'many',
+        requiredOnCreate: true,
+        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 function emitLedgerObjectSchemas({ objects = [] } = {}) {
+  const ledgers = _extractLedgers(objects);
+  if (ledgers.length === 0) {
+    return [];
+  }
+
+  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(schema)
+    });
+  }
+
+  return artifacts;
+}
+
+export function emitLedgerRelationshipSchemas({
+  objects = [],
+  serviceTag = ''
+} = {}) {
+  const ledgers = _extractLedgers(objects);
+  if (ledgers.length === 0) {
+    return [];
+  }
+
+  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(
+        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(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: true
+          },
+          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(isRelTag, isRel)
+      });
+    }
+  }
+
+  return artifacts;
+}

package/src/emit/{systemText → schemas/systemText}/emitSystemTextSchemas.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import ejsLib from 'ejs';
-import { rbacFlowTag } from '../rbac/rbacFlowTag.js';
+import { rbacFlowTag } from '../../application/rbac/rbacFlowTag.js';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 const SYSTEM_TEXT_SCHEMA_PATH =