export function getBuiltInOperationInfo()

in libs/logic-apps-shared/src/designer-client-services/lib/base/operationmanifest.ts [363:521]
148 lines of code
43 McCabe index (conditional complexity)

export function getBuiltInOperationInfo(definition: any, isTrigger: boolean): OperationInfo {
  const normalizedOperationType = definition.type?.toLowerCase();
  const kind = definition.kind?.toLowerCase();

  if (kind === undefined) {
    const operationInfo = builtInOperationsMetadata[normalizedOperationType];
    if (operationInfo) {
      return operationInfo;
    }
  }

  switch (normalizedOperationType) {
    case expression:
      switch (definition.kind?.toLowerCase()) {
        case addtotime:
        case converttimezone:
        case currenttime:
        case getfuturetime:
        case getpasttime:
        case subtractfromtime:
          return {
            connectorId: dateTimeConnectorId,
            operationId: definition.kind.toLowerCase(),
          };

        default:
          throw new UnsupportedException(`Unsupported datetime kind '${definition.kind}'`);
      }

    case http: {
      if (equals(definition?.metadata?.swaggerSource, 'website')) {
        return {
          connectorId: appServiceConnectorId,
          operationId: isTrigger ? appservicetrigger : appservice,
        };
      }
      return {
        connectorId: httpConnectorId,
        operationId: definition?.metadata?.apiDefinitionUrl
          ? isTrigger
            ? httpswaggertrigger
            : httpswaggeraction
          : isTrigger
            ? httptrigger
            : httpaction,
      };
    }
    case httpwebhook:
      return { connectorId: httpConnectorId, operationId: isTrigger ? httpwebhooktrigger : httpwebhookaction };
    case liquid:
      switch (kind) {
        case 'jsontojson':
          return {
            connectorId: liquidConnectorId,
            operationId: 'liquidJsonToJson',
          };
        case 'jsontotext':
          return {
            connectorId: liquidConnectorId,
            operationId: 'liquidJsonToText',
          };
        case 'xmltojson':
          return {
            connectorId: liquidConnectorId,
            operationId: 'liquidXmlToJson',
          };
        case 'xmltotext':
          return {
            connectorId: liquidConnectorId,
            operationId: 'liquidXmlToText',
          };
        default:
          throw new UnsupportedException(`Unsupported operation kind ${kind}`);
      }
    case request:
      switch (kind) {
        case 'http':
          return {
            connectorId: 'connectionProviders/request',
            operationId: request,
          };
        default: {
          if (kind === undefined) {
            return {
              connectorId: 'connectionProviders/request',
              operationId: request,
            };
          }
          throw new UnsupportedException(`Unsupported operation kind ${kind} for request type`);
        }
      }
    case response:
      switch (kind) {
        case 'http':
          return {
            connectorId: 'connectionProviders/request',
            operationId: response,
          };
        default: {
          if (kind === undefined) {
            return {
              connectorId: 'connectionProviders/request',
              operationId: response,
            };
          }
          throw new UnsupportedException(`Unsupported operation kind ${kind} for response type`);
        }
      }
    case table:
      switch (definition.inputs?.format?.toLowerCase()) {
        case 'csv':
          return {
            connectorId: dataOperationConnectorId,
            operationId: csvtable,
          };

        case 'html':
          return {
            connectorId: dataOperationConnectorId,
            operationId: htmltable,
          };

        default:
          throw new UnsupportedException(`Unsupported table format ${definition.inputs?.format} for table type`);
      }

    case wait:
      return {
        connectorId: scheduleConnectorId,
        operationId: definition.inputs?.until ? delayuntil : delay,
      };

    case apimanagement:
      return {
        connectorId: apiManagementConnectorId,
        operationId: isTrigger ? apimanagementtrigger : apimanagement,
      };

    case appservice:
      return {
        connectorId: appServiceConnectorId,
        operationId: isTrigger ? appservicetrigger : appservice,
      };

    case xslt:
      switch (kind) {
        case datamapper:
          return {
            connectorId: dataMapperConnectorId,
            operationId: xslttransform,
          };
        default:
          throw new UnsupportedException(`Unsupported operation kind ${kind}`);
      }

    default:
      throw new UnsupportedException(`Unsupported built in operation type ${normalizedOperationType}`);
  }
}