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

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

@@ -181,6 +181,7 @@ export function renderS3FunctionYaml({
   handlerPath,
   roleName,
   bucketName,
+  s3KeyPrefix,
   flowTag,
   flowStepName
 }) {
@@ -189,6 +190,35 @@ export function renderS3FunctionYaml({
     handlerPath,
     roleName,
     bucketName,
+    s3KeyPrefix,
+    environmentSetting: _environmentSetting(
+      functionName,
+      flowTag,
+      flowStepName
+    ),
+    functionSetting: _functionSetting(functionName)
+  });
+}
+
+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,
@@ -314,15 +344,8 @@ function _sqsFilterPatterns(
           - body:
               MessageAttributes:
                 callingFlow:
-                  Value:
+                  StringValue:
                     - \${self:custom.iz_resourcePrefix}${callingFlowName}
-          - body:
-              MessageAttributes:
-                callingFlow:
-                  - exists: false
-          - body:
-              MessageAttributes:
-                - exists: false
         #<#/${hookFunctionName}FilterPatterns#>
 `;
 }

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/functions/templates/S3Function_Yaml.ejs

@@ -8,9 +8,8 @@
         bucket: <%= bucketName %>
         event: s3:ObjectCreated:*
         existing: true
-        rules:
+        rules:<% if (s3KeyPrefix) { %>
+          - prefix: <%- s3KeyPrefix %><% } %>
         #<#<%= functionName %>rules#>
         #<#/<%= functionName %>rules#>
-          - prefix: uploads/
-          - suffix: .csv
         forceDeploy: true

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,
@@ -122,6 +139,25 @@ export function roleStatements(state, roleName) {
       resource: ['arn:aws:s3:::${self:custom.iz_serviceSchemaBucketName}']
     });
   }
+  const s3FlowsForRole = (state.flows || []).filter((candidate) => {
+    const roleCandidate = customFlowRoleName(candidate?.flowTag ?? '');
+    return (
+      roleCandidate === roleName &&
+      includesEvent(candidate, 's3') &&
+      Boolean(candidate.bucketName)
+    );
+  });
+  if (s3FlowsForRole.length > 0) {
+    const bucketResources = [
+      ...new Set(
+        s3FlowsForRole.map((flow) => `arn:aws:s3:::${flow.bucketName}/*`)
+      )
+    ].sort();
+    statements.push({
+      action: ['s3:GetObject'],
+      resource: bucketResources
+    });
+  }
   addStatement(statements, dynamoActionsForRole(roleName), [
     ...dynamoArns(roleTableNames(state, roleName)),
     ...externalDynamoArns(roleExternalDynamoTables(state, roleName))
@@ -160,6 +196,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;
 }
 
@@ -449,6 +498,9 @@ export function roleTopicNames(state, roleName) {
     if (flowHasOwnTopic(flow)) {
       topics.push(`${name}_In`);
     }
+    if (includesEvent(flow, 's3')) {
+      topics.push('Create_In');
+    }
     return topics;
   }
   return [];
@@ -508,11 +560,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 +593,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/resourceState.js

@@ -4,7 +4,8 @@ import {
   flowExtTopicSteps,
   generatedDsqFlows,
   generatedOwnTopicFlows,
-  supportedCustomFlows
+  supportedCustomFlows,
+  resolveS3Parts
 } from '../../application/custom/customFlows.js';
 import { hasSystemWebSocket } from '../../application/system/emitSystemWebSocketArtifacts.js';
 import { rbacFlowTag } from '../../application/rbac/rbacFlowTag.js';
@@ -161,9 +162,12 @@ export function createResourceState({ objects, relationships, flows }) {
 
   for (const flow of flows.filter((flow) => includesEvent(flow, 's3'))) {
     const tag = upperFirst(flow.flowTag);
-    customSqsQueues.push(`${tag}CreatePreSignUrlHdrSqs`);
-    customSqsQueues.push(`${tag}ReservedLimitHdrSqs`);
-    customSqsQueues.push(`${tag}ConfirmAfterUploadHdrSqs`);
+    const parts = resolveS3Parts(flow);
+    for (const part of parts) {
+      if (part.type === 'sqs') {
+        customSqsQueues.push(`${tag}${part.action}HdrSqs`);
+      }
+    }
   }
 
   const customDsqQueues = flows
@@ -281,8 +285,14 @@ export function createResourceState({ objects, relationships, flows }) {
           topicName = `Out${upperFirst(flow.outputTopic)}`;
         }
       }
+      let targetAction = 'ReservedLimit';
+      const parts = resolveS3Parts(flow);
+      const firstSqsPart = parts.find((p) => p.type === 'sqs');
+      if (firstSqsPart && firstSqsPart.action) {
+        targetAction = firstSqsPart.action;
+      }
       const queueName =
-        flow.s3Subscription?.queueName || `${tag}ReservedLimitHdrSqs`;
+        flow.s3Subscription?.queueName || `${tag}${targetAction}HdrSqs`;
       const subscriptionName =
         flow.s3Subscription?.subscriptionName ||
         `Subscription${topicName}To${queueName}`;

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

@@ -1,13 +1,29 @@
 import { indentYaml, renderResourceTemplate } from './resourceTemplate.js';
 
+export function toAlphanumericPascalCase(str) {
+  if (!str) {
+    return '';
+  }
+  const parts = str.split(/[^a-zA-Z0-9]+/);
+  const validParts = parts.filter(Boolean);
+  const capitalizedParts = validParts.map((word) => {
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  });
+  return capitalizedParts.join('');
+}
+
 export async function renderS3(state) {
   if (state.s3Buckets.length === 0) {
     return '';
   }
   const renderedBuckets = await Promise.all(
-    state.s3Buckets.map((bucketName) =>
-      renderResourceTemplate('S3Bucket_Yaml.ejs', { bucketName })
-    )
+    state.s3Buckets.map((bucketName) => {
+      const bucketLogicalId = `${toAlphanumericPascalCase(bucketName)}S3Bucket`;
+      return renderResourceTemplate('S3Bucket_Yaml.ejs', {
+        bucketName,
+        bucketLogicalId
+      });
+    })
   );
   const body = renderedBuckets.join('\n');
   return `Resources:\n${indentYaml(body, 2)}`;

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/infrastructure/resources/templates/S3Bucket_Yaml.ejs

@@ -1,5 +1,5 @@
 ##===== [S3 Bucket: <%- bucketName %>]
-<%- bucketName %>S3Bucket:
+<%- bucketLogicalId %>:
   Type: AWS::S3::Bucket
   Properties:
     BucketName: <%- bucketName %>

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

@@ -230,7 +230,7 @@ Resources:
         - AttributeName: cacheKey
           KeyType: RANGE
       TimeToLiveSpecification:
-        AttributeName: ttlTimestamp
+        AttributeName: expirationTime
         Enabled: true
 
   RunningTotalUsageTable:
@@ -265,7 +265,7 @@ Resources:
         - AttributeName: usedTimestampId
           KeyType: RANGE
       TimeToLiveSpecification:
-        AttributeName: ttlTimestamp
+        AttributeName: expirationTime
         Enabled: true
       StreamSpecification:
         StreamViewType: NEW_AND_OLD_IMAGES

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/emit/schemas/error/emitErrorSchemas.js

@@ -1,19 +1,43 @@
+import { existsSync, readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import ejsLib from 'ejs';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 export const ERROR_SCHEMA_PATH =
-  'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js';
+  'app/src/schemas/ErrorSchemas/generateCode/errorConsts.js';
+export const ERROR_CONSTS_PATH = ERROR_SCHEMA_PATH;
+
+export const SHARED_ERROR_PACKAGE_PATH = 'libs/errorLib/package.json';
+export const SHARED_ERROR_INDEX_PATH = 'libs/errorLib/index.js';
+export const SHARED_ERROR_CONSTS_PATH = 'libs/errorLib/src/errorConsts.js';
 
 export function errorSchemaManagedPaths(errors = []) {
   if (!errors || errors.length === 0) {
     return [];
   }
-  return [ERROR_SCHEMA_PATH];
+  const paths = [ERROR_SCHEMA_PATH];
+  const safeErrors = Array.isArray(errors) ? errors : [];
+  let hasShared = false;
+  for (const item of safeErrors) {
+    if (item && item.sharedLibrary === true) {
+      hasShared = true;
+      break;
+    }
+  }
+  if (hasShared) {
+    paths.push(
+      SHARED_ERROR_PACKAGE_PATH,
+      SHARED_ERROR_INDEX_PATH,
+      SHARED_ERROR_CONSTS_PATH
+    );
+  }
+  return paths;
 }
 
 /**
- * Emits errorSchema.js artifact based on loaded ErrorSchemas
+ * Emits errorConsts.js artifact and shared library artifacts based on
+ * loaded ErrorSchemas
  *
  * @param {Object} params
  * @param {Object} params.project
@@ -31,21 +55,28 @@ export async function emitErrorSchemas({
     return [];
   }
 
-  const defaultGraphServiceTag =
-    objectGraphServiceTags[0] || 'GraphHandler';
   const defaultServiceTag = project?.serviceTag || '';
 
   const errorTypes = {};
+  const sharedErrorTypes = {};
+
   for (const item of safeErrors) {
     if (!item || typeof item !== 'object' || !item.errorTag) {
       continue;
     }
     const errorTag = item.errorTag;
-    const serviceTag = item.serviceTag || defaultServiceTag;
-    errorTypes[errorTag] = {
+    let serviceTag = item.serviceTag;
+    if (!serviceTag) {
+      serviceTag = defaultServiceTag;
+    }
+    const errorEntry = {
       errorTag,
       serviceTag
     };
+    errorTypes[errorTag] = errorEntry;
+    if (item.sharedLibrary === true) {
+      sharedErrorTypes[errorTag] = errorEntry;
+    }
   }
 
   const sortedKeys = Object.keys(errorTypes).sort();
@@ -58,16 +89,95 @@ export async function emitErrorSchemas({
     sortedErrorTypes[key] = errorTypes[key];
   }
 
-  const templatePath = new URL('errorSchema.ejs', TEMPLATE_URL);
+  const templatePath = new URL('errorConsts.ejs', TEMPLATE_URL);
   const template = await readFile(templatePath, 'utf8');
   const content = ejsLib.render(template, {
-    errorTypes: sortedErrorTypes
+    errorTypes: sortedErrorTypes,
+    headerComment: null
   });
 
-  return [
+  const artifacts = [
     {
       path: ERROR_SCHEMA_PATH,
       content
     }
   ];
+
+  const sortedSharedKeys = Object.keys(sharedErrorTypes).sort();
+  if (sortedSharedKeys.length > 0) {
+    const sortedSharedErrorTypes = {};
+    for (const key of sortedSharedKeys) {
+      sortedSharedErrorTypes[key] = sharedErrorTypes[key];
+    }
+
+    const sharedContent = ejsLib.render(template, {
+      errorTypes: sortedSharedErrorTypes,
+      headerComment: '// only generate error that sharedLibrary: true'
+    });
+
+    let serviceName = 'service';
+    if (project?.serviceTag) {
+      serviceName = project.serviceTag.toLowerCase();
+    }
+    const packageName = `@izara_project/izara-${serviceName}-library-errorlib`;
+
+    let packageJson = {
+      name: packageName,
+      version: '1.0.0',
+      description: '',
+      type: 'module',
+      main: 'index.js',
+      scripts: {},
+      keywords: [],
+      author: '',
+      license: 'ISC',
+      devDependencies: {},
+      dependencies: {}
+    };
+
+    let targetDir = project?.outputPath;
+    if (!targetDir) {
+      targetDir = project?.rootPath;
+    }
+    if (targetDir) {
+      const existingPkgPath = join(targetDir, SHARED_ERROR_PACKAGE_PATH);
+      if (existsSync(existingPkgPath)) {
+        try {
+          const raw = readFileSync(existingPkgPath, 'utf8');
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === 'object') {
+            packageJson = {
+              ...parsed,
+              name: packageName,
+              type: 'module',
+              main: 'index.js'
+            };
+          }
+        } catch {
+          // If parsing fails (e.g. comments in JSON), use default packageJson
+        }
+      }
+    }
+
+    const packageJsonContent = `${JSON.stringify(packageJson, null, 2)}\n`;
+    const indexContent =
+      "import * as errorLib from './src/errorConsts.js';\n\nexport { errorLib };\n";
+
+    artifacts.push(
+      {
+        path: SHARED_ERROR_PACKAGE_PATH,
+        content: packageJsonContent
+      },
+      {
+        path: SHARED_ERROR_INDEX_PATH,
+        content: indexContent
+      },
+      {
+        path: SHARED_ERROR_CONSTS_PATH,
+        content: sharedContent
+      }
+    );
+  }
+
+  return artifacts;
 }

package/src/emit/schemas/error/templates/errorConsts.ejs

@@ -0,0 +1,12 @@
+<% if (locals.headerComment) { -%>
+<%- headerComment %>
+<% } -%>
+export const ERROR_TYPES = {
+<% const keys = Object.keys(errorTypes); -%>
+<% keys.forEach((key, index) => { -%>
+  <%- key %>: {
+    errorTag: '<%- errorTypes[key].errorTag %>',
+    serviceTag: '<%- errorTypes[key].serviceTag %>'
+  }<%- index < keys.length - 1 ? ',' : '' %>
+<% }); -%>
+};