@cdktn/cli-core 0.22.0-pre.2

package/src/lib/dependencies/dependency-manager.d.ts

@@ -0,0 +1,84 @@
+import { Language, TerraformDependencyConstraint } from "@cdktn/commons";
+export declare const DEFAULT_HOSTNAME = "registry.terraform.io";
+export declare const DEFAULT_NAMESPACE = "hashicorp";
+export declare class ProviderConstraint {
+    readonly version: string | undefined;
+    /**
+     * normalized source of the provider
+     * e.g. "registry.terraform.io/hashicorp/aws"
+     */
+    readonly source: string;
+    constructor(source: string, version: string | undefined);
+    static fromConfigEntry(provider: string | TerraformDependencyConstraint): ProviderConstraint;
+    isFromTerraformRegistry(): boolean;
+    /**
+     * the namespace of the provider
+     * e.g. "hashicorp" or "kreuzwerker"
+     */
+    get namespace(): string;
+    /**
+     * the name of the provider
+     * e.g. "aws"
+     */
+    get name(): string;
+    /**
+     * the hostname of the provider
+     * e.g. "registry.terraform.io"
+     */
+    get hostname(): string;
+    /**
+     * returns a simplified provider name, dropping namespace and hostname
+     * if they match the defaults
+     */
+    get simplifiedName(): string;
+    /**
+     * checks if the version constraint matches the given version
+     * @param version an actual version (e.g. "4.12.1")
+     * @returns true if the version is compatible with the constraint
+     */
+    matchesVersion(version: string): boolean;
+    toString(): string;
+}
+/**
+ * manages dependencies of a CDKTN project (e.g. terraform providers)
+ */
+export declare class DependencyManager {
+    private readonly targetLanguage;
+    private cdktfVersion;
+    private readonly projectDirectory;
+    private packageManager;
+    constructor(targetLanguage: Language, cdktfVersion: string, projectDirectory: string);
+    addProvider(constraint: ProviderConstraint): Promise<{
+        addedLocalProvider: boolean;
+    }>;
+    upgradeProvider(constraint: ProviderConstraint): Promise<{
+        addedLocalProvider: boolean;
+    }>;
+    getCurrentlyInstalledVersion(constraint: ProviderConstraint): Promise<string | undefined>;
+    upgradePrebuiltProvider(constraint: ProviderConstraint, currentVersion: string): Promise<void>;
+    hasPrebuiltProvider(constraint: ProviderConstraint): Promise<boolean>;
+    private tryGetPackageName;
+    private getPackageName;
+    getMatchingProviderVersion(constraint: ProviderConstraint): Promise<string>;
+    addPrebuiltProvider(constraint: ProviderConstraint, silent?: boolean): Promise<void>;
+    private getLanguageSpecificPackageVersion;
+    addLocalProvider(constraint: ProviderConstraint): Promise<void>;
+    /**
+     * Converts an NPM package name of a pre-built provider package to the name in the target language
+     */
+    private convertPackageName;
+    /**
+     * Converts an package name of a pre-built provider package in target language to the name in npm
+     * Inverse of: `convertPackageName`
+     */
+    private convertFromPackageNameToNpm;
+    allProviders(): Promise<{
+        local: {
+            providerName: string;
+            providerConstraint: string | undefined;
+            providerVersion: string | null;
+        }[];
+        prebuilt: any[];
+    }>;
+}
+//# sourceMappingURL=dependency-manager.d.ts.map

package/src/lib/dependencies/dependency-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-manager.d.ts","sourceRoot":"","sources":["dependency-manager.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAGR,6BAA6B,EAC9B,MAAM,gBAAgB,CAAC;AAkBxB,eAAO,MAAM,gBAAgB,0BAA0B,CAAC;AACxD,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAc7C,qBAAa,kBAAkB;aAYX,OAAO,EAAE,MAAM,GAAG,SAAS;IAX7C;;;OAGG;IACH,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAM7B,MAAM,EAAE,MAAM,EACE,OAAO,EAAE,MAAM,GAAG,SAAS;IAK7C,MAAM,CAAC,eAAe,CACpB,QAAQ,EAAE,MAAM,GAAG,6BAA6B,GAC/C,kBAAkB;IAgBd,uBAAuB,IAAI,OAAO;IAIzC;;;OAGG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;OAGG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;OAGG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;OAGG;IACH,IAAW,cAAc,IAAI,MAAM,CAKlC;IAED;;;;OAIG;IACI,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAOxC,QAAQ;CAGhB;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAI1B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IALnC,OAAO,CAAC,cAAc,CAAiB;gBAGpB,cAAc,EAAE,QAAQ,EACjC,YAAY,EAAE,MAAM,EACX,gBAAgB,EAAE,MAAM;IAQrC,WAAW,CACf,UAAU,EAAE,kBAAkB,GAC7B,OAAO,CAAC;QAAE,kBAAkB,EAAE,OAAO,CAAA;KAAE,CAAC;IAUrC,eAAe,CAAC,UAAU,EAAE,kBAAkB;;;IAkB9C,4BAA4B,CAAC,UAAU,EAAE,kBAAkB;IAwB3D,uBAAuB,CAC3B,UAAU,EAAE,kBAAkB,EAC9B,cAAc,EAAE,MAAM;IAmBlB,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;YAoC7D,iBAAiB;YAajB,cAAc;IAYtB,0BAA0B,CAAC,UAAU,EAAE,kBAAkB;IA2BzD,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,EAAE,MAAM,UAAQ;YAe1D,iCAAiC;IA8BzC,gBAAgB,CAAC,UAAU,EAAE,kBAAkB;IAuBrD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwB1B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAsCtB,YAAY;;;;;;;;CAoD1B"}

package/src/lib/dependencies/dependency-manager.js

