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

package/index.js

@@ -16,8 +16,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { generate } from './src/generate.js';
-import { generateIntTest } from './src/generateIntTest.js';
-import { generateResourceIntTest } from './src/generateResourceIntTest.js';
+import { generateIntTest } from './src/intTest/generateIntTest.js';
+import { generateResourceIntTest } from './src/intTest/generateResourceIntTest.js';
 
 export {
   // High-level API (recommended for consumers) — wires legacy Logger+validateLocalSchema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.96",
+  "version": "1.0.98",
   "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": {
@@ -19,6 +19,7 @@
   "dependencies": {
     "@izara_project/izara-attribute-tree": "^1.0.15",
     "@izara_project/izara-core-library-core": "^1.0.37",
+    "@izara_project/izara-core-library-ledger": "^1.0.2",
     "@izara_project/izara-core-library-s3": "^1.0.12",
     "@izara_project/izara-property-nodes": "^1.0.16",
     "@izara_project/izara-shared-core": "^1.0.13",

package/src/compile/loadSchemas.js

@@ -1,13 +1,23 @@
 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 { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
-import { s3 } from '@izara_project/izara-core-library-s3';
+import { utils } from '@izara_project/izara-core-library-service-schemas';
 import { validateFlowSchema } from './flowValidator.js';
+import {
+  ensureBasicValidatorConfigured,
+  VALID_INITIATE_BY_ENUM,
+  VALID_EVENT_ENUM,
+  VALID_CODE_HOOK_TAG_ENUM,
+  VALID_GENERATE_CODE_TAG_ENUM,
+  VALID_INVOCATION_TYPE_ENUM,
+  VALID_GENERATED_BY_ENUM
+} from './schemaValidatorSetup.js';
+import {
+  resolveExtendedObjectSchemas,
+  resolveGraphServiceTags
+} from './loadSchemasRemote.js';
+
+ensureBasicValidatorConfigured();
 
 const consoleLogger = {
   debug: console.log,
@@ -16,130 +26,10 @@ const consoleLogger = {
   error: console.error
 };
 
-const VALID_INITIATE_BY_ENUM = ['user', 'systemWithUser', 'systemNoUser'];
-const VALID_EVENT_ENUM = [
-  'ownTopic',
-  'extTopic',
-  's3',
-  'eventBridge',
-  'lambdaSyncInv',
-  'lambdaSyncApi',
-  'dsq',
-  'generateCode'
-];
-const VALID_CODE_HOOK_TAG_ENUM = ['before', 'after'];
-const VALID_GENERATE_CODE_TAG_ENUM = ['create', 'update', 'delete'];
-const VALID_INVOCATION_TYPE_ENUM = ['ownTopic', 'lambdaSyncInv'];
-
-if (basicValidatorSchema?.basicFlowSchema?.properties?.initiateBy) {
-  basicValidatorSchema.basicFlowSchema.properties.initiateBy.enum =
-    VALID_INITIATE_BY_ENUM;
-}
-
-if (basicValidatorSchema?.basicFlowSchema?.properties?.event?.items) {
-  basicValidatorSchema.basicFlowSchema.properties.event.items.enum =
-    VALID_EVENT_ENUM;
-}
-
-if (
-  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
-    ?.properties?.codeHookTag
-) {
-  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.codeHookTag.enum =
-    VALID_CODE_HOOK_TAG_ENUM;
-}
-
-if (
-  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
-    ?.properties?.invocationType
-) {
-  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.invocationType.enum =
-    VALID_INVOCATION_TYPE_ENUM;
-}
-
-if (
-  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
-    ?.properties?.generateCodeTag
-) {
-  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.generateCodeTag =
-    {
-      anyOf: [
-        {
-          type: 'array',
-          items: {
-            type: 'string',
-            enum: VALID_GENERATE_CODE_TAG_ENUM
-          }
-        },
-        {
-          type: 'string',
-          enum: VALID_GENERATE_CODE_TAG_ENUM
-        }
-      ]
-    };
-}
-
-if (
-  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
-    ?.properties
-) {
-  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.objType =
-    {
-      anyOf: [
-        { type: 'string' },
-        {
-          type: 'array',
-          items: { type: 'string' }
-        },
-        {
-          type: 'object',
-          properties: {
-            objectType: { type: 'string' },
-            serviceTag: { type: 'string' }
-          },
-          required: ['objectType']
-        }
-      ]
-    };
-}
-
-const VALID_GENERATED_BY_ENUM = [
-  'user',
-  'systemWithUser',
-  'systemNoUser',
-  'searchResultGenerated'
-];
-
-if (basicValidatorSchema?.basicObjectSchema?.properties?.generatedBy) {
-  basicValidatorSchema.basicObjectSchema.properties.generatedBy.enum =
-    VALID_GENERATED_BY_ENUM;
-}
-
-if (basicValidatorSchema?.basicExtendObjectSchema?.properties?.generatedBy) {
-  basicValidatorSchema.basicExtendObjectSchema.properties.generatedBy.enum =
-    VALID_GENERATED_BY_ENUM;
-}
+export { resolveExtendedObjectSchemas, resolveGraphServiceTags };
 
-const objectSchemasToPatch = [
-  basicValidatorSchema?.basicObjectSchema,
-  basicValidatorSchema?.basicExtendObjectSchema
-];
-
-for (const objSchema of objectSchemasToPatch) {
-  const addOnItems = objSchema?.properties?.addOnDataStructure?.items?.anyOf;
-  if (Array.isArray(addOnItems)) {
-    for (const item of addOnItems) {
-      if (item?.properties?.type?.enum?.includes('rbac')) {
-        if (item.properties.billalble) {
-          delete item.properties.billalble;
-        }
-        item.properties.billable = { type: 'boolean' };
-        if (Array.isArray(item.required)) {
-          item.required = item.required.filter((r) => r !== 'billalble');
-        }
-      }
-    }
-  }
+export async function loadGenerateDirectives(project, options = {}) {
+  return loadLocalSchemaDirectory(project, 'GenerateDirectives', options);
 }
 
 export async function loadLocalSchemaDirectory(
@@ -151,7 +41,10 @@ export async function loadLocalSchemaDirectory(
   const logger = options.logger || consoleLogger;
   let entries;
   try {
-    entries = await readdir(directoryPath, { withFileTypes: true });
+    entries = await readdir(directoryPath, {
+      recursive: true,
+      withFileTypes: true
+    });
   } catch (error) {
     if (error.code === 'ENOENT') {
       return [];
@@ -159,14 +52,30 @@ export async function loadLocalSchemaDirectory(
     throw error;
   }
 
-  const validEntries = entries.filter(
-    (entry) => entry.isFile() && entry.name.endsWith('.js')
-  );
-  validEntries.sort((a, b) => a.name.localeCompare(b.name));
+  const validEntries = entries.filter((entry) => {
+    if (!entry.isFile() || !entry.name.endsWith('.js')) {
+      return false;
+    }
+    if (directoryName === 'FlowSchemas') {
+      const parentDir = entry.parentPath || entry.path || '';
+      if (parentDir.includes('generateCode')) {
+        return false;
+      }
+    }
+    return true;
+  });
+  validEntries.sort((a, b) => {
+    const aParent = a.parentPath || a.path || directoryPath;
+    const bParent = b.parentPath || b.path || directoryPath;
+    const aPath = join(aParent, a.name);
+    const bPath = join(bParent, b.name);
+    return aPath.localeCompare(bPath);
+  });
 
   const schemas = [];
   for (const entry of validEntries) {
-    const filePath = join(directoryPath, entry.name);
+    const parentDir = entry.parentPath || entry.path || directoryPath;
+    const filePath = join(parentDir, entry.name);
     const details = await stat(filePath);
     const module = await import(
       `${pathToFileURL(filePath).href}?schemaVersion=${details.mtimeMs}-${details.size}`
@@ -654,194 +563,7 @@ export async function loadLocalSchemaArrays(project, options = {}) {
   return { objects, flows };
 }
 
-/**
- * Resolves extendObjType for ObjectSchemas by fetching the parent schema
- * from S3 and merging its storageResources into the child schema.
- *
- * Only schemas with `extendObjType` are processed; others are returned as-is.
- * If `bucketName` is not provided, falls back to the
- * `iz_serviceSchemaBucketName` environment variable.
- *
- * @param {Object[]} objectSchemas - Array of local ObjectSchemas from
- *   loadLocalSchemaDirectory.
- * @param {string} [bucketName] - S3 bucket name for fetching parent schemas.
- * @returns {Promise<Object[]>} The same array with extended storageResources
- *   merged in.
- */
-export async function resolveExtendedObjectSchemas(
-  objectSchemas,
-  bucketName = process.env.iz_serviceSchemaBucketName
-) {
-  if (!Array.isArray(objectSchemas)) {
-    throw new TypeError('objectSchemas must be an array');
-  }
-  const resolvedSchemas = [];
-  for (const schema of objectSchemas) {
-    let currentSchema = schema;
-    if (currentSchema.hasOwnProperty('extendObjType')) {
-      try {
-        console.log(
-          `[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: consoleLogger },
-          currentSchema,
-          bucketName
-        );
 
-        const externalDynamoResources = [];
-        const ownStorageResources = {};
-        const mergedStorageResources = mergedSchema.storageResources || {};
-        for (const [key, resource] of Object.entries(mergedStorageResources)) {
-          if (
-            resource &&
-            (resource.storageType === 'dynamo' ||
-              resource.storageType === 'dynamoDB' ||
-              !resource.storageType) &&
-            !childStorageResourceKeys.has(key)
-          ) {
-            externalDynamoResources.push({
-              serviceTag: parentServiceTag,
-              tableName: resource.tableName
-            });
-          } else {
-            ownStorageResources[key] = resource;
-          }
-        }
-
-        mergedSchema.storageResources = ownStorageResources;
-        if (externalDynamoResources.length > 0) {
-          mergedSchema.externalDynamoResources = externalDynamoResources;
-        }
-
-        currentSchema = mergedSchema;
-      } catch (error) {
-        console.log(
-          `[ERROR] [resolveExtendedObjectSchemas] Failed to merge ` +
-            `extendObjType for objectType=${currentSchema.objectType}`,
-          { error }
-        );
-        throw error;
-      }
-    }
-
-    if (currentSchema.hasOwnProperty('belongTo') && currentSchema.belongTo) {
-      const belongToTarget = Array.isArray(currentSchema.belongTo)
-        ? currentSchema.belongTo[0]
-        : currentSchema.belongTo;
-
-      if (
-        belongToTarget &&
-        belongToTarget.serviceTag &&
-        belongToTarget.objectType
-      ) {
-        try {
-          console.log(
-            `[DEBUG] [resolveExtendedObjectSchemas] Fetching belongTo ` +
-              `schema for objectType=${currentSchema.objectType}`,
-            { belongTo: belongToTarget }
-          );
-          const belongToObjType = {
-            serviceTag: belongToTarget.serviceTag,
-            objectType: belongToTarget.objectType
-          };
-          const belongToSchema = await getObjectSchema.getObjSchemaS3(
-            { logger: consoleLogger },
-            belongToObjType,
-            false,
-            bucketName
-          );
-          currentSchema.belongToSchema = belongToSchema;
-          console.log(
-            `[DEBUG] [resolveExtendedObjectSchemas] Successfully fetched ` +
-              `belongTo schema for objectType=${currentSchema.objectType}`,
-            { belongToObjectType: belongToSchema?.objectType }
-          );
-        } catch (error) {
-          console.log(
-            `[WARN] [resolveExtendedObjectSchemas] Failed to fetch ` +
-              `belongTo schema for objectType=${currentSchema.objectType}`,
-            { error }
-          );
-        }
-      }
-    }
-
-    resolvedSchemas.push(currentSchema);
-  }
-  return resolvedSchemas;
-}
-
-export async function resolveGraphServiceTags(
-  schemas,
-  bucketName = process.env.iz_serviceSchemaBucketName
-) {
-  if (!Array.isArray(schemas) || schemas.length === 0) {
-    return [];
-  }
-
-  const graphServerTags = new Set();
-  for (const schema of schemas) {
-    if (!schema || typeof schema !== 'object') continue;
-    let targetObjs = [];
-    if (schema.storageResources) {
-      targetObjs = [schema];
-    } else {
-      targetObjs = Object.values(schema).filter(
-        (val) => val && typeof val === 'object' && val.storageResources
-      );
-    }
-
-    for (const targetObj of targetObjs) {
-      const resources = targetObj.storageResources;
-      if (resources && typeof resources === 'object') {
-        for (const res of Object.values(resources)) {
-          if (res?.storageType === 'graph' && res.graphServerTag) {
-            graphServerTags.add(res.graphServerTag);
-          }
-        }
-      }
-    }
-  }
-
-  if (graphServerTags.size === 0) {
-    return [];
-  }
-
-  let graphServerTagsMap = {};
-  if (bucketName) {
-    try {
-      const _izContext = { logger: consoleLogger };
-      const s3Data = await s3.getObjectS3(_izContext, {
-        Bucket: bucketName,
-        Key: 'serviceConfig/GraphServerTags.json'
-      });
-      if (s3Data && typeof s3Data === 'object') {
-        graphServerTagsMap = s3Data;
-      }
-    } catch (error) {
-      console.log(
-        `[DEBUG] [resolveGraphServiceTags] Could not fetch ` +
-          `GraphServerTags.json from bucket=${bucketName}`,
-        error
-      );
-    }
-  }
-
-  const resolvedTags = new Set();
-  for (const tag of graphServerTags) {
-    const serviceTag = graphServerTagsMap[tag] || tag || 'GraphHandler';
-    resolvedTags.add(serviceTag);
-  }
-
-  return Array.from(resolvedTags);
-}
 
 function _isTestEnvironment() {
   return (

package/src/compile/loadSchemasRemote.js

@@ -0,0 +1,195 @@
+import {
+  getObjectSchema
+} from '@izara_project/izara-core-library-service-schemas';
+import { s3 } from '@izara_project/izara-core-library-s3';
+
+const consoleLogger = {
+  debug: console.log,
+  info: console.log,
+  warn: console.log,
+  error: console.error
+};
+
+/**
+ * Resolves extendObjType for ObjectSchemas by fetching the parent schema
+ * from S3 and merging its storageResources into the child schema.
+ *
+ * @param {Object[]} objectSchemas - Array of local ObjectSchemas.
+ * @param {string} [bucketName] - S3 bucket name for fetching parent schemas.
+ * @returns {Promise<Object[]>} The same array with extended storageResources.
+ */
+export async function resolveExtendedObjectSchemas(
+  objectSchemas,
+  bucketName = process.env.iz_serviceSchemaBucketName
+) {
+  if (!Array.isArray(objectSchemas)) {
+    throw new TypeError('objectSchemas must be an array');
+  }
+  const resolvedSchemas = [];
+  for (const schema of objectSchemas) {
+    let currentSchema = schema;
+    if (currentSchema.hasOwnProperty('extendObjType')) {
+      try {
+        console.log(
+          `[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: consoleLogger },
+          currentSchema,
+          bucketName
+        );
+
+        const externalDynamoResources = [];
+        const ownStorageResources = {};
+        const mergedStorageResources = mergedSchema.storageResources || {};
+        for (const [key, resource] of Object.entries(mergedStorageResources)) {
+          if (
+            resource &&
+            (resource.storageType === 'dynamo' ||
+              resource.storageType === 'dynamoDB' ||
+              !resource.storageType) &&
+            !childStorageResourceKeys.has(key)
+          ) {
+            externalDynamoResources.push({
+              serviceTag: parentServiceTag,
+              tableName: resource.tableName
+            });
+          } else {
+            ownStorageResources[key] = resource;
+          }
+        }
+
+        mergedSchema.storageResources = ownStorageResources;
+        if (externalDynamoResources.length > 0) {
+          mergedSchema.externalDynamoResources = externalDynamoResources;
+        }
+
+        currentSchema = mergedSchema;
+      } catch (error) {
+        console.log(
+          `[ERROR] [resolveExtendedObjectSchemas] Failed to merge ` +
+            `extendObjType for objectType=${currentSchema.objectType}`,
+          { error }
+        );
+        throw error;
+      }
+    }
+
+    if (currentSchema.hasOwnProperty('belongTo') && currentSchema.belongTo) {
+      let belongToTarget = currentSchema.belongTo;
+      if (Array.isArray(currentSchema.belongTo)) {
+        belongToTarget = currentSchema.belongTo[0];
+      }
+
+      if (
+        belongToTarget &&
+        belongToTarget.serviceTag &&
+        belongToTarget.objectType
+      ) {
+        try {
+          console.log(
+            `[DEBUG] [resolveExtendedObjectSchemas] Fetching belongTo ` +
+              `schema for objectType=${currentSchema.objectType}`,
+            { belongTo: belongToTarget }
+          );
+          const belongToObjType = {
+            serviceTag: belongToTarget.serviceTag,
+            objectType: belongToTarget.objectType
+          };
+          const belongToSchema = await getObjectSchema.getObjSchemaS3(
+            { logger: consoleLogger },
+            belongToObjType,
+            false,
+            bucketName
+          );
+          currentSchema.belongToSchema = belongToSchema;
+          console.log(
+            `[DEBUG] [resolveExtendedObjectSchemas] Successfully fetched ` +
+              `belongTo schema for objectType=${currentSchema.objectType}`,
+            { belongToObjectType: belongToSchema?.objectType }
+          );
+        } catch (error) {
+          console.log(
+            `[WARN] [resolveExtendedObjectSchemas] Failed to fetch ` +
+              `belongTo schema for objectType=${currentSchema.objectType}`,
+            { error }
+          );
+        }
+      }
+    }
+
+    resolvedSchemas.push(currentSchema);
+  }
+  return resolvedSchemas;
+}
+
+export async function resolveGraphServiceTags(
+  schemas,
+  bucketName = process.env.iz_serviceSchemaBucketName
+) {
+  if (!Array.isArray(schemas) || schemas.length === 0) {
+    return [];
+  }
+
+  const graphServerTags = new Set();
+  for (const schema of schemas) {
+    if (!schema || typeof schema !== 'object') continue;
+    let targetObjs = [];
+    if (schema.storageResources) {
+      targetObjs = [schema];
+    } else {
+      targetObjs = Object.values(schema).filter(
+        (val) => val && typeof val === 'object' && val.storageResources
+      );
+    }
+
+    for (const targetObj of targetObjs) {
+      const resources = targetObj.storageResources;
+      if (resources && typeof resources === 'object') {
+        for (const res of Object.values(resources)) {
+          if (res?.storageType === 'graph' && res.graphServerTag) {
+            graphServerTags.add(res.graphServerTag);
+          }
+        }
+      }
+    }
+  }
+
+  if (graphServerTags.size === 0) {
+    return [];
+  }
+
+  let graphServerTagsMap = {};
+  if (bucketName) {
+    try {
+      const _izContext = { logger: consoleLogger };
+      const s3Data = await s3.getObjectS3(_izContext, {
+        Bucket: bucketName,
+        Key: 'serviceConfig/GraphServerTags.json'
+      });
+      if (s3Data && typeof s3Data === 'object') {
+        graphServerTagsMap = s3Data;
+      }
+    } catch (error) {
+      console.log(
+        `[DEBUG] [resolveGraphServiceTags] Could not fetch ` +
+          `GraphServerTags.json from bucket=${bucketName}`,
+        error
+      );
+    }
+  }
+
+  const resolvedTags = new Set();
+  for (const tag of graphServerTags) {
+    const serviceTag = graphServerTagsMap[tag] || tag || 'GraphHandler';
+    resolvedTags.add(serviceTag);
+  }
+
+  return Array.from(resolvedTags);
+}