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

package/chunk-YCTVEW2I.js

@@ -0,0 +1,546 @@
+import { getPathString } from './chunk-WNFRDIBW.js';
+
+// src/common/TypeParsing/TypeInfo.ts
+var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
+  TypeOperation2["CREATE"] = "CREATE";
+  TypeOperation2["READ"] = "READ";
+  TypeOperation2["UPDATE"] = "UPDATE";
+  TypeOperation2["DELETE"] = "DELETE";
+  return TypeOperation2;
+})(TypeOperation || {});
+
+// src/common/TypeParsing/Validation.ts
+var RelationshipValidationType = /* @__PURE__ */ ((RelationshipValidationType2) => {
+  RelationshipValidationType2["INCLUDE"] = "INCLUDE";
+  RelationshipValidationType2["EXCLUDE"] = "EXCLUDE";
+  RelationshipValidationType2["STRICT_EXCLUDE"] = "STRICT_EXCLUDE";
+  return RelationshipValidationType2;
+})(RelationshipValidationType || {});
+var INVALID_CUSTOM_TYPE = "INVALID_CUSTOM_TYPE";
+var PRIMITIVE_ERROR_MESSAGE_CONSTANTS = {
+  string: "NOT_A_STRING",
+  number: "NOT_A_NUMBER",
+  boolean: "NOT_A_BOOLEAN"
+};
+var DENIED_TYPE_OPERATIONS = {
+  CREATE: "DENIED_TYPE_OPERATION_CREATE",
+  READ: "DENIED_TYPE_OPERATION_READ",
+  UPDATE: "DENIED_TYPE_OPERATION_UPDATE",
+  DELETE: "DENIED_TYPE_OPERATION_DELETE"
+};
+var ERROR_MESSAGE_CONSTANTS = {
+  NONE: "NONE",
+  INVALID_CUSTOM_TYPE,
+  [PRIMITIVE_ERROR_MESSAGE_CONSTANTS.string]: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.string,
+  [PRIMITIVE_ERROR_MESSAGE_CONSTANTS.number]: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.number,
+  [PRIMITIVE_ERROR_MESSAGE_CONSTANTS.boolean]: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.boolean,
+  [DENIED_TYPE_OPERATIONS.CREATE]: DENIED_TYPE_OPERATIONS.CREATE,
+  [DENIED_TYPE_OPERATIONS.READ]: DENIED_TYPE_OPERATIONS.READ,
+  [DENIED_TYPE_OPERATIONS.UPDATE]: DENIED_TYPE_OPERATIONS.UPDATE,
+  [DENIED_TYPE_OPERATIONS.DELETE]: DENIED_TYPE_OPERATIONS.DELETE,
+  MISSING_FIELD_VALUE: "MISSING_FIELD_VALUE",
+  INVALID_OPTION: "INVALID_OPTION",
+  INVALID_FIELD: "INVALID_FIELD",
+  RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED: "RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED",
+  INVALID_TYPE: "INVALID_TYPE",
+  NO_UNION_TYPE_MATCHED: "NO_UNION_TYPE_MATCHED",
+  TYPE_DOES_NOT_EXIST: "TYPE_DOES_NOT_EXIST",
+  INVALID_PATTERN: "INVALID_PATTERN",
+  VALUE_DOES_NOT_MATCH_PATTERN: "VALUE_DOES_NOT_MATCH_PATTERN",
+  VALUE_BELOW_MINIMUM: "VALUE_BELOW_MINIMUM",
+  VALUE_ABOVE_MAXIMUM: "VALUE_ABOVE_MAXIMUM"
+};
+var TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS = {
+  string: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.string,
+  number: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.number,
+  boolean: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.boolean
+};
+var ARRAY_ITEM_ERROR_MAP_KEY = "__arrayItemErrors__";
+var getErrorDescriptor = (code = ERROR_MESSAGE_CONSTANTS.NONE, values) => ({
+  code,
+  values
+});
+var getNoErrorDescriptor = () => getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.NONE);
+var isArrayErrorDescriptorCollection = (value) => typeof value === "object" && value !== null && "itemErrorMap" in value;
+var getErrorDescriptors = (values = []) => values.filter(
+  (value) => !isArrayErrorDescriptorCollection(value)
+);
+var getArrayItemErrorMap = (values = []) => values.reduce((acc, value) => {
+  if (isArrayErrorDescriptorCollection(value)) {
+    for (const [indexKey, descriptors] of Object.entries(value.itemErrorMap)) {
+      const index = Number(indexKey);
+      if (!Number.isFinite(index)) {
+        continue;
+      }
+      acc[index] = [...acc[index] ?? [], ...descriptors];
+    }
+  }
+  return acc;
+}, {});
+var validateValueMatchesPattern = (typeName, value, pattern) => {
+  const results = {
+    typeName,
+    valid: true,
+    error: getNoErrorDescriptor(),
+    errorMap: {}
+  };
+  const valueSupplied = typeof value !== "undefined";
+  const patternSupplied = typeof pattern === "string" && pattern.trim() !== "";
+  if (valueSupplied && patternSupplied) {
+    try {
+      const regex = new RegExp(pattern);
+      const testResult = typeof value === "string" && regex.test(value);
+      if (!testResult) {
+        results.valid = false;
+        results.error = getErrorDescriptor(
+          ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN
+        );
+      }
+    } catch (e) {
+      results.valid = false;
+      results.error = getErrorDescriptor(
+        ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN
+      );
+    }
+  }
+  return results;
+};
+var getValidityValue = (existing, pending) => !existing ? false : pending;
+var TYPE_KEYWORD_VALIDATORS = {
+  string: (value) => typeof value === "string",
+  number: (value) => typeof value === "number",
+  boolean: (value) => typeof value === "boolean"
+};
+var hasValue = (value) => {
+  if (typeof value === "undefined" || value === null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  return true;
+};
+var validateKeywordType = (value, type) => {
+  const validator = TYPE_KEYWORD_VALIDATORS[type];
+  let valid = true;
+  if (validator) {
+    valid = validator(value);
+  }
+  return valid;
+};
+var validateCustomType = (value, customType, customValidators) => {
+  let valid = true;
+  if (customValidators && customType) {
+    const validator = customValidators[customType];
+    if (validator) {
+      try {
+        valid = validator(value);
+      } catch (e) {
+        valid = false;
+      }
+    }
+  }
+  return valid;
+};
+var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray = false, strict = false, customValidators, typeOperation, relationshipValidationType = "STRICT_EXCLUDE" /* STRICT_EXCLUDE */, itemIsPartial) => {
+  const {
+    type,
+    typeReference,
+    array,
+    optional,
+    possibleValues,
+    tags: {
+      customType,
+      validation: {
+        emptyArrayIsValid: emptyArrayIsValidOverride = void 0
+      } = {},
+      constraints: {
+        pattern = void 0,
+        min = void 0,
+        max = void 0
+      } = {}
+    } = {}
+  } = typeInfoField;
+  const results = {
+    typeName: typeReference ?? type,
+    valid: true,
+    error: getNoErrorDescriptor(),
+    errorMap: {}
+  };
+  const requiredValueAllowed = !typeReference || relationshipValidationType === "INCLUDE" /* INCLUDE */;
+  const valueIsUndefined = typeof value === "undefined";
+  const valueIsNull = value === null;
+  const canSkipValidation = itemIsPartial && (valueIsUndefined || valueIsNull) || optional && valueIsUndefined;
+  const emptyArrayIsValid = emptyArrayIsValidOverride ?? false;
+  if (canSkipValidation) {
+    results.valid = true;
+  } else if (requiredValueAllowed && !itemIsPartial && !optional && !hasValue(value)) {
+    results.valid = false;
+    results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.MISSING_FIELD_VALUE);
+  } else if (array && !ignoreArray && !Array.isArray(value)) {
+    results.valid = false;
+    results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_TYPE);
+  } else if (array && !ignoreArray && !optional && Array.isArray(value) && value.length === 0 && !emptyArrayIsValid) {
+    results.valid = false;
+    results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.MISSING_FIELD_VALUE);
+  } else if (array && !ignoreArray) {
+    const {
+      valid: validArray,
+      error: arrayError,
+      errorMap: arrayErrorMap
+    } = validateArrayOfTypeInfoFieldValues(
+      value,
+      typeInfoField,
+      typeInfoMap,
+      strict,
+      customValidators,
+      typeOperation,
+      relationshipValidationType,
+      itemIsPartial
+    );
+    results.valid = getValidityValue(results.valid, validArray);
+    results.error = arrayError;
+    results.errorMap = arrayErrorMap;
+  } else {
+    if (typeReference) {
+      if (relationshipValidationType === "INCLUDE" /* INCLUDE */) {
+        const {
+          valid: validTypeInfo,
+          error: typeInfoError,
+          errorMap: typeInfoErrorMap
+        } = validateTypeInfoValue(
+          value,
+          typeReference,
+          typeInfoMap,
+          strict,
+          customValidators,
+          typeOperation,
+          relationshipValidationType,
+          itemIsPartial
+        );
+        results.valid = getValidityValue(results.valid, validTypeInfo);
+        results.error = typeInfoError;
+        results.errorMap = typeInfoErrorMap;
+      } else if (relationshipValidationType === "STRICT_EXCLUDE" /* STRICT_EXCLUDE */) {
+        const valueSupplied = typeof value !== "undefined";
+        if (valueSupplied) {
+          results.valid = false;
+          results.error = getErrorDescriptor(
+            ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED
+          );
+        }
+      } else if (relationshipValidationType === "EXCLUDE" /* EXCLUDE */) {
+        results.valid = getValidityValue(results.valid, true);
+      }
+    } else if (possibleValues && !possibleValues.includes(value)) {
+      results.valid = false;
+      results.error = getErrorDescriptor(
+        ERROR_MESSAGE_CONSTANTS.INVALID_OPTION
+      );
+    } else {
+      const pendingValid = validateKeywordType(value, type);
+      const customValid = validateCustomType(
+        value,
+        customType,
+        customValidators
+      );
+      results.valid = getValidityValue(results.valid, pendingValid);
+      results.valid = getValidityValue(results.valid, customValid);
+      if (type === "string" && typeof pattern === "string") {
+        const { valid: patternValid, error: patternError } = validateValueMatchesPattern(typeReference ?? type, value, pattern);
+        results.valid = getValidityValue(results.valid, patternValid);
+        results.error = patternError;
+      }
+      if (type === "number" && typeof value === "number") {
+        if (typeof min === "number" && value < min) {
+          results.valid = false;
+          results.error = getErrorDescriptor(
+            ERROR_MESSAGE_CONSTANTS.VALUE_BELOW_MINIMUM,
+            [`${min}`]
+          );
+        } else if (typeof max === "number" && value > max) {
+          results.valid = false;
+          results.error = getErrorDescriptor(
+            ERROR_MESSAGE_CONSTANTS.VALUE_ABOVE_MAXIMUM,
+            [`${max}`]
+          );
+        }
+      }
+      if (!customValid) {
+        results.error = getErrorDescriptor(
+          ERROR_MESSAGE_CONSTANTS.INVALID_CUSTOM_TYPE
+        );
+      } else if (!results.valid) {
+        results.error = results.error.code !== ERROR_MESSAGE_CONSTANTS.NONE ? results.error : getErrorDescriptor(
+          TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS[type]
+        );
+      }
+    }
+  }
+  return results;
+};
+var validateArrayOfTypeInfoFieldValues = (values = [], typeInfoField, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
+  const { type, typeReference } = typeInfoField;
+  const results = {
+    typeName: typeReference ?? type,
+    valid: true,
+    error: getNoErrorDescriptor(),
+    errorMap: {}
+  };
+  const itemErrorMap = {};
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    const {
+      valid: indexValid,
+      error: indexError = getNoErrorDescriptor(),
+      errorMap: indexErrorMap
+    } = validateTypeInfoFieldValue(
+      v,
+      typeInfoField,
+      typeInfoMap,
+      true,
+      strict,
+      customValidators,
+      typeOperation,
+      relationshipValidationType,
+      itemIsPartial
+    );
+    results.valid = getValidityValue(results.valid, indexValid);
+    const indexErrors = [
+      ...indexError.code !== ERROR_MESSAGE_CONSTANTS.NONE ? [indexError] : [],
+      ...getErrorDescriptors(indexErrorMap[ARRAY_ITEM_ERROR_MAP_KEY] ?? []),
+      ...Object.entries(indexErrorMap).filter(([key]) => key !== ARRAY_ITEM_ERROR_MAP_KEY).flatMap(([, entries]) => getErrorDescriptors(entries)).filter((descriptor) => descriptor.code !== ERROR_MESSAGE_CONSTANTS.NONE)
+    ];
+    if (indexErrors.length) {
+      itemErrorMap[i] = indexErrors;
+      if (results.error.code === ERROR_MESSAGE_CONSTANTS.NONE) {
+        results.error = indexErrors[0];
+      }
+    }
+    for (const [er, entries] of Object.entries(indexErrorMap)) {
+      if (er === ARRAY_ITEM_ERROR_MAP_KEY) {
+        continue;
+      }
+      results.errorMap[getPathString([i, er])] = entries;
+    }
+  }
+  results.errorMap[ARRAY_ITEM_ERROR_MAP_KEY] = [{ itemErrorMap }];
+  return results;
+};
+var validateTypeInfoFieldOperationAllowed = (fieldName, fieldOperation, typeInfoField) => {
+  const results = {
+    typeName: null,
+    valid: true,
+    error: getNoErrorDescriptor(),
+    errorMap: {}
+  };
+  if (fieldOperation && typeInfoField) {
+    const {
+      type,
+      typeReference,
+      tags = {}
+    } = typeInfoField || {};
+    const { deniedOperations: { [fieldOperation]: denied = false } = {} } = tags;
+    results.typeName = typeReference ?? type;
+    results.valid = !denied;
+    if (!results.valid) {
+      results.error = getErrorDescriptor(
+        DENIED_TYPE_OPERATIONS[fieldOperation]
+      );
+      results.errorMap[fieldName] = [results.error];
+    }
+  }
+  return results;
+};
+var validateTypeOperationAllowed = (typeName, valueFields, typeOperation, typeInfo) => {
+  const results = {
+    typeName,
+    valid: true,
+    error: getNoErrorDescriptor(),
+    errorMap: {}
+  };
+  const { fields = {}, tags = {} } = typeInfo;
+  const { deniedOperations: { [typeOperation]: denied = false } = {} } = tags;
+  if (denied) {
+    results.valid = false;
+    results.error = getErrorDescriptor(DENIED_TYPE_OPERATIONS[typeOperation]);
+  } else {
+    for (const vF of valueFields) {
+      const vFieldInfo = fields[vF];
+      const { valid: vFValid, error: vFError } = validateTypeInfoFieldOperationAllowed(vF, typeOperation, vFieldInfo);
+      results.valid = getValidityValue(results.valid, vFValid);
+      if (!vFValid) {
+        results.errorMap[vF] = [vFError];
+      }
+    }
+  }
+  return results;
+};
+var TYPE_INFO_DATA_ITEM_TYPE_NAME = "__TYPE_INFO_DATA_ITEM__";
+var validateTypeInfoDataItem = (value = {}, typeInfo, customValidatorMap = {}, options) => {
+  const {
+    typeName = TYPE_INFO_DATA_ITEM_TYPE_NAME,
+    typeInfoMap = {},
+    strict = true,
+    customTypeValidators,
+    typeOperation = "CREATE" /* CREATE */,
+    relationshipValidationType = "STRICT_EXCLUDE" /* STRICT_EXCLUDE */,
+    itemIsPartial = typeOperation === "UPDATE" /* UPDATE */,
+    validateHidden = false,
+    validateReadonly = false
+  } = options ?? {};
+  const sourceFields = typeInfo.fields ?? {};
+  const normalizedFields = {};
+  for (const [fieldName, field] of Object.entries(sourceFields)) {
+    const validationTags = field.tags?.validation ?? {};
+    const shouldValidateHidden = validationTags.validateHidden ?? validateHidden;
+    const shouldValidateReadonly = validationTags.validateReadonly ?? validateReadonly;
+    const shouldSkipRequiredChecks = field.tags?.hidden && !shouldValidateHidden || field.readonly && !shouldValidateReadonly;
+    normalizedFields[fieldName] = shouldSkipRequiredChecks ? {
+      ...field,
+      optional: true
+    } : field;
+  }
+  const normalizedTypeInfo = {
+    ...typeInfo,
+    fields: normalizedFields
+  };
+  const results = validateTypeInfoValue(
+    value ?? {},
+    typeName,
+    { ...typeInfoMap, [typeName]: normalizedTypeInfo },
+    strict,
+    customTypeValidators,
+    typeOperation,
+    relationshipValidationType,
+    itemIsPartial
+  );
+  for (const [fieldName, validator] of Object.entries(customValidatorMap)) {
+    const field = normalizedFields[fieldName];
+    if (!field) {
+      continue;
+    }
+    let error = getNoErrorDescriptor();
+    try {
+      error = validator(value[fieldName], field);
+    } catch (e) {
+      error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_CUSTOM_TYPE);
+    }
+    if (error.code !== ERROR_MESSAGE_CONSTANTS.NONE) {
+      results.valid = false;
+      results.errorMap[fieldName] = [
+        ...results.errorMap[fieldName] ?? [],
+        error
+      ];
+      if (results.error.code === ERROR_MESSAGE_CONSTANTS.NONE) {
+        results.error = error;
+      }
+    }
+  }
+  return results;
+};
+var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
+  const typeInfo = typeInfoMap[typeInfoFullName];
+  const results = {
+    typeName: typeInfoFullName,
+    valid: !!typeInfo,
+    error: !!typeInfo ? getNoErrorDescriptor() : getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST),
+    errorMap: {}
+  };
+  if (typeInfo) {
+    const { primaryField, fields, unionFieldSets } = typeInfo;
+    if (typeOperation) {
+      const valueFields = typeof value === "object" ? Object.keys(value ?? {}) : [];
+      const {
+        valid: operationValid,
+        error: operationError,
+        errorMap: operationErrorMap
+      } = validateTypeOperationAllowed(
+        typeInfoFullName,
+        valueFields,
+        typeOperation,
+        typeInfo
+      );
+      results.valid = getValidityValue(results.valid, operationValid);
+      results.error = operationError;
+      for (const oE in operationErrorMap) {
+        const existingError = results.errorMap[oE] ?? [];
+        results.errorMap[oE] = existingError ? [...existingError, ...operationErrorMap[oE]] : operationErrorMap[oE];
+      }
+      if (!operationValid && operationError.code !== ERROR_MESSAGE_CONSTANTS.NONE) {
+        results.error = operationError;
+      }
+    }
+    if (unionFieldSets) {
+      const valueFields = Object.keys(value || {});
+      let valid = false;
+      for (const uFS of unionFieldSets) {
+        valid = valueFields.every((vF) => uFS.includes(vF));
+        if (valid) {
+          break;
+        }
+      }
+      if (!valid) {
+        results.valid = false;
+        results.error = getErrorDescriptor(
+          ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED
+        );
+      }
+    } else if (strict) {
+      const knownFields = Object.keys(fields || {});
+      const valueFields = Object.keys(value || {});
+      for (const vF of valueFields) {
+        if (!knownFields.includes(vF)) {
+          results.valid = false;
+          results.errorMap[vF] = [
+            getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_FIELD)
+          ];
+        }
+      }
+    }
+    if (fields) {
+      for (const key in fields) {
+        if (typeOperation !== "CREATE" /* CREATE */ || typeof primaryField !== "string" || key !== primaryField) {
+          const typeInfoField = fields[key];
+          const fieldValue = value[key];
+          const {
+            valid: fieldValid,
+            error: fieldError,
+            errorMap: fieldErrorMap
+          } = validateTypeInfoFieldValue(
+            fieldValue,
+            typeInfoField,
+            typeInfoMap,
+            false,
+            strict,
+            customValidators,
+            typeOperation,
+            relationshipValidationType,
+            itemIsPartial
+          );
+          results.valid = getValidityValue(results.valid, fieldValid);
+          const fieldEntries = [fieldError];
+          const arrayItemErrorMap = getArrayItemErrorMap(
+            fieldErrorMap[ARRAY_ITEM_ERROR_MAP_KEY]
+          );
+          if (Object.keys(arrayItemErrorMap).length) {
+            fieldEntries.push({ itemErrorMap: arrayItemErrorMap });
+          }
+          results.errorMap[key] = fieldEntries;
+          for (const [fE, entries] of Object.entries(fieldErrorMap)) {
+            if (fE === ARRAY_ITEM_ERROR_MAP_KEY) {
+              continue;
+            }
+            results.errorMap[getPathString([key, fE])] = entries;
+          }
+        }
+      }
+    }
+    if (!results.valid && results.error.code === ERROR_MESSAGE_CONSTANTS.NONE) {
+      results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_TYPE);
+    }
+  }
+  return results;
+};
+
+export { DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, INVALID_CUSTOM_TYPE, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS, TYPE_KEYWORD_VALIDATORS, TypeOperation, getArrayItemErrorMap, getErrorDescriptor, getErrorDescriptors, getNoErrorDescriptor, getValidityValue, hasValue, isArrayErrorDescriptorCollection, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoDataItem, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern };

package/common/CommandLine/collectRequiredEnvironmentVariables.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Collect required environment variables or throw with a missing-name error.
+ *
+ * @typeParam VarName - Allowed environment variable names.
+ * @param varNames - List of required environment variable names.
+ * @returns Map of environment variable names to values.
+ * @throws Error when a required variable is missing or empty.
+ */
+export declare const collectRequiredEnvironmentVariables: <VarName extends string>(varNames: VarName[]) => Record<VarName, string>;

package/common/CommandLine/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ *
+ * Command-line utilities.
+ */
+export * from "./collectRequiredEnvironmentVariables";

package/common/HelperTypes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Expand inferred types for clearer IntelliSense/display.
+ *
+ * @typeParam T - Type to expand.
+ */
+export type ExpandComplexType<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export declare const HelperTypes: {};

package/common/IdGeneration/getSimpleId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get a simple id, unique to the current run session.
+ *
+ * Includes a counter and timestamp so it stays unique within the same process.
+ *
+ * @returns A process-unique string id.
+ */
+export declare const getSimpleId: () => string;

package/common/IdGeneration/index.d.ts

@@ -0,0 +1 @@
+export * from "./getSimpleId";

package/common/ItemRelationshipInfoTypes.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Relationship info types used by ORM and relationship utilities.
+ */
+import type { ExpandComplexType } from "./HelperTypes";
+/**
+ * The keys for item relationship info.
+ * */
+export declare enum ItemRelationshipInfoKeys {
+    /**
+     * Relationship origin type name.
+     * */
+    fromTypeName = "fromTypeName",
+    /**
+     * Relationship origin field name.
+     * */
+    fromTypeFieldName = "fromTypeFieldName",
+    /**
+     * Relationship origin primary field value.
+     * */
+    fromTypePrimaryFieldValue = "fromTypePrimaryFieldValue",
+    /**
+     * Relationship destination primary field value.
+     * */
+    toTypePrimaryFieldValue = "toTypePrimaryFieldValue"
+}
+/**
+ * The identifying keys for item relationship info.
+ * */
+export declare enum ItemRelationshipInfoIdentifyingKeys {
+    /**
+     * Identifier value for a relationship item.
+     * */
+    id = "id"
+}
+/**
+ * The basis for an `ItemRelationshipInfo` without an assigned identifier.
+ * */
+export type BaseItemRelationshipInfo = Record<ItemRelationshipInfoKeys, string>;
+/**
+ * An item containing the information about a relationship between two items.
+ * */
+export type ItemRelationshipInfo = BaseItemRelationshipInfo & Record<ItemRelationshipInfoIdentifyingKeys, string>;
+/**
+ * The origination portion of an `ItemRelationshipInfo`.
+ * */
+export type ItemRelationshipOriginInfo = Record<ItemRelationshipInfoKeys.fromTypeName | ItemRelationshipInfoKeys.fromTypeFieldName, string>;
+/**
+ * The origination portion of an `ItemRelationshipInfo` for a specific item and field relationship.
+ * */
+export type ItemRelationshipOriginItemInfo = ExpandComplexType<ItemRelationshipOriginInfo & Record<ItemRelationshipInfoKeys.fromTypePrimaryFieldValue, string>>;
+/**
+ * The destination portion of an `ItemRelationshipInfo` for a specific, related item.
+ * */
+export type ItemRelationshipDestinationItemInfo = Record<ItemRelationshipInfoKeys.toTypePrimaryFieldValue, string>;
+/**
+ * The originating item info portion of an `ItemRelationshipInfo`.
+ *
+ * Used for relationship originating from a specific item, regardless of field relationship.
+ * */
+export type ItemRelationshipOriginatingItemInfo = Record<ItemRelationshipInfoKeys.fromTypeName | ItemRelationshipInfoKeys.fromTypePrimaryFieldValue, string>;
+/**
+ * One of the various types describing an item relationship.
+ * */
+export type ItemRelationshipInfoType = BaseItemRelationshipInfo | ItemRelationshipInfo | ItemRelationshipOriginInfo | ItemRelationshipOriginItemInfo;

