@izara_project/izara-core-generate-service-code 1.0.68 → 1.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.68",
+  "version": "1.0.70",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/scripts/format-ejs.js

@@ -34,8 +34,7 @@ export async function formatEjsFiles(targetDir = 'src/emit') {
       const id = placeholders.length;
       const isExpr = match.startsWith('<%=') || match.startsWith('<%-');
       const isConditionalComma =
-        match.includes('?') &&
-        (match.includes("','") || match.includes('","'));
+        match.includes('?') && (match.includes("','") || match.includes('","'));
 
       let replacement;
       if (isYaml) {
@@ -58,38 +57,42 @@ export async function formatEjsFiles(targetDir = 'src/emit') {
       return replacement;
     });
 
-    const parser = isYaml ? 'yaml' : 'babel';
-    let formatted = await prettier.format(masked, {
-      parser,
-      singleQuote: true,
-      semi: true,
-      tabWidth: 2,
-      useTabs: false,
-      trailingComma: 'none',
-      printWidth: 80,
-      endOfLine: 'lf'
-    });
+    try {
+      const parser = isYaml ? 'yaml' : 'babel';
+      let formatted = await prettier.format(masked, {
+        parser,
+        singleQuote: true,
+        semi: true,
+        tabWidth: 2,
+        useTabs: false,
+        trailingComma: 'none',
+        printWidth: 80,
+        endOfLine: 'lf'
+      });
 
-    for (const item of placeholders) {
-      if (item.isConditionalComma) {
-        formatted = formatted.replace(item.replacement, item.original);
-        formatted = formatted.replace(
-          `, /*__EJS_COMMA_${item.id}__*/`,
-          item.original
-        );
-      } else {
-        formatted = formatted.replace(item.replacement, item.original);
+      for (const item of placeholders) {
+        if (item.isConditionalComma) {
+          formatted = formatted.replace(item.replacement, item.original);
+          formatted = formatted.replace(
+            `, /*__EJS_COMMA_${item.id}__*/`,
+            item.original
+          );
+        } else {
+          formatted = formatted.replace(item.replacement, item.original);
+        }
       }
-    }
 
-    // Ensure unix newline at EOF
-    if (!formatted.endsWith('\n')) {
-      formatted += '\n';
-    }
+      // Ensure unix newline at EOF
+      if (!formatted.endsWith('\n')) {
+        formatted += '\n';
+      }
 
-    if (formatted !== content) {
-      fs.writeFileSync(filePath, formatted, 'utf8');
-      updatedCount++;
+      if (formatted !== content) {
+        fs.writeFileSync(filePath, formatted, 'utf8');
+        updatedCount++;
+      }
+    } catch (err) {
+      console.warn(`[WARN] Skipping ${filePath}: prettier error: ${err.message}`);
     }
   }
 
@@ -97,9 +100,10 @@ export async function formatEjsFiles(targetDir = 'src/emit') {
 }
 
 if (process.argv[1] === new URL(import.meta.url).pathname) {
-  formatEjsFiles().then(({ total, updated }) => {
+  const targetDir = process.argv[2] || 'src/emit';
+  formatEjsFiles(targetDir).then(({ total, updated }) => {
     console.log(
-      `Successfully formatted ${updated} / ${total} EJS template files in src/emit.`
+      `Successfully formatted ${updated} / ${total} EJS template files in ${targetDir}.`
     );
   });
 }

package/src/compile/compileProject.js

@@ -1,17 +1,24 @@
+import Logger from '@izara_project/izara-core-library-logger';
 import { join, resolve } from 'node:path';
 import { readFileSync, existsSync } from 'node:fs';
 import { parse as parseYaml } from 'yaml';
 
 export function compileProject(request = {}) {
-  if (!isNonEmptyString(request.rootPath)) {
-    throw new TypeError('GenerationRequest.rootPath must be a non-empty string');
+  if (!_isNonEmptyString(request.rootPath)) {
+    throw new TypeError(
+      'GenerationRequest.rootPath must be a non-empty string'
+    );
   }
 
   const rootPath = resolve(request.rootPath);
-  const outputPath = resolve(request.outputPath ?? rootPath);
-  const configPath = resolve(
-    request.configPath ?? join(rootPath, 'config', 'serverless.config.yml')
-  );
+  let outputPath = rootPath;
+  if (request.outputPath) {
+    outputPath = resolve(request.outputPath);
+  }
+  let configPath = join(rootPath, 'config', 'serverless.config.yml');
+  if (request.configPath) {
+    configPath = resolve(request.configPath);
+  }
 
   let serviceTag = request.serviceTag;
   if (!serviceTag && existsSync(configPath)) {
@@ -19,23 +26,32 @@ export function compileProject(request = {}) {
       const configContent = readFileSync(configPath, 'utf8');
       const parsedConfig = parseYaml(configContent);
       if (parsedConfig && parsedConfig.main_config) {
-        serviceTag = parsedConfig.main_config.iz_serviceTag || parsedConfig.main_config.iz_serviceName;
+        if (parsedConfig.main_config.iz_serviceTag) {
+          serviceTag = parsedConfig.main_config.iz_serviceTag;
+        } else if (parsedConfig.main_config.iz_serviceName) {
+          serviceTag = parsedConfig.main_config.iz_serviceName;
+        }
       }
     } catch (err) {
-      // Ignore configuration read error
+      Logger?.debug?.('Could not read serverless.config.yml', err);
     }
   }
 
+  let schemaTemplateConfig = [];
+  if (request.schemaTemplateConfig) {
+    schemaTemplateConfig = request.schemaTemplateConfig;
+  }
+
   return Object.freeze({
     rootPath,
     outputPath,
     configPath,
     schemaRoot: join(rootPath, 'app', 'src', 'schemas'),
     serviceTag,
-    schemaTemplateConfig: request.schemaTemplateConfig ?? []
+    schemaTemplateConfig
   });
 }
 
-function isNonEmptyString(value) {
+function _isNonEmptyString(value) {
   return typeof value === 'string' && value.trim() !== '';
 }

package/src/compile/loadSchemas.js

@@ -1,7 +1,10 @@
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { getObjectSchema, utils } from '@izara_project/izara-core-library-service-schemas';
+import {
+  getObjectSchema,
+  utils
+} from '@izara_project/izara-core-library-service-schemas';
 import Logger from '@izara_project/izara-core-library-logger';
 
 export async function loadLocalSchemaDirectory(project, directoryName) {
@@ -16,35 +19,61 @@ export async function loadLocalSchemaDirectory(project, directoryName) {
     throw error;
   }
 
+  const validEntries = entries.filter(
+    (entry) => entry.isFile() && entry.name.endsWith('.js')
+  );
+  validEntries.sort((a, b) => a.name.localeCompare(b.name));
+
   const schemas = [];
-  for (const entry of entries.filter(entry => entry.isFile() && entry.name.endsWith('.js')).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of validEntries) {
     const filePath = join(directoryPath, entry.name);
     const details = await stat(filePath);
-    const module = await import(`${pathToFileURL(filePath).href}?schemaVersion=${details.mtimeMs}-${details.size}`);
+    const module = await import(
+      `${pathToFileURL(filePath).href}?schemaVersion=${details.mtimeMs}-${details.size}`
+    );
     if (!module.default || typeof module.default !== 'object') {
-      throw new TypeError(`Schema module must default-export an object or array: ${filePath}`);
+      throw new TypeError(
+        `Schema module must default-export an object or array: ${filePath}`
+      );
+    }
+    let loadedSchemas = [module.default];
+    if (Array.isArray(module.default)) {
+      loadedSchemas = module.default;
     }
-    const loadedSchemas = Array.isArray(module.default) ? module.default : [module.default];
 
-    if (process.env.NODE_ENV !== 'test') {
+    if (process.env.NODE_ENV && process.env.NODE_ENV !== 'test') {
       for (const schema of loadedSchemas) {
         let status = true;
         let errors = [];
-        
+
         if (directoryName === 'ObjectSchemas') {
-          [status, errors] = utils.validateObjectSchema({ logger: Logger }, schema);
+          [status, errors] = utils.validateObjectSchema(
+            { logger: Logger },
+            schema
+          );
         } else if (directoryName === 'RelationshipSchemas') {
           if (entry.name.toLowerCase() === 'refobjectrelationships.js') {
-            [status, errors] = utils.validateRefRelationshipSchema({ logger: Logger }, schema);
+            [status, errors] = utils.validateRefRelationshipSchema(
+              { logger: Logger },
+              schema
+            );
           } else {
-            [status, errors] = utils.validateRelationshipSchema({ logger: Logger }, schema);
+            [status, errors] = utils.validateRelationshipSchema(
+              { logger: Logger },
+              schema
+            );
           }
         } else if (directoryName === 'FlowSchemas') {
-          [status, errors] = utils.validateBasicFlowSchema({ logger: Logger }, schema);
+          [status, errors] = utils.validateBasicFlowSchema(
+            { logger: Logger },
+            schema
+          );
         }
 
         if (!status) {
-          throw new Error(`Schema validation failed for ${entry.name}:\n${errors.join('\n')}`);
+          throw new Error(
+            `Schema validation failed for ${entry.name}:\n${errors.join('\n')}`
+          );
         }
       }
     }
@@ -70,66 +99,100 @@ export async function loadLocalSchemaDirectory(project, directoryName) {
  */
 export async function resolveExtendedObjectSchemas(
   objectSchemas,
-  bucketName
+  bucketName = process.env.iz_serviceSchemaBucketName
 ) {
   if (!Array.isArray(objectSchemas)) {
     throw new TypeError('objectSchemas must be an array');
   }
   const resolvedSchemas = [];
   for (const schema of objectSchemas) {
-    if (!schema.hasOwnProperty('extendObjType')) {
-      resolvedSchemas.push(schema);
-      continue;
-    }
-    try {
-      // Track which storageResource keys existed in the child before merge
-      const childStorageResourceKeys = new Set(
-        Object.keys(schema.storageResources ?? {})
-      );
-      const parentServiceTag = schema.extendObjType.serviceTag;
+    let currentSchema = schema;
+    if (currentSchema.hasOwnProperty('extendObjType')) {
+      try {
+        Logger.debug(
+          `[DEBUG] [resolveExtendedObjectSchemas] Merging extendObjType for objectType=${currentSchema.objectType}`,
+          { extendObjType: currentSchema.extendObjType }
+        );
+        const initialResources = currentSchema.storageResources || {};
+        const childStorageResourceKeys = new Set(Object.keys(initialResources));
+        const parentServiceTag = currentSchema.extendObjType.serviceTag;
 
-      const mergedSchema = await getObjectSchema.mergeExtendObjSchema(
-        { logger: Logger },
-        schema,
-        bucketName
-      );
+        const mergedSchema = await getObjectSchema.mergeExtendObjSchema(
+          { logger: Logger },
+          currentSchema,
+          bucketName
+        );
+
+        const externalDynamoResources = [];
+        const ownStorageResources = {};
+        const mergedStorageResources = mergedSchema.storageResources || {};
+        for (const [key, resource] of Object.entries(mergedStorageResources)) {
+          if (
+            resource &&
+            resource.storageType === 'dynamoDB' &&
+            !childStorageResourceKeys.has(key)
+          ) {
+            externalDynamoResources.push({
+              serviceTag: parentServiceTag,
+              tableName: resource.tableName
+            });
+          } else {
+            ownStorageResources[key] = resource;
+          }
+        }
 
-      // Separate parent DynamoDB resources from child's own storageResources.
-      // Parent DynamoDB tables exist in the parent service — they must NOT be
-      // re-created here. Instead, track them as external references so that
-      // emitResourceArtifacts can add cross-service ARNs to IAM roles.
-      const externalDynamoResources = [];
-      const ownStorageResources = {};
-      for (const [key, resource] of Object.entries(
-        mergedSchema.storageResources ?? {}
-      )) {
-        if (
-          resource?.storageType === 'dynamoDB' &&
-          !childStorageResourceKeys.has(key)
-        ) {
-          externalDynamoResources.push({
-            serviceTag: parentServiceTag,
-            tableName: resource.tableName
-          });
-        } else {
-          ownStorageResources[key] = resource;
+        mergedSchema.storageResources = ownStorageResources;
+        if (externalDynamoResources.length > 0) {
+          mergedSchema.externalDynamoResources = externalDynamoResources;
         }
-      }
 
-      mergedSchema.storageResources = ownStorageResources;
-      if (externalDynamoResources.length > 0) {
-        mergedSchema.externalDynamoResources = externalDynamoResources;
+        currentSchema = mergedSchema;
+      } catch (error) {
+        Logger.error(
+          `[ERROR] [resolveExtendedObjectSchemas] Failed to merge extendObjType for objectType=${currentSchema.objectType}`,
+          { error }
+        );
+        throw error;
       }
+    }
 
-      resolvedSchemas.push(mergedSchema);
-    } catch (error) {
-      Logger.error(
-        `resolveExtendedObjectSchemas: failed to merge extendObjType` +
-        ` for objectType=${schema.objectType}`,
-        { error }
-      );
-      throw error;
+    /*
+    if (
+      currentSchema.hasOwnProperty('belongTo') &&
+      currentSchema.belongTo &&
+      currentSchema.belongTo.serviceTag &&
+      currentSchema.belongTo.objectType
+    ) {
+      try {
+        Logger.debug(
+          `[DEBUG] [resolveExtendedObjectSchemas] Fetching belongTo schema for objectType=${currentSchema.objectType}`,
+          { belongTo: currentSchema.belongTo }
+        );
+        const belongToObjType = {
+          serviceTag: currentSchema.belongTo.serviceTag,
+          objectType: currentSchema.belongTo.objectType
+        };
+        const belongToSchema = await getObjectSchema.getObjSchemaS3(
+          { logger: Logger },
+          belongToObjType,
+          false,
+          bucketName
+        );
+        currentSchema.belongToSchema = belongToSchema;
+        Logger.debug(
+          `[DEBUG] [resolveExtendedObjectSchemas] Successfully fetched belongTo schema for objectType=${currentSchema.objectType}`,
+          { belongToObjectType: belongToSchema?.objectType }
+        );
+      } catch (error) {
+        Logger.warn(
+          `[WARN] [resolveExtendedObjectSchemas] Failed to fetch belongTo schema for objectType=${currentSchema.objectType}`,
+          { error }
+        );
+      }
     }
+    */
+
+    resolvedSchemas.push(currentSchema);
   }
   return resolvedSchemas;
 }

package/src/emit/coreFunction/emitCoreFunctionArtifacts.js

@@ -0,0 +1,163 @@
+import ejsLib from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+const APP_ROOT = 'app/sls_yaml/generatedCode/source';
+const SRC_ROOT = 'app/src/generatedCode/CoreFunctions';
+
+export const coreFunctionManagedPaths = [
+  `${APP_ROOT}/core-function.yml`,
+  `${APP_ROOT}/core-resource.yml`,
+  `${SRC_ROOT}/UploadSchema_HdrInv.js`,
+  `${SRC_ROOT}/UploadSchema_Main.js`,
+  `${SRC_ROOT}/GenerateSeedDataDynamo_HdrInv.js`,
+  `${SRC_ROOT}/GenerateSeedDataDynamo_Main.js`,
+  `${SRC_ROOT}/RemoveSeedDataDynamo_HdrInv.js`,
+  `${SRC_ROOT}/RemoveSeedDataDynamo_Main.js`,
+  `${SRC_ROOT}/GenerateSeedDataGraphData_HdrInv.js`,
+  `${SRC_ROOT}/GenerateSeedDataGraphData_Main.js`,
+  `${SRC_ROOT}/GenerateSeedDataGraphSchema_HdrInv.js`,
+  `${SRC_ROOT}/GenerateSeedDataGraphSchema_Main.js`,
+  `${SRC_ROOT}/InitialSetup_HdrInv.js`,
+  `${SRC_ROOT}/InitialSetup_Main.js`,
+  `${SRC_ROOT}/generated/GeneratedTableConfigs.js`,
+  `${SRC_ROOT}/generated/GeneratedGraphNodeSchemas.js`,
+  `${SRC_ROOT}/generated/GeneratedGraphRelSchemas.js`,
+  `${SRC_ROOT}/InitialSetupConfig.js`
+];
+
+export async function emitCoreFunctionArtifacts({ project, objects = [], relationships = [] }) {
+  const state = { 
+    project, 
+    objects, 
+    relationships,
+    hasGenerateGraph: objects.length > 0 || relationships.length > 0
+  };
+
+  const [
+    coreFunctionYaml,
+    coreResourceYaml,
+    uploadSchemaHdrInv,
+    uploadSchemaMain,
+    generateSeedDataDynamoHdrInv,
+    generateSeedDataDynamoMain,
+    removeSeedDataDynamoHdrInv,
+    removeSeedDataDynamoMain,
+    generateSeedDataGraphDataHdrInv,
+    generateSeedDataGraphDataMain,
+    generateSeedDataGraphSchemaHdrInv,
+    generateSeedDataGraphSchemaMain,
+    generatedTableConfigs,
+    generatedGraphNodeSchemas,
+    generatedGraphRelSchemas,
+    initialSetupConfig,
+    initialSetupHdrInv,
+    initialSetupMain
+  ] = await Promise.all([
+    render('CoreFunction_Yaml.ejs', state),
+    render('CoreResource_Yaml.ejs', state),
+    render('UploadSchema_HdrInv.ejs', state),
+    render('UploadSchema_Main.ejs', state),
+    render('GenerateSeedDataDynamo_HdrInv.ejs', state),
+    render('GenerateSeedDataDynamo_Main.ejs', state),
+    render('RemoveSeedDataDynamo_HdrInv.ejs', state),
+    render('RemoveSeedDataDynamo_Main.ejs', state),
+    render('GenerateSeedDataGraphData_HdrInv.ejs', state),
+    render('GenerateSeedDataGraphData_Main.ejs', state),
+    render('GenerateSeedDataGraphSchema_HdrInv.ejs', state),
+    render('GenerateSeedDataGraphSchema_Main.ejs', state),
+    render('GeneratedTableConfigs.ejs', state),
+    render('GeneratedGraphNodeSchemas.ejs', state),
+    render('GeneratedGraphRelSchemas.ejs', state),
+    render('InitialSetupConfig.ejs', state),
+    render('InitialSetup_HdrInv.ejs', state),
+    render('InitialSetup_Main.ejs', state)
+  ]);
+
+  return [
+    {
+      path: `${APP_ROOT}/core-function.yml`,
+      content: normalizeYaml(coreFunctionYaml)
+    },
+    {
+      path: `${APP_ROOT}/core-resource.yml`,
+      content: normalizeYaml(coreResourceYaml)
+    },
+    {
+      path: `${SRC_ROOT}/UploadSchema_HdrInv.js`,
+      content: uploadSchemaHdrInv
+    },
+    {
+      path: `${SRC_ROOT}/UploadSchema_Main.js`,
+      content: uploadSchemaMain
+    },
+    {
+      path: `${SRC_ROOT}/GenerateSeedDataDynamo_HdrInv.js`,
+      content: generateSeedDataDynamoHdrInv
+    },
+    {
+      path: `${SRC_ROOT}/GenerateSeedDataDynamo_Main.js`,
+      content: generateSeedDataDynamoMain
+    },
+    {
+      path: `${SRC_ROOT}/RemoveSeedDataDynamo_HdrInv.js`,
+      content: removeSeedDataDynamoHdrInv
+    },
+    {
+      path: `${SRC_ROOT}/RemoveSeedDataDynamo_Main.js`,
+      content: removeSeedDataDynamoMain
+    },
+    {
+      path: `${SRC_ROOT}/GenerateSeedDataGraphData_HdrInv.js`,
+      content: generateSeedDataGraphDataHdrInv
+    },
+    {
+      path: `${SRC_ROOT}/GenerateSeedDataGraphData_Main.js`,
+      content: generateSeedDataGraphDataMain
+    },
+    {
+      path: `${SRC_ROOT}/GenerateSeedDataGraphSchema_HdrInv.js`,
+      content: generateSeedDataGraphSchemaHdrInv
+    },
+    {
+      path: `${SRC_ROOT}/GenerateSeedDataGraphSchema_Main.js`,
+      content: generateSeedDataGraphSchemaMain
+    },
+    {
+      path: `${SRC_ROOT}/generated/GeneratedTableConfigs.js`,
+      content: generatedTableConfigs
+    },
+    {
+      path: `${SRC_ROOT}/generated/GeneratedGraphNodeSchemas.js`,
+      content: generatedGraphNodeSchemas
+    },
+    {
+      path: `${SRC_ROOT}/generated/GeneratedGraphRelSchemas.js`,
+      content: generatedGraphRelSchemas
+    },
+    {
+      path: `${SRC_ROOT}/InitialSetupConfig.js`,
+      content: initialSetupConfig,
+      writeWhenFileExist: false // Don't overwrite the file that dev modifies
+    },
+    {
+      path: `${SRC_ROOT}/InitialSetup_HdrInv.js`,
+      content: initialSetupHdrInv
+    },
+    {
+      path: `${SRC_ROOT}/InitialSetup_Main.js`,
+      content: initialSetupMain
+    }
+  ];
+}
+
+function normalizeYaml(content) {
+  return `${content.trimEnd()}\n`;
+}
+
+async function render(templateName, data) {
+  return ejsLib.render(
+    await readFile(new URL(templateName, TEMPLATE_URL), 'utf8'),
+    data
+  );
+}

package/src/emit/coreFunction/templates/CoreFunction_Yaml.ejs

@@ -0,0 +1,38 @@
+# --- FOR PROD STAGE
+UploadSchemaHdrInv:
+  handler: src/generatedCode/CoreFunctions/UploadSchema_HdrInv.main
+  name: ${self:custom.iz_resourcePrefix}UploadSchemaHdrInv
+  role: UploadSchemaRole
+  timeout: 30
+  #<#UploadSchemaHdrInvHookCode#>
+  #<#/UploadSchemaHdrInvHookCode#>
+
+# --- FOR TEST STAGE
+GenerateSeedGraph: # --- FOR TEST STAGE
+  handler: src/generatedCode/CoreFunctions/GenerateSeedDataGraphData_HdrInv.main
+  name: ${self:custom.iz_resourcePrefix}GenerateSeedDataGraphDataTestEnv
+  role: GenerateSeedGraphRole
+  #<#GenerateSeedGraphHookCode#>
+  #<#/GenerateSeedGraphHookCode#>
+
+GenerateGraphSchema:
+  handler: src/generatedCode/CoreFunctions/GenerateSeedDataGraphSchema_HdrInv.main
+  name: ${self:custom.iz_resourcePrefix}GenerateSeedDataGraphSchemaTestEnv
+  role: GenerateGraphSchemaRole
+  #<#GenerateGraphSchemaHookCode#>
+  #<#/GenerateGraphSchemaHookCode#>
+
+RemoveSeedDataDynamo:
+  handler: src/generatedCode/CoreFunctions/RemoveSeedDataDynamo_HdrInv.main
+  name: ${self:custom.iz_resourcePrefix}RemoveSeedDataDynamo
+  role: RemoveSeedDataDynamoRole
+  #<#RemoveSeedDataDynamoHookCode#>
+  #<#/RemoveSeedDataDynamoHookCode#>
+
+InitialSetup:
+  handler: src/generatedCode/CoreFunctions/InitialSetup_HdrInv.main
+  name: ${self:custom.iz_resourcePrefix}InitialSetup
+  role: InitialSetupRole
+  timeout: 300
+  #<#InitialSetupHookCode#>
+  #<#/InitialSetupHookCode#>