@@ -0,0 +1,365 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyManager = exports.ProviderConstraint = exports.DEFAULT_NAMESPACE = exports.DEFAULT_HOSTNAME = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const commons_1 = require("@cdktn/commons");
+const codemaker_1 = require("codemaker");
+const cdktf_config_1 = require("../cdktf-config");
+const cdktf_config_manager_1 = require("./cdktf-config-manager");
+const package_manager_1 = require("./package-manager");
+const prebuilt_providers_1 = require("./prebuilt-providers");
+const registry_api_1 = require("./registry-api");
+const version_constraints_1 = require("./version-constraints");
+const semver = __importStar(require("semver"));
+const local_provider_versions_1 = require("../local-provider-versions");
+const local_provider_constraints_1 = require("../local-provider-constraints");
+// ref: https://www.terraform.io/language/providers/requirements#source-addresses
+exports.DEFAULT_HOSTNAME = "registry.terraform.io";
+exports.DEFAULT_NAMESPACE = "hashicorp";
+function normalizeProviderSource(source) {
+    // returns <HOSTNAME>/<NAMESPACE>/<TYPE>
+    const slashes = source.split("/").length - 1;
+    switch (slashes) {
+        case 0:
+            return `${exports.DEFAULT_HOSTNAME}/${exports.DEFAULT_NAMESPACE}/${source}`;
+        case 1:
+            return `${exports.DEFAULT_HOSTNAME}/${source}`;
+        default:
+            return source;
+    }
+}
+class ProviderConstraint {
+    // TODO: add examples to cli command description (i.e. =,~>.> etc.)
+    // if no version constraint is specified, we assume the latest version
+    // if specific version is specified without e.g. =, we allow patch level increments (e.g. ~>2.12 for "2.12")
+    constructor(source, version) {
+        this.version = version;
+        this.source = normalizeProviderSource(source);
+    }
+    static fromConfigEntry(provider) {
+        if (typeof provider === "string") {
+            const [src, version] = provider.split("@");
+            return new ProviderConstraint(src.trim(), version ? version.trim() : undefined);
+        }
+        const src = (provider.namespace ? `${provider.namespace}/` : "") +
+            (provider.source || provider.name);
+        return new ProviderConstraint(src, provider.version);
+    }
+    isFromTerraformRegistry() {
+        return this.hostname === exports.DEFAULT_HOSTNAME;
+    }
+    /**
+     * the namespace of the provider
+     * e.g. "hashicorp" or "kreuzwerker"
+     */
+    get namespace() {
+        return this.source.split("/")[1];
+    }
+    /**
+     * the name of the provider
+     * e.g. "aws"
+     */
+    get name() {
+        return this.source.split("/")[2];
+    }
+    /**
+     * the hostname of the provider
+     * e.g. "registry.terraform.io"
+     */
+    get hostname() {
+        return this.source.split("/")[0];
+    }
+    /**
+     * returns a simplified provider name, dropping namespace and hostname
+     * if they match the defaults
+     */
+    get simplifiedName() {
+        return this.source
+            .split("/")
+            .filter((part) => part !== exports.DEFAULT_HOSTNAME && part !== exports.DEFAULT_NAMESPACE)
+            .join("/");
+    }
+    /**
+     * checks if the version constraint matches the given version
+     * @param version an actual version (e.g. "4.12.1")
+     * @returns true if the version is compatible with the constraint
+     */
+    matchesVersion(version) {
+        if (this.version) {
+            return (0, version_constraints_1.versionMatchesConstraint)(version, this.version);
+        }
+        return true;
+    }
+    toString() {
+        return `${this.source}${this.version ? `@${this.version}` : ""}`;
+    }
+}
+exports.ProviderConstraint = ProviderConstraint;
+/**
+ * manages dependencies of a CDKTN project (e.g. terraform providers)
+ */
+class DependencyManager {
+    constructor(targetLanguage, cdktfVersion, projectDirectory) {
+        this.targetLanguage = targetLanguage;
+        this.cdktfVersion = cdktfVersion;
+        this.projectDirectory = projectDirectory;
+        this.packageManager = package_manager_1.PackageManager.forLanguage(targetLanguage, this.projectDirectory);
+    }
+    async addProvider(constraint) {
+        if (await this.hasPrebuiltProvider(constraint)) {
+            await this.addPrebuiltProvider(constraint);
+            return { addedLocalProvider: false };
+        }
+        else {
+            await this.addLocalProvider(constraint);
+            return { addedLocalProvider: true };
+        }
+    }
+    async upgradeProvider(constraint) {
+        console.log(`Upgrading ${constraint.simplifiedName}...`);
+        const cdktfJson = new cdktf_config_manager_1.CdktfConfigManager();
+        const prebuiltVersion = await this.getCurrentlyInstalledVersion(constraint);
+        if (prebuiltVersion) {
+            await this.upgradePrebuiltProvider(constraint, prebuiltVersion);
+            return { addedLocalProvider: false };
+        }
+        if (await cdktfJson.hasProvider(constraint)) {
+            await cdktfJson.updateProvider(constraint);
+            return { addedLocalProvider: true };
+        }
+        throw commons_1.Errors.Usage(`Trying to upgrade ${constraint.simplifiedName} but it is not installed, please use "cdktf provider add ${constraint.simplifiedName}" to add it.`);
+    }
+    async getCurrentlyInstalledVersion(constraint) {
+        var _a;
+        commons_1.logger.info(`Checking if ${constraint.simplifiedName} is installed...`);
+        const packageName = await this.tryGetPackageName(constraint);
+        if (!packageName)
+            return; // not available as pre-built provider, so can't be installed as such
+        commons_1.logger.debug(`Expecting package ${packageName} to be installed if provider is installed as pre-built one`);
+        let installedPackages;
+        try {
+            installedPackages = await this.packageManager.listProviderPackages();
+        }
+        catch (e) {
+            throw new Error(`Failed to list packages: ${e}`);
+        }
+        commons_1.logger.debug(`Installed packages found: ${JSON.stringify(installedPackages, null, 2)}`);
+        return (_a = installedPackages.find((pkg) => pkg.name === packageName)) === null || _a === void 0 ? void 0 : _a.version;
+    }
+    async upgradePrebuiltProvider(constraint, currentVersion) {
+        commons_1.logger.debug(`Searching for latest matching version of ${constraint.simplifiedName}`);
+        const packageName = await this.getPackageName(constraint);
+        const packageVersion = await this.getMatchingProviderVersion(constraint);
+        commons_1.logger.debug(`Found package ${packageName}@${packageVersion}`);
+        if (packageVersion !== currentVersion) {
+            await this.packageManager.addPackage(packageName, packageVersion);
+        }
+        else {
+            console.log(`The latest version of ${packageName} is already installed: ${packageVersion}`);
+        }
+    }
+    async hasPrebuiltProvider(constraint) {
+        commons_1.logger.debug(`determining whether pre-built provider exists for ${constraint.source} with version constraint ${constraint.version} and cdktf version ${this.cdktfVersion}`);
+        commons_1.logger.info(`Checking whether pre-built provider exists for the following constraints:
+  provider: ${constraint.simplifiedName}
+  version : ${constraint.version || "latest"}
+  language: ${this.targetLanguage}
+  cdktf   : ${this.cdktfVersion}
+`);
+        if (this.targetLanguage === commons_1.Language.GO &&
+            semver.lt(this.cdktfVersion, "0.12.0")) {
+            commons_1.logger.info(`Before CDKTF 0.12.0 there were no pre-built providers published for Go.`);
+            return false;
+        }
+        const v = await (0, prebuilt_providers_1.getPrebuiltProviderVersions)(constraint, this.cdktfVersion);
+        const exists = v !== null;
+        if (exists) {
+            commons_1.logger.info(`Found pre-built provider.`);
+        }
+        else {
+            commons_1.logger.info(`Pre-built provider does not exist for the given constraints.`);
+        }
+        return exists;
+    }
+    async tryGetPackageName(constraint) {
+        const npmPackageName = await (0, prebuilt_providers_1.getNpmPackageName)(constraint);
+        if (!npmPackageName)
+            return;
+        const prebuiltProviderRepository = await (0, prebuilt_providers_1.getPrebuiltProviderRepositoryName)(npmPackageName);
+        return this.convertPackageName(npmPackageName, prebuiltProviderRepository);
+    }
+    async getPackageName(constraint) {
+        const packageName = await this.tryGetPackageName(constraint);
+        if (!packageName) {
+            throw commons_1.Errors.Usage(`Could not find pre-built provider for ${constraint.source}`);
+        }
+        return packageName;
+    }
+    async getMatchingProviderVersion(constraint) {
+        const packageName = await this.getPackageName(constraint);
+        const prebuiltProviderNpmVersions = await (0, prebuilt_providers_1.getPrebuiltProviderVersions)(constraint, this.cdktfVersion);
+        if (!prebuiltProviderNpmVersions) {
+            throw commons_1.Errors.Usage(`No pre-built provider found for ${constraint.source} with version constraint ${constraint.version} and cdktf version ${this.cdktfVersion}`);
+        }
+        const packageVersion = await this.getLanguageSpecificPackageVersion(packageName, prebuiltProviderNpmVersions);
+        if (!packageVersion) {
+            throw commons_1.Errors.Usage(`No pre-built provider found for ${constraint.source} with version constraint ${constraint.version} and cdktf version ${this.cdktfVersion} for language ${this.targetLanguage}.`);
+        }
+        return packageVersion;
+    }
+    async addPrebuiltProvider(constraint, silent = false) {
+        commons_1.logger.debug(`adding pre-built provider ${constraint.source} with version constraint ${constraint.version} for cdktf version ${this.cdktfVersion}`);
+        const packageName = await this.getPackageName(constraint);
+        const packageVersion = await this.getMatchingProviderVersion(constraint);
+        await this.packageManager.addPackage(packageName, packageVersion, silent);
+        // TODO: more debug logs
+    }
+    // The version we use for npm might differ from other registries
+    // This happens mostly in cases where a provider update failed to publish to one of the registries
+    // In that case we use the latest version that was published successfully and works with the current cdktf release
+    async getLanguageSpecificPackageVersion(packageName, prebuiltProviderNpmVersions) {
+        commons_1.logger.debug("Found possibly matching versions (released on npm): ", prebuiltProviderNpmVersions);
+        commons_1.logger.debug("Searching through package manager to find latest available version for given language");
+        for (const version of prebuiltProviderNpmVersions) {
+            try {
+                const isAvailable = await this.packageManager.isNpmVersionAvailable(packageName, version);
+                if (isAvailable) {
+                    return version;
+                }
+            }
+            catch (err) {
+                commons_1.logger.info(`Could not find version ${version} for package ${packageName}: '${err}'. Skipping...`);
+            }
+        }
+        return null;
+    }
+    async addLocalProvider(constraint) {
+        commons_1.logger.info(`Adding local provider ${constraint.source} with version constraint ${constraint.version} to cdktf.json`);
+        if (!constraint.version && constraint.isFromTerraformRegistry()) {
+            const v = await (0, registry_api_1.getLatestVersion)(constraint);
+            if (v) {
+                constraint = new ProviderConstraint(constraint.source, 
+                // "1.3.2" -> "~> 1.3"
+                `~> ${v.split(".").slice(0, 2).join(".")}`);
+            }
+            else {
+                throw commons_1.Errors.Usage(`Could not find a version for the provider '${constraint}' in the public registry. This could be due to a typo, please take a look at https://cdk.tf/registry-providers to find all supported providers.`);
+            }
+        }
+        await new cdktf_config_manager_1.CdktfConfigManager().addProvider(constraint);
+    }
+    /**
+     * Converts an NPM package name of a pre-built provider package to the name in the target language
+     */
+    convertPackageName(name, repository) {
+        const providerName = name.replace("@cdktf/provider-", "");
+        switch (this.targetLanguage) {
+            case commons_1.Language.GO: // e.g. github.com/cdktf/cdktf-provider-opentelekomcloud-go/opentelekomcloud
+                if (repository) {
+                    return `${repository}-go/${providerName}`;
+                }
+                return `github.com/cdktf/cdktf-provider-${providerName}-go/${providerName}`;
+            case commons_1.Language.TYPESCRIPT: // e.g. @cdktf/provider-random
+                return name; // already the correct name
+            case commons_1.Language.CSHARP: // e.g. HashiCorp.Cdktf.Providers.Opentelekomcloud
+                return `HashiCorp.Cdktf.Providers.` + (0, codemaker_1.toPascalCase)(providerName);
+            case commons_1.Language.JAVA: // e.g. com.hashicorp.opentelekomcloud
+                return `com.hashicorp.cdktf-provider-${providerName}`;
+            case commons_1.Language.PYTHON: // e.g. cdktf-cdktf-provider-opentelekomcloud
+                return `cdktf-cdktf-provider-${providerName}`;
+            default:
+                throw new Error(`converting package name for language ${this.targetLanguage} not implemented yet`);
+        }
+    }
+    /**
+     * Converts an package name of a pre-built provider package in target language to the name in npm
+     * Inverse of: `convertPackageName`
+     */
+    convertFromPackageNameToNpm(name) {
+        const npmPackagePrefix = "@cdktf/provider-";
+        const regexes = {
+            [commons_1.Language.GO]: /github.com\/(?:cdktf|hashicorp)\/cdktf-provider-(.+)-go\//i,
+            [commons_1.Language.TYPESCRIPT]: /(.+)/i,
+            [commons_1.Language.CSHARP]: /HashiCorp\.Cdktf\.Providers\.(.+)/i,
+            [commons_1.Language.JAVA]: /com\.hashicorp\.cdktf-provider-(.+)/i,
+            [commons_1.Language.PYTHON]: /cdktf-cdktf-provider-(.+)/i,
+        };
+        const regex = regexes[this.targetLanguage];
+        if (!regex) {
+            throw commons_1.Errors.Usage("Language not supported for pre-built providers");
+        }
+        const match = regex.exec(name);
+        if (!match) {
+            throw new Error(`Package name is not in expected format: ${name}`);
+        }
+        switch (this.targetLanguage) {
+            case commons_1.Language.GO: // e.g. github.com/cdktf/cdktf-provider-opentelekomcloud-go/opentelekomcloud
+                return npmPackagePrefix + match[1];
+            case commons_1.Language.TYPESCRIPT: // e.g. @cdktf/provider-random
+                return match[1]; // already the correct name
+            case commons_1.Language.CSHARP: // e.g. HashiCorp.Cdktf.Providers.Opentelekomcloud
+                return npmPackagePrefix + (0, codemaker_1.toSnakeCase)(match[1]);
+            case commons_1.Language.JAVA: // e.g. com.hashicorp.opentelekomcloud
+                return npmPackagePrefix + match[1];
+            case commons_1.Language.PYTHON: // e.g. cdktf-cdktf-provider-opentelekomcloud
+                return npmPackagePrefix + match[1];
+            default:
+                throw new Error(`converting package name for language ${this.targetLanguage} not implemented yet`);
+        }
+    }
+    async allProviders() {
+        const cdktfJson = cdktf_config_1.CdktfConfig.read();
+        const localVersions = new local_provider_versions_1.LocalProviderVersions();
+        const localProviderConfigs = cdktfJson.terraformProviders;
+        const prebuiltProviderConfigs = await this.packageManager.listProviderPackages();
+        const prebuiltProvidersInfo = await Promise.all(prebuiltProviderConfigs.map(async (prebuiltProviderConfig) => {
+            const packageName = this.convertFromPackageNameToNpm(prebuiltProviderConfig.name);
+            const providerInformation = await (0, prebuilt_providers_1.getPrebuiltProviderVersionInformation)(packageName, prebuiltProviderConfig.version);
+            return {
+                ...providerInformation,
+                packageName: prebuiltProviderConfig.name,
+            };
+        }));
+        const constraints = new local_provider_constraints_1.LocalProviderConstraints();
+        const localProvidersInfo = await Promise.all(localProviderConfigs.map(async (localProviderConfig) => {
+            const constraint = ProviderConstraint.fromConfigEntry(localProviderConfig);
+            const version = await localVersions.versionForProvider(constraint.simplifiedName);
+            const constraintValue = await constraints.constraintForProvider(constraint.simplifiedName);
+            return {
+                providerName: constraint.simplifiedName,
+                providerConstraint: constraintValue || constraint.version,
+                providerVersion: version,
+            };
+        }));
+        return {
+            local: localProvidersInfo,
+            prebuilt: prebuiltProvidersInfo,
+        };
+    }
+}
+exports.DependencyManager = DependencyManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency-manager.js","sourceRoot":"","sources":["dependency-manager.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,4CAKwB;AACxB,yCAAsD;AACtD,kDAA8C;AAC9C,iEAA4D;AAC5D,uDAAmD;AACnD,6DAK8B;AAC9B,iDAAkD;AAClD,+DAAiE;AACjE,+CAAiC;AACjC,wEAAmE;AACnE,8EAAyE;AAEzE,iFAAiF;AACpE,QAAA,gBAAgB,GAAG,uBAAuB,CAAC;AAC3C,QAAA,iBAAiB,GAAG,WAAW,CAAC;AAC7C,SAAS,uBAAuB,CAAC,MAAc;IAC7C,wCAAwC;IACxC,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAC7C,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,CAAC;YACJ,OAAO,GAAG,wBAAgB,IAAI,yBAAiB,IAAI,MAAM,EAAE,CAAC;QAC9D,KAAK,CAAC;YACJ,OAAO,GAAG,wBAAgB,IAAI,MAAM,EAAE,CAAC;QACzC;YACE,OAAO,MAAM,CAAC;IAClB,CAAC;AACH,CAAC;AAED,MAAa,kBAAkB;IAO7B,mEAAmE;IACnE,sEAAsE;IACtE,4GAA4G;IAC5G,YACE,MAAc,EACE,OAA2B;QAA3B,YAAO,GAAP,OAAO,CAAoB;QAE3C,IAAI,CAAC,MAAM,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IAED,MAAM,CAAC,eAAe,CACpB,QAAgD;QAEhD,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACjC,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC3C,OAAO,IAAI,kBAAkB,CAC3B,GAAG,CAAC,IAAI,EAAE,EACV,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CACrC,CAAC;QACJ,CAAC;QAED,MAAM,GAAG,GACP,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACpD,CAAC,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC;QAErC,OAAO,IAAI,kBAAkB,CAAC,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACvD,CAAC;IAEM,uBAAuB;QAC5B,OAAO,IAAI,CAAC,QAAQ,KAAK,wBAAgB,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,MAAM;aACf,KAAK,CAAC,GAAG,CAAC;aACV,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,wBAAgB,IAAI,IAAI,KAAK,yBAAiB,CAAC;aACzE,IAAI,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,OAAe;QACnC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAA,8CAAwB,EAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,QAAQ;QACb,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACnE,CAAC;CACF;AAzFD,gDAyFC;AAED;;GAEG;AACH,MAAa,iBAAiB;IAG5B,YACmB,cAAwB,EACjC,YAAoB,EACX,gBAAwB;QAFxB,mBAAc,GAAd,cAAc,CAAU;QACjC,iBAAY,GAAZ,YAAY,CAAQ;QACX,qBAAgB,GAAhB,gBAAgB,CAAQ;QAEzC,IAAI,CAAC,cAAc,GAAG,gCAAc,CAAC,WAAW,CAC9C,cAAc,EACd,IAAI,CAAC,gBAAgB,CACtB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,WAAW,CACf,UAA8B;QAE9B,IAAI,MAAM,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,EAAE,CAAC;YAC/C,MAAM,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;YAC3C,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;QACvC,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;YACxC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;QACtC,CAAC;IACH,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,UAA8B;QAClD,OAAO,CAAC,GAAG,CAAC,aAAa,UAAU,CAAC,cAAc,KAAK,CAAC,CAAC;QACzD,MAAM,SAAS,GAAG,IAAI,yCAAkB,EAAE,CAAC;QAC3C,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAAC,UAAU,CAAC,CAAC;QAC5E,IAAI,eAAe,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,uBAAuB,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;YAChE,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;QACvC,CAAC;QACD,IAAI,MAAM,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC;YAC5C,MAAM,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;YAC3C,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;QACtC,CAAC;QAED,MAAM,gBAAM,CAAC,KAAK,CAChB,qBAAqB,UAAU,CAAC,cAAc,4DAA4D,UAAU,CAAC,cAAc,cAAc,CAClJ,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,4BAA4B,CAAC,UAA8B;;QAC/D,gBAAM,CAAC,IAAI,CAAC,eAAe,UAAU,CAAC,cAAc,kBAAkB,CAAC,CAAC;QACxE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAE7D,IAAI,CAAC,WAAW;YAAE,OAAO,CAAC,qEAAqE;QAE/F,gBAAM,CAAC,KAAK,CACV,qBAAqB,WAAW,4DAA4D,CAC7F,CAAC;QAEF,IAAI,iBAAiB,CAAC;QACtB,IAAI,CAAC;YACH,iBAAiB,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,EAAE,CAAC;QACvE,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;QACnD,CAAC;QAED,gBAAM,CAAC,KAAK,CACV,6BAA6B,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAC1E,CAAC;QAEF,OAAO,MAAA,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,0CAAE,OAAO,CAAC;IAC5E,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,UAA8B,EAC9B,cAAsB;QAEtB,gBAAM,CAAC,KAAK,CACV,4CAA4C,UAAU,CAAC,cAAc,EAAE,CACxE,CAAC;QAEF,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAC1D,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;QAEzE,gBAAM,CAAC,KAAK,CAAC,iBAAiB,WAAW,IAAI,cAAc,EAAE,CAAC,CAAC;QAC/D,IAAI,cAAc,KAAK,cAAc,EAAE,CAAC;YACtC,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QACpE,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CACT,yBAAyB,WAAW,0BAA0B,cAAc,EAAE,CAC/E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,UAA8B;QACtD,gBAAM,CAAC,KAAK,CACV,qDAAqD,UAAU,CAAC,MAAM,4BAA4B,UAAU,CAAC,OAAO,sBAAsB,IAAI,CAAC,YAAY,EAAE,CAC9J,CAAC;QAEF,gBAAM,CAAC,IAAI,CAAC;cACF,UAAU,CAAC,cAAc;cACzB,UAAU,CAAC,OAAO,IAAI,QAAQ;cAC9B,IAAI,CAAC,cAAc;cACnB,IAAI,CAAC,YAAY;CAC9B,CAAC,CAAC;QAEC,IACE,IAAI,CAAC,cAAc,KAAK,kBAAQ,CAAC,EAAE;YACnC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,EACtC,CAAC;YACD,gBAAM,CAAC,IAAI,CACT,yEAAyE,CAC1E,CAAC;YACF,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,CAAC,GAAG,MAAM,IAAA,gDAA2B,EAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,CAAC,KAAK,IAAI,CAAC;QAE1B,IAAI,MAAM,EAAE,CAAC;YACX,gBAAM,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;QAC3C,CAAC;aAAM,CAAC;YACN,gBAAM,CAAC,IAAI,CACT,8DAA8D,CAC/D,CAAC;QACJ,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC7B,UAA8B;QAE9B,MAAM,cAAc,GAAG,MAAM,IAAA,sCAAiB,EAAC,UAAU,CAAC,CAAC;QAE3D,IAAI,CAAC,cAAc;YAAE,OAAO;QAE5B,MAAM,0BAA0B,GAC9B,MAAM,IAAA,sDAAiC,EAAC,cAAc,CAAC,CAAC;QAE1D,OAAO,IAAI,CAAC,kBAAkB,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC;IAC7E,CAAC;IAEO,KAAK,CAAC,cAAc,CAC1B,UAA8B;QAE9B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,gBAAM,CAAC,KAAK,CAChB,yCAAyC,UAAU,CAAC,MAAM,EAAE,CAC7D,CAAC;QACJ,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,0BAA0B,CAAC,UAA8B;QAC7D,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAE1D,MAAM,2BAA2B,GAAG,MAAM,IAAA,gDAA2B,EACnE,UAAU,EACV,IAAI,CAAC,YAAY,CAClB,CAAC;QACF,IAAI,CAAC,2BAA2B,EAAE,CAAC;YACjC,MAAM,gBAAM,CAAC,KAAK,CAChB,mCAAmC,UAAU,CAAC,MAAM,4BAA4B,UAAU,CAAC,OAAO,sBAAsB,IAAI,CAAC,YAAY,EAAE,CAC5I,CAAC;QACJ,CAAC;QAED,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iCAAiC,CACjE,WAAW,EACX,2BAA2B,CAC5B,CAAC;QAEF,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,gBAAM,CAAC,KAAK,CAChB,mCAAmC,UAAU,CAAC,MAAM,4BAA4B,UAAU,CAAC,OAAO,sBAAsB,IAAI,CAAC,YAAY,iBAAiB,IAAI,CAAC,cAAc,GAAG,CACjL,CAAC;QACJ,CAAC;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,UAA8B,EAAE,MAAM,GAAG,KAAK;QACtE,gBAAM,CAAC,KAAK,CACV,6BAA6B,UAAU,CAAC,MAAM,4BAA4B,UAAU,CAAC,OAAO,sBAAsB,IAAI,CAAC,YAAY,EAAE,CACtI,CAAC;QAEF,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAC1D,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;QACzE,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,WAAW,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;QAE1E,wBAAwB;IAC1B,CAAC;IAED,gEAAgE;IAChE,kGAAkG;IAClG,kHAAkH;IAC1G,KAAK,CAAC,iCAAiC,CAC7C,WAAmB,EACnB,2BAAqC;QAErC,gBAAM,CAAC,KAAK,CACV,sDAAsD,EACtD,2BAA2B,CAC5B,CAAC;QACF,gBAAM,CAAC,KAAK,CACV,uFAAuF,CACxF,CAAC;QAEF,KAAK,MAAM,OAAO,IAAI,2BAA2B,EAAE,CAAC;YAClD,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,qBAAqB,CACjE,WAAW,EACX,OAAO,CACR,CAAC;gBACF,IAAI,WAAW,EAAE,CAAC;oBAChB,OAAO,OAAO,CAAC;gBACjB,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,gBAAM,CAAC,IAAI,CACT,0BAA0B,OAAO,gBAAgB,WAAW,MAAM,GAAG,gBAAgB,CACtF,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,UAA8B;QACnD,gBAAM,CAAC,IAAI,CACT,yBAAyB,UAAU,CAAC,MAAM,4BAA4B,UAAU,CAAC,OAAO,gBAAgB,CACzG,CAAC;QAEF,IAAI,CAAC,UAAU,CAAC,OAAO,IAAI,UAAU,CAAC,uBAAuB,EAAE,EAAE,CAAC;YAChE,MAAM,CAAC,GAAG,MAAM,IAAA,+BAAgB,EAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,CAAC,EAAE,CAAC;gBACN,UAAU,GAAG,IAAI,kBAAkB,CACjC,UAAU,CAAC,MAAM;gBACjB,sBAAsB;gBACtB,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAC3C,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,MAAM,gBAAM,CAAC,KAAK,CAChB,8CAA8C,UAAU,iJAAiJ,CAC1M,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,IAAI,yCAAkB,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,IAAY,EAAE,UAAkB;QACzD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;QAC1D,QAAQ,IAAI,CAAC,cAAc,EAAE,CAAC;YAC5B,KAAK,kBAAQ,CAAC,EAAE,EAAE,4EAA4E;gBAC5F,IAAI,UAAU,EAAE,CAAC;oBACf,OAAO,GAAG,UAAU,OAAO,YAAY,EAAE,CAAC;gBAC5C,CAAC;gBAED,OAAO,mCAAmC,YAAY,OAAO,YAAY,EAAE,CAAC;YAC9E,KAAK,kBAAQ,CAAC,UAAU,EAAE,8BAA8B;gBACtD,OAAO,IAAI,CAAC,CAAC,2BAA2B;YAC1C,KAAK,kBAAQ,CAAC,MAAM,EAAE,kDAAkD;gBACtE,OAAO,4BAA4B,GAAG,IAAA,wBAAY,EAAC,YAAY,CAAC,CAAC;YACnE,KAAK,kBAAQ,CAAC,IAAI,EAAE,sCAAsC;gBACxD,OAAO,gCAAgC,YAAY,EAAE,CAAC;YACxD,KAAK,kBAAQ,CAAC,MAAM,EAAE,6CAA6C;gBACjE,OAAO,wBAAwB,YAAY,EAAE,CAAC;YAChD;gBACE,MAAM,IAAI,KAAK,CACb,wCAAwC,IAAI,CAAC,cAAc,sBAAsB,CAClF,CAAC;QACN,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,2BAA2B,CAAC,IAAY;QAC9C,MAAM,gBAAgB,GAAG,kBAAkB,CAAC;QAC5C,MAAM,OAAO,GAAG;YACd,CAAC,kBAAQ,CAAC,EAAE,CAAC,EACX,4DAA4D;YAC9D,CAAC,kBAAQ,CAAC,UAAU,CAAC,EAAE,OAAO;YAC9B,CAAC,kBAAQ,CAAC,MAAM,CAAC,EAAE,oCAAoC;YACvD,CAAC,kBAAQ,CAAC,IAAI,CAAC,EAAE,sCAAsC;YACvD,CAAC,kBAAQ,CAAC,MAAM,CAAC,EAAE,4BAA4B;SAChD,CAAC;QACF,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,gBAAM,CAAC,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACvE,CAAC;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,2CAA2C,IAAI,EAAE,CAAC,CAAC;QACrE,CAAC;QAED,QAAQ,IAAI,CAAC,cAAc,EAAE,CAAC;YAC5B,KAAK,kBAAQ,CAAC,EAAE,EAAE,4EAA4E;gBAC5F,OAAO,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACrC,KAAK,kBAAQ,CAAC,UAAU,EAAE,8BAA8B;gBACtD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,2BAA2B;YAC9C,KAAK,kBAAQ,CAAC,MAAM,EAAE,kDAAkD;gBACtE,OAAO,gBAAgB,GAAG,IAAA,uBAAW,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAClD,KAAK,kBAAQ,CAAC,IAAI,EAAE,sCAAsC;gBACxD,OAAO,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACrC,KAAK,kBAAQ,CAAC,MAAM,EAAE,6CAA6C;gBACjE,OAAO,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACrC;gBACE,MAAM,IAAI,KAAK,CACb,wCAAwC,IAAI,CAAC,cAAc,sBAAsB,CAClF,CAAC;QACN,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,YAAY;QACvB,MAAM,SAAS,GAAG,0BAAW,CAAC,IAAI,EAAE,CAAC;QACrC,MAAM,aAAa,GAAG,IAAI,+CAAqB,EAAE,CAAC;QAElD,MAAM,oBAAoB,GAAG,SAAS,CAAC,kBAAkB,CAAC;QAC1D,MAAM,uBAAuB,GAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,EAAE,CAAC;QAEnD,MAAM,qBAAqB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC7C,uBAAuB,CAAC,GAAG,CAAC,KAAK,EAAE,sBAAsB,EAAE,EAAE;YAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,2BAA2B,CAClD,sBAAsB,CAAC,IAAI,CAC5B,CAAC;YAEF,MAAM,mBAAmB,GAAG,MAAM,IAAA,0DAAqC,EACrE,WAAW,EACX,sBAAsB,CAAC,OAAO,CAC/B,CAAC;YAEF,OAAO;gBACL,GAAG,mBAAmB;gBACtB,WAAW,EAAE,sBAAsB,CAAC,IAAI;aACzC,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;QAEF,MAAM,WAAW,GAAG,IAAI,qDAAwB,EAAE,CAAC;QAEnD,MAAM,kBAAkB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC1C,oBAAoB,CAAC,GAAG,CAAC,KAAK,EAAE,mBAAmB,EAAE,EAAE;YACrD,MAAM,UAAU,GACd,kBAAkB,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAAC;YAC1D,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,kBAAkB,CACpD,UAAU,CAAC,cAAc,CAC1B,CAAC;YACF,MAAM,eAAe,GAAG,MAAM,WAAW,CAAC,qBAAqB,CAC7D,UAAU,CAAC,cAAc,CAC1B,CAAC;YAEF,OAAO;gBACL,YAAY,EAAE,UAAU,CAAC,cAAc;gBACvC,kBAAkB,EAAE,eAAe,IAAI,UAAU,CAAC,OAAO;gBACzD,eAAe,EAAE,OAAO;aACzB,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;QAEF,OAAO;YACL,KAAK,EAAE,kBAAkB;YACzB,QAAQ,EAAE,qBAAqB;SAChC,CAAC;IACJ,CAAC;CACF;AA9WD,8CA8WC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport {\n  Language,\n  Errors,\n  logger,\n  TerraformDependencyConstraint,\n} from \"@cdktn/commons\";\nimport { toPascalCase, toSnakeCase } from \"codemaker\";\nimport { CdktfConfig } from \"../cdktf-config\";\nimport { CdktfConfigManager } from \"./cdktf-config-manager\";\nimport { PackageManager } from \"./package-manager\";\nimport {\n  getNpmPackageName,\n  getPrebuiltProviderRepositoryName,\n  getPrebuiltProviderVersionInformation,\n  getPrebuiltProviderVersions,\n} from \"./prebuilt-providers\";\nimport { getLatestVersion } from \"./registry-api\";\nimport { versionMatchesConstraint } from \"./version-constraints\";\nimport * as semver from \"semver\";\nimport { LocalProviderVersions } from \"../local-provider-versions\";\nimport { LocalProviderConstraints } from \"../local-provider-constraints\";\n\n// ref: https://www.terraform.io/language/providers/requirements#source-addresses\nexport const DEFAULT_HOSTNAME = \"registry.terraform.io\";\nexport const DEFAULT_NAMESPACE = \"hashicorp\";\nfunction normalizeProviderSource(source: string) {\n  // returns <HOSTNAME>/<NAMESPACE>/<TYPE>\n  const slashes = source.split(\"/\").length - 1;\n  switch (slashes) {\n    case 0:\n      return `${DEFAULT_HOSTNAME}/${DEFAULT_NAMESPACE}/${source}`;\n    case 1:\n      return `${DEFAULT_HOSTNAME}/${source}`;\n    default:\n      return source;\n  }\n}\n\nexport class ProviderConstraint {\n  /**\n   * normalized source of the provider\n   * e.g. \"registry.terraform.io/hashicorp/aws\"\n   */\n  public readonly source: string;\n\n  // TODO: add examples to cli command description (i.e. =,~>.> etc.)\n  // if no version constraint is specified, we assume the latest version\n  // if specific version is specified without e.g. =, we allow patch level increments (e.g. ~>2.12 for \"2.12\")\n  constructor(\n    source: string,\n    public readonly version: string | undefined,\n  ) {\n    this.source = normalizeProviderSource(source);\n  }\n\n  static fromConfigEntry(\n    provider: string | TerraformDependencyConstraint,\n  ): ProviderConstraint {\n    if (typeof provider === \"string\") {\n      const [src, version] = provider.split(\"@\");\n      return new ProviderConstraint(\n        src.trim(),\n        version ? version.trim() : undefined,\n      );\n    }\n\n    const src =\n      (provider.namespace ? `${provider.namespace}/` : \"\") +\n      (provider.source || provider.name);\n\n    return new ProviderConstraint(src, provider.version);\n  }\n\n  public isFromTerraformRegistry(): boolean {\n    return this.hostname === DEFAULT_HOSTNAME;\n  }\n\n  /**\n   * the namespace of the provider\n   * e.g. \"hashicorp\" or \"kreuzwerker\"\n   */\n  public get namespace(): string {\n    return this.source.split(\"/\")[1];\n  }\n\n  /**\n   * the name of the provider\n   * e.g. \"aws\"\n   */\n  public get name(): string {\n    return this.source.split(\"/\")[2];\n  }\n\n  /**\n   * the hostname of the provider\n   * e.g. \"registry.terraform.io\"\n   */\n  public get hostname(): string {\n    return this.source.split(\"/\")[0];\n  }\n\n  /**\n   * returns a simplified provider name, dropping namespace and hostname\n   * if they match the defaults\n   */\n  public get simplifiedName(): string {\n    return this.source\n      .split(\"/\")\n      .filter((part) => part !== DEFAULT_HOSTNAME && part !== DEFAULT_NAMESPACE)\n      .join(\"/\");\n  }\n\n  /**\n   * checks if the version constraint matches the given version\n   * @param version an actual version (e.g. \"4.12.1\")\n   * @returns true if the version is compatible with the constraint\n   */\n  public matchesVersion(version: string): boolean {\n    if (this.version) {\n      return versionMatchesConstraint(version, this.version);\n    }\n    return true;\n  }\n\n  public toString() {\n    return `${this.source}${this.version ? `@${this.version}` : \"\"}`;\n  }\n}\n\n/**\n * manages dependencies of a CDKTN project (e.g. terraform providers)\n */\nexport class DependencyManager {\n  private packageManager: PackageManager;\n\n  constructor(\n    private readonly targetLanguage: Language,\n    private cdktfVersion: string,\n    private readonly projectDirectory: string,\n  ) {\n    this.packageManager = PackageManager.forLanguage(\n      targetLanguage,\n      this.projectDirectory,\n    );\n  }\n\n  async addProvider(\n    constraint: ProviderConstraint,\n  ): Promise<{ addedLocalProvider: boolean }> {\n    if (await this.hasPrebuiltProvider(constraint)) {\n      await this.addPrebuiltProvider(constraint);\n      return { addedLocalProvider: false };\n    } else {\n      await this.addLocalProvider(constraint);\n      return { addedLocalProvider: true };\n    }\n  }\n\n  async upgradeProvider(constraint: ProviderConstraint) {\n    console.log(`Upgrading ${constraint.simplifiedName}...`);\n    const cdktfJson = new CdktfConfigManager();\n    const prebuiltVersion = await this.getCurrentlyInstalledVersion(constraint);\n    if (prebuiltVersion) {\n      await this.upgradePrebuiltProvider(constraint, prebuiltVersion);\n      return { addedLocalProvider: false };\n    }\n    if (await cdktfJson.hasProvider(constraint)) {\n      await cdktfJson.updateProvider(constraint);\n      return { addedLocalProvider: true };\n    }\n\n    throw Errors.Usage(\n      `Trying to upgrade ${constraint.simplifiedName} but it is not installed, please use \"cdktf provider add ${constraint.simplifiedName}\" to add it.`,\n    );\n  }\n\n  async getCurrentlyInstalledVersion(constraint: ProviderConstraint) {\n    logger.info(`Checking if ${constraint.simplifiedName} is installed...`);\n    const packageName = await this.tryGetPackageName(constraint);\n\n    if (!packageName) return; // not available as pre-built provider, so can't be installed as such\n\n    logger.debug(\n      `Expecting package ${packageName} to be installed if provider is installed as pre-built one`,\n    );\n\n    let installedPackages;\n    try {\n      installedPackages = await this.packageManager.listProviderPackages();\n    } catch (e) {\n      throw new Error(`Failed to list packages: ${e}`);\n    }\n\n    logger.debug(\n      `Installed packages found: ${JSON.stringify(installedPackages, null, 2)}`,\n    );\n\n    return installedPackages.find((pkg) => pkg.name === packageName)?.version;\n  }\n\n  async upgradePrebuiltProvider(\n    constraint: ProviderConstraint,\n    currentVersion: string,\n  ) {\n    logger.debug(\n      `Searching for latest matching version of ${constraint.simplifiedName}`,\n    );\n\n    const packageName = await this.getPackageName(constraint);\n    const packageVersion = await this.getMatchingProviderVersion(constraint);\n\n    logger.debug(`Found package ${packageName}@${packageVersion}`);\n    if (packageVersion !== currentVersion) {\n      await this.packageManager.addPackage(packageName, packageVersion);\n    } else {\n      console.log(\n        `The latest version of ${packageName} is already installed: ${packageVersion}`,\n      );\n    }\n  }\n\n  async hasPrebuiltProvider(constraint: ProviderConstraint): Promise<boolean> {\n    logger.debug(\n      `determining whether pre-built provider exists for ${constraint.source} with version constraint ${constraint.version} and cdktf version ${this.cdktfVersion}`,\n    );\n\n    logger.info(`Checking whether pre-built provider exists for the following constraints:\n  provider: ${constraint.simplifiedName}\n  version : ${constraint.version || \"latest\"}\n  language: ${this.targetLanguage}\n  cdktf   : ${this.cdktfVersion}\n`);\n\n    if (\n      this.targetLanguage === Language.GO &&\n      semver.lt(this.cdktfVersion, \"0.12.0\")\n    ) {\n      logger.info(\n        `Before CDKTF 0.12.0 there were no pre-built providers published for Go.`,\n      );\n      return false;\n    }\n\n    const v = await getPrebuiltProviderVersions(constraint, this.cdktfVersion);\n    const exists = v !== null;\n\n    if (exists) {\n      logger.info(`Found pre-built provider.`);\n    } else {\n      logger.info(\n        `Pre-built provider does not exist for the given constraints.`,\n      );\n    }\n\n    return exists;\n  }\n\n  private async tryGetPackageName(\n    constraint: ProviderConstraint,\n  ): Promise<string | undefined> {\n    const npmPackageName = await getNpmPackageName(constraint);\n\n    if (!npmPackageName) return;\n\n    const prebuiltProviderRepository =\n      await getPrebuiltProviderRepositoryName(npmPackageName);\n\n    return this.convertPackageName(npmPackageName, prebuiltProviderRepository);\n  }\n\n  private async getPackageName(\n    constraint: ProviderConstraint,\n  ): Promise<string> {\n    const packageName = await this.tryGetPackageName(constraint);\n    if (!packageName) {\n      throw Errors.Usage(\n        `Could not find pre-built provider for ${constraint.source}`,\n      );\n    }\n    return packageName;\n  }\n\n  async getMatchingProviderVersion(constraint: ProviderConstraint) {\n    const packageName = await this.getPackageName(constraint);\n\n    const prebuiltProviderNpmVersions = await getPrebuiltProviderVersions(\n      constraint,\n      this.cdktfVersion,\n    );\n    if (!prebuiltProviderNpmVersions) {\n      throw Errors.Usage(\n        `No pre-built provider found for ${constraint.source} with version constraint ${constraint.version} and cdktf version ${this.cdktfVersion}`,\n      );\n    }\n\n    const packageVersion = await this.getLanguageSpecificPackageVersion(\n      packageName,\n      prebuiltProviderNpmVersions,\n    );\n\n    if (!packageVersion) {\n      throw Errors.Usage(\n        `No pre-built provider found for ${constraint.source} with version constraint ${constraint.version} and cdktf version ${this.cdktfVersion} for language ${this.targetLanguage}.`,\n      );\n    }\n\n    return packageVersion;\n  }\n\n  async addPrebuiltProvider(constraint: ProviderConstraint, silent = false) {\n    logger.debug(\n      `adding pre-built provider ${constraint.source} with version constraint ${constraint.version} for cdktf version ${this.cdktfVersion}`,\n    );\n\n    const packageName = await this.getPackageName(constraint);\n    const packageVersion = await this.getMatchingProviderVersion(constraint);\n    await this.packageManager.addPackage(packageName, packageVersion, silent);\n\n    // TODO: more debug logs\n  }\n\n  // The version we use for npm might differ from other registries\n  // This happens mostly in cases where a provider update failed to publish to one of the registries\n  // In that case we use the latest version that was published successfully and works with the current cdktf release\n  private async getLanguageSpecificPackageVersion(\n    packageName: string,\n    prebuiltProviderNpmVersions: string[],\n  ) {\n    logger.debug(\n      \"Found possibly matching versions (released on npm): \",\n      prebuiltProviderNpmVersions,\n    );\n    logger.debug(\n      \"Searching through package manager to find latest available version for given language\",\n    );\n\n    for (const version of prebuiltProviderNpmVersions) {\n      try {\n        const isAvailable = await this.packageManager.isNpmVersionAvailable(\n          packageName,\n          version,\n        );\n        if (isAvailable) {\n          return version;\n        }\n      } catch (err) {\n        logger.info(\n          `Could not find version ${version} for package ${packageName}: '${err}'. Skipping...`,\n        );\n      }\n    }\n    return null;\n  }\n\n  async addLocalProvider(constraint: ProviderConstraint) {\n    logger.info(\n      `Adding local provider ${constraint.source} with version constraint ${constraint.version} to cdktf.json`,\n    );\n\n    if (!constraint.version && constraint.isFromTerraformRegistry()) {\n      const v = await getLatestVersion(constraint);\n      if (v) {\n        constraint = new ProviderConstraint(\n          constraint.source,\n          // \"1.3.2\" -> \"~> 1.3\"\n          `~> ${v.split(\".\").slice(0, 2).join(\".\")}`,\n        );\n      } else {\n        throw Errors.Usage(\n          `Could not find a version for the provider '${constraint}' in the public registry. This could be due to a typo, please take a look at https://cdk.tf/registry-providers to find all supported providers.`,\n        );\n      }\n    }\n\n    await new CdktfConfigManager().addProvider(constraint);\n  }\n\n  /**\n   * Converts an NPM package name of a pre-built provider package to the name in the target language\n   */\n  private convertPackageName(name: string, repository: string): string {\n    const providerName = name.replace(\"@cdktf/provider-\", \"\");\n    switch (this.targetLanguage) {\n      case Language.GO: // e.g. github.com/cdktf/cdktf-provider-opentelekomcloud-go/opentelekomcloud\n        if (repository) {\n          return `${repository}-go/${providerName}`;\n        }\n\n        return `github.com/cdktf/cdktf-provider-${providerName}-go/${providerName}`;\n      case Language.TYPESCRIPT: // e.g. @cdktf/provider-random\n        return name; // already the correct name\n      case Language.CSHARP: // e.g. HashiCorp.Cdktf.Providers.Opentelekomcloud\n        return `HashiCorp.Cdktf.Providers.` + toPascalCase(providerName);\n      case Language.JAVA: // e.g. com.hashicorp.opentelekomcloud\n        return `com.hashicorp.cdktf-provider-${providerName}`;\n      case Language.PYTHON: // e.g. cdktf-cdktf-provider-opentelekomcloud\n        return `cdktf-cdktf-provider-${providerName}`;\n      default:\n        throw new Error(\n          `converting package name for language ${this.targetLanguage} not implemented yet`,\n        );\n    }\n  }\n\n  /**\n   * Converts an package name of a pre-built provider package in target language to the name in npm\n   * Inverse of: `convertPackageName`\n   */\n  private convertFromPackageNameToNpm(name: string): string {\n    const npmPackagePrefix = \"@cdktf/provider-\";\n    const regexes = {\n      [Language.GO]:\n        /github.com\\/(?:cdktf|hashicorp)\\/cdktf-provider-(.+)-go\\//i,\n      [Language.TYPESCRIPT]: /(.+)/i,\n      [Language.CSHARP]: /HashiCorp\\.Cdktf\\.Providers\\.(.+)/i,\n      [Language.JAVA]: /com\\.hashicorp\\.cdktf-provider-(.+)/i,\n      [Language.PYTHON]: /cdktf-cdktf-provider-(.+)/i,\n    };\n    const regex = regexes[this.targetLanguage];\n    if (!regex) {\n      throw Errors.Usage(\"Language not supported for pre-built providers\");\n    }\n\n    const match = regex.exec(name);\n    if (!match) {\n      throw new Error(`Package name is not in expected format: ${name}`);\n    }\n\n    switch (this.targetLanguage) {\n      case Language.GO: // e.g. github.com/cdktf/cdktf-provider-opentelekomcloud-go/opentelekomcloud\n        return npmPackagePrefix + match[1];\n      case Language.TYPESCRIPT: // e.g. @cdktf/provider-random\n        return match[1]; // already the correct name\n      case Language.CSHARP: // e.g. HashiCorp.Cdktf.Providers.Opentelekomcloud\n        return npmPackagePrefix + toSnakeCase(match[1]);\n      case Language.JAVA: // e.g. com.hashicorp.opentelekomcloud\n        return npmPackagePrefix + match[1];\n      case Language.PYTHON: // e.g. cdktf-cdktf-provider-opentelekomcloud\n        return npmPackagePrefix + match[1];\n      default:\n        throw new Error(\n          `converting package name for language ${this.targetLanguage} not implemented yet`,\n        );\n    }\n  }\n\n  public async allProviders() {\n    const cdktfJson = CdktfConfig.read();\n    const localVersions = new LocalProviderVersions();\n\n    const localProviderConfigs = cdktfJson.terraformProviders;\n    const prebuiltProviderConfigs =\n      await this.packageManager.listProviderPackages();\n\n    const prebuiltProvidersInfo = await Promise.all(\n      prebuiltProviderConfigs.map(async (prebuiltProviderConfig) => {\n        const packageName = this.convertFromPackageNameToNpm(\n          prebuiltProviderConfig.name,\n        );\n\n        const providerInformation = await getPrebuiltProviderVersionInformation(\n          packageName,\n          prebuiltProviderConfig.version,\n        );\n\n        return {\n          ...providerInformation,\n          packageName: prebuiltProviderConfig.name,\n        };\n      }),\n    );\n\n    const constraints = new LocalProviderConstraints();\n\n    const localProvidersInfo = await Promise.all(\n      localProviderConfigs.map(async (localProviderConfig) => {\n        const constraint =\n          ProviderConstraint.fromConfigEntry(localProviderConfig);\n        const version = await localVersions.versionForProvider(\n          constraint.simplifiedName,\n        );\n        const constraintValue = await constraints.constraintForProvider(\n          constraint.simplifiedName,\n        );\n\n        return {\n          providerName: constraint.simplifiedName,\n          providerConstraint: constraintValue || constraint.version,\n          providerVersion: version,\n        };\n      }),\n    );\n\n    return {\n      local: localProvidersInfo,\n      prebuilt: prebuiltProvidersInfo,\n    };\n  }\n}\n"]}