package/common/ItemRelationships/ItemRelationshipValidation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Validation helpers for relationship items.
+ */
+import type { TypeInfoValidationResults } from "../TypeParsing/Validation";
+import { ItemRelationshipInfoKeys, ItemRelationshipInfoType } from "../ItemRelationshipInfoTypes";
+/**
+ * Error codes for relationship validation.
+ * */
+export declare const TYPE_INFO_ORM_RELATIONSHIP_ERRORS: {
+    INVALID_RELATIONSHIP_ITEM: string;
+    INVALID_RELATIONSHIP_ITEM_FIELD: string;
+    MISSING_RELATIONSHIP_ITEM_FIELD: string;
+};
+/**
+ * Validates a relationship item.
+ *
+ * @param relationshipItem - Relationship item to validate.
+ * @param omitFields - Relationship keys to ignore during validation.
+ * @returns Validation results with errors and errorMap when invalid.
+ * */
+export declare const validateRelationshipItem: (relationshipItem: ItemRelationshipInfoType, omitFields: ItemRelationshipInfoKeys[]) => TypeInfoValidationResults;

package/common/ItemRelationships/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ItemRelationshipValidation";
+export * from "../TypeParsing/Validation";

package/common/Logging/Utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Logging tags used by {@link logFunctionCall}.
+ */
+export declare enum LOGGING_MESSAGES {
+    LOGGING_FUNCTION_CALL = "LOGGING_FUNCTION_CALL",
+    INPUT = "INPUT",
+    OUTPUT = "OUTPUT",
+    ERROR = "ERROR"
+}
+export declare const logFunctionCall: (label: string, args: any[], functionRef: (...args: any[]) => Promise<any> | any, enabled: boolean) => Promise<any>;

package/common/Logging/index.d.ts

@@ -0,0 +1 @@
+export * from "./Utils";