@alma-cdk/project 0.0.14

package/lib/configurations/accounts.d.ts

@@ -0,0 +1,108 @@
+import { Account } from '../project';
+export declare enum AccountType {
+    MOCK = "mock",
+    SHARED = "shared",
+    DEV = "dev",
+    PREPROD = "preprod",
+    PROD = "prod"
+}
+export interface AccountConfiguration {
+    readonly id: string;
+    readonly config?: Record<string, any>;
+}
+export interface ProjectAccounts {
+    readonly mock?: Account;
+    readonly shared?: Account;
+    readonly dev?: Account;
+    readonly preprod?: Account;
+    readonly prod?: Account;
+}
+export interface AccountsOneProps {
+    readonly [AccountType.MOCK]?: AccountConfiguration;
+    readonly [AccountType.SHARED]: AccountConfiguration;
+}
+export interface AccountsTwoProps {
+    readonly [AccountType.MOCK]?: AccountConfiguration;
+    readonly [AccountType.DEV]: AccountConfiguration;
+    readonly [AccountType.PROD]: AccountConfiguration;
+}
+export interface AccountsThreeProps {
+    readonly [AccountType.MOCK]?: AccountConfiguration;
+    readonly [AccountType.DEV]: AccountConfiguration;
+    readonly [AccountType.PREPROD]: AccountConfiguration;
+    readonly [AccountType.PROD]: AccountConfiguration;
+}
+export declare class Accounts {
+    /**
+     * Enables single account strategy.
+     *
+     * 1. `shared` account with environments:
+     *    - development
+     *    - feature/*
+     *    - test
+     *    - qaN
+     *    - staging
+     *    - preproduction
+     *    - production
+     *
+     * @example
+     * Accounts.ONE({
+     *   shared: {
+     *     id: '111111111111',
+     *   },
+     * }),
+     */
+    static one(props: AccountsOneProps): Record<string, Account>;
+    /**
+     * Enables dual account strategy.
+     *
+     * 1. `dev` account with environments:
+     *    - development
+     *    - feature/*
+     *    - test
+     *    - qaN
+     *    - staging
+     * 2. `prod` account with environments:
+     *    - preproduction
+     *    - production
+     *
+     * @example
+     * Accounts.TWO({
+     *   dev: {
+     *     id: '111111111111',
+     *   },
+     *   prod: {
+     *     id: '222222222222',
+     *   },
+     * }),
+     */
+    static two(props: AccountsTwoProps): Record<string, Account>;
+    /**
+     * Enables triple account strategy.
+     *
+     * 1. `dev` account with environments:
+     *    - development
+     *    - feature/*
+     *    - test
+     *    - staging
+     * 2. `preprod` account with environments:
+     *    - qaN
+     *    - preproduction
+     * 3. `prod` account with environments:
+     *    - production
+     *
+     * @example
+     * Accounts.THREE({
+     *   dev: {
+     *     id: '111111111111',
+     *   },
+     *   preprod: {
+     *     id: '222222222222',
+     *   },
+     *   prod: {
+     *     id: '333333333333',
+     *   },
+     * }),
+     */
+    static three(props: AccountsThreeProps): Record<string, Account>;
+}

package/lib/configurations/accounts.js

