@izara_project/izara-core-generate-service-code 1.0.92 → 1.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.92",
+  "version": "1.0.93",
   "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/src/compile/loadSchemas.js

@@ -186,6 +186,24 @@ export async function loadLocalSchemaDirectory(
     );
     if (loadedSchemas.length === 0) continue;
 
+    if (directoryName === 'ErrorSchemas') {
+      for (const schema of loadedSchemas) {
+        if (!schema._sourceFile) {
+          schema._sourceFile = entry.name;
+        }
+        if (!schema.errorTag || typeof schema.errorTag !== 'string') {
+          throw new Error(
+            `Invalid ErrorSchema in ${entry.name}: errorTag is required and must be a non-empty string`
+          );
+        }
+        if (!schema.errorAction || typeof schema.errorAction !== 'string') {
+          throw new Error(
+            `Invalid ErrorSchema in ${entry.name}: errorAction is required and must be a non-empty string`
+          );
+        }
+      }
+    }
+
     if (directoryName === 'FlowSchemas') {
       for (const schema of loadedSchemas) {
         if (

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

@@ -15,7 +15,7 @@ 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 { uploadObjSchema } from '@izara_project/izara-core-library-service-schemas';
+import initialSetupSharedLib from '@izara_project/izara-core-library-initial-setup';
 
 const SERVICE_TAG = {
   TRANSLATIONS: 'Translations',
@@ -39,7 +39,7 @@ const uploadSchema = async (_izContext) => {
   try {
     _izContext.logger.debug('uploadSchema _izContext: ', _izContext);
 
-    await uploadObjSchema.uploadObjectSchemaByUseCase(_izContext, {
+    await initialSetupSharedLib.uploadObjectSchema(_izContext, {
       ignoreExternalServices: ignoreExternalServices
     });
     return 'upload successfully';

package/src/emit/error/emitErrorSchemas.js

@@ -0,0 +1,73 @@
+import { readFile } from 'node:fs/promises';
+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';
+
+export function errorSchemaManagedPaths(errors = []) {
+  if (!errors || errors.length === 0) {
+    return [];
+  }
+  return [ERROR_SCHEMA_PATH];
+}
+
+/**
+ * Emits errorSchema.js artifact based on loaded ErrorSchemas
+ *
+ * @param {Object} params
+ * @param {Object} params.project
+ * @param {Array} [params.errors=[]]
+ * @param {Array} [params.objectGraphServiceTags=[]]
+ * @returns {Promise<Array<{path: string, content: string}>>}
+ */
+export async function emitErrorSchemas({
+  project = {},
+  errors = [],
+  objectGraphServiceTags = []
+} = {}) {
+  const safeErrors = Array.isArray(errors) ? errors : [];
+  if (safeErrors.length === 0) {
+    return [];
+  }
+
+  const defaultGraphServiceTag =
+    objectGraphServiceTags[0] || 'GraphHandler';
+  const defaultServiceTag = project?.serviceTag || '';
+
+  const errorTypes = {};
+  for (const item of safeErrors) {
+    if (!item || typeof item !== 'object' || !item.errorTag) {
+      continue;
+    }
+    const errorTag = item.errorTag;
+    const serviceTag = item.serviceTag || defaultServiceTag;
+    errorTypes[errorTag] = {
+      errorTag,
+      serviceTag
+    };
+  }
+
+  const sortedKeys = Object.keys(errorTypes).sort();
+  if (sortedKeys.length === 0) {
+    return [];
+  }
+
+  const sortedErrorTypes = {};
+  for (const key of sortedKeys) {
+    sortedErrorTypes[key] = errorTypes[key];
+  }
+
+  const templatePath = new URL('errorSchema.ejs', TEMPLATE_URL);
+  const template = await readFile(templatePath, 'utf8');
+  const content = ejsLib.render(template, {
+    errorTypes: sortedErrorTypes
+  });
+
+  return [
+    {
+      path: ERROR_SCHEMA_PATH,
+      content
+    }
+  ];
+}

package/src/emit/error/templates/errorSchema.ejs

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

package/src/generate.js

@@ -61,6 +61,10 @@ import {
   attributeTreeObjectSchemaManagedPaths,
   attributeTreeRelationshipSchemaManagedPaths
 } from './emit/attributeTree/emitAttributeTreeSchemas.js';
+import {
+  emitErrorSchemas,
+  errorSchemaManagedPaths
+} from './emit/error/emitErrorSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -70,11 +74,18 @@ export async function generate(rootPath, options = {}) {
     const schemaLoadOptions = {
       skipValidation: options.skipValidation
     };
-    const [rawObjects, relationships, flows, notifications] = await Promise.all([
+    const [
+      rawObjects,
+      relationships,
+      flows,
+      notifications,
+      errors
+    ] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(project, 'RelationshipSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions)
+      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -93,14 +104,24 @@ export async function generate(rootPath, options = {}) {
     console.log(
       `[DEBUG] [Generate] STATUS=SCHEMAS_LOADED | ` +
       `objects=${objects.length} ` +
-      `relationships=${relationships.length} flows=${flows.length}`
+      `relationships=${relationships.length} flows=${flows.length} ` +
+      `notifications=${notifications.length} ` +
+      `errors=${errors.length}`
     );
+    for (const objectSchema of objects) {
+      const objectType = objectSchema.objectType || 'unknown';
+      console.log(
+        `[DEBUG] [Generate] OBJECT_SCHEMA | objectType=${objectType}\n` +
+        JSON.stringify(objectSchema, null, 2)
+      );
+    }
     const groups = await _emitGroups({
       project,
       objects,
       relationships,
       flows,
       notifications,
+      errors,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger
@@ -149,6 +170,7 @@ async function _emitGroups({
   relationships,
   flows,
   notifications,
+  errors,
   objectGraphServiceTags,
   relationshipGraphServiceTags,
   logger
@@ -161,7 +183,8 @@ async function _emitGroups({
     findData,
     resource,
     coreFunction,
-    systemText
+    systemText,
+    errorSchemas
   ] = await Promise.all([
     emitCrudApplicationArtifacts({
       objects,
@@ -196,6 +219,11 @@ async function _emitGroups({
       relationships,
       flows,
       notifications
+    }),
+    emitErrorSchemas({
+      project,
+      errors,
+      objectGraphServiceTags
     })
   ]);
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
@@ -307,6 +335,11 @@ async function _emitGroups({
       scope: 'system-text-schemas',
       managedPaths: systemTextSchemaManagedPaths(),
       artifacts: systemText
+    },
+    {
+      scope: 'error-schemas',
+      managedPaths: errorSchemaManagedPaths(errors),
+      artifacts: errorSchemas
     }
   ];
 }

package/test/errorSchemas.test.js

@@ -0,0 +1,154 @@
+import assert from 'node:assert/strict';
+import { readFile, rm, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import test, { after } from 'node:test';
+
+import {
+  emitErrorSchemas,
+  errorSchemaManagedPaths,
+  ERROR_SCHEMA_PATH
+} from '../src/emit/error/emitErrorSchemas.js';
+import { generate } from '../src/generate.js';
+
+const roots = new Set();
+after(() =>
+  Promise.all(
+    [...roots].map((root) => rm(root, { recursive: true, force: true }))
+  )
+);
+
+test('emitErrorSchemas produces expected ERROR_TYPES for graph and general errors', async () => {
+  const artifacts = await emitErrorSchemas({
+    project: { serviceTag: 'MyService' },
+    objectGraphServiceTags: ['GraphHandler'],
+    errors: [
+      {
+        errorTag: 'NOT_FOUND_SCHEMA',
+        errorAction: 'throw',
+        sharedLibrary: true,
+        _sourceFile: 'errorgraph.js'
+      },
+      {
+        errorTag: 'INVALID_GENERATED_BY',
+        errorAction: 'throw',
+        sharedLibrary: true,
+        _sourceFile: 'errorgraph.js'
+      },
+      {
+        errorTag: 'CUSTOM_INTERNAL_ERROR',
+        errorAction: 'return',
+        _sourceFile: 'errors.js'
+      },
+      {
+        errorTag: 'EXPLICIT_SERVICE_ERROR',
+        errorAction: 'throw',
+        serviceTag: 'CustomService',
+        _sourceFile: 'custom.js'
+      }
+    ]
+  });
+
+  assert.equal(artifacts.length, 1);
+  assert.equal(artifacts[0].path, ERROR_SCHEMA_PATH);
+
+  const content = artifacts[0].content;
+  assert.match(content, /^export const ERROR_TYPES = {/m);
+  assert.doesNotMatch(content, /export default/);
+
+  // Errors without explicit serviceTag resolve to project.serviceTag
+  assert.match(
+    content,
+    /NOT_FOUND_SCHEMA:\s*{\s*errorTag:\s*'NOT_FOUND_SCHEMA',\s*serviceTag:\s*'MyService'\s*}/
+  );
+  assert.match(
+    content,
+    /INVALID_GENERATED_BY:\s*{\s*errorTag:\s*'INVALID_GENERATED_BY',\s*serviceTag:\s*'MyService'\s*}/
+  );
+
+  // General error resolved to project.serviceTag
+  assert.match(
+    content,
+    /CUSTOM_INTERNAL_ERROR:\s*{\s*errorTag:\s*'CUSTOM_INTERNAL_ERROR',\s*serviceTag:\s*'MyService'\s*}/
+  );
+
+  // Explicit serviceTag respected
+  assert.match(
+    content,
+    /EXPLICIT_SERVICE_ERROR:\s*{\s*errorTag:\s*'EXPLICIT_SERVICE_ERROR',\s*serviceTag:\s*'CustomService'\s*}/
+  );
+
+  // Keys sorted alphabetically
+  const customIdx = content.indexOf('CUSTOM_INTERNAL_ERROR');
+  const explicitIdx = content.indexOf('EXPLICIT_SERVICE_ERROR');
+  const invalidIdx = content.indexOf('INVALID_GENERATED_BY');
+  const notFoundIdx = content.indexOf('NOT_FOUND_SCHEMA');
+  assert.ok(customIdx < explicitIdx);
+  assert.ok(explicitIdx < invalidIdx);
+  assert.ok(invalidIdx < notFoundIdx);
+});
+
+test('emitErrorSchemas returns empty array when no errors provided', async () => {
+  const artifacts = await emitErrorSchemas({
+    project: { serviceTag: 'MyService' },
+    errors: []
+  });
+
+  assert.deepEqual(artifacts, []);
+  assert.deepEqual(errorSchemaManagedPaths([]), []);
+  assert.deepEqual(errorSchemaManagedPaths(['someError']), [ERROR_SCHEMA_PATH]);
+});
+
+test('generate creates errorSchema.js when ErrorSchemas directory exists', async () => {
+  const rootPath = join(
+    tmpdir(),
+    `error-schema-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  roots.add(rootPath);
+  await mkdir(join(rootPath, 'app/src/schemas/ErrorSchemas'), {
+    recursive: true
+  });
+  await mkdir(join(rootPath, 'config'), { recursive: true });
+
+  await writeFile(
+    join(rootPath, 'config/serverless.config.yml'),
+    'main_config:\n  iz_serviceTag: CategoryTreeStandard\n'
+  );
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ErrorSchemas/errorgraph.js'),
+    `export default [
+  {
+    errorTag: 'NOT_FOUND_SCHEMA',
+    errorAction: 'throw',
+    sharedLibrary: true
+  },
+  {
+    errorTag: 'INVALID_GENERATED_BY',
+    errorAction: 'throw',
+    sharedLibrary: true
+  },
+  {
+    errorTag: 'MISSING_USER_NODE',
+    errorAction: 'throw',
+    sharedLibrary: true
+  }
+];
+`
+  );
+
+  // Run generate
+  await generate(rootPath);
+
+  const targetFile = join(
+    rootPath,
+    'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js'
+  );
+  const content = await readFile(targetFile, 'utf8');
+
+  assert.match(content, /export const ERROR_TYPES = {/);
+  assert.match(content, /NOT_FOUND_SCHEMA:/);
+  assert.match(content, /INVALID_GENERATED_BY:/);
+  assert.match(content, /MISSING_USER_NODE:/);
+  assert.match(content, /serviceTag:\s*'CategoryTreeStandard'/);
+  assert.doesNotMatch(content, /export default/);
+});

package/test/publicApi.test.js

@@ -70,7 +70,7 @@ test('generate logs its lifecycle through console.log', async () => {
 
     assert.match(messages[0], /STATUS=STARTED/);
     assert.ok(messages.some((message) => {
-      return /STATUS=SCHEMAS_LOADED/.test(message);
+      return /STATUS=SCHEMAS_LOADED.*notifications=/.test(message);
     }));
     assert.ok(messages.some((message) => {
       return /STATUS=ARTIFACTS_EMITTED/.test(message);