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

package/src/emit/custom/generateCustomFlowApplicationArtifacts.js

@@ -1,7 +1,5 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   customFlowApplicationManagedPaths,
   emitCustomFlowApplicationArtifacts
@@ -16,27 +14,31 @@ export async function generateCustomFlowApplicationArtifacts(
   rootPath,
   options = {}
 ) {
-  const project = compileProject({ ...options, rootPath });
-  const [flows, objects] = await Promise.all([
-    loadLocalSchemaDirectory(project, 'FlowSchemas'),
-    loadLocalSchemaDirectory(project, 'ObjectSchemas')
-  ]);
-  const system = await emitSystemWebSocketArtifacts(flows);
-  const custom = await emitCustomFlowApplicationArtifacts(flows, {
-    systemFunctions: system.functions,
-    objects
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: async (project) => {
+      const [flows, objects] = await Promise.all([
+        loadLocalSchemaDirectory(project, 'FlowSchemas'),
+        loadLocalSchemaDirectory(project, 'ObjectSchemas')
+      ]);
+      return { flows, objects };
+    },
+    emitArtifacts: async ({ flows, objects }) => {
+      const system = await emitSystemWebSocketArtifacts(flows);
+      const custom = await emitCustomFlowApplicationArtifacts(flows, {
+        systemFunctions: system.functions,
+        objects
+      });
+      return [...system.artifacts, ...custom];
+    },
+    managedScope: 'custom-flow-application',
+    resolveManagedPaths: ({ flows, objects }) => [
+      ...systemWebSocketManagedPaths(),
+      ...customFlowApplicationManagedPaths(flows, {
+        includeYaml: hasSystemWebSocket(flows),
+        objects
+      })
+    ]
   });
-  const artifacts = [...system.artifacts, ...custom];
-  const files = await commitArtifacts(
-    buildGenerationPlan(project, artifacts, {
-      managedPaths: [
-        ...systemWebSocketManagedPaths(),
-        ...customFlowApplicationManagedPaths(flows, {
-          includeYaml: hasSystemWebSocket(flows), objects
-        })
-      ],
-      managedScope: 'custom-flow-application'
-    })
-  );
-  return { project, files };
 }

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/emit/rbac/generateCreateTargetRoleHandler.js

@@ -1,21 +1,19 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   emitRbacApplicationArtifacts,
   rbacApplicationManagedPaths
 } from './emitRbacApplicationArtifacts.js';
 
 export async function generateCreateTargetRoleHandler(rootPath, options = {}) {
-  const project = compileProject({ ...options, rootPath });
-  const objects = await loadLocalSchemaDirectory(project, 'ObjectSchemas');
-  const artifacts = await emitRbacApplicationArtifacts(objects);
-  const files = await commitArtifacts(
-    buildGenerationPlan(project, artifacts, {
-      managedPaths: rbacApplicationManagedPaths(),
-      managedScope: 'rbac-application'
-    })
-  );
-  return { project, files };
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: async (project) => ({
+      objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas')
+    }),
+    emitArtifacts: ({ objects }) => emitRbacApplicationArtifacts(objects),
+    managedScope: 'rbac-application',
+    resolveManagedPaths: () => rbacApplicationManagedPaths()
+  });
 }

package/src/emit/rbac/generateDynamicRbacFlowSchemas.js

@@ -1,27 +1,23 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   emitDynamicRbacFlowSchemas,
   rbacFlowSchemaManagedPaths
 } from './emitDynamicRbacFlowSchemas.js';
 
 export async function generateDynamicRbacFlowSchemas(rootPath, options = {}) {
-  const project = compileProject({ ...options, rootPath });
-  const objects = await loadLocalSchemaDirectory(project, 'ObjectSchemas');
-  const plan = buildGenerationPlan(
-    project,
-    await emitDynamicRbacFlowSchemas({
-      objects,
-      serviceTag: project.serviceTag
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: async (project) => ({
+      objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas')
     }),
-    {
-      managedPaths: rbacFlowSchemaManagedPaths(objects),
-      managedScope: 'rbac-flow-schemas'
-    }
-  );
-  const files = await commitArtifacts(plan);
-
-  return { project, files };
+    emitArtifacts: ({ objects, project }) =>
+      emitDynamicRbacFlowSchemas({
+        objects,
+        serviceTag: project.serviceTag
+      }),
+    managedScope: 'rbac-flow-schemas',
+    resolveManagedPaths: ({ objects }) => rbacFlowSchemaManagedPaths(objects)
+  });
 }

package/src/emit/relationship/generateDynamicRelationshipFlowSchemas.js

@@ -1,7 +1,5 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   dynamicRelationshipFlowSchemaManagedPaths,
   emitDynamicRelationshipFlowSchemas
@@ -11,20 +9,19 @@ export async function generateDynamicRelationshipFlowSchemas(
   rootPath,
   options = {}
 ) {
-  const project = compileProject({ ...options, rootPath });
-  const relationships = await loadLocalSchemaDirectory(
-    project,
-    'RelationshipSchemas'
-  );
-  const plan = buildGenerationPlan(
-    project,
-    emitDynamicRelationshipFlowSchemas({ relationships }),
-    {
-      managedPaths: dynamicRelationshipFlowSchemaManagedPaths(relationships),
-      managedScope: 'relationship-flow-schemas'
-    }
-  );
-  const files = await commitArtifacts(plan);
-
-  return { project, files };
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: async (project) => ({
+      relationships: await loadLocalSchemaDirectory(
+        project,
+        'RelationshipSchemas'
+      )
+    }),
+    emitArtifacts: ({ relationships }) =>
+      emitDynamicRelationshipFlowSchemas({ relationships }),
+    managedScope: 'relationship-flow-schemas',
+    resolveManagedPaths: ({ relationships }) =>
+      dynamicRelationshipFlowSchemaManagedPaths(relationships)
+  });
 }

package/src/emit/relationship/generateRelationshipApplicationArtifacts.js

@@ -1,7 +1,5 @@
-import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
-import { commitArtifacts } from '../../output/commitArtifacts.js';
-import { compileProject } from '../../compile/compileProject.js';
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { runSubsystemGeneration } from '../shared/runSubsystemGeneration.js';
 import {
   emitRelationshipApplicationArtifacts,
   relationshipApplicationManagedPaths
@@ -11,21 +9,23 @@ export async function generateRelationshipApplicationArtifacts(
   rootPath,
   options = {}
 ) {
-  const project = compileProject({ ...options, rootPath });
-  const [relationships, flows] = await Promise.all([
-    loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
-    loadLocalSchemaDirectory(project, 'FlowSchemas')
-  ]);
-  const artifacts = await emitRelationshipApplicationArtifacts({
-    relationships,
-    flows,
-    serviceTag: project.serviceTag
+  return await runSubsystemGeneration({
+    rootPath,
+    options,
+    loadInputs: async (project) => {
+      const [relationships, flows] = await Promise.all([
+        loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
+        loadLocalSchemaDirectory(project, 'FlowSchemas')
+      ]);
+      return { relationships, flows };
+    },
+    emitArtifacts: ({ relationships, flows, project }) =>
+      emitRelationshipApplicationArtifacts({
+        relationships,
+        flows,
+        serviceTag: project.serviceTag
+      }),
+    managedScope: 'relationship-application',
+    resolveManagedPaths: () => relationshipApplicationManagedPaths()
   });
-  const files = await commitArtifacts(
-    buildGenerationPlan(project, artifacts, {
-      managedPaths: relationshipApplicationManagedPaths(),
-      managedScope: 'relationship-application'
-    })
-  );
-  return { project, files };
 }

package/src/emit/resource/dynamoResourceArtifacts.js

@@ -0,0 +1,18 @@
+import { indentYaml, renderResourceTemplate } from './resourceTemplate.js';
+
+export async function renderDynamo(state) {
+  const [system, ...tables] = await Promise.all([
+    renderResourceTemplate('SystemDynamoDB_Yaml.ejs', {
+      hasS3: state.s3FlowTags.length > 0,
+      hasRbac: state.selfRbac
+    }),
+    ...state.tables.map((table) =>
+      renderResourceTemplate('DynamoDBTable_Yaml.ejs', table)
+    )
+  ]);
+  const indentedTables = tables.map((t) => indentYaml(t, 2)).join('\n');
+  if (indentedTables) {
+    return `${system}\n${indentedTables}`;
+  }
+  return `${system}`;
+}