@@ -0,0 +1,176 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accounts = exports.AccountType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const environments_1 = require("./environments");
+var AccountType;
+(function (AccountType) {
+    AccountType["MOCK"] = "mock";
+    AccountType["SHARED"] = "shared";
+    AccountType["DEV"] = "dev";
+    AccountType["PREPROD"] = "preprod";
+    AccountType["PROD"] = "prod";
+})(AccountType = exports.AccountType || (exports.AccountType = {}));
+const emptyMockAccountProps = {
+    id: '123456789012',
+};
+class Accounts {
+    /**
+     * Enables single account strategy.
+     *
+     * 1. `shared` account with environments:
+     *    - development
+     *    - feature/*
+     *    - test
+     *    - qaN
+     *    - staging
+     *    - preproduction
+     *    - production
+     *
+     * @example
+     * Accounts.ONE({
+     *   shared: {
+     *     id: '111111111111',
+     *   },
+     * }),
+     */
+    static one(props) {
+        const mockProps = props[AccountType.MOCK];
+        return {
+            [AccountType.MOCK]: {
+                ...(mockProps ? mockProps : emptyMockAccountProps),
+                environments: [
+                    environments_1.EnvironmentLabel.MOCK,
+                ],
+            },
+            [AccountType.SHARED]: {
+                ...props[AccountType.SHARED],
+                environments: [
+                    environments_1.EnvironmentLabel.DEVELOPMENT,
+                    environments_1.EnvironmentLabel.FEATURE,
+                    environments_1.EnvironmentLabel.TEST,
+                    environments_1.EnvironmentLabel.QA,
+                    environments_1.EnvironmentLabel.STAGING,
+                    environments_1.EnvironmentLabel.PREPRODUCTION,
+                    environments_1.EnvironmentLabel.PRODUCTION,
+                ],
+            },
+        };
+    }
+    /**
+     * Enables dual account strategy.
+     *
+     * 1. `dev` account with environments:
+     *    - development
+     *    - feature/*
+     *    - test
+     *    - qaN
+     *    - staging
+     * 2. `prod` account with environments:
+     *    - preproduction
+     *    - production
+     *
+     * @example
+     * Accounts.TWO({
+     *   dev: {
+     *     id: '111111111111',
+     *   },
+     *   prod: {
+     *     id: '222222222222',
+     *   },
+     * }),
+     */
+    static two(props) {
+        const mockProps = props[AccountType.MOCK];
+        return {
+            [AccountType.MOCK]: {
+                ...(mockProps ? mockProps : emptyMockAccountProps),
+                environments: [
+                    environments_1.EnvironmentLabel.MOCK,
+                ],
+            },
+            [AccountType.DEV]: {
+                ...props[AccountType.DEV],
+                environments: [
+                    environments_1.EnvironmentLabel.DEVELOPMENT,
+                    environments_1.EnvironmentLabel.FEATURE,
+                    environments_1.EnvironmentLabel.TEST,
+                    environments_1.EnvironmentLabel.QA,
+                    environments_1.EnvironmentLabel.STAGING,
+                ],
+            },
+            [AccountType.PROD]: {
+                ...props[AccountType.PROD],
+                environments: [
+                    environments_1.EnvironmentLabel.PREPRODUCTION,
+                    environments_1.EnvironmentLabel.PRODUCTION,
+                ],
+            },
+        };
+    }
+    /**
+     * Enables triple account strategy.
+     *
+     * 1. `dev` account with environments:
+     *    - development
+     *    - feature/*
+     *    - test
+     *    - staging
+     * 2. `preprod` account with environments:
+     *    - qaN
+     *    - preproduction
+     * 3. `prod` account with environments:
+     *    - production
+     *
+     * @example
+     * Accounts.THREE({
+     *   dev: {
+     *     id: '111111111111',
+     *   },
+     *   preprod: {
+     *     id: '222222222222',
+     *   },
+     *   prod: {
+     *     id: '333333333333',
+     *   },
+     * }),
+     */
+    static three(props) {
+        const mockProps = props[AccountType.MOCK];
+        return {
+            [AccountType.MOCK]: {
+                ...(mockProps ? mockProps : emptyMockAccountProps),
+                environments: [
+                    environments_1.EnvironmentLabel.MOCK,
+                ],
+            },
+            [AccountType.DEV]: {
+                ...props[AccountType.DEV],
+                environments: [
+                    environments_1.EnvironmentLabel.DEVELOPMENT,
+                    environments_1.EnvironmentLabel.FEATURE,
+                    environments_1.EnvironmentLabel.TEST,
+                    environments_1.EnvironmentLabel.STAGING,
+                ],
+            },
+            [AccountType.PREPROD]: {
+                ...props[AccountType.PREPROD],
+                environments: [
+                    environments_1.EnvironmentLabel.QA,
+                    environments_1.EnvironmentLabel.PREPRODUCTION,
+                ],
+            },
+            [AccountType.PROD]: {
+                ...props[AccountType.PROD],
+                environments: [
+                    environments_1.EnvironmentLabel.PRODUCTION,
+                ],
+            },
+        };
+    }
+}
+exports.Accounts = Accounts;
+_a = JSII_RTTI_SYMBOL_1;
+Accounts[_a] = { fqn: "@alma-cdk/project.Accounts", version: "0.0.14" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accounts.js","sourceRoot":"","sources":["../../src/configurations/accounts.ts"],"names":[],"mappings":"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","sourcesContent":["import { Account } from '../project';\nimport { EnvironmentLabel } from './environments';\n\nexport enum AccountType {\n  MOCK='mock',\n  SHARED='shared',\n  DEV='dev',\n  PREPROD='preprod',\n  PROD='prod',\n}\n\nexport interface AccountConfiguration {\n  readonly id: string;\n  readonly config?: Record<string, any>;\n}\n\nexport interface ProjectAccounts {\n  readonly mock?: Account;\n  readonly shared?: Account;\n  readonly dev?: Account;\n  readonly preprod?: Account;\n  readonly prod?: Account;\n}\n\nexport interface AccountsOneProps {\n  readonly [AccountType.MOCK]?: AccountConfiguration;\n  readonly [AccountType.SHARED]: AccountConfiguration;\n}\n\nexport interface AccountsTwoProps {\n  readonly [AccountType.MOCK]?: AccountConfiguration;\n  readonly [AccountType.DEV]: AccountConfiguration;\n  readonly [AccountType.PROD]: AccountConfiguration;\n}\n\nexport interface AccountsThreeProps {\n  readonly [AccountType.MOCK]?: AccountConfiguration;\n  readonly [AccountType.DEV]: AccountConfiguration;\n  readonly [AccountType.PREPROD]: AccountConfiguration;\n  readonly [AccountType.PROD]: AccountConfiguration;\n}\n\nconst emptyMockAccountProps: AccountConfiguration = {\n  id: '123456789012',\n};\n\n\nexport class Accounts {\n\n  /**\n   * Enables single account strategy.\n   *\n   * 1. `shared` account with environments:\n   *    - development\n   *    - feature/*\n   *    - test\n   *    - qaN\n   *    - staging\n   *    - preproduction\n   *    - production\n   *\n   * @example\n   * Accounts.ONE({\n   *   shared: {\n   *     id: '111111111111',\n   *   },\n   * }),\n   */\n  public static one(props: AccountsOneProps): Record<string, Account> {\n    const mockProps = props[AccountType.MOCK];\n    return {\n      [AccountType.MOCK]: {\n        ...(mockProps ? mockProps : emptyMockAccountProps),\n        environments: [\n          EnvironmentLabel.MOCK,\n        ],\n      },\n      [AccountType.SHARED]: {\n        ...props[AccountType.SHARED],\n        environments: [\n          EnvironmentLabel.DEVELOPMENT,\n          EnvironmentLabel.FEATURE,\n          EnvironmentLabel.TEST,\n          EnvironmentLabel.QA,\n          EnvironmentLabel.STAGING,\n          EnvironmentLabel.PREPRODUCTION,\n          EnvironmentLabel.PRODUCTION,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Enables dual account strategy.\n   *\n   * 1. `dev` account with environments:\n   *    - development\n   *    - feature/*\n   *    - test\n   *    - qaN\n   *    - staging\n   * 2. `prod` account with environments:\n   *    - preproduction\n   *    - production\n   *\n   * @example\n   * Accounts.TWO({\n   *   dev: {\n   *     id: '111111111111',\n   *   },\n   *   prod: {\n   *     id: '222222222222',\n   *   },\n   * }),\n   */\n  public static two(props: AccountsTwoProps): Record<string, Account> {\n    const mockProps = props[AccountType.MOCK];\n    return {\n      [AccountType.MOCK]: {\n        ...(mockProps ? mockProps : emptyMockAccountProps),\n        environments: [\n          EnvironmentLabel.MOCK,\n        ],\n      },\n      [AccountType.DEV]: {\n        ...props[AccountType.DEV],\n        environments: [\n          EnvironmentLabel.DEVELOPMENT,\n          EnvironmentLabel.FEATURE,\n          EnvironmentLabel.TEST,\n          EnvironmentLabel.QA,\n          EnvironmentLabel.STAGING,\n        ],\n      },\n      [AccountType.PROD]: {\n        ...props[AccountType.PROD],\n        environments: [\n          EnvironmentLabel.PREPRODUCTION,\n          EnvironmentLabel.PRODUCTION,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Enables triple account strategy.\n   *\n   * 1. `dev` account with environments:\n   *    - development\n   *    - feature/*\n   *    - test\n   *    - staging\n   * 2. `preprod` account with environments:\n   *    - qaN\n   *    - preproduction\n   * 3. `prod` account with environments:\n   *    - production\n   *\n   * @example\n   * Accounts.THREE({\n   *   dev: {\n   *     id: '111111111111',\n   *   },\n   *   preprod: {\n   *     id: '222222222222',\n   *   },\n   *   prod: {\n   *     id: '333333333333',\n   *   },\n   * }),\n   */\n  public static three(props: AccountsThreeProps): Record<string, Account> {\n    const mockProps = props[AccountType.MOCK];\n    return {\n      [AccountType.MOCK]: {\n        ...(mockProps ? mockProps : emptyMockAccountProps),\n        environments: [\n          EnvironmentLabel.MOCK,\n        ],\n      },\n      [AccountType.DEV]: {\n        ...props[AccountType.DEV],\n        environments: [\n          EnvironmentLabel.DEVELOPMENT,\n          EnvironmentLabel.FEATURE,\n          EnvironmentLabel.TEST,\n          EnvironmentLabel.STAGING,\n        ],\n      },\n\n      [AccountType.PREPROD]: {\n        ...props[AccountType.PREPROD],\n        environments: [\n          EnvironmentLabel.QA,\n          EnvironmentLabel.PREPRODUCTION,\n        ],\n      },\n\n      [AccountType.PROD]: {\n        ...props[AccountType.PROD],\n        environments: [\n          EnvironmentLabel.PRODUCTION,\n        ],\n      },\n    };\n  }\n\n}\n"]}

package/lib/configurations/environments.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Availalbe Enviroment Categories.
+ *
+ * Categories are useful grouping to make distinction between `stable`
+ * environments (`staging` & `production`) from `feature` or `verification`
+ * environments (such as `test` or `preproduction`).
+ */
+export declare enum EnvironmentCategory {
+    MOCK = "mock",
+    DEVELOPMENT = "development",
+    FEATURE = "feature",
+    VERIFICATION = "verification",
+    STABLE = "stable"
+}
+/**
+ * Available Environment Labels.
+ *
+ * Labels are useful since Environment Name can be complex,
+ * such as `feature/foo-bar` or `qa3`,
+ * but we need to be able to “label” all `feature/*` and `qaN` environments
+ * as either `feature` or `qa`.
+ */
+export declare enum EnvironmentLabel {
+    MOCK = "mock[0-9]",
+    DEVELOPMENT = "development",
+    FEATURE = "feature/[/a-zA-z0-9-]+",
+    TEST = "test",
+    STAGING = "staging",
+    QA = "qa[0-9]",
+    PREPRODUCTION = "preproduction",
+    PRODUCTION = "production"
+}
+/**
+ * Map Environment Type to Environment Category.
+ * I.e. `staging` and `production` are considered being `stable` environments.
+ */
+export declare const labelToCategory: Record<EnvironmentLabel, EnvironmentCategory>;
+/**
+ * TODO document
+ */
+export declare function getLabelByName(name: string): EnvironmentLabel;
+/**
+ * TODO document
+ */
+export declare function getCategoryByLabel(label: EnvironmentLabel): EnvironmentCategory;

package/lib/configurations/environments.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCategoryByLabel = exports.getLabelByName = exports.labelToCategory = exports.EnvironmentLabel = exports.EnvironmentCategory = void 0;
+class EnvRegExp {
+    constructor(base) {
+        this.regexp = new RegExp(`^${base}$`, 'i');
+    }
+    test(value) {
+        return this.regexp.test(value);
+    }
+}
+/**
+ * Availalbe Enviroment Categories.
+ *
+ * Categories are useful grouping to make distinction between `stable`
+ * environments (`staging` & `production`) from `feature` or `verification`
+ * environments (such as `test` or `preproduction`).
+ */
+var EnvironmentCategory;
+(function (EnvironmentCategory) {
+    EnvironmentCategory["MOCK"] = "mock";
+    EnvironmentCategory["DEVELOPMENT"] = "development";
+    EnvironmentCategory["FEATURE"] = "feature";
+    EnvironmentCategory["VERIFICATION"] = "verification";
+    EnvironmentCategory["STABLE"] = "stable";
+})(EnvironmentCategory = exports.EnvironmentCategory || (exports.EnvironmentCategory = {}));
+/**
+ * Available Environment Labels.
+ *
+ * Labels are useful since Environment Name can be complex,
+ * such as `feature/foo-bar` or `qa3`,
+ * but we need to be able to “label” all `feature/*` and `qaN` environments
+ * as either `feature` or `qa`.
+ */
+var EnvironmentLabel;
+(function (EnvironmentLabel) {
+    EnvironmentLabel["MOCK"] = "mock[0-9]";
+    EnvironmentLabel["DEVELOPMENT"] = "development";
+    EnvironmentLabel["FEATURE"] = "feature/[/a-zA-z0-9-]+";
+    EnvironmentLabel["TEST"] = "test";
+    EnvironmentLabel["STAGING"] = "staging";
+    EnvironmentLabel["QA"] = "qa[0-9]";
+    EnvironmentLabel["PREPRODUCTION"] = "preproduction";
+    EnvironmentLabel["PRODUCTION"] = "production";
+})(EnvironmentLabel = exports.EnvironmentLabel || (exports.EnvironmentLabel = {}));
+/**
+ * Map Environment Type to Environment Category.
+ * I.e. `staging` and `production` are considered being `stable` environments.
+ */
+exports.labelToCategory = {
+    [EnvironmentLabel.MOCK]: EnvironmentCategory.MOCK,
+    [EnvironmentLabel.DEVELOPMENT]: EnvironmentCategory.DEVELOPMENT,
+    [EnvironmentLabel.FEATURE]: EnvironmentCategory.FEATURE,
+    [EnvironmentLabel.TEST]: EnvironmentCategory.VERIFICATION,
+    [EnvironmentLabel.STAGING]: EnvironmentCategory.STABLE,
+    [EnvironmentLabel.QA]: EnvironmentCategory.VERIFICATION,
+    [EnvironmentLabel.PREPRODUCTION]: EnvironmentCategory.VERIFICATION,
+    [EnvironmentLabel.PRODUCTION]: EnvironmentCategory.STABLE,
+};
+const ENV_REGEXP_MOCK = new EnvRegExp(EnvironmentLabel.MOCK);
+const ENV_REGEXP_FEATURE = new EnvRegExp(EnvironmentLabel.FEATURE);
+const ENV_REGEXP_QA = new EnvRegExp(EnvironmentLabel.QA);
+/**
+ * TODO document
+ */
+function getLabelByName(name) {
+    if (ENV_REGEXP_MOCK.test(name))
+        return EnvironmentLabel.MOCK;
+    if (ENV_REGEXP_FEATURE.test(name))
+        return EnvironmentLabel.FEATURE;
+    if (ENV_REGEXP_QA.test(name))
+        return EnvironmentLabel.QA;
+    return name;
+}
+exports.getLabelByName = getLabelByName;
+/**
+ * TODO document
+ */
+function getCategoryByLabel(label) {
+    return exports.labelToCategory[label];
+}
+exports.getCategoryByLabel = getCategoryByLabel;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/configurations/index.d.ts

@@ -0,0 +1,2 @@
+export { Accounts, AccountConfiguration, AccountsOneProps, AccountsTwoProps, AccountsThreeProps, } from './accounts';
+export { EnvironmentCategory, EnvironmentLabel, } from './environments';

package/lib/configurations/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var accounts_1 = require("./accounts");
+Object.defineProperty(exports, "Accounts", { enumerable: true, get: function () { return accounts_1.Accounts; } });
+var environments_1 = require("./environments");
+Object.defineProperty(exports, "EnvironmentCategory", { enumerable: true, get: function () { return environments_1.EnvironmentCategory; } });
+Object.defineProperty(exports, "EnvironmentLabel", { enumerable: true, get: function () { return environments_1.EnvironmentLabel; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlndXJhdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx1Q0FNb0I7QUFMbEIsb0dBQUEsUUFBUSxPQUFBO0FBT1YsK0NBR3dCO0FBRnRCLG1IQUFBLG1CQUFtQixPQUFBO0FBQ25CLGdIQUFBLGdCQUFnQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgQWNjb3VudHMsXG4gIEFjY291bnRDb25maWd1cmF0aW9uLFxuICBBY2NvdW50c09uZVByb3BzLFxuICBBY2NvdW50c1R3b1Byb3BzLFxuICBBY2NvdW50c1RocmVlUHJvcHMsXG59IGZyb20gJy4vYWNjb3VudHMnO1xuXG5leHBvcnQge1xuICBFbnZpcm9ubWVudENhdGVnb3J5LFxuICBFbnZpcm9ubWVudExhYmVsLFxufSBmcm9tICcuL2Vudmlyb25tZW50cyc7XG4iXX0=

package/lib/context/account.d.ts

@@ -0,0 +1,12 @@
+import { Construct } from 'constructs';
+export declare class AccountContext {
+    static getAccountId(scope: Construct): string;
+    static getAccountConfig(scope: Construct, key: string): any;
+    static getAccountType(scope: Construct): string;
+    static isMock(scope: Construct): boolean;
+    static isShared(scope: Construct): boolean;
+    static isDev(scope: Construct): boolean;
+    static isPreProd(scope: Construct): boolean;
+    static isProd(scope: Construct): boolean;
+    private static isAccountTypeMatch;
+}

package/lib/context/account.js

@@ -0,0 +1,41 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountContext = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const accounts_1 = require("../configurations/accounts");
+const project_1 = require("../project");
+class AccountContext {
+    static getAccountId(scope) {
+        return project_1.ProjectContext.getAccountId(scope);
+    }
+    static getAccountConfig(scope, key) {
+        return project_1.ProjectContext.getAccountConfig(scope, key);
+    }
+    static getAccountType(scope) {
+        return project_1.ProjectContext.getAccountType(scope);
+    }
+    static isMock(scope) {
+        return AccountContext.isAccountTypeMatch(scope, accounts_1.AccountType.MOCK);
+    }
+    static isShared(scope) {
+        return AccountContext.isAccountTypeMatch(scope, accounts_1.AccountType.SHARED);
+    }
+    static isDev(scope) {
+        return AccountContext.isAccountTypeMatch(scope, accounts_1.AccountType.DEV);
+    }
+    static isPreProd(scope) {
+        return AccountContext.isAccountTypeMatch(scope, accounts_1.AccountType.PREPROD);
+    }
+    static isProd(scope) {
+        return AccountContext.isAccountTypeMatch(scope, accounts_1.AccountType.PROD);
+    }
+    static isAccountTypeMatch(scope, matchType) {
+        const type = AccountContext.getAccountType(scope);
+        return type === matchType;
+    }
+}
+exports.AccountContext = AccountContext;
+_a = JSII_RTTI_SYMBOL_1;
+AccountContext[_a] = { fqn: "@alma-cdk/project.AccountContext", version: "0.0.14" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context/environment.d.ts

@@ -0,0 +1,144 @@
+import { Construct } from 'constructs';
+import { EnvironmentLabel, EnvironmentCategory } from '../configurations/environments';
+export declare class EnvironmentContext {
+    /**
+     * Get Environment Name
+     *
+     * @example
+     * 'mock1'
+     * 'mock2'
+     * 'mock3'
+     * 'development'
+     * 'feature/foo-bar'
+     * 'feature/ABC-123/new-stuff'
+     * 'test'
+     * 'staging'
+     * 'qa1'
+     * 'qa2'
+     * 'qa3'
+     * 'preproduction'
+     * 'production'
+     *
+     * @param scope Construct
+     * @returns Environment Name (as given via `--context environment`)
+     */
+    static getName(scope: Construct): string;
+    /**
+     * Get Environment URL/DNS Compatible Name
+     *
+     * @example
+     * 'mock1'
+     * 'mock2'
+     * 'mock3'
+     * 'development'
+     * 'feature-foo-bar'
+     * 'feature-abc-123-new-stuff'
+     * 'test'
+     * 'staging'
+     * 'qa1'
+     * 'qa2'
+     * 'qa3'
+     * 'preproduction'
+     * 'production'
+     *
+     * @param scope Construct
+     * @returns Environment URL/DNS Compatible Name (as given via `--context environment` but `param-cased`)
+     */
+    static getUrlName(scope: Construct): string;
+    /**
+     * Get Environment Label
+     *
+     * Labels are useful since Environment Name can be complex,
+     * such as `feature/foo-bar` or `qa3`,
+     * but we need to be able to “label” all `feature/*` and `qaN` environments
+     * as either `feature` or `qa`.
+     *
+     * @example
+     * 'mock'
+     * 'development'
+     * 'feature'
+     * 'test'
+     * 'staging'
+     * 'qa'
+     * 'preproduction'
+     * 'production'
+     *
+     * @param scope Construct
+     * @returns Environment Label
+     */
+    static getLabel(scope: Construct): EnvironmentLabel;
+    /**
+     * Get Environment Category
+     *
+     * Categories are useful grouping to make distinction between `stable`
+     * environments (`staging` & `production`) from `feature` or `verification`
+     * environments (such as `test` or `preproduction`).
+     *
+     * @example
+     * 'mock'
+     * 'development'
+     * 'feature'
+     * 'verification'
+     * 'stable'
+     *
+     * @param scope Construct
+     * @returns Environment Category
+     */
+    static getCategory(scope: Construct): EnvironmentCategory;
+    /**
+     * Check if Environment is part of `mock` category.
+     *
+     * @param scope Construct
+     * @returns boolean indicating does Environment belong to `mock` category
+     */
+    static isMock(scope: Construct): boolean;
+    /**
+     * Check if Environment is part of `development` category.
+     *
+     * Returns true for `development`, otherwise `false`.
+     *
+     * @param scope Construct
+     * @returns boolean indicating does Environment belong to `development` category
+     */
+    static isDevelopment(scope: Construct): boolean;
+    /**
+     * Check if Environment is part of `feature` category.
+     *
+     * Returns `true` for environments with name beginning with `feature/`-prefix, otherwise `false`.
+     *
+     * @param scope Construct
+     * @returns boolean indicating does Environment belong to `feature` category
+     */
+    static isFeature(scope: Construct): boolean;
+    /**
+     * Check if Environment is part of `verification` category.
+     *
+     * Returns `true` for `test` & `preproduction`, otherwise `false`.
+     *
+     * @param scope Construct
+     * @returns boolean indicating does Environment belong to `verification` category
+     */
+    static isVerification(scope: Construct): boolean;
+    /**
+     * Check if Environment is part of `stable` category.
+     *
+     * Returns `true` for `staging` & `production`, otherwise `false`.
+     *
+     * @param scope Construct
+     * @returns boolean indicating does Environment belong to `stable` category
+     */
+    static isStable(scope: Construct): boolean;
+    /**
+     * Get Feature Info
+     *
+     * If environment belongs to `feature` category,
+     * this will return a string describing the feature (sting after `feature/`-prefix).
+     *
+     * If environment is not a feature environment, will return an empty string.
+     *
+     * @param scope Construct
+     * @returns string indicating the feature this environment relates to, if not feature environment returns an empty string
+     */
+    static getFeatureInfo(scope: Construct): string;
+    private static isEnvironmentCategoryMatch;
+}