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

package/src/emit/resource/resourceState.js

@@ -0,0 +1,564 @@
+import {
+  customFlowRoleName,
+  flowDsqSteps,
+  flowExtTopicSteps,
+  generatedDsqFlows,
+  generatedOwnTopicFlows,
+  supportedCustomFlows,
+  flowHasRbac
+} from '../custom/customFlows.js';
+import { hasSystemWebSocket } from '../system/emitSystemWebSocketArtifacts.js';
+import { rbacFlowTag } from '../rbac/rbacFlowTag.js';
+import { CRUD_ACTIONS, createCrudActionPlans } from '../crud/crudActionPlan.js';
+
+export const RELATIONSHIP_ACTIONS = [
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+];
+
+export const RBAC_ACTIONS = [
+  'CreateTargetRole',
+  'UpdateTargetRole',
+  'DeleteTargetRole',
+  'GetTargetRole',
+  'ListTargetRole',
+  'CreateRolePermissions',
+  'ListRolePermissions',
+  'DeleteRolePermissions',
+  'CreateUserRole',
+  'ListUserInRoles',
+  'DeleteUserFromRole',
+  'GetMyPermissions',
+  'ValidatorRbac',
+  'ReservedDynamicUsage',
+  'ConfirmUsage',
+  'CancelUsage'
+];
+
+export const SYSTEM_TABLES = [
+  'WebSocketTask',
+  'UserUploadRecords',
+  'RegisterRecords',
+  'AwaitingMultipleSteps',
+  'AwaitingMultipleStepByPending',
+  'FindDataMain',
+  'LogicalResultsMain',
+  'LogicalResultsData',
+  'AwaitingStep'
+];
+
+export const RBAC_TABLES = [
+  'Roles',
+  'TargetRoles',
+  'RolePermissions',
+  'RoleUsers',
+  'UserRoles',
+  'RbacPermissionCaches',
+  'RunningTotalUsage',
+  'RunningTotalReservedUsage',
+  'WebSocketTask'
+];
+
+const VALID_CRUD_GENERATED_BY = new Set([
+  'user',
+  'systemWithUser',
+  'systemNoUser'
+]);
+
+export function createResourceState({ objects, relationships, flows }) {
+  const crud = objects.some(isCrudObject);
+  const selfRbac = objects.some(hasSelfRbacAddOn);
+  const rbac = objects.some((obj) => hasRbacAddOn(obj, objects));
+  const crudActionPlans = createCrudActionPlans(objects, flows);
+
+  let crudOwnTopics = [];
+  if (crud) {
+    crudOwnTopics = [...CRUD_ACTIONS];
+  }
+
+  const crudSqsQueues = [];
+  if (crud) {
+    for (const action of ['Create', 'Update', 'Delete']) {
+      const plan = crudActionPlans[action];
+      if (plan.hasCreateNodeCallback) {
+        crudSqsQueues.push(`${action}NodeCallbackHdrSqs`);
+      }
+      if (plan.hasBeforeHookCallback) {
+        crudSqsQueues.push(`${action}BeforeHookCallbackHdrSqs`);
+      }
+      if (plan.hasAfterHookCallback) {
+        crudSqsQueues.push(`${action}AfterHookCallbackHdrSqs`);
+      }
+      if (plan.hasComplete) {
+        crudSqsQueues.push(`${action}CompleteHdrSqs`);
+      }
+    }
+  }
+
+  let relationshipOwnTopics = [];
+  if (relationships.length > 0) {
+    relationshipOwnTopics = [...RELATIONSHIP_ACTIONS];
+  }
+
+  let relationshipSqsQueues = [];
+  if (relationships.length > 0) {
+    relationshipSqsQueues = RELATIONSHIP_ACTIONS.map(
+      (action) => `${action}CompleteHdrSqs`
+    );
+  }
+
+  let relationshipDsqQueues = [];
+  if (relationships.length > 0) {
+    relationshipDsqQueues = ['GetRelationshipHdrDsq'];
+  }
+
+  const rbacOwnTopics = [];
+  const rbacSqsQueues = [];
+  if (selfRbac) {
+    for (const action of RBAC_ACTIONS) {
+      rbacOwnTopics.push(action);
+      rbacSqsQueues.push(`Process${action}HdrSqs`);
+    }
+    const flowTags = [
+      ...new Set(objects.filter(hasSelfRbacAddOn).map(rbacFlowTag))
+    ];
+    for (const flowTag of flowTags) {
+      rbacOwnTopics.push(flowTag);
+    }
+  }
+  if (crud) {
+    for (const action of ['Create', 'Update', 'Delete']) {
+      const plan = crudActionPlans[action];
+      if (plan.hasRbacCallback) {
+        rbacSqsQueues.push(`${action}RbacCallbackHdrSqs`);
+      }
+    }
+  }
+
+  const customOwnTopics = flows
+    .filter((flow) => flowHasOwnTopic(flow))
+    .map((flow) => upperFirst(flow.flowTag));
+
+  const customSqsQueues = [
+    ...flows
+      .filter((flow) => includesEvent(flow, 'extTopic'))
+      .map((flow) => `Process${upperFirst(flow.flowTag)}HdrSqs`),
+    ...flows
+      .filter(
+        (flow) =>
+          flow?.outputTopic &&
+          !flow?.generatedCodeConfig &&
+          upperFirst(flow.flowTag)
+      )
+      .map((flow) => `${upperFirst(flow.flowTag)}CompleteHdrSqs`)
+  ];
+  for (const { flowTag, stepName } of flowExtTopicSteps(flows)) {
+    customSqsQueues.push(`${flowTag}${stepName}HdrSqs`);
+  }
+  for (const flow of flows) {
+    if (flowHasRbac(flow, objects)) {
+      const tag = upperFirst(flow.flowTag);
+      customSqsQueues.push(`${tag}RbacCallbackHdrSqs`);
+    }
+  }
+  for (const flow of flows.filter((flow) => includesEvent(flow, 's3'))) {
+    const tag = upperFirst(flow.flowTag);
+    customSqsQueues.push(`${tag}CreatePreSignUrlHdrSqs`);
+    customSqsQueues.push(`${tag}ReservedLimitHdrSqs`);
+    customSqsQueues.push(`${tag}ConfirmAfterUploadHdrSqs`);
+  }
+
+  const customDsqQueues = flows
+    .filter((flow) => includesEvent(flow, 'dsq'))
+    .map((flow) => `${upperFirst(flow.flowTag)}HdrDsq`);
+  for (const { flowTag, stepName } of flowDsqSteps(flows)) {
+    customDsqQueues.push(`${flowTag}${stepName}HdrDsq`);
+  }
+
+  const websocket = hasSystemWebSocket(flows, {
+    includeRelationshipOwnTopic: true,
+    objects,
+    relationships
+  });
+
+  const systemOwnTopics = ['ProcessLogical', 'FindData'];
+  let systemSqsQueues = ['PaginateProcessLogicalHdrSqs'];
+  if (websocket) {
+    systemSqsQueues.push('WebSocketCompleteHdrSqs', 'RegisterCompleteHdrSqs');
+  }
+  const systemDsqQueues = ['PaginateProcessLogicalHdrDsq'];
+
+  const ownTopics = new Set([
+    ...systemOwnTopics,
+    ...crudOwnTopics,
+    ...relationshipOwnTopics,
+    ...rbacOwnTopics,
+    ...customOwnTopics
+  ]);
+  const sqsQueues = new Set([
+    ...systemSqsQueues,
+    ...crudSqsQueues,
+    ...relationshipSqsQueues,
+    ...rbacSqsQueues,
+    ...customSqsQueues
+  ]);
+  const dsqQueues = new Set([
+    ...systemDsqQueues,
+    ...relationshipDsqQueues,
+    ...customDsqQueues
+  ]);
+
+  const customRoles = [
+    ...new Set([
+      ...supportedCustomFlows(flows).map((flow) =>
+        customFlowRoleName(flow.flowTag)
+      ),
+      ...generatedOwnTopicFlows(flows).map((flow) =>
+        customFlowRoleName(flow.flowTag)
+      ),
+      ...generatedDsqFlows(flows).map((flow) =>
+        customFlowRoleName(flow.flowTag)
+      ),
+      ...flowExtTopicSteps(flows).map(({ flow }) =>
+        customFlowRoleName(flow.flowTag)
+      ),
+      ...flowDsqSteps(flows).map(({ flow }) => customFlowRoleName(flow.flowTag))
+    ])
+  ];
+  const webSocketRoles = new Set();
+  if (websocket) {
+    webSocketRoles.add('WebSocketMainRole');
+    webSocketRoles.add('RegisterRole');
+  }
+  if (crud) {
+    webSocketRoles.add('FlowObjectsRole');
+  }
+  if (relationships.length > 0) {
+    webSocketRoles.add('FlowRelationshipRole');
+  }
+  if (rbac) {
+    webSocketRoles.add('FlowRbacRole');
+  }
+  const filteredWsFlows = [
+    ...supportedCustomFlows(flows),
+    ...generatedOwnTopicFlows(flows)
+  ].filter(
+    (flow) => flowHasOwnTopic(flow) || includesEvent(flow, 's3')
+  );
+  for (const flow of filteredWsFlows) {
+    webSocketRoles.add(customFlowRoleName(flow.flowTag));
+  }
+  const outTopics = new Set([
+    ...ownTopics,
+    ...flows
+      .filter((flow) => flow?.outputTopic && upperFirst(flow.flowTag))
+      .map((flow) => upperFirst(flow.flowTag))
+  ]);
+  const objectTableNames = [...collectTables(objects).keys()];
+  const relationshipTableNames = [...collectTables(relationships).keys()];
+  const tableMap = new Map([
+    ...collectTables(objects),
+    ...collectTables(relationships),
+    ...collectTables(flows)
+  ]);
+  const externalDynamoTables = objects.flatMap(
+    (object) => object.externalDynamoResources ?? []
+  );
+  const s3Buckets = flows
+    .filter((flow) => includesEvent(flow, 's3') && flow.createBucket === true)
+    .map((flow) => flow.bucketName)
+    .filter(Boolean);
+  const s3FlowTags = flows
+    .filter((flow) => includesEvent(flow, 's3'))
+    .map((flow) => upperFirst(flow.flowTag));
+  const s3Subscriptions = flows
+    .filter((flow) => includesEvent(flow, 's3'))
+    .map((flow) => {
+      const tag = upperFirst(flow.flowTag);
+      let topicName = flow.s3Subscription?.topicName || 'OutCreate';
+      if (typeof flow.outputTopic === 'string') {
+        if (flow.outputTopic.startsWith('Out')) {
+          topicName = flow.outputTopic;
+        } else {
+          topicName = `Out${upperFirst(flow.outputTopic)}`;
+        }
+      }
+      const queueName =
+        flow.s3Subscription?.queueName || `${tag}ReservedLimitHdrSqs`;
+      const subscriptionName =
+        flow.s3Subscription?.subscriptionName ||
+        `Subscription${topicName}To${queueName}`;
+      return { subscriptionName, topicName, queueName };
+    });
+  const systemTables = [...SYSTEM_TABLES];
+  if (rbac) {
+    systemTables.push(
+      'Roles',
+      'TargetRoles',
+      'RolePermissions',
+      'RoleUsers',
+      'UserRoles',
+      'RbacPermissionCaches',
+      'RunningTotalUsage',
+      'RunningTotalReservedUsage'
+    );
+  }
+  if (s3FlowTags.length > 0) {
+    systemTables.push('ReservedDataMain');
+  }
+  const hasHttpApi =
+    crud ||
+    relationships.length > 0 ||
+    rbac ||
+    flows.some((flow) => includesEvent(flow, 'lambdaSyncApi'));
+
+  let webSocketSubscriptions = [];
+  if (websocket) {
+    webSocketSubscriptions = [...outTopics]
+      .filter(
+        (topic) =>
+          flows.some(
+            (flow) =>
+              (flow?.outputTopic ||
+                (flowHasOwnTopic(flow) &&
+                  (flow.initiateBy === 'user' ||
+                    flow.initiateBy === 'systemWithUser'))) &&
+              upperFirst(flow.flowTag) === topic
+          ) ||
+          (objects.length > 0 &&
+            topic !== 'Get' &&
+            CRUD_ACTIONS.includes(topic)) ||
+          (relationships.length > 0 &&
+            topic !== 'GetRelationship' &&
+            RELATIONSHIP_ACTIONS.includes(topic))
+      )
+      .sort();
+  }
+
+  return {
+    crud,
+    rbac,
+    selfRbac,
+    crudActionPlans,
+    crudOwnTopics: [...new Set(crudOwnTopics)].filter(Boolean).sort(),
+    crudSqsQueues: [...new Set(crudSqsQueues)].filter(Boolean).sort(),
+    relationshipOwnTopics: [...new Set(relationshipOwnTopics)]
+      .filter(Boolean)
+      .sort(),
+    relationshipSqsQueues: [...new Set(relationshipSqsQueues)]
+      .filter(Boolean)
+      .sort(),
+    relationshipDsqQueues: [...new Set(relationshipDsqQueues)]
+      .filter(Boolean)
+      .sort(),
+    rbacOwnTopics: [...new Set(rbacOwnTopics)].filter(Boolean).sort(),
+    rbacSqsQueues: [...new Set(rbacSqsQueues)].filter(Boolean).sort(),
+    customOwnTopics: [...new Set(customOwnTopics)].filter(Boolean).sort(),
+    customSqsQueues: [...new Set(customSqsQueues)].filter(Boolean).sort(),
+    customDsqQueues: [...new Set(customDsqQueues)].filter(Boolean).sort(),
+    systemOwnTopics: [...new Set(systemOwnTopics)].filter(Boolean).sort(),
+    systemSqsQueues: [...new Set(systemSqsQueues)].filter(Boolean).sort(),
+    systemDsqQueues: [...new Set(systemDsqQueues)].filter(Boolean).sort(),
+    s3Subscriptions,
+    s3FlowTags,
+    hasHttpApi,
+    relationships: relationships.length > 0,
+    ownTopics: [...ownTopics].filter(Boolean).sort(),
+    sqsQueues: [...sqsQueues].filter(Boolean).sort(),
+    dsqQueues: [...dsqQueues].filter(Boolean).sort(),
+    customRoles,
+    websocket,
+    webSocketRoles,
+    webSocketSubscriptions,
+    outTopics: [...outTopics].filter(Boolean).sort(),
+    tables: [...tableMap.entries()].map(([tableName, keys]) => ({
+      tableName,
+      ...keys
+    })),
+    allTableNames: [...new Set([...systemTables, ...tableMap.keys()])].sort(),
+    objectTableNames,
+    relationshipTableNames,
+    externalDynamoTables,
+    objectTablesByType: new Map(
+      objects
+        .map((object) => {
+          const resource = Object.values(object.storageResources ?? {}).find(
+            (res) =>
+              res?.storageType === 'dynamo' ||
+              res?.storageType === 'dynamoDB' ||
+              !res?.storageType
+          );
+          return [object.objectType, resource?.tableName];
+        })
+        .filter(([, tableName]) => tableName)
+    ),
+    s3Buckets,
+    flows,
+    objects
+  };
+}
+
+export function collectTables(schemas) {
+  const tables = new Map();
+  for (const schema of schemas) {
+    if (!schema?.storageResources) continue;
+    const identifiers = Array.isArray(schema.identifiers)
+      ? schema.identifiers
+      : [];
+    const pkIdentifier = identifiers.find(
+      (identifier) =>
+        identifier.type === 'partitionKey' || identifier.type === 'identifier'
+    );
+    const skIdentifier = identifiers.find(
+      (identifier) => identifier.type === 'sortKey'
+    );
+    const pk = keyName(pkIdentifier) ?? 'PK';
+    const sk = keyName(skIdentifier);
+    const pkType = keyAttributeType(pkIdentifier, schema);
+    const skType = keyAttributeType(skIdentifier, schema);
+    for (const resource of Object.values(schema.storageResources)) {
+      if (
+        (resource?.storageType === 'dynamo' ||
+          resource?.storageType === 'dynamoDB' ||
+          !resource?.storageType) &&
+        resource.tableName &&
+        !tables.has(resource.tableName)
+      ) {
+        tables.set(resource.tableName, { pk, sk, pkType, skType });
+      }
+    }
+  }
+  return tables;
+}
+
+export function keyAttributeType(identifier, schema) {
+  if (!identifier) return 'S';
+  if (identifier.attributeType) {
+    return identifier.attributeType;
+  }
+  if (identifier.dataType) {
+    return mapTypeToAttributeType(identifier.dataType);
+  }
+  if (identifier.fieldType) {
+    return mapTypeToAttributeType(identifier.fieldType);
+  }
+  const fieldName = identifier.fieldName ?? identifier.name;
+  if (fieldName && schema) {
+    let fieldDef =
+      schema.fieldNames?.[fieldName] ?? schema.properties?.[fieldName];
+    if (!fieldDef && Array.isArray(schema.addOnDataStructure)) {
+      for (const addOn of schema.addOnDataStructure) {
+        if (addOn?.fieldNames?.[fieldName]) {
+          fieldDef = addOn.fieldNames[fieldName];
+          break;
+        }
+      }
+    }
+    if (fieldDef?.attributeType) {
+      return fieldDef.attributeType;
+    }
+    const type = fieldDef?.type ?? fieldDef?.dataType;
+    if (type) {
+      return mapTypeToAttributeType(type);
+    }
+  }
+  return 'S';
+}
+
+export function mapTypeToAttributeType(type) {
+  if (typeof type !== 'string') return 'S';
+  const lower = type.toLowerCase();
+  if (
+    lower === 'number' ||
+    lower === 'numeric' ||
+    lower === 'integer' ||
+    lower === 'float' ||
+    lower === 'int' ||
+    lower === 'double' ||
+    lower === 'n'
+  ) {
+    return 'N';
+  }
+  if (lower === 'binary' || lower === 'b') {
+    return 'B';
+  }
+  return 'S';
+}
+
+export function keyName(identifier) {
+  if (!identifier) return null;
+  return (
+    identifier.name ??
+    identifier.fieldName ??
+    (Array.isArray(identifier.fieldNames)
+      ? identifier.fieldNames.join(identifier.deliminator ?? '_')
+      : null)
+  );
+}
+
+export function isCrudObject(object) {
+  return VALID_CRUD_GENERATED_BY.has(object?.generatedBy);
+}
+
+export function hasSelfRbacAddOn(object) {
+  return (
+    Array.isArray(object?.addOnDataStructure) &&
+    object.addOnDataStructure.some((addOn) => addOn?.type === 'rbac')
+  );
+}
+
+export function hasRbacAddOn(object, objects = []) {
+  const selfHasRbac = hasSelfRbacAddOn(object);
+  const belongToTargets = object?.belongTo
+    ? Array.isArray(object.belongTo)
+      ? object.belongTo
+      : [object.belongTo]
+    : [];
+  const belongToHasRbac =
+    (Array.isArray(object?.belongToSchema?.addOnDataStructure) &&
+      object.belongToSchema.addOnDataStructure.some(
+        (addOn) => addOn?.type === 'rbac'
+      )) ||
+    belongToTargets.some((target) => {
+      if (target?.serviceTag === 'UserAccount') return true;
+      const matched = objects.find(
+        (candidate) =>
+          candidate?.serviceTag === target?.serviceTag &&
+          candidate?.objectType === target?.objectType
+      );
+      return hasSelfRbacAddOn(matched);
+    });
+  return selfHasRbac || belongToHasRbac;
+}
+
+export function rbacFlowQueueNames(state) {
+  return [];
+}
+
+export function includesEvent(flow, event) {
+  return Array.isArray(flow?.event) && flow.event.includes(event);
+}
+
+export function flowHasOwnTopic(flow) {
+  if (includesEvent(flow, 'ownTopic')) {
+    return true;
+  }
+  if (
+    includesEvent(flow, 'generateCode') &&
+    flow?.generatedCodeConfig?.invocationType === 'ownTopic'
+  ) {
+    return true;
+  }
+  return false;
+}
+
+export function upperFirst(value) {
+  if (typeof value === 'string' && value) {
+    return value[0].toUpperCase() + value.slice(1);
+  }
+  return '';
+}

package/src/emit/resource/resourceTemplate.js

@@ -0,0 +1,30 @@
+import ejsLib from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+
+export function indentYaml(content, spaces = 2) {
+  const prefix = ' '.repeat(spaces);
+  return content
+    .split('\n')
+    .map((line) => {
+      if (line.trim()) {
+        return `${prefix}${line}`;
+      }
+      return '';
+    })
+    .join('\n');
+}
+
+export function normalizeYaml(content) {
+  return `${content.trimEnd()}\n`;
+}
+
+export async function renderResourceTemplate(templateName, data) {
+  const templatePath = new URL(templateName, TEMPLATE_URL);
+  const templateContent = await readFile(templatePath, 'utf8');
+  return ejsLib.render(templateContent, {
+    resourceQueueName: data.queueName,
+    ...data
+  });
+}

package/src/emit/resource/s3ResourceArtifacts.js

@@ -0,0 +1,14 @@
+import { indentYaml, renderResourceTemplate } from './resourceTemplate.js';
+
+export async function renderS3(state) {
+  if (state.s3Buckets.length === 0) {
+    return '';
+  }
+  const renderedBuckets = await Promise.all(
+    state.s3Buckets.map((bucketName) =>
+      renderResourceTemplate('S3Bucket_Yaml.ejs', { bucketName })
+    )
+  );
+  const body = renderedBuckets.join('\n');
+  return `Resources:\n${indentYaml(body, 2)}`;
+}