package/src/lib/dependencies/package-manager.d.ts

@@ -0,0 +1,18 @@
+import { Language } from "@cdktn/commons";
+/**
+ * manages installing, updating, and removing dependencies
+ * in the package system used by the target language of a CDKTN
+ * project
+ */
+export declare abstract class PackageManager {
+    protected readonly workingDirectory: string;
+    constructor(workingDirectory: string);
+    static forLanguage(language: Language, workingDirectory: string): PackageManager;
+    abstract addPackage(packageName: string, packageVersion?: string, silent?: boolean): Promise<void>;
+    abstract isNpmVersionAvailable(packageName: string, packageVersion: string): Promise<boolean>;
+    abstract listProviderPackages(): Promise<{
+        name: string;
+        version: string;
+    }[]>;
+}
+//# sourceMappingURL=package-manager.d.ts.map

package/src/lib/dependencies/package-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manager.d.ts","sourceRoot":"","sources":["package-manager.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAOT,MAAM,gBAAgB,CAAC;AA+ExB;;;;GAIG;AACH,8BAAsB,cAAc;IACtB,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,MAAM;gBAAxB,gBAAgB,EAAE,MAAM;WAEzC,WAAW,CACvB,QAAQ,EAAE,QAAQ,EAClB,gBAAgB,EAAE,MAAM,GACvB,cAAc;aAoBD,UAAU,CACxB,WAAW,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC;aAGA,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;aAEH,oBAAoB,IAAI,OAAO,CAC7C;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CACpC;CACF"}