@microsoft/terraform-cdk-constructs 1.0.0 → 1.2.0

package/lib/testing/lib/naming.js

@@ -0,0 +1,336 @@
+"use strict";
+/**
+ * Resource naming utilities for integration tests
+ *
+ * Provides functions for generating unique, Azure-compliant
+ * resource names with proper length constraints and character restrictions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateResourceName = generateResourceName;
+exports.getResourcePrefix = getResourcePrefix;
+exports.sanitizeIdentifier = sanitizeIdentifier;
+exports.generateShortId = generateShortId;
+exports.getResourceConstraints = getResourceConstraints;
+/**
+ * Resource type prefix mapping for Azure resources
+ */
+const RESOURCE_PREFIXES = {
+    "Microsoft.Resources/resourceGroups": "rg",
+    "Microsoft.Storage/storageAccounts": "st",
+    "Microsoft.Compute/virtualMachines": "vm",
+    "Microsoft.Compute/virtualMachineScaleSets": "vmss",
+    "Microsoft.ContainerService/managedClusters": "aks",
+    "Microsoft.Network/virtualNetworks": "vnet",
+    "Microsoft.Network/subnets": "snet",
+    "Microsoft.Network/networkInterfaces": "nic",
+    "Microsoft.Network/publicIPAddresses": "pip",
+    "Microsoft.Network/networkSecurityGroups": "nsg",
+    "Microsoft.Insights/actionGroups": "ag",
+    "Microsoft.Insights/metricAlerts": "ma",
+    "Microsoft.Insights/activityLogAlerts": "ala",
+};
+/**
+ * Resource naming constraints by type
+ */
+const RESOURCE_CONSTRAINTS = {
+    "Microsoft.Resources/resourceGroups": {
+        maxLength: 90,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Storage/storageAccounts": {
+        maxLength: 24,
+        allowHyphens: false,
+        allowUnderscores: false,
+        allowPeriods: false,
+        casePolicy: "lower",
+    },
+    "Microsoft.Compute/virtualMachines": {
+        maxLength: 64, // Windows: 15, Linux: 64
+        allowHyphens: true,
+        allowUnderscores: false,
+        allowPeriods: false,
+        casePolicy: "any",
+    },
+    "Microsoft.Compute/virtualMachineScaleSets": {
+        maxLength: 64,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: false,
+        casePolicy: "any",
+    },
+    "Microsoft.ContainerService/managedClusters": {
+        maxLength: 63,
+        allowHyphens: true,
+        allowUnderscores: false,
+        allowPeriods: false,
+        casePolicy: "any",
+    },
+    "Microsoft.Network/virtualNetworks": {
+        maxLength: 64,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Network/subnets": {
+        maxLength: 80,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Network/networkInterfaces": {
+        maxLength: 80,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Network/publicIPAddresses": {
+        maxLength: 80,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Network/networkSecurityGroups": {
+        maxLength: 80,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Insights/actionGroups": {
+        maxLength: 260,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Insights/metricAlerts": {
+        maxLength: 260,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+    "Microsoft.Insights/activityLogAlerts": {
+        maxLength: 260,
+        allowHyphens: true,
+        allowUnderscores: true,
+        allowPeriods: true,
+        casePolicy: "any",
+    },
+};
+/**
+ * Default constraints for unknown resource types
+ */
+const DEFAULT_CONSTRAINTS = {
+    maxLength: 64,
+    allowHyphens: true,
+    allowUnderscores: false,
+    allowPeriods: false,
+    casePolicy: "any",
+};
+/**
+ * Generates a unique, Azure-compliant resource name
+ *
+ * Creates names in format: {prefix}-{identifier}-{suffix} or
+ * {prefix}{identifier}{suffix} depending on resource constraints.
+ *
+ * @param options - Name generation options
+ * @returns Azure-compliant resource name
+ *
+ * @example
+ * generateResourceName({
+ *   resourceType: 'Microsoft.Resources/resourceGroups',
+ *   testName: 'storage-test',
+ *   runId: 'a1b2c3d4-e5f6-4789-b012-3456789abcde'
+ * });
+ * // Returns: 'rg-storage-test-a1b2c3'
+ *
+ * generateResourceName({
+ *   resourceType: 'Microsoft.Storage/storageAccounts',
+ *   testName: 'basic-test',
+ *   runId: 'a1b2c3d4-e5f6-4789-b012-3456789abcde'
+ * });
+ * // Returns: 'stbasictesta1b2c3'
+ */
+function generateResourceName(options) {
+    const { resourceType, testName, runId, customIdentifier } = options;
+    // Get resource constraints
+    const constraints = RESOURCE_CONSTRAINTS[resourceType] || DEFAULT_CONSTRAINTS;
+    // Get resource prefix
+    const prefix = getResourcePrefix(resourceType);
+    // Sanitize identifier
+    const identifier = customIdentifier
+        ? sanitizeIdentifier(customIdentifier, constraints)
+        : sanitizeIdentifier(testName, constraints);
+    // Generate short suffix from run ID
+    const suffix = generateShortId(runId);
+    // Build name based on constraints
+    const separator = constraints.allowHyphens ? "-" : "";
+    let name = separator
+        ? `${prefix}${separator}${identifier}${separator}${suffix}`
+        : `${prefix}${identifier}${suffix}`;
+    // Apply case policy
+    name = applyCasePolicy(name, constraints.casePolicy);
+    // Truncate if exceeds max length
+    if (name.length > constraints.maxLength) {
+        name = truncateName(prefix, identifier, suffix, constraints);
+    }
+    // Validate final name
+    validateResourceName(name, resourceType, constraints);
+    return name;
+}
+/**
+ * Gets the resource type prefix
+ *
+ * @param resourceType - Azure resource type
+ * @returns Short prefix for the resource type
+ */
+function getResourcePrefix(resourceType) {
+    return RESOURCE_PREFIXES[resourceType] || "test";
+}
+/**
+ * Sanitizes a test identifier to be Azure-compliant
+ *
+ * @param identifier - Raw identifier
+ * @param constraints - Resource naming constraints
+ * @returns Sanitized identifier
+ */
+function sanitizeIdentifier(identifier, constraints) {
+    let sanitized = identifier.toLowerCase();
+    // Remove or replace special characters based on constraints
+    if (!constraints.allowHyphens) {
+        sanitized = sanitized.replace(/-/g, "");
+    }
+    if (!constraints.allowUnderscores) {
+        sanitized = sanitized.replace(/_/g, "");
+    }
+    if (!constraints.allowPeriods) {
+        sanitized = sanitized.replace(/\./g, "");
+    }
+    // Remove any remaining non-alphanumeric characters (except allowed ones)
+    const allowedChars = [
+        "a-z0-9",
+        constraints.allowHyphens ? "-" : "",
+        constraints.allowUnderscores ? "_" : "",
+        constraints.allowPeriods ? "\\." : "",
+    ].join("");
+    const pattern = new RegExp(`[^${allowedChars}]`, "g");
+    sanitized = sanitized.replace(pattern, "");
+    // Remove leading/trailing special characters
+    sanitized = sanitized.replace(/^[-_.]+|[-_.]+$/g, "");
+    // Collapse multiple consecutive special characters
+    sanitized = sanitized.replace(/[-_.]{2,}/g, constraints.allowHyphens ? "-" : "");
+    return sanitized;
+}
+/**
+ * Generates a short unique ID from a UUID
+ *
+ * Takes the first 6 characters of the UUID (without hyphens)
+ * to create a short, unique suffix.
+ *
+ * @param runId - UUID v4 run ID
+ * @returns Short ID (6 characters)
+ */
+function generateShortId(runId) {
+    return runId.replace(/-/g, "").substring(0, 6).toLowerCase();
+}
+/**
+ * Applies case policy to a name
+ *
+ * @param name - Resource name
+ * @param policy - Case policy to apply
+ * @returns Name with applied case policy
+ */
+function applyCasePolicy(name, policy) {
+    switch (policy) {
+        case "lower":
+            return name.toLowerCase();
+        case "upper":
+            return name.toUpperCase();
+        case "any":
+        default:
+            return name;
+    }
+}
+/**
+ * Truncates a name to fit within constraints
+ *
+ * @param prefix - Resource type prefix
+ * @param identifier - Sanitized identifier
+ * @param suffix - Short unique ID
+ * @param constraints - Resource naming constraints
+ * @returns Truncated name
+ */
+function truncateName(prefix, identifier, suffix, constraints) {
+    const separator = constraints.allowHyphens ? "-" : "";
+    const separatorLength = separator.length;
+    // Calculate available space for identifier
+    const reservedLength = prefix.length + suffix.length + separatorLength * 2;
+    const availableLength = constraints.maxLength - reservedLength;
+    if (availableLength <= 0) {
+        // Not enough space even for minimal identifier
+        // Use just prefix and suffix
+        const minName = separator
+            ? `${prefix}${separator}${suffix}`
+            : `${prefix}${suffix}`;
+        return applyCasePolicy(minName, constraints.casePolicy);
+    }
+    // Truncate identifier to fit
+    const truncatedIdentifier = identifier.substring(0, availableLength);
+    const name = separator
+        ? `${prefix}${separator}${truncatedIdentifier}${separator}${suffix}`
+        : `${prefix}${truncatedIdentifier}${suffix}`;
+    return applyCasePolicy(name, constraints.casePolicy);
+}
+/**
+ * Validates a generated resource name
+ *
+ * @param name - Generated resource name
+ * @param resourceType - Azure resource type
+ * @param constraints - Resource naming constraints
+ * @throws Error if name is invalid
+ */
+function validateResourceName(name, resourceType, constraints) {
+    if (name.length === 0) {
+        throw new Error(`Generated name for ${resourceType} is empty`);
+    }
+    if (name.length > constraints.maxLength) {
+        throw new Error(`Generated name "${name}" exceeds maximum length ${constraints.maxLength} ` +
+            `for ${resourceType}`);
+    }
+    // Validate case policy
+    if (constraints.casePolicy === "lower" && name !== name.toLowerCase()) {
+        throw new Error(`Generated name "${name}" must be lowercase for ${resourceType}`);
+    }
+    if (constraints.casePolicy === "upper" && name !== name.toUpperCase()) {
+        throw new Error(`Generated name "${name}" must be uppercase for ${resourceType}`);
+    }
+    // Validate character constraints
+    const allowedChars = [
+        "a-zA-Z0-9",
+        constraints.allowHyphens ? "-" : "",
+        constraints.allowUnderscores ? "_" : "",
+        constraints.allowPeriods ? "\\." : "",
+    ].join("");
+    const pattern = new RegExp(`^[${allowedChars}]+$`);
+    if (!pattern.test(name)) {
+        throw new Error(`Generated name "${name}" contains invalid characters for ${resourceType}`);
+    }
+}
+/**
+ * Gets resource naming constraints for a resource type
+ *
+ * @param resourceType - Azure resource type
+ * @returns Naming constraints for the resource type
+ */
+function getResourceConstraints(resourceType) {
+    return RESOURCE_CONSTRAINTS[resourceType] || DEFAULT_CONSTRAINTS;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"naming.js","sourceRoot":"","sources":["../../../src/testing/lib/naming.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Resource naming utilities for integration tests\n *\n * Provides functions for generating unique, Azure-compliant\n * resource names with proper length constraints and character restrictions.\n */\n\n/**\n * Resource type prefix mapping for Azure resources\n */\nconst RESOURCE_PREFIXES: Record<string, string> = {\n  \"Microsoft.Resources/resourceGroups\": \"rg\",\n  \"Microsoft.Storage/storageAccounts\": \"st\",\n  \"Microsoft.Compute/virtualMachines\": \"vm\",\n  \"Microsoft.Compute/virtualMachineScaleSets\": \"vmss\",\n  \"Microsoft.ContainerService/managedClusters\": \"aks\",\n  \"Microsoft.Network/virtualNetworks\": \"vnet\",\n  \"Microsoft.Network/subnets\": \"snet\",\n  \"Microsoft.Network/networkInterfaces\": \"nic\",\n  \"Microsoft.Network/publicIPAddresses\": \"pip\",\n  \"Microsoft.Network/networkSecurityGroups\": \"nsg\",\n  \"Microsoft.Insights/actionGroups\": \"ag\",\n  \"Microsoft.Insights/metricAlerts\": \"ma\",\n  \"Microsoft.Insights/activityLogAlerts\": \"ala\",\n};\n\n/**\n * Azure resource naming constraints\n */\ninterface ResourceConstraints {\n  maxLength: number;\n  allowHyphens: boolean;\n  allowUnderscores: boolean;\n  allowPeriods: boolean;\n  casePolicy: \"lower\" | \"upper\" | \"any\";\n  allowedPattern?: RegExp;\n}\n\n/**\n * Resource naming constraints by type\n */\nconst RESOURCE_CONSTRAINTS: Record<string, ResourceConstraints> = {\n  \"Microsoft.Resources/resourceGroups\": {\n    maxLength: 90,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Storage/storageAccounts\": {\n    maxLength: 24,\n    allowHyphens: false,\n    allowUnderscores: false,\n    allowPeriods: false,\n    casePolicy: \"lower\",\n  },\n  \"Microsoft.Compute/virtualMachines\": {\n    maxLength: 64, // Windows: 15, Linux: 64\n    allowHyphens: true,\n    allowUnderscores: false,\n    allowPeriods: false,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Compute/virtualMachineScaleSets\": {\n    maxLength: 64,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: false,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.ContainerService/managedClusters\": {\n    maxLength: 63,\n    allowHyphens: true,\n    allowUnderscores: false,\n    allowPeriods: false,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Network/virtualNetworks\": {\n    maxLength: 64,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Network/subnets\": {\n    maxLength: 80,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Network/networkInterfaces\": {\n    maxLength: 80,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Network/publicIPAddresses\": {\n    maxLength: 80,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Network/networkSecurityGroups\": {\n    maxLength: 80,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Insights/actionGroups\": {\n    maxLength: 260,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Insights/metricAlerts\": {\n    maxLength: 260,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n  \"Microsoft.Insights/activityLogAlerts\": {\n    maxLength: 260,\n    allowHyphens: true,\n    allowUnderscores: true,\n    allowPeriods: true,\n    casePolicy: \"any\",\n  },\n};\n\n/**\n * Default constraints for unknown resource types\n */\nconst DEFAULT_CONSTRAINTS: ResourceConstraints = {\n  maxLength: 64,\n  allowHyphens: true,\n  allowUnderscores: false,\n  allowPeriods: false,\n  casePolicy: \"any\",\n};\n\n/**\n * Options for generating resource names\n */\nexport interface NameGenerationOptions {\n  /**\n   * Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')\n   */\n  resourceType: string;\n\n  /**\n   * Test name or identifier\n   */\n  testName: string;\n\n  /**\n   * Test run UUID\n   */\n  runId: string;\n\n  /**\n   * Optional custom identifier to include in name\n   */\n  customIdentifier?: string;\n}\n\n/**\n * Generates a unique, Azure-compliant resource name\n *\n * Creates names in format: {prefix}-{identifier}-{suffix} or\n * {prefix}{identifier}{suffix} depending on resource constraints.\n *\n * @param options - Name generation options\n * @returns Azure-compliant resource name\n *\n * @example\n * generateResourceName({\n *   resourceType: 'Microsoft.Resources/resourceGroups',\n *   testName: 'storage-test',\n *   runId: 'a1b2c3d4-e5f6-4789-b012-3456789abcde'\n * });\n * // Returns: 'rg-storage-test-a1b2c3'\n *\n * generateResourceName({\n *   resourceType: 'Microsoft.Storage/storageAccounts',\n *   testName: 'basic-test',\n *   runId: 'a1b2c3d4-e5f6-4789-b012-3456789abcde'\n * });\n * // Returns: 'stbasictesta1b2c3'\n */\nexport function generateResourceName(options: NameGenerationOptions): string {\n  const { resourceType, testName, runId, customIdentifier } = options;\n\n  // Get resource constraints\n  const constraints = RESOURCE_CONSTRAINTS[resourceType] || DEFAULT_CONSTRAINTS;\n\n  // Get resource prefix\n  const prefix = getResourcePrefix(resourceType);\n\n  // Sanitize identifier\n  const identifier = customIdentifier\n    ? sanitizeIdentifier(customIdentifier, constraints)\n    : sanitizeIdentifier(testName, constraints);\n\n  // Generate short suffix from run ID\n  const suffix = generateShortId(runId);\n\n  // Build name based on constraints\n  const separator = constraints.allowHyphens ? \"-\" : \"\";\n  let name = separator\n    ? `${prefix}${separator}${identifier}${separator}${suffix}`\n    : `${prefix}${identifier}${suffix}`;\n\n  // Apply case policy\n  name = applyCasePolicy(name, constraints.casePolicy);\n\n  // Truncate if exceeds max length\n  if (name.length > constraints.maxLength) {\n    name = truncateName(prefix, identifier, suffix, constraints);\n  }\n\n  // Validate final name\n  validateResourceName(name, resourceType, constraints);\n\n  return name;\n}\n\n/**\n * Gets the resource type prefix\n *\n * @param resourceType - Azure resource type\n * @returns Short prefix for the resource type\n */\nexport function getResourcePrefix(resourceType: string): string {\n  return RESOURCE_PREFIXES[resourceType] || \"test\";\n}\n\n/**\n * Sanitizes a test identifier to be Azure-compliant\n *\n * @param identifier - Raw identifier\n * @param constraints - Resource naming constraints\n * @returns Sanitized identifier\n */\nexport function sanitizeIdentifier(\n  identifier: string,\n  constraints: ResourceConstraints,\n): string {\n  let sanitized = identifier.toLowerCase();\n\n  // Remove or replace special characters based on constraints\n  if (!constraints.allowHyphens) {\n    sanitized = sanitized.replace(/-/g, \"\");\n  }\n  if (!constraints.allowUnderscores) {\n    sanitized = sanitized.replace(/_/g, \"\");\n  }\n  if (!constraints.allowPeriods) {\n    sanitized = sanitized.replace(/\\./g, \"\");\n  }\n\n  // Remove any remaining non-alphanumeric characters (except allowed ones)\n  const allowedChars = [\n    \"a-z0-9\",\n    constraints.allowHyphens ? \"-\" : \"\",\n    constraints.allowUnderscores ? \"_\" : \"\",\n    constraints.allowPeriods ? \"\\\\.\" : \"\",\n  ].join(\"\");\n\n  const pattern = new RegExp(`[^${allowedChars}]`, \"g\");\n  sanitized = sanitized.replace(pattern, \"\");\n\n  // Remove leading/trailing special characters\n  sanitized = sanitized.replace(/^[-_.]+|[-_.]+$/g, \"\");\n\n  // Collapse multiple consecutive special characters\n  sanitized = sanitized.replace(\n    /[-_.]{2,}/g,\n    constraints.allowHyphens ? \"-\" : \"\",\n  );\n\n  return sanitized;\n}\n\n/**\n * Generates a short unique ID from a UUID\n *\n * Takes the first 6 characters of the UUID (without hyphens)\n * to create a short, unique suffix.\n *\n * @param runId - UUID v4 run ID\n * @returns Short ID (6 characters)\n */\nexport function generateShortId(runId: string): string {\n  return runId.replace(/-/g, \"\").substring(0, 6).toLowerCase();\n}\n\n/**\n * Applies case policy to a name\n *\n * @param name - Resource name\n * @param policy - Case policy to apply\n * @returns Name with applied case policy\n */\nfunction applyCasePolicy(\n  name: string,\n  policy: \"lower\" | \"upper\" | \"any\",\n): string {\n  switch (policy) {\n    case \"lower\":\n      return name.toLowerCase();\n    case \"upper\":\n      return name.toUpperCase();\n    case \"any\":\n    default:\n      return name;\n  }\n}\n\n/**\n * Truncates a name to fit within constraints\n *\n * @param prefix - Resource type prefix\n * @param identifier - Sanitized identifier\n * @param suffix - Short unique ID\n * @param constraints - Resource naming constraints\n * @returns Truncated name\n */\nfunction truncateName(\n  prefix: string,\n  identifier: string,\n  suffix: string,\n  constraints: ResourceConstraints,\n): string {\n  const separator = constraints.allowHyphens ? \"-\" : \"\";\n  const separatorLength = separator.length;\n\n  // Calculate available space for identifier\n  const reservedLength = prefix.length + suffix.length + separatorLength * 2;\n  const availableLength = constraints.maxLength - reservedLength;\n\n  if (availableLength <= 0) {\n    // Not enough space even for minimal identifier\n    // Use just prefix and suffix\n    const minName = separator\n      ? `${prefix}${separator}${suffix}`\n      : `${prefix}${suffix}`;\n    return applyCasePolicy(minName, constraints.casePolicy);\n  }\n\n  // Truncate identifier to fit\n  const truncatedIdentifier = identifier.substring(0, availableLength);\n\n  const name = separator\n    ? `${prefix}${separator}${truncatedIdentifier}${separator}${suffix}`\n    : `${prefix}${truncatedIdentifier}${suffix}`;\n\n  return applyCasePolicy(name, constraints.casePolicy);\n}\n\n/**\n * Validates a generated resource name\n *\n * @param name - Generated resource name\n * @param resourceType - Azure resource type\n * @param constraints - Resource naming constraints\n * @throws Error if name is invalid\n */\nfunction validateResourceName(\n  name: string,\n  resourceType: string,\n  constraints: ResourceConstraints,\n): void {\n  if (name.length === 0) {\n    throw new Error(`Generated name for ${resourceType} is empty`);\n  }\n\n  if (name.length > constraints.maxLength) {\n    throw new Error(\n      `Generated name \"${name}\" exceeds maximum length ${constraints.maxLength} ` +\n        `for ${resourceType}`,\n    );\n  }\n\n  // Validate case policy\n  if (constraints.casePolicy === \"lower\" && name !== name.toLowerCase()) {\n    throw new Error(\n      `Generated name \"${name}\" must be lowercase for ${resourceType}`,\n    );\n  }\n\n  if (constraints.casePolicy === \"upper\" && name !== name.toUpperCase()) {\n    throw new Error(\n      `Generated name \"${name}\" must be uppercase for ${resourceType}`,\n    );\n  }\n\n  // Validate character constraints\n  const allowedChars = [\n    \"a-zA-Z0-9\",\n    constraints.allowHyphens ? \"-\" : \"\",\n    constraints.allowUnderscores ? \"_\" : \"\",\n    constraints.allowPeriods ? \"\\\\.\" : \"\",\n  ].join(\"\");\n\n  const pattern = new RegExp(`^[${allowedChars}]+$`);\n  if (!pattern.test(name)) {\n    throw new Error(\n      `Generated name \"${name}\" contains invalid characters for ${resourceType}`,\n    );\n  }\n}\n\n/**\n * Gets resource naming constraints for a resource type\n *\n * @param resourceType - Azure resource type\n * @returns Naming constraints for the resource type\n */\nexport function getResourceConstraints(\n  resourceType: string,\n): ResourceConstraints {\n  return RESOURCE_CONSTRAINTS[resourceType] || DEFAULT_CONSTRAINTS;\n}\n"]}

package/node_modules/uuid/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2010-2020 Robert Kieffer and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.