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

package/src/emit/application/rbac/templates/ReservedUsageTtlExpired_HdrDss.ejs

@@ -0,0 +1,176 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+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 { middlewareHandler as middleware } from '@izara_project/izara-middleware';
+import Logger from '@izara_project/izara-core-library-logger';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
+/**
+ * DynamoDB Stream handler for TTL expired records in RunningTotalReservedUsage.
+ * Automatically refunds abandoned reservations with atomic decrement.
+ */
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    if (!event || !Array.isArray(event.Records)) {
+      Logger.debug('No records in DynamoDB stream event');
+      return;
+    }
+
+    let _izContext = event._izContext;
+    if (!_izContext) {
+      _izContext = {
+        logger: Logger,
+        correlationIds: new Map()
+      };
+    }
+
+    for (const record of event.Records) {
+      let recordContext = record._izContext;
+      if (!recordContext) {
+        recordContext = _izContext;
+      }
+      let recordLogger = recordContext.logger;
+      if (!recordLogger) {
+        recordLogger = Logger;
+      }
+
+      const isTtlDelete =
+        record.eventName === 'REMOVE' &&
+        record.userIdentity &&
+        record.userIdentity.type === 'Service' &&
+        record.userIdentity.principalId === 'dynamodb.amazonaws.com';
+
+      if (!isTtlDelete) {
+        continue;
+      }
+
+      const oldImage = record.dynamodb && record.dynamodb.OldImage;
+      if (!oldImage) {
+        continue;
+      }
+
+      let oldStatus = null;
+      if (oldImage.runningTotalUsageStatus && oldImage.runningTotalUsageStatus.S) {
+        oldStatus = oldImage.runningTotalUsageStatus.S;
+      }
+
+      if (oldStatus !== 'reserved') {
+        continue;
+      }
+
+      let identifiersConcat = null;
+      if (oldImage.identifiersConcat && oldImage.identifiersConcat.S) {
+        identifiersConcat = oldImage.identifiersConcat.S;
+      }
+      let flowTypeConcat = null;
+      if (oldImage.flowTypeConcat && oldImage.flowTypeConcat.S) {
+        flowTypeConcat = oldImage.flowTypeConcat.S;
+      }
+
+      if ((!identifiersConcat || !flowTypeConcat) && oldImage.runningTotalReservedId && oldImage.runningTotalReservedId.S) {
+        const reservedId = oldImage.runningTotalReservedId.S;
+        const lastUnderscoreIndex = reservedId.lastIndexOf('_');
+        if (lastUnderscoreIndex > 0) {
+          if (!identifiersConcat) {
+            identifiersConcat = reservedId.substring(0, lastUnderscoreIndex);
+          }
+          if (!flowTypeConcat) {
+            flowTypeConcat = reservedId.substring(lastUnderscoreIndex + 1);
+          }
+        }
+      }
+
+      let usageCount = 1;
+      if (oldImage.usageCount && oldImage.usageCount.N) {
+        usageCount = Number(oldImage.usageCount.N);
+      }
+
+      if (identifiersConcat && flowTypeConcat && usageCount > 0) {
+        const usageTable = dynamodbSharedLib.tableName(
+          recordContext,
+          'RunningTotalUsage'
+        );
+
+        const usageRecord = await dynamodbSharedLib.getItem(
+          recordContext,
+          usageTable,
+          {
+            identifiersConcat: identifiersConcat,
+            flowTypeConcat: flowTypeConcat
+          }
+        );
+
+        if (usageRecord) {
+          let currentTotal = 0;
+          if (typeof usageRecord.totalCount === 'number') {
+            currentTotal = usageRecord.totalCount;
+          }
+          const newTotal = Math.max(0, currentTotal - usageCount);
+          const updateUuid = recordContext.uniqueRequestId || `${Date.now()}`;
+
+          const queryElementsWhenUpdate = {
+            additionalAttributes: { currentUuid: usageRecord.updateUuid },
+            logicalElements: [
+              {
+                type: 'logical',
+                comparison: 'equals',
+                lhsAttribute: 'updateUuid',
+                rhsReference: 'currentUuid'
+              }
+            ],
+            returnValues: 'ALL_NEW'
+          };
+
+          const updateAttributes = [
+            { attributeName: 'totalCount', action: 'set', value: newTotal },
+            { attributeName: 'updateUuid', action: 'set', value: updateUuid }
+          ];
+
+          await dynamodbSharedLib.updateItem(
+            recordContext,
+            usageTable,
+            {
+              identifiersConcat: identifiersConcat,
+              flowTypeConcat: flowTypeConcat
+            },
+            updateAttributes,
+            queryElementsWhenUpdate,
+            {
+              complexAttributes: true,
+              errorOnConditionalExpNotPass: false
+            }
+          ).catch(() => null);
+
+          recordLogger.info({
+            message: '[ReservedUsageTtlExpired] Auto-refunded expired reservation',
+            identifiersConcat: identifiersConcat,
+            flowTypeConcat: flowTypeConcat,
+            usageCount: usageCount,
+            previousTotal: currentTotal,
+            newTotal: newTotal
+          });
+        }
+      }
+    }
+  } catch (err) {
+    Logger.error({
+      message: 'Unhandled error in ReservedUsageTtlExpired_HdrDss',
+      error: err
+    });
+    throw err;
+  }
+});

package/src/emit/infrastructure/functions/functionYamlArtifact.js

@@ -198,6 +198,34 @@ export function renderS3FunctionYaml({
   });
 }
 
+export function renderDssFunctionYaml({
+  functionName,
+  handlerPath,
+  roleName,
+  tableName,
+  batchSize = 100,
+  startingPosition = 'TRIM_HORIZON',
+  filterPatterns = [],
+  flowTag,
+  flowStepName
+}) {
+  return _renderFunctionTemplate('DssFunction_Yaml.ejs', {
+    functionName,
+    handlerPath,
+    roleName,
+    tableName,
+    batchSize,
+    startingPosition,
+    filterPatterns,
+    environmentSetting: _environmentSetting(
+      functionName,
+      flowTag,
+      flowStepName
+    ),
+    functionSetting: _functionSetting(functionName)
+  });
+}
+
 export function renderEventBridgeFunctionYaml({
   functionName,
   handlerPath,

package/src/emit/infrastructure/functions/templates/DssFunction_Yaml.ejs

@@ -0,0 +1,21 @@
+<%= functionName %>:
+  handler: <%= handlerPath %>
+  name: ${self:custom.iz_resourcePrefix}<%= functionName %>
+  role: <%= roleName %>
+<%- environmentSetting %><%- functionSetting %>
+  events:
+    - stream:
+        type: dynamodb
+        arn:
+          Fn::GetAtt: [<%= tableName %>Table, StreamArn]
+        batchSize: <%= batchSize %>
+        startingPosition: <%= startingPosition %>
+<% if (Array.isArray(filterPatterns) && filterPatterns.length > 0) { -%>
+        filterPatterns:
+<% filterPatterns.forEach(function(pattern) { -%>
+          - eventName: <%- JSON.stringify(pattern.eventName) %>
+            userIdentity:
+              type: <%- JSON.stringify(pattern.userIdentity.type) %>
+              principalId: <%- JSON.stringify(pattern.userIdentity.principalId) %>
+<% }); -%>
+<% } -%>

package/src/emit/infrastructure/resources/iamResourceArtifacts.js

@@ -96,9 +96,26 @@ export function getRbacValidatorServiceTags(state) {
 export async function renderLambdaRoleConfig(state) {
   const s3Flows = state.flows
     .filter((flow) => includesEvent(flow, 's3'))
-    .map((flow) => ({
-      roleName: upperFirst(flow.flowTag)
-    }));
+    .map((flow) => {
+      let quotaServiceTag = flow.quotaServiceTag;
+      if (!quotaServiceTag && flow.belongTo) {
+        if (Array.isArray(flow.belongTo)) {
+          quotaServiceTag = flow.belongTo[0]?.serviceTag;
+        } else if (flow.belongTo.serviceTag) {
+          quotaServiceTag = flow.belongTo.serviceTag;
+        }
+      }
+      if (!quotaServiceTag && flow.objType?.serviceTag) {
+        quotaServiceTag = flow.objType.serviceTag;
+      }
+      if (!quotaServiceTag) {
+        quotaServiceTag = state.project?.serviceTag || 'Rbac';
+      }
+      return {
+        roleName: upperFirst(flow.flowTag),
+        quotaServiceTag
+      };
+    });
   const rbacValidatorServiceTags = getRbacValidatorServiceTags(state);
   return renderResourceTemplate('GeneratedLambdaRoleServiceConfig.ejs', {
     crud: state.crud,
@@ -160,6 +177,19 @@ export function roleStatements(state, roleName) {
       ]
     });
   }
+  if (roleName === 'FlowRbacRole' && state.selfRbac) {
+    statements.push({
+      action: [
+        'dynamodb:DescribeStream',
+        'dynamodb:GetRecords',
+        'dynamodb:GetShardIterator',
+        'dynamodb:ListStreams'
+      ],
+      resource: [
+        'arn:aws:dynamodb:${self:custom.iz_region}:${self:custom.iz_accountId}:table/${self:custom.iz_resourcePrefix}RunningTotalReservedUsage/stream/*'
+      ]
+    });
+  }
   return statements;
 }
 
@@ -508,11 +538,16 @@ export function roleExternalTopicArns(state, roleName) {
       `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:${tag}_\${self:custom.iz_stage}_ValidatorRbac_In`
   );
   if (roleName === 'FlowObjectsRole') {
+    const extraCrudTopics = extraTags.flatMap((tag) => [
+      `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:${tag}_\${self:custom.iz_stage}_ValidatorRbac_In`,
+      `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:${tag}_\${self:custom.iz_stage}_ConfirmUsage_In`,
+      `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:${tag}_\${self:custom.iz_stage}_CancelUsage_In`
+    ]);
     return [
       `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:Rbac_\${self:custom.iz_stage}_ValidatorRbac_In`,
       `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:Rbac_\${self:custom.iz_stage}_ConfirmUsage_In`,
       `arn:aws:sns:\${self:custom.iz_region}:\${self:custom.iz_accountId}:Rbac_\${self:custom.iz_stage}_CancelUsage_In`,
-      ...extraTopics
+      ...extraCrudTopics
     ];
   }
   if (roleName === 'FlowRbacRole' || roleName === 'FlowRelationshipRole') {
@@ -536,11 +571,16 @@ export function roleExternalLambdaArns(state, roleName) {
       `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:${tag}\${self:custom.iz_stage}ValidatorRbacHdrInv`
   );
   if (roleName === 'FlowObjectsRole') {
+    const extraCrudLambdas = extraTags.flatMap((tag) => [
+      `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:${tag}\${self:custom.iz_stage}ValidatorRbacHdrInv`,
+      `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:${tag}\${self:custom.iz_stage}ConfirmUsageHdrInv`,
+      `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:${tag}\${self:custom.iz_stage}CancelUsageHdrInv`
+    ]);
     return [
       `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:Rbac\${self:custom.iz_stage}ValidatorRbacHdrInv`,
       `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:Rbac\${self:custom.iz_stage}ConfirmUsageHdrInv`,
       `arn:aws:lambda:\${self:custom.iz_region}:\${self:custom.iz_accountId}:function:Rbac\${self:custom.iz_stage}CancelUsageHdrInv`,
-      ...extraLambdas
+      ...extraCrudLambdas
     ];
   }
   if (roleName === 'FlowRbacRole' || roleName === 'FlowRelationshipRole') {

package/src/emit/infrastructure/resources/templates/GeneratedLambdaRoleServiceConfig.ejs

@@ -60,7 +60,9 @@ export function generatedLambdaRole() {
             `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ConfirmUsage_In', 'Rbac')}`,
             `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'CancelUsage_In', 'Rbac')}`<% if (rbac) { %>,
             `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ValidatorRbac_In')}`<% } %><% (rbacValidatorServiceTags || []).forEach(function(tag) { %>,
-            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ValidatorRbac_In', '<%= tag %>')}`<% }); %>
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ValidatorRbac_In', '<%= tag %>')}`,
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ConfirmUsage_In', '<%= tag %>')}`,
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'CancelUsage_In', '<%= tag %>')}`<% }); %>
           ]
         }<% } %>
         //(<createFlowObjectsRole>)
@@ -144,7 +146,7 @@ export function generatedLambdaRole() {
           Effect: 'Allow',
           Action: ['sns:Publish'],
           Resource: [
-            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ReservedDynamicUsage_In', 'AccountLimits')}`
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ReservedDynamicUsage_In', '<%= flow.quotaServiceTag || 'Rbac' %>')}`
           ]
         },
 
@@ -153,7 +155,7 @@ export function generatedLambdaRole() {
           Effect: 'Allow',
           Action: ['sns:Publish'],
           Resource: [
-            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ConfirmDynamicAfterUpload_In', 'AccountLimits')}`
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ConfirmDynamicAfterUpload_In', '<%= flow.quotaServiceTag || 'Rbac' %>')}`
           ]
         }
         //(<create<%= flow.roleName %>Role>)

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

@@ -62,6 +62,60 @@ function _renderRelationshipSchema(relationshipTag, content) {
   return `export default ${JSON.stringify(wrapper, null, 2)};\n`;
 }
 
+function _renderValueStandardSchema(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 attributeTreeObjectSchemaManagedPaths(objects = []) {
   const trees = _extractAttributeTrees(objects);
   const paths = [];
@@ -71,7 +125,8 @@ export function attributeTreeObjectSchemaManagedPaths(objects = []) {
     paths.push(
       `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`
+      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Label.js`,
+      `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}ValueStandard.js`
     );
   }
 
@@ -205,6 +260,12 @@ export function emitAttributeTreeObjectSchemas({ objects = [] } = {}) {
       path: `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}Label.js`,
       content: _renderObjectSchema(labelSchema)
     });
+
+    // 4. {tag}ValueStandard.js
+    artifacts.push({
+      path: `app/src/schemas/ObjectSchemas/generatedCode/attributeTree/${tag}ValueStandard.js`,
+      content: _renderValueStandardSchema(tag, graphStorageResources)
+    });
   }
 
   return artifacts;

package/src/generate.js

@@ -4,7 +4,6 @@ import { commitArtifacts } from './output/commitArtifacts.js';
 import { compileProject } from './compile/compileProject.js';
 import {
   loadLocalSchemaDirectory,
-  loadGenerateDirectives,
   resolveExtendedObjectSchemas,
   resolveGraphServiceTags
 } from './compile/loadSchemas.js';
@@ -22,8 +21,7 @@ export async function generate(rootPath, options = {}) {
       relationships,
       flows,
       notifications,
-      errors,
-      directives
+      errors
     ] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(
@@ -37,8 +35,7 @@ export async function generate(rootPath, options = {}) {
         'NotificationSchemas',
         schemaLoadOptions
       ),
-      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions),
-      loadGenerateDirectives(project, schemaLoadOptions)
+      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -82,7 +79,6 @@ export async function generate(rootPath, options = {}) {
       flows,
       notifications,
       errors,
-      directives,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger

package/src/output/mergeHooks.js

@@ -40,6 +40,14 @@ async function mergeHook(outputRoot, artifact) {
     return artifact.content;
   }
 
+  _validateHookIntegrity(artifact.path, sourceContent);
+  _warnOrphanedHooks(
+    artifact.path,
+    sourceContent,
+    artifact.content,
+    matchers
+  );
+
   const tagOccurrences = new Map();
   return artifact.content.replace(
     matchers.anyTag,
@@ -60,13 +68,105 @@ async function mergeHook(outputRoot, artifact) {
       }
       const hookBlock = matches[count];
       if (hookBlock !== null && hookBlock !== undefined) {
-        return hookBlock;
+        return _normalizeHookBlock(hookBlock, tagName);
       }
       return _match;
     }
   );
 }
 
+function _validateHookIntegrity(filePath, content) {
+  const lower = filePath.toLowerCase();
+  let openCount = 0;
+  let closeCount = 0;
+
+  if (
+    lower.endsWith('.js') ||
+    lower.endsWith('.mjs') ||
+    lower.endsWith('.cjs')
+  ) {
+    const openP1 = content.match(/\/\/\s*\(<\s*[\w.-]+/g);
+    const closeP1 = content.match(/\/\/\s*\(<\/\s*[\w.-]+/g);
+    const openP2 = content.match(/\/\/\s*<#\s*[\w.-]+/g);
+    const closeP2 = content.match(/\/\/\s*<#\/\s*[\w.-]+/g);
+
+    if (openP1) {
+      openCount += openP1.length;
+    }
+    if (closeP1) {
+      closeCount += closeP1.length;
+    }
+    if (openP2) {
+      openCount += openP2.length;
+    }
+    if (closeP2) {
+      closeCount += closeP2.length;
+    }
+  } else if (lower.endsWith('.yml') || lower.endsWith('.yaml')) {
+    const openYml = content.match(/#\s*<#\s*[\w.-]+/g);
+    const closeYml = content.match(/#\s*<#\/\s*[\w.-]+/g);
+
+    if (openYml) {
+      openCount += openYml.length;
+    }
+    if (closeYml) {
+      closeCount += closeYml.length;
+    }
+  }
+
+  if (openCount !== closeCount) {
+    throw new Error(
+      `[mergeHooks] Malformed hook tags in '${filePath}': found ` +
+      `${openCount} open tag(s) but ${closeCount} close tag(s). ` +
+      `Aborting to prevent code loss.`
+    );
+  }
+}
+
+function _warnOrphanedHooks(
+  filePath,
+  sourceContent,
+  artifactContent,
+  matchers
+) {
+  const anyTagRegex = new RegExp(matchers.anyTag.source, 'gm');
+  let match = anyTagRegex.exec(sourceContent);
+
+  while (match !== null) {
+    const tagName = _extractTagName(match[1], match[3]);
+    let body = '';
+    if (typeof match[2] === 'string') {
+      body = match[2];
+    } else if (typeof match[4] === 'string') {
+      body = match[4];
+    }
+
+    if (tagName && body.trim().length > 0) {
+      const templatePattern = matchers.tagPattern(tagName);
+      const existsInTemplate = templatePattern.test(artifactContent);
+      if (!existsInTemplate) {
+        console.warn(
+          `[WARN] [mergeHooks] Hook '${tagName}' in '${filePath}' ` +
+          `contains custom code but is no longer present in template.`
+        );
+      }
+    }
+    match = anyTagRegex.exec(sourceContent);
+  }
+}
+
+function _normalizeHookBlock(hookBlock, tagName) {
+  if (typeof hookBlock !== 'string' || hookBlock.length === 0) {
+    return hookBlock;
+  }
+  const esc = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const openRegex = new RegExp(`(//\\s*\\(<\\s*${esc}\\s*)(?!>)\\)`);
+  const closeRegex = new RegExp(`(//\\s*\\(<\\/\\s*${esc}\\s*)(?!>)\\)`);
+  let normalized = hookBlock.replace(openRegex, '$1>)');
+  normalized = normalized.replace(closeRegex, '$1>)');
+  return normalized;
+}
+
 function _extractTagName(p1, p2) {
   if (typeof p1 === 'string' && p1.length > 0) {
     return p1;
@@ -85,8 +185,8 @@ function hookMatchers(filePath) {
     lower.endsWith('.cjs')
   ) {
     const jsP1 =
-      '\\/\\/\\s*\\(<\\s*([\\w.-]+)\\s*>\\)([\\s\\S]*?)' +
-      '\\/\\/\\s*\\(<\\/\\s*\\1\\s*>\\)';
+      '\\/\\/\\s*\\(<\\s*([\\w.-]+)\\s*>?\\s*\\)([\\s\\S]*?)' +
+      '\\/\\/\\s*\\(<\\/\\s*\\1\\s*>?\\s*\\)';
     const jsP2 =
       '\\/\\/\\s*<#\\s*([\\w.-]+)\\s*#>([\\s\\S]*?)' +
       '\\/\\/\\s*<#\\/\\s*\\3\\s*#>';
@@ -95,8 +195,8 @@ function hookMatchers(filePath) {
       tagPattern: (name) => {
         const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const p1 =
-          `\\/\\/\\s*\\(<\\s*${esc}\\s*>\\)([\\s\\S]*?)` +
-          `\\/\\/\\s*\\(<\\/\\s*${esc}\\s*>\\)`;
+          `\\/\\/\\s*\\(<\\s*${esc}\\s*>?\\s*\\)([\\s\\S]*?)` +
+          `\\/\\/\\s*\\(<\\/\\s*${esc}\\s*>?\\s*\\)`;
         const p2 =
           `\\/\\/\\s*<#\\s*${esc}\\s*#>([\\s\\S]*?)` +
           `\\/\\/\\s*<#\\/\\s*${esc}\\s*#>`;

package/src/plan/domainRegistry.js

@@ -52,10 +52,6 @@ import {
   attributeTreeObjectSchemaManagedPaths,
   attributeTreeRelationshipSchemaManagedPaths
 } from '../emit/schemas/attributeTree/emitAttributeTreeSchemas.js';
-import {
-  emitAttributeTreeTargetValueStandard,
-  attributeTreeTargetValueStandardManagedPaths
-} from '../emit/schemas/attributeTree/emitAttributeTreeTargetValueStandard.js';
 import {
   emitLedgerObjectSchemas,
   emitLedgerRelationshipSchemas,
@@ -81,7 +77,6 @@ export async function resolveEmissionGroups(context) {
     flows,
     notifications,
     errors,
-    directives = [],
     objectGraphServiceTags,
     relationshipGraphServiceTags,
     logger
@@ -206,11 +201,6 @@ export async function resolveEmissionGroups(context) {
       managedPaths: rbacFlowSchemaManagedPaths(objects),
       artifacts: rbacFlowArtifacts
     },
-    {
-      scope: 'attribute-tree-target-value-standard',
-      managedPaths: attributeTreeTargetValueStandardManagedPaths(directives),
-      artifacts: emitAttributeTreeTargetValueStandard({ directives })
-    },
     {
       scope: 'attribute-tree-object-schemas',
       managedPaths: attributeTreeObjectSchemaManagedPaths(objects),