@resistdesign/voltra 3.0.0-alpha.4 → 3.0.0-alpha.40

package/chunk-7AMEFPPP.js

@@ -0,0 +1,78 @@
+// src/common/SearchTypes.ts
+var LogicalOperators = /* @__PURE__ */ ((LogicalOperators2) => {
+  LogicalOperators2["AND"] = "AND";
+  LogicalOperators2["OR"] = "OR";
+  return LogicalOperators2;
+})(LogicalOperators || {});
+var ComparisonOperators = /* @__PURE__ */ ((ComparisonOperators2) => {
+  ComparisonOperators2["EQUALS"] = "EQUALS";
+  ComparisonOperators2["NOT_EQUALS"] = "NOT_EQUALS";
+  ComparisonOperators2["GREATER_THAN"] = "GREATER_THAN";
+  ComparisonOperators2["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+  ComparisonOperators2["LESS_THAN"] = "LESS_THAN";
+  ComparisonOperators2["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+  ComparisonOperators2["IN"] = "IN";
+  ComparisonOperators2["NOT_IN"] = "NOT_IN";
+  ComparisonOperators2["LIKE"] = "LIKE";
+  ComparisonOperators2["NOT_LIKE"] = "NOT_LIKE";
+  ComparisonOperators2["EXISTS"] = "EXISTS";
+  ComparisonOperators2["NOT_EXISTS"] = "NOT_EXISTS";
+  ComparisonOperators2["IS_NOT_EMPTY"] = "IS_NOT_EMPTY";
+  ComparisonOperators2["IS_EMPTY"] = "IS_EMPTY";
+  ComparisonOperators2["BETWEEN"] = "BETWEEN";
+  ComparisonOperators2["NOT_BETWEEN"] = "NOT_BETWEEN";
+  ComparisonOperators2["CONTAINS"] = "CONTAINS";
+  ComparisonOperators2["NOT_CONTAINS"] = "NOT_CONTAINS";
+  ComparisonOperators2["STARTS_WITH"] = "STARTS_WITH";
+  ComparisonOperators2["ENDS_WITH"] = "ENDS_WITH";
+  ComparisonOperators2["DOES_NOT_START_WITH"] = "DOES_NOT_START_WITH";
+  ComparisonOperators2["DOES_NOT_END_WITH"] = "DOES_NOT_END_WITH";
+  return ComparisonOperators2;
+})(ComparisonOperators || {});
+
+// src/common/TypeInfoORM/Types.ts
+var ITEM_RELATIONSHIP_DAC_RESOURCE_NAME = "TYPE_INFO_ORM_ITEM_RELATIONSHIP";
+var RelationshipOperation = /* @__PURE__ */ ((RelationshipOperation2) => {
+  RelationshipOperation2["GET"] = "GET";
+  RelationshipOperation2["SET"] = "SET";
+  RelationshipOperation2["UNSET"] = "UNSET";
+  return RelationshipOperation2;
+})(RelationshipOperation || {});
+var OperationGroup = /* @__PURE__ */ ((OperationGroup2) => {
+  OperationGroup2["ALL_OPERATIONS"] = "ALL_OPERATIONS";
+  OperationGroup2["ALL_ITEM_OPERATIONS"] = "ALL_ITEM_OPERATIONS";
+  OperationGroup2["ALL_RELATIONSHIP_OPERATIONS"] = "ALL_RELATIONSHIP_OPERATIONS";
+  return OperationGroup2;
+})(OperationGroup || {});
+var TypeInfoORMServiceError = /* @__PURE__ */ ((TypeInfoORMServiceError2) => {
+  TypeInfoORMServiceError2["NO_DRIVERS_SUPPLIED"] = "NO_DRIVERS_SUPPLIED";
+  TypeInfoORMServiceError2["NO_RELATIONSHIP_DRIVERS_SUPPLIED"] = "NO_RELATIONSHIP_DRIVERS_SUPPLIED";
+  TypeInfoORMServiceError2["NO_PRIMARY_FIELD_VALUE_SUPPLIED"] = "NO_PRIMARY_FIELD_VALUE_SUPPLIED";
+  TypeInfoORMServiceError2["INVALID_DRIVER"] = "INVALID_DRIVER";
+  TypeInfoORMServiceError2["INVALID_RELATIONSHIP_DRIVER"] = "INVALID_RELATIONSHIP_DRIVER";
+  TypeInfoORMServiceError2["INVALID_TYPE_INFO"] = "INVALID_TYPE_INFO";
+  TypeInfoORMServiceError2["TYPE_INFO_MISSING_PRIMARY_FIELD"] = "TYPE_INFO_MISSING_PRIMARY_FIELD";
+  TypeInfoORMServiceError2["INVALID_RELATIONSHIP"] = "INVALID_RELATIONSHIP";
+  TypeInfoORMServiceError2["INVALID_OPERATION"] = "INVALID_OPERATION";
+  TypeInfoORMServiceError2["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
+  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_CRITERIA"] = "INDEXING_UNSUPPORTED_CRITERIA";
+  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_COMBINATION"] = "INDEXING_UNSUPPORTED_COMBINATION";
+  TypeInfoORMServiceError2["INDEXING_MISSING_INDEX_FIELD"] = "INDEXING_MISSING_INDEX_FIELD";
+  TypeInfoORMServiceError2["INDEXING_MISSING_BACKEND"] = "INDEXING_MISSING_BACKEND";
+  TypeInfoORMServiceError2["INDEXING_REQUIRES_CRITERIA"] = "INDEXING_REQUIRES_CRITERIA";
+  return TypeInfoORMServiceError2;
+})(TypeInfoORMServiceError || {});
+var TypeInfoORMAPIRoutePaths = /* @__PURE__ */ ((TypeInfoORMAPIRoutePaths2) => {
+  TypeInfoORMAPIRoutePaths2["CREATE"] = "create";
+  TypeInfoORMAPIRoutePaths2["READ"] = "read";
+  TypeInfoORMAPIRoutePaths2["UPDATE"] = "update";
+  TypeInfoORMAPIRoutePaths2["DELETE"] = "delete";
+  TypeInfoORMAPIRoutePaths2["LIST"] = "list";
+  TypeInfoORMAPIRoutePaths2["CREATE_RELATIONSHIP"] = "create-relationship";
+  TypeInfoORMAPIRoutePaths2["DELETE_RELATIONSHIP"] = "delete-relationship";
+  TypeInfoORMAPIRoutePaths2["LIST_RELATIONSHIPS"] = "list-relationships";
+  TypeInfoORMAPIRoutePaths2["LIST_RELATED_ITEMS"] = "list-related-items";
+  return TypeInfoORMAPIRoutePaths2;
+})(TypeInfoORMAPIRoutePaths || {});
+
+export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError };

package/chunk-ATO2455Q.js

@@ -0,0 +1,258 @@
+import YAML from 'yaml';
+
+// src/iac/utils/patch-utils.ts
+var DEFAULT_MERGE_STRATEGY = "transpose";
+var getValuePathString = (valuePathArray = []) => valuePathArray.map((p) => encodeURIComponent(p)).join("/");
+var getValuePathArray = (valuePathString = "") => valuePathString.split("/").map((p) => decodeURIComponent(p));
+var isConstructedFrom = (value, constructorReference) => value !== null && typeof value === "object" && "constructor" in value && value.constructor === constructorReference;
+var mergeValues = (valuePathArray = [], existingValue, newValue, mergeStrategyMap = {}) => {
+  const valuePathString = getValuePathString(valuePathArray);
+  const arrayIndexWildcardValuePathString = getValuePathString(
+    valuePathArray.map((p) => typeof p === "number" ? "#" : p)
+  );
+  const {
+    [valuePathString]: {
+      strategy: specificKeyMergeStrategy = DEFAULT_MERGE_STRATEGY,
+      data: specificKeyMergeStrategyData = void 0
+    } = {},
+    [arrayIndexWildcardValuePathString]: {
+      strategy: arrayIndexWildcardMergeStrategy = DEFAULT_MERGE_STRATEGY,
+      data: arrayIndexWildcardMergeStrategyData = void 0
+    } = {}
+  } = mergeStrategyMap;
+  const mergeStrategy = valuePathString in mergeStrategyMap ? specificKeyMergeStrategy : arrayIndexWildcardMergeStrategy;
+  const mergeStrategyData = valuePathString in mergeStrategyMap ? specificKeyMergeStrategyData : arrayIndexWildcardMergeStrategyData;
+  let mergedValue = typeof newValue !== "undefined" ? newValue : existingValue;
+  if (mergeStrategy !== "replace") {
+    if (isConstructedFrom(existingValue, Array) && isConstructedFrom(newValue, Array)) {
+      if (mergeStrategy === "accumulate") {
+        mergedValue = [...existingValue, ...newValue];
+      } else if (mergeStrategy === "accumulate-unique") {
+        mergedValue = [
+          ...existingValue,
+          ...newValue.filter((item) => existingValue.indexOf(item) === -1)
+        ];
+      } else if (mergeStrategy === "accumulate-unique-by") {
+        const existingItemMap = {};
+        const newItemMap = {};
+        for (let i = 0; i < existingValue.length; i++) {
+          const existingItem = existingValue[i];
+          if (existingItem && typeof existingItem === "object") {
+            const identifier = mergeStrategyData instanceof Function ? mergeStrategyData(existingItem) : existingItem[mergeStrategyData];
+            existingItemMap[identifier] = existingItem;
+          }
+        }
+        for (let j = 0; j < newValue.length; j++) {
+          const newItem = newValue[j];
+          if (newItem && typeof newItem === "object") {
+            const identifier = mergeStrategyData instanceof Function ? mergeStrategyData(newItem) : newItem[mergeStrategyData];
+            newItemMap[identifier] = newItem;
+          }
+        }
+        mergedValue = Object.keys({
+          ...existingItemMap,
+          ...newItemMap
+        }).map(
+          (id, index) => mergeValues(
+            [...valuePathArray, index],
+            existingItemMap[id],
+            newItemMap[id],
+            mergeStrategyMap
+          )
+        );
+      } else if (mergeStrategy === "transpose") {
+        const fullLength = Math.max(existingValue.length, newValue.length);
+        mergedValue = [...new Array(fullLength)].map(
+          (_empty, index) => mergeValues(
+            [...valuePathArray, index],
+            existingValue[index],
+            newValue[index],
+            mergeStrategyMap
+          )
+        );
+      }
+    } else if (isConstructedFrom(existingValue, Object) && isConstructedFrom(newValue, Object)) {
+      mergedValue = Object.keys({ ...existingValue, ...newValue }).reduce(
+        (acc, k) => ({
+          ...acc,
+          [k]: mergeValues(
+            [...valuePathArray, k],
+            existingValue[k],
+            newValue[k],
+            mergeStrategyMap
+          )
+        }),
+        {}
+      );
+    }
+  }
+  return mergedValue;
+};
+
+// src/iac/utils/index.ts
+var addParameter = (parameterInfo, template) => {
+  const { ParameterId, Parameter, Label, Group } = parameterInfo;
+  const {
+    Parameters,
+    Metadata: {
+      "AWS::CloudFormation::Interface": {
+        ParameterGroups = [],
+        ParameterLabels = {}
+      } = {}
+    } = {}
+  } = template;
+  let NewParameterGroups = ParameterGroups;
+  if (Group) {
+    const GroupObject = ParameterGroups.filter(
+      (g) => g.Label?.default === Group
+    )[0];
+    NewParameterGroups = GroupObject ? ParameterGroups.map(
+      (g) => g.Label?.default === Group ? {
+        ...g,
+        Parameters: [...g.Parameters || [], ParameterId]
+      } : g
+    ) : [
+      ...ParameterGroups,
+      {
+        Label: {
+          default: Group
+        },
+        Parameters: [ParameterId]
+      }
+    ];
+  }
+  return {
+    ...template,
+    Parameters: {
+      ...Parameters,
+      [ParameterId]: Parameter
+    },
+    Metadata: {
+      ...template.Metadata,
+      "AWS::CloudFormation::Interface": {
+        ...template?.Metadata?.["AWS::CloudFormation::Interface"],
+        ParameterGroups: NewParameterGroups,
+        ParameterLabels: {
+          ...ParameterLabels,
+          [ParameterId]: {
+            default: Label
+          }
+        }
+      }
+    }
+  };
+};
+var addParameters = (parameters, template) => parameters.reduce((acc, p) => addParameter(p, acc), template);
+var patchTemplate = (patch, template) => mergeValues([], template, patch, {
+  [getValuePathString([
+    // Parameter Groups
+    "Metadata",
+    "AWS::CloudFormation::Interface",
+    "ParameterGroups"
+  ])]: {
+    strategy: "accumulate-unique-by",
+    data: (pG) => pG?.Label?.default
+  },
+  [getValuePathString([
+    // Parameter Group Parameter Ids
+    "Metadata",
+    "AWS::CloudFormation::Interface",
+    "ParameterGroups",
+    "#",
+    "Parameters"
+  ])]: {
+    strategy: "accumulate-unique"
+  }
+});
+var createResourcePack = (creator) => (params, template) => {
+  const patch = creator(params);
+  return patchTemplate(patch, template);
+};
+var SimpleCFT = class {
+  /**
+   * Create a SimpleCFT template wrapper.
+   *
+   * @param template - Initial CloudFormation template.
+   */
+  constructor(template = {
+    AWSTemplateFormatVersion: "2010-09-09"
+  }) {
+    this.template = template;
+  }
+  /**
+   * Apply a pack with configuration to the stack template.
+   * @see `@resistdesign/voltra/iac` and `@resistdesign/voltra/iac/packs` for examples.
+   * */
+  applyPack = (pack, params) => {
+    this.template = pack(params, this.template);
+    return this;
+  };
+  /**
+   * Apply a patch to the stack template.
+   *
+   * @param patch - Template patch to merge.
+   * */
+  patch = (patch) => {
+    this.template = patchTemplate(patch, this.template);
+    return this;
+  };
+  /**
+   * Add a stack parameter including its descriptive info and an optional parameter group.
+   *
+   * @param parameter - Parameter definition and metadata.
+   * */
+  addParameter = (parameter) => {
+    this.template = addParameter(parameter, this.template);
+    return this;
+  };
+  /**
+   * Add a group of stack parameters including their descriptive info and an optional parameter group.
+   *
+   * @param group - Parameter group definition.
+   * */
+  addParameterGroup = ({ Label: Group, Parameters }) => {
+    const parameterIds = Object.keys(Parameters);
+    const parameterList = parameterIds.map((ParameterId) => {
+      const { Label, ...Parameter } = Parameters[ParameterId];
+      return {
+        Group,
+        ParameterId,
+        Label,
+        Parameter
+      };
+    });
+    this.template = addParameters(parameterList, this.template);
+    return this;
+  };
+  /**
+   * Use a modification to dynamically apply various changes at once.
+   *
+   * @param modification - Modification callback to apply.
+   * */
+  modify = (modification) => {
+    modification(this);
+    return this;
+  };
+  /**
+   * Convert the stack template to a string.
+   *
+   * @returns JSON string representation of the template.
+   * */
+  toString = () => JSON.stringify(this.template, null, 2);
+  /**
+   * Convert the stack template to a JSON object.
+   *
+   * @returns Template JSON object.
+   * */
+  toJSON = () => this.template;
+  /**
+   * Convert the stack template to a YAML string.
+   *
+   * @returns YAML string representation of the template.
+   * */
+  toYAML = () => YAML.stringify(this.template, {
+    aliasDuplicateObjects: false
+  });
+};
+
+export { DEFAULT_MERGE_STRATEGY, SimpleCFT, addParameter, addParameters, createResourcePack, getValuePathArray, getValuePathString, isConstructedFrom, mergeValues, patchTemplate };