@izara_project/izara-core-generate-service-code 1.0.45 → 1.0.47

package/src/libs/consts/resources.js

@@ -0,0 +1,48 @@
+const RESOURCE_CLASSES = {
+  sqs: 'sqs',
+  s3: 's3',
+  dynamoDbTable: 'dynamodb',
+  dynamoDbAcrossService: 'dynamodb',
+  sns: 'sns',
+  lambda: 'lambda',
+  webSocket: 'webSocket'
+};
+
+const SQS_RESOURCE = {
+  sendMessage: 'SendMessage',
+  receiveMessage: 'ReceiveMessage',
+  deleteMessage: 'DeleteMessage',
+  getQueueAttributes: 'GetQueueAttributes',
+  deleteMessageBatch: 'DeleteMessageBatch',
+  getQueueUrl: 'GetQueueUrl'
+};
+
+const SNS_RESOURCE = {
+  publish: 'Publish',
+  subscribe: 'Subscribe'
+};
+
+const DYNAMO_RESOURCE = {
+  putItem: 'PutItem',
+  getItem: 'GetItem',
+  query: 'Query',
+  updateItem: 'UpdateItem',
+  deleteItem: 'DeleteItem'
+};
+
+const LAMBDA_RESOURCE = {
+  invokeFunction: 'InvokeFunction'
+};
+
+const S3_RESOURCE = {
+  getObject: 'GetObject',
+  getObjectTagging: 'GetObjectTagging',
+  deleteObject: 'DeleteObject',
+  deleteObjectTagging: 'DeleteObjectTagging',
+  putObject: 'PutObject',
+  putObjectTagging: 'PutObjectTagging',
+  getObjectVersion: 'GetObjectVersion',
+  listBucket: 'ListBucket'
+};
+
+export { RESOURCE_CLASSES, SQS_RESOURCE, SNS_RESOURCE, DYNAMO_RESOURCE, LAMBDA_RESOURCE, S3_RESOURCE };

package/src/libs/consts/tags.js

@@ -0,0 +1,68 @@
+const ADD_ON_DATA_STRUCTURE_TYPE = {
+  versionedData: 'versionedData',
+  attributeTree: 'attributeTree',
+  propertyValue: 'propertyValue',
+  translation: 'translation'
+};
+
+const ATTRIBUTE_TAG = {
+  attributeTagValue: 'Value',
+  attributeTagLabel: 'Label',
+  attributeTagLink: 'Link',
+  attributeTagValueStandard: 'ValueStandard',
+  attributeTagProperty: 'Property',
+  attributeTagPropertyLabel: 'PropertyLabel'
+};
+
+const PROPERTY_VALUE_TAG = {
+  property: 'PropertyValue',
+  propertyLabel: 'PropertyLabel'
+};
+
+const FIELD_NAME_TYPE = {
+  identifiers: 'identifiers',
+  nonIdentifiers: 'nonIdentifiers',
+  requiredOnCreateFieldName: 'requiredOnCreateFieldName',
+  randomOnCreateFieldName: 'randomOnCreateFieldName',
+  optionalOnCreate: 'optionalOnCreate'
+};
+
+const GENERATE_SEED_DATA_TYPE = {
+  RANDOM_ON_CREATE_IDENTIFIERS: 'randomOnCreateIdentifier',
+  NON_RANDOM_ON_CREATE_IDENTIFIERS: 'notRandomOnIdentifier',
+  RELATIONSHIPS: 'relationships'
+};
+
+const SEED_DATA_TAG = {
+  dynamoDBSeedDataTags: 'dynamoDBSeedDataTags',
+  graphSeedDataTags: 'graphSeedDataTags',
+  cleaningDynamoOneRecordsTags: 'cleaningDynamoOneRecordsTags',
+  cleaningDynamoManyRecordsTags: 'cleaningDynamoManyRecordsTags'
+};
+
+const ACCOUNTLIMIT_TAG = {
+  staticLimit: 'staticLimit',
+  reservedDynamic: 'reservedDynamic'
+};
+
+const LIMIT_TAG = {
+  uploadImage: 'uploadImageS3',
+  uploadData: 'uploadDataS3'
+};
+
+const RBAC_TYPE = {
+  appLevel: 'AppLevel',
+  userLevel: 'UserLevel'
+};
+
+export {
+  ADD_ON_DATA_STRUCTURE_TYPE,
+  ATTRIBUTE_TAG,
+  PROPERTY_VALUE_TAG,
+  FIELD_NAME_TYPE,
+  GENERATE_SEED_DATA_TYPE,
+  SEED_DATA_TAG,
+  ACCOUNTLIMIT_TAG,
+  LIMIT_TAG,
+  RBAC_TYPE
+};

package/src/libs/consts/topics.js

@@ -0,0 +1,67 @@
+const TOPIC_NAME_GRAPH_HANDLER = {
+  inUpdateRel: 'UpdateRelationship_In',
+  inCreateRel: 'CreateRelationship_In',
+  outUpdateRel: 'UpdateRelationship_Out',
+  outCreateRel: 'CreateRelationship_Out',
+  inDeleteRel: 'DeleteRelationship_In',
+  outDeleteRel: 'DeleteRelationship_Out',
+  inUpdateNode: 'UpdateNode_In',
+  outUpdateNode: 'UpdateNode_Out',
+  inCreateNode: 'CreateNode_In',
+  outCreateNode: 'CreateNode_Out',
+  inDeleteNode: 'DeleteNode_In',
+  outDeleteNode: 'DeleteNode_Out',
+  inChangeRelationship: 'ChangeRelationshipType_In',
+  outChangeRelationship: 'ChangeRelationshipType_Out',
+  inMoveRelationship: 'MoveRelationship_In',
+  outMoveRelationship: 'MoveRelationship_Out'
+};
+
+const TOPIC_NAME_GENERATE_CODE = {
+  updateRelComplete: 'UpdateRelationshipComplete',
+  createRelComplete: 'CreateRelationshipComplete',
+  deleteRelComplete: 'DeleteRelationshipComplete',
+  getRelComplete: 'GetRelationshipComplete',
+  outUpdateRelComplete: 'UpdateRelationshipComplete_Out',
+  outCreateRelComplete: 'CreateRelationshipComplete_Out',
+  outDeleteRelComplete: 'DeleteRelationshipComplete_Out',
+  outGetRelComplete: 'GetRelationshipComplete_Out',
+  updateNodeComplete: 'UpdateNodeComplete',
+  outUpdateNodeComplete: 'UpdateNodeComplete_Out',
+  createNodeComplete: 'CreateObjectComplete',
+  outCreateNodeComplete: 'CreateObjectComplete_Out',
+  deleteNodeComplete: 'DeleteNodeComplete',
+  outDeleteNodeComplete: 'DeleteNodeComplete_Out',
+  getNodeComplete: 'GetNodeComplete',
+  outGetNodeComplete: 'GetNodeComplete_Out',
+  reservedLimitComplete: 'ReservedLimitComplete',
+  createPresignUrl: 'CreatePresignUrl',
+  flowSchemaOwnTopicComplete: 'FlowSchemaOwnTopicComplete',
+  flowSchemaOwnTopicEndpointComplete: 'FlowSchemaOwnTopicEndpointComplete',
+  createRecordComplete: 'CreateRecordComplete',
+  changeRelationshipComplete: 'ChangeRelationshipComplete',
+  outChangeRelationshipComplete: 'ChangeRelationshipComplete_Out',
+  moveRelationshipComplete: 'MoveRelationshipComplete',
+  outMoveRelationshipComplete: 'MoveRelationshipComplete_Out'
+};
+
+const GRAPH_HANDLER_SERVICE_NAME = {
+  graphHandler: 'GraphHandler'
+};
+
+const TOPIC_NAME_EXTERNAL_SERVICE = {
+  staticLimitProcessComplete: 'StaticLimitProcessComplete_Out',
+  reservedDynamicUsageComplete: 'ReservedDynamicUsageComplete_Out'
+};
+
+const EXTERNAL_SERVICE_NAME = {
+  accountLimits: 'AccountLimits'
+};
+
+export {
+  TOPIC_NAME_GRAPH_HANDLER,
+  TOPIC_NAME_GENERATE_CODE,
+  GRAPH_HANDLER_SERVICE_NAME,
+  TOPIC_NAME_EXTERNAL_SERVICE,
+  EXTERNAL_SERVICE_NAME
+};

package/src/pipeline/fetchSchemas.js

@@ -0,0 +1,31 @@
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import path from 'path';
+
+/**
+ * Phase 1: Load all schema types from local filesystem in parallel.
+ * @param {Object} _izContext
+ * @param {string} rootServicePath
+ * @returns {Promise<{flowSchemas, objSchemas, relSchemas, notifSchemas}>}
+ */
+async function fetchSchemas(_izContext, rootServicePath) {
+  const schemasPath = path.join(rootServicePath, '/app/src/schemas');
+
+  console.info('[INFO] [generateCode] STATUS=FETCHING  | schemas...');
+  const fetchStartTime = Date.now();
+
+  const [flowSchemas, objSchemas, relSchemas, notifSchemas] = await Promise.all([
+    getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath),
+    getObjectSchema.getAllLocalObjectSchemasWithHierarchy(_izContext, schemasPath),
+    getObjectSchema.getAllLocalRelationshipSchema(_izContext, schemasPath),
+    getObjectSchema.getLocalNotificationSystemSchemas(_izContext, schemasPath)
+  ]);
+
+  const fetchStr = `flow=${flowSchemas.records?.length ?? 0} obj=${objSchemas.records?.length ?? 0} rel=${relSchemas.length ?? 0}`;
+  console.info(
+    `[INFO] [generateCode] STATUS=FETCHED   | ${fetchStr.padEnd(40)} | elapsedMs=${Date.now() - fetchStartTime}`
+  );
+
+  return { flowSchemas, objSchemas, relSchemas, notifSchemas };
+}
+
+export { fetchSchemas };

package/src/pipeline/transformSchemas.js

@@ -0,0 +1,75 @@
+import path from 'path';
+import generateTemplateDataFromFlowSchema from '../generators/fromFlowSchema/index.js';
+import generateTemplateDataFromSchema from '../generators/fromObjectSchema/index.js';
+import generateTemplateDataInitialSetup from '../generators/fromExternalService/index.js';
+import generateTemplateDataOther from '../generators/other/index.js';
+import generatePlugIn from '../generators/fromPlugIn/index.js';
+import generateTemplateDataRole from '../generators/roles/index.js';
+
+/**
+ * Phase 2: Run all generators against loaded schemas and return the flat source list.
+ * @param {Object} _izContext
+ * @param {string} rootServicePath
+ * @param {{flowSchemas, objSchemas, relSchemas, notifSchemas}} schemas
+ * @param {Object} settings
+ * @returns {Promise<Array>} allCreateSource items
+ */
+async function transformSchemas(_izContext, rootServicePath, schemas, settings = {}) {
+  const { flowSchemas, objSchemas, relSchemas, notifSchemas } = schemas;
+  const appPath = path.join(rootServicePath, '/app');
+
+  console.info('[INFO] [generateCode] STATUS=GENERATING| template data...');
+  _izContext.logger.info('[generateCode] generating template data...');
+  const genStartTime = Date.now();
+
+  const [
+    flowSchemaResult,
+    schemaResult,
+    initialSetupResult,
+    otherResult,
+    generatePlugInResult
+  ] = await Promise.all([
+    generateTemplateDataFromFlowSchema(_izContext, appPath, flowSchemas.records, settings),
+    generateTemplateDataFromSchema(
+      _izContext,
+      appPath,
+      objSchemas,
+      relSchemas,
+      flowSchemas.records,
+      notifSchemas,
+      settings
+    ).catch(error => {
+      console.error('[generateCode] schemaResult error:', error);
+      _izContext.logger.error('[generateCode] schemaResult error:', error);
+      return [];
+    }),
+    generateTemplateDataInitialSetup(_izContext, appPath, objSchemas.records, relSchemas, flowSchemas.records, settings),
+    generateTemplateDataOther(_izContext, appPath),
+    generatePlugIn(_izContext, rootServicePath, appPath, objSchemas.records, flowSchemas.records)
+  ]);
+
+  const genStr = `flow=${flowSchemaResult.length} sch=${schemaResult.length} setup=${initialSetupResult.length} other=${otherResult.length}`;
+  console.info(
+    `[INFO] [generateCode] STATUS=GENERATED | ${genStr.padEnd(40)} | elapsedMs=${Date.now() - genStartTime}`
+  );
+
+  const allCreateSource = [
+    ...flowSchemaResult,
+    ...schemaResult,
+    ...initialSetupResult,
+    ...otherResult,
+    ...generatePlugInResult
+  ];
+
+  // Append role configs derived from the collected sources
+  console.info('[INFO] [generateCode] STATUS=GENERATING| role configs...');
+  const createSourceRole = generateTemplateDataRole(_izContext, appPath, allCreateSource);
+  allCreateSource.push(...createSourceRole);
+
+  const roleStr = `items=${allCreateSource.length} roles=${createSourceRole.length}`;
+  console.info(`[INFO] [generateCode] STATUS=ROLES_GEN | ${roleStr.padEnd(40)} |`);
+
+  return allCreateSource;
+}
+
+export { transformSchemas };

package/src/pipeline/validateSources.js

@@ -0,0 +1,47 @@
+import { readFileSync } from 'fs';
+import validatePathWithRootServicePath from '#libs/GenerateCodeLibs.js';
+import utils from '#libs/Utils.js';
+import createSource from '../sourceManager/CreateSource.js';
+
+const { deleteFileInDir } = utils;
+
+/**
+ * Phase 3: Validate every source item against its template and clear output dirs.
+ * Throws on first invalid item so nothing is written from a broken state.
+ * @param {Object} _izContext
+ * @param {string} rootServicePath
+ * @param {Array} allCreateSource
+ */
+async function validateSources(_izContext, rootServicePath, allCreateSource) {
+  const validateStartTime = Date.now();
+  console.info('[INFO] [generateCode] STATUS=VALIDATING| source items...');
+
+  for (const item of allCreateSource) {
+    if (!item?.templatePath || !item?.templateData || !item?.setting) {
+      console.debug('###### error item:', item);
+      throw new Error(`[generateCode] invalid source item: ${JSON.stringify(item)}`);
+    }
+    const { templatePath, templateData, setting } = item;
+    setting.checkCreateSourcePass = true;
+
+    const [status, errors] = await createSource(
+      readFileSync(templatePath, 'utf8'),
+      templateData,
+      setting
+    );
+    if (!status) {
+      console.error('[generateCode] validation failed:', errors);
+      console.debug('###### item:', item);
+      throw new Error(errors);
+    }
+
+    validatePathWithRootServicePath(rootServicePath, setting.savePath);
+    await deleteFileInDir(setting.savePath);
+  }
+
+  console.info(
+    `[INFO] [generateCode] STATUS=VALIDATED | ${'items=' + allCreateSource.length} | elapsedMs=${Date.now() - validateStartTime}`
+  );
+}
+
+export { validateSources };

package/src/pipeline/writeSources.js

@@ -0,0 +1,24 @@
+import { readFileSync } from 'fs';
+import createSource from '../sourceManager/CreateSource.js';
+
+/**
+ * Phase 4: Write all generated files in parallel.
+ * @param {Array} allCreateSource
+ */
+async function writeSources(allCreateSource) {
+  console.info('[INFO] [generateCode] STATUS=WRITING   | source files...');
+  const writeStartTime = Date.now();
+
+  await Promise.all(
+    allCreateSource.map(({ templatePath, templateData, setting }) => {
+      setting.checkCreateSourcePass = false;
+      return createSource(readFileSync(templatePath, 'utf8'), templateData, setting);
+    })
+  );
+
+  console.info(
+    `[INFO] [generateCode] STATUS=WRITTEN   | ${'files=' + allCreateSource.length} | elapsedMs=${Date.now() - writeStartTime}`
+  );
+}
+
+export { writeSources };

package/src/generateCode/generateFlowSchema/GenerateCodeFlowSchema.js

@@ -1,224 +0,0 @@
-/*
-Copyright (C) 2020 Sven Mason <http://izara.io>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-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 event component
-import createFlowSchemaOwnTopicComponent from './event/ownTopicComponent/index.js';
-import createFlowSchemaExtTopicComponent from './event/extTopicComponent/index.js';
-import createFlowSchemaS3Component from './event/s3Component/index.js';
-import createFlowSchemaEventBridgeComponent from './event/eventBridgeComponent/index.js';
-import createLambdaSyncInvComponent from './event/lambdaSyncInvComponent/index.js';
-import createLambdaSyncApiComponent from './event/lambdaSyncApiComponent/index.js';
-
-// import statusType component
-import createStatusFieldComponent from './statusType/statusFieldComponent/index.js';
-import createTriggerCacheComponent from './statusType/triggerCacheComponent/index.js';
-
-// import webSocket component
-import createWebSocketComponent from './webSocketComponent/index.js';
-
-// import register component
-import createRegisterComponent from './registerComponent/index.js';
-
-// import per-flowSchema components
-import createWebSocketGenerateCodeLibs from './libs/data.js';
-import createFlowSchemaEndpointMainFunction from './flowSchemaMainFunction/data.js';
-import buildFlowStepResources from './flowStep/flowStep.js';
-
-import libs from '#libs/Libs.js';
-
-/**
- * Generates template data from flow schemas
- * @param {Object} _izContext - Context object with logger
- * @param {string} appPath - Root path of the service
- * @param {Array} allLocalFlowSchemas - Array of flow schema objects
- * @param {Object} settings - Optional generation settings
- * @returns {Promise<Array>} Array of generated source params
- */
-async function generateTemplateDataFromFlowSchema(
-  _izContext,
-  appPath,
-  allLocalFlowSchemas,
-  settings
-) {
-  try {
-    const startAllMs = Date.now();
-
-    const EVENT_HANDLERS = {
-      ownTopic: createFlowSchemaOwnTopicComponent,
-      extTopic: createFlowSchemaExtTopicComponent,
-      s3: createFlowSchemaS3Component,
-      eventBridge: createFlowSchemaEventBridgeComponent,
-      lambdaSyncInv: createLambdaSyncInvComponent,
-      lambdaSyncApi: createLambdaSyncApiComponent,
-      generatedCode: null
-    };
-
-    const shouldGenerateWebSocketAndRegister = allLocalFlowSchemas.some(
-      flowSchema =>
-        Array.isArray(flowSchema?.event) &&
-        flowSchema.event.some(e => e === 'ownTopic' || e === 'extTopic')
-    );
-
-    const flowResults = await Promise.all(
-      allLocalFlowSchemas.map(async flowSchema => {
-        const flowStartMs = Date.now();
-        const flowTag = flowSchema?.flowTag ?? '(unknownFlowTag)';
-        const events = Array.isArray(flowSchema?.event) ? flowSchema.event : [];
-
-        console.info(
-          `[FlowSchema:${flowTag}] start events=${JSON.stringify(events)} statusType=${flowSchema?.statusType}`
-        );
-
-        // ── per-flowSchema resources ─────────────────────────────────────────
-        const perFlowParams = [
-          createWebSocketGenerateCodeLibs(_izContext, flowSchema, appPath),
-          // ...buildFlowStepResources(_izContext, flowSchema, appPath)
-        ];
-
-        if (!flowSchema.event.includes('s3')) {
-          perFlowParams.push(
-            await createFlowSchemaEndpointMainFunction(
-              _izContext,
-              flowSchema,
-              appPath
-            )
-          );
-        }
-
-        // ── event handlers ───────────────────────────────────────────────────
-        const eventPromises = events
-          .filter(event => {
-            if (!(event in EVENT_HANDLERS)) {
-              console.warn(
-                `[FlowSchema:${flowTag}] skip unsupported event=${event}`
-              );
-              return false;
-            }
-            if (EVENT_HANDLERS[event] === null) {
-              console.info(
-                `[FlowSchema:${flowTag}] skip not implemented event=${event}`
-              );
-              return false;
-            }
-            return true;
-          })
-          .map(event =>
-            Promise.resolve(
-              EVENT_HANDLERS[event](_izContext, flowSchema, appPath)
-            ).then(result => {
-              console.info(
-                `[FlowSchema:${flowTag}] done event=${event} generated=${Array.isArray(result) ? result.flat(5).length : 0}`
-              );
-              return result;
-            })
-          );
-
-        // ── statusType handler ───────────────────────────────────────────────
-        const statusPromise = (() => {
-          const { statusType, event } = flowSchema;
-          if (
-            statusType === 'statusField' &&
-            event.includes('ownTopic') &&
-            event.includes('extTopic')
-          ) {
-            return Promise.resolve(
-              createStatusFieldComponent(_izContext, flowSchema, appPath)
-            ).then(result => {
-              console.info(
-                `[FlowSchema:${flowTag}] done statusType=StatusField generated=${Array.isArray(result) ? result.flat(5).length : 0}`
-              );
-              return result;
-            });
-          } else if (statusType === 'triggerCache') {
-            return Promise.resolve(
-              createTriggerCacheComponent(_izContext, flowSchema, appPath)
-            ).then(result => {
-              console.info(
-                `[FlowSchema:${flowTag}] done statusType=TriggerCache generated=${Array.isArray(result) ? result.flat(5).length : 0}`
-              );
-              return result;
-            });
-          } else if (statusType === 'storedCache') {
-            console.info(
-              `[FlowSchema:${flowTag}] skip statusType=StoredCache (noop)`
-            );
-          } else if (statusType === 'none') {
-            console.info(`[FlowSchema:${flowTag}] skip statusType=None (noop)`);
-          } else if (statusType !== 'statusField') {
-            throw new Error('Not supported statusType: ' + statusType);
-          }
-          return Promise.resolve([]);
-        })();
-
-        const results = [
-          ...perFlowParams,
-          ...(await Promise.all([...eventPromises, statusPromise])).flat(5)
-        ];
-
-        const targetFiles = libs.toUniqueFilePaths(results);
-
-        console.info(
-          `[FlowSchema:${flowTag}] completed generated=${results.length} elapsedMs=${Date.now() - flowStartMs}`
-        );
-        if (targetFiles.length)
-          console.info(`[FlowSchema:${flowTag}] targetFiles: `, targetFiles);
-
-        return results;
-      })
-    );
-
-    const createSourceParams = flowResults.flat(5);
-
-    if (shouldGenerateWebSocketAndRegister) {
-      const [webSocketResults, registerResults] = await Promise.all([
-        Promise.resolve(
-          createWebSocketComponent(_izContext, appPath, allLocalFlowSchemas)
-        ),
-        Promise.resolve(
-          createRegisterComponent(_izContext, allLocalFlowSchemas, appPath)
-        )
-      ]);
-
-      createSourceParams.push(...webSocketResults, ...registerResults);
-
-      const wsAndRegisterFiles = libs.toUniqueFilePaths([
-        ...webSocketResults,
-        ...registerResults
-      ]);
-
-      console.info(
-        `[FlowSchema:*] completed webSocket+register generated=${webSocketResults.length + registerResults.length}`
-      );
-      if (wsAndRegisterFiles.length)
-        console.info(
-          '[FlowSchema:*] targetFiles (webSocket+register) : ',
-          wsAndRegisterFiles
-        );
-    }
-
-    console.info(
-      `[FlowSchema:*] all completed flows=${allLocalFlowSchemas.length} generated=${createSourceParams.length} elapsedMs=${Date.now() - startAllMs}`
-    );
-
-    return createSourceParams;
-  } catch (error) {
-    console.error('Error in generateTemplateDataFromFlowSchema:', error);
-    throw error;
-  }
-}
-
-export default generateTemplateDataFromFlowSchema;