projen 0.48.0 → 0.49.2

package/lib/gitlab/configuration.js

@@ -0,0 +1,296 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CiConfiguration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const case_1 = require("case");
+const component_1 = require("../component");
+const yaml_1 = require("../yaml");
+/**
+ * (experimental) CI for GitLab.
+ *
+ * A CI is a configurable automated process made up of one or more stages/jobs.
+ *
+ * @see https://docs.gitlab.com/ee/ci/yaml/
+ * @experimental
+ */
+class CiConfiguration extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, name, options) {
+        var _b;
+        super(project);
+        /**
+         * (experimental) Defines default scripts that should run *after* all jobs.
+         *
+         * Can be overriden by the job level `afterScript`.
+         *
+         * @experimental
+         */
+        this.defaultAfterScript = [];
+        /**
+         * (experimental) Defines default scripts that should run *before* all jobs.
+         *
+         * Can be overriden by the job level `afterScript`.
+         *
+         * @experimental
+         */
+        this.defaultBeforeScript = [];
+        /**
+         * A default list of additional Docker images to run scripts in. The service image is linked to the image specified in the  image parameter.
+         */
+        this.defaultServices = [];
+        /**
+         * (experimental) Used to select a specific runner from the list of all runners that are available for the project.
+         *
+         * @experimental
+         */
+        this.defaultTags = [];
+        /**
+         * Can be `Include` or `Include[]`. Each `Include` will be a string, or an
+         * object with properties for the method if including external YAML file. The external
+         * content will be fetched, included and evaluated along the `.gitlab-ci.yml`.
+         */
+        this.include = [];
+        /**
+         * (experimental) Groups jobs into stages.
+         *
+         * All jobs in one stage must complete before next stage is
+         * executed. Defaults to ['build', 'test', 'deploy'].
+         *
+         * @experimental
+         */
+        this.stages = [];
+        /**
+         * (experimental) Global variables that are passed to jobs.
+         *
+         * If the job already has that variable defined, the job-level variable takes precedence.
+         *
+         * @experimental
+         */
+        this.variables = {};
+        /**
+         * (experimental) The jobs in the CI configuration.
+         *
+         * @experimental
+         */
+        this.jobs = {};
+        this.project = project;
+        this.name = path.parse(name).name;
+        this.path =
+            this.name === "gitlab-ci"
+                ? ".gitlab-ci.yml"
+                : `.gitlab/ci-templates/${name.toLocaleLowerCase()}.yml`;
+        this.file = new yaml_1.YamlFile(this.project, this.path, {
+            obj: () => this.renderCI(),
+        });
+        const defaults = options === null || options === void 0 ? void 0 : options.default;
+        if (defaults) {
+            this.defaultAfterScript.push(...((_b = defaults.afterScript) !== null && _b !== void 0 ? _b : []));
+            this.defaultArtifacts = defaults.artifacts;
+            defaults.beforeScript &&
+                this.defaultBeforeScript.push(...defaults.beforeScript);
+            this.defaultCache = defaults.cache;
+            this.defaultImage = defaults.image;
+            this.defaultInterruptible = defaults.interruptible;
+            this.defaultRetry = defaults.retry;
+            defaults.services && this.addServices(...defaults.services);
+            defaults.tags && this.defaultTags.push(...defaults.tags);
+            this.defaultTimeout = defaults.timeout;
+        }
+        this.pages = options === null || options === void 0 ? void 0 : options.pages;
+        this.workflow = options === null || options === void 0 ? void 0 : options.workflow;
+        if (options === null || options === void 0 ? void 0 : options.stages) {
+            this.addStages(...options.stages);
+        }
+        if (options === null || options === void 0 ? void 0 : options.variables) {
+            this.addJobs(options.variables);
+        }
+        if (options === null || options === void 0 ? void 0 : options.jobs) {
+            this.addJobs(options.jobs);
+        }
+    }
+    /**
+     * (experimental) Add additional yml/yaml files to the CI includes.
+     *
+     * @param includes The includes to add.
+     * @experimental
+     */
+    addIncludes(...includes) {
+        for (const additional of includes) {
+            this.assertIsValidInclude(additional);
+            for (const existing of this.include) {
+                if (this.areEqualIncludes(existing, additional)) {
+                    throw new Error(`${this.name}: GitLab CI ${existing} already contains one or more templates specified in ${additional}.`);
+                }
+            }
+            this.include.push(additional);
+        }
+    }
+    /**
+     * Throw an error if the provided Include is invalid.
+     * @see https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/config/external/mapper.rb
+     * @param include the Include to validate.
+     */
+    assertIsValidInclude(include) {
+        const combos = [
+            include.local,
+            include.file && include.project,
+            include.remote,
+            include.template,
+        ];
+        const len = combos.filter((x) => Boolean(x)).length;
+        if (len !== 1) {
+            throw new Error(`${this.name}: GitLab CI include ${include} contains ${len} property combination(s).
+        A valid include configuration specifies *one* of the following property combinations.
+        * local
+        * file, project
+        * remote
+        * template  
+        `);
+        }
+    }
+    /**
+     * Check if the equality of Includes.
+     * @see https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/config/external/mapper.rb
+     * @param x First include to compare.
+     * @param y Second include to compare.
+     * @returns Whether the includes are equal.
+     */
+    areEqualIncludes(x, y) {
+        if (x.local === y.local && x.local !== undefined) {
+            return true;
+        }
+        else if (x.template === y.template && x.template !== undefined) {
+            return true;
+        }
+        else if (x.remote === y.remote && x.remote !== undefined) {
+            return true;
+        }
+        else if (x.project === y.project && x.ref === y.ref) {
+            const xFiles = x.file ? x.file : [];
+            const yFiles = y.file ? y.file : [];
+            const allFiles = xFiles.concat(yFiles);
+            return new Set(allFiles).size !== allFiles.length;
+        }
+        return false;
+    }
+    /**
+     * (experimental) Add additional services.
+     *
+     * @param services The services to add.
+     * @experimental
+     */
+    addServices(...services) {
+        for (const additional of services) {
+            for (const existing of this.defaultServices) {
+                if (additional.name === existing.name &&
+                    additional.alias === existing.alias) {
+                    throw new Error(`${this.name}: GitLab CI already contains service ${additional}.`);
+                }
+            }
+            this.defaultServices.push(additional);
+        }
+    }
+    /**
+     * (experimental) Add a globally defined variable to the CI configuration.
+     *
+     * @param variables The variables to add.
+     * @experimental
+     */
+    addGlobalVariables(variables) {
+        for (const [key, value] of Object.entries(variables)) {
+            if (this.variables[key] !== undefined) {
+                throw new Error(`${this.name}: GitLab CI already contains variable ${key}.`);
+            }
+            this.variables[key] = value;
+        }
+    }
+    /**
+     * (experimental) Add stages to the CI configuration if not already present.
+     *
+     * @param stages stages to add.
+     * @experimental
+     */
+    addStages(...stages) {
+        for (const stage of stages) {
+            if (!this.stages.includes(stage)) {
+                this.stages.push(stage);
+            }
+        }
+    }
+    /**
+     * (experimental) Add jobs and their stages to the CI configuration.
+     *
+     * @param jobs Jobs to add.
+     * @experimental
+     */
+    addJobs(jobs) {
+        for (const [key, value] of Object.entries(jobs)) {
+            if (this.jobs[key] !== undefined) {
+                throw new Error(`${this.name}: GitLab CI already contains job ${key}.`);
+            }
+            this.jobs[key] = value;
+            if (value.stage) {
+                this.addStages(value.stage);
+            }
+        }
+    }
+    renderCI() {
+        return {
+            default: this.renderDefault(),
+            include: this.include.length > 0 ? snakeCaseKeys(this.include) : undefined,
+            pages: snakeCaseKeys(this.pages),
+            services: this.defaultServices.length > 0
+                ? snakeCaseKeys(this.defaultServices)
+                : undefined,
+            variables: Object.entries(this.variables).length > 0 ? this.variables : undefined,
+            workflow: snakeCaseKeys(this.workflow),
+            stages: this.stages.length > 0 ? this.stages : undefined,
+            ...snakeCaseKeys(this.jobs),
+        };
+    }
+    renderDefault() {
+        const defaults = {
+            afterScript: this.defaultAfterScript.length > 0
+                ? this.defaultAfterScript
+                : undefined,
+            artifacts: this.defaultArtifacts,
+            beforeScript: this.defaultBeforeScript.length > 0
+                ? this.defaultBeforeScript
+                : undefined,
+            cache: this.defaultCache,
+            image: this.defaultImage,
+            interruptible: this.defaultInterruptible,
+            retry: this.defaultRetry,
+            services: this.defaultServices.length > 0 ? this.defaultServices : undefined,
+            tags: this.defaultTags.length > 0 ? this.defaultTags : undefined,
+            timeout: this.defaultTimeout,
+        };
+        return Object.values(defaults).filter((x) => x).length
+            ? snakeCaseKeys(defaults)
+            : undefined;
+    }
+}
+exports.CiConfiguration = CiConfiguration;
+_a = JSII_RTTI_SYMBOL_1;
+CiConfiguration[_a] = { fqn: "projen.gitlab.CiConfiguration", version: "0.49.2" };
+function snakeCaseKeys(obj) {
+    if (typeof obj !== "object" || obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(snakeCaseKeys);
+    }
+    const result = {};
+    for (let [k, v] of Object.entries(obj)) {
+        if (typeof v === "object" && v != null) {
+            v = snakeCaseKeys(v);
+        }
+        result[case_1.snake(k)] = v;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../src/gitlab/configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"path\";\nimport { snake } from \"case\";\nimport { Component } from \"../component\";\nimport { Project } from \"../project\";\nimport { YamlFile } from \"../yaml\";\nimport {\n  Artifacts,\n  Cache,\n  Default,\n  Image,\n  Include,\n  Job,\n  Retry,\n  Service,\n  VariableConfig,\n  Workflow,\n} from \"./configuration-model\";\n\n                                         \nexport interface CiConfigurationOptions {\n                                                                                                                                                                    \n  readonly default?: Default;\n                                                                                                                                                     \n  readonly pages?: Job;\n                                                   \n  readonly workflow?: Workflow;\n                                                                                                                                                                                      \n  readonly stages?: string[];\n                                                                                                                                                      \n  readonly variables?: Record<string, any>;\n                                                                    \n  readonly jobs?: Record<string, Job>;\n}\n\n                                                                                                                                                     \nexport class CiConfiguration extends Component {\n                                                          \n  public readonly project: Project;\n                                               \n  public readonly name: string;\n                                                                \n  public readonly path: string;\n                                        \n  public readonly file: YamlFile;\n                                                                                                                           \n  public readonly defaultAfterScript: string[] = [];\n                                                                                                                                                                    \n  public readonly defaultArtifacts?: Artifacts;\n                                                                                                                            \n  public readonly defaultBeforeScript: string[] = [];\n                                                                                                                                          \n  public readonly defaultCache?: Cache;\n                                                                                 \n  public readonly defaultImage?: Image;\n                                                                                                                                                  \n  public readonly defaultInterruptible?: boolean;\n                                                                                                                  \n  public readonly defaultRetry?: Retry;\n  /**\n   * A default list of additional Docker images to run scripts in. The service image is linked to the image specified in the  image parameter.\n   */\n  private defaultServices: Service[] = [];\n                                                                                                                  \n  readonly defaultTags: string[] = [];\n                                                                                                            \n  readonly defaultTimeout?: string;\n  /**\n   * Can be `Include` or `Include[]`. Each `Include` will be a string, or an\n   * object with properties for the method if including external YAML file. The external\n   * content will be fetched, included and evaluated along the `.gitlab-ci.yml`.\n   */\n  private include: Include[] = [];\n                                                                                                                                                     \n  public readonly pages?: Job;\n                                                                                                                                                          \n  public readonly stages: string[] = [];\n                                                                                                                                                      \n  public readonly variables: Record<string, number | VariableConfig | string> =\n    {};\n                                                   \n  public readonly workflow?: Workflow;\n                                                  \n  public readonly jobs: Record<string, Job> = {};\n\n  constructor(\n    project: Project,\n    name: string,\n    options?: CiConfigurationOptions\n  ) {\n    super(project);\n    this.project = project;\n    this.name = path.parse(name).name;\n    this.path =\n      this.name === \"gitlab-ci\"\n        ? \".gitlab-ci.yml\"\n        : `.gitlab/ci-templates/${name.toLocaleLowerCase()}.yml`;\n    this.file = new YamlFile(this.project, this.path, {\n      obj: () => this.renderCI(),\n    });\n    const defaults = options?.default;\n    if (defaults) {\n      this.defaultAfterScript.push(...(defaults.afterScript ?? []));\n      this.defaultArtifacts = defaults.artifacts;\n      defaults.beforeScript &&\n        this.defaultBeforeScript.push(...defaults.beforeScript);\n      this.defaultCache = defaults.cache;\n      this.defaultImage = defaults.image;\n      this.defaultInterruptible = defaults.interruptible;\n      this.defaultRetry = defaults.retry;\n      defaults.services && this.addServices(...defaults.services);\n      defaults.tags && this.defaultTags.push(...defaults.tags);\n      this.defaultTimeout = defaults.timeout;\n    }\n    this.pages = options?.pages;\n    this.workflow = options?.workflow;\n    if (options?.stages) {\n      this.addStages(...options.stages);\n    }\n    if (options?.variables) {\n      this.addJobs(options.variables);\n    }\n    if (options?.jobs) {\n      this.addJobs(options.jobs);\n    }\n  }\n\n                                                                                                           \n  public addIncludes(...includes: Include[]) {\n    for (const additional of includes) {\n      this.assertIsValidInclude(additional);\n      for (const existing of this.include) {\n        if (this.areEqualIncludes(existing, additional)) {\n          throw new Error(\n            `${this.name}: GitLab CI ${existing} already contains one or more templates specified in ${additional}.`\n          );\n        }\n      }\n      this.include.push(additional);\n    }\n  }\n\n  /**\n   * Throw an error if the provided Include is invalid.\n   * @see https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/config/external/mapper.rb\n   * @param include the Include to validate.\n   */\n  private assertIsValidInclude(include: Include) {\n    const combos = [\n      include.local,\n      include.file && include.project,\n      include.remote,\n      include.template,\n    ];\n    const len = combos.filter((x) => Boolean(x)).length;\n    if (len !== 1) {\n      throw new Error(\n        `${this.name}: GitLab CI include ${include} contains ${len} property combination(s).\n        A valid include configuration specifies *one* of the following property combinations.\n        * local\n        * file, project\n        * remote\n        * template  \n        `\n      );\n    }\n  }\n\n  /**\n   * Check if the equality of Includes.\n   * @see https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/config/external/mapper.rb\n   * @param x First include to compare.\n   * @param y Second include to compare.\n   * @returns Whether the includes are equal.\n   */\n  private areEqualIncludes(x: Include, y: Include): boolean {\n    if (x.local === y.local && x.local !== undefined) {\n      return true;\n    } else if (x.template === y.template && x.template !== undefined) {\n      return true;\n    } else if (x.remote === y.remote && x.remote !== undefined) {\n      return true;\n    } else if (x.project === y.project && x.ref === y.ref) {\n      const xFiles = x.file ? x.file : [];\n      const yFiles = y.file ? y.file : [];\n      const allFiles = xFiles.concat(yFiles);\n      return new Set(allFiles).size !== allFiles.length;\n    }\n    return false;\n  }\n\n                                                                                   \n  public addServices(...services: Service[]) {\n    for (const additional of services) {\n      for (const existing of this.defaultServices) {\n        if (\n          additional.name === existing.name &&\n          additional.alias === existing.alias\n        ) {\n          throw new Error(\n            `${this.name}: GitLab CI already contains service ${additional}.`\n          );\n        }\n      }\n      this.defaultServices.push(additional);\n    }\n  }\n\n                                                                                                                     \n  public addGlobalVariables(variables: Record<string, any>) {\n    for (const [key, value] of Object.entries(variables)) {\n      if (this.variables[key] !== undefined) {\n        throw new Error(\n          `${this.name}: GitLab CI already contains variable ${key}.`\n        );\n      }\n      this.variables[key] = value;\n    }\n  }\n\n                                                                                                             \n  public addStages(...stages: string[]) {\n    for (const stage of stages) {\n      if (!this.stages.includes(stage)) {\n        this.stages.push(stage);\n      }\n    }\n  }\n\n                                                                                                 \n  public addJobs(jobs: Record<string, Job>) {\n    for (const [key, value] of Object.entries(jobs)) {\n      if (this.jobs[key] !== undefined) {\n        throw new Error(`${this.name}: GitLab CI already contains job ${key}.`);\n      }\n      this.jobs[key] = value;\n      if (value.stage) {\n        this.addStages(value.stage);\n      }\n    }\n  }\n\n  private renderCI() {\n    return {\n      default: this.renderDefault(),\n      include:\n        this.include.length > 0 ? snakeCaseKeys(this.include) : undefined,\n      pages: snakeCaseKeys(this.pages),\n      services:\n        this.defaultServices.length > 0\n          ? snakeCaseKeys(this.defaultServices)\n          : undefined,\n      variables:\n        Object.entries(this.variables).length > 0 ? this.variables : undefined,\n      workflow: snakeCaseKeys(this.workflow),\n      stages: this.stages.length > 0 ? this.stages : undefined,\n      ...snakeCaseKeys(this.jobs),\n    };\n  }\n\n  private renderDefault() {\n    const defaults: Default = {\n      afterScript:\n        this.defaultAfterScript.length > 0\n          ? this.defaultAfterScript\n          : undefined,\n      artifacts: this.defaultArtifacts,\n      beforeScript:\n        this.defaultBeforeScript.length > 0\n          ? this.defaultBeforeScript\n          : undefined,\n      cache: this.defaultCache,\n      image: this.defaultImage,\n      interruptible: this.defaultInterruptible,\n      retry: this.defaultRetry,\n      services:\n        this.defaultServices.length > 0 ? this.defaultServices : undefined,\n      tags: this.defaultTags.length > 0 ? this.defaultTags : undefined,\n      timeout: this.defaultTimeout,\n    };\n    return Object.values(defaults).filter((x) => x).length\n      ? snakeCaseKeys(defaults)\n      : undefined;\n  }\n}\n\nfunction snakeCaseKeys<T = unknown>(obj: T): T {\n  if (typeof obj !== \"object\" || obj == null) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(snakeCaseKeys) as any;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (let [k, v] of Object.entries(obj)) {\n    if (typeof v === \"object\" && v != null) {\n      v = snakeCaseKeys(v);\n    }\n    result[snake(k)] = v;\n  }\n  return result as any;\n}\n"]}

package/lib/gitlab/gitlab-configuration.d.ts

@@ -0,0 +1,30 @@
+import { CiConfigurationOptions } from ".";
+import { Project } from "../project";
+import { CiConfiguration } from "./configuration";
+import { NestedConfiguration } from "./nested-configuration";
+/**
+ * (experimental) A GitLab CI for the main `.gitlab-ci.yml` file.
+ *
+ * @experimental
+ */
+export declare class GitlabConfiguration extends CiConfiguration {
+    /**
+     * @experimental
+     */
+    readonly nestedTemplates: Record<string, NestedConfiguration>;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, options?: CiConfigurationOptions);
+    /**
+     * (experimental) Creates and adds nested templates to the includes of the main CI.
+     *
+     * Additionally adds their stages to the main CI if they are not already present.
+     * You can futher customize nested templates through the `nestedTemplates` property.
+     * E.g. gitlabConfig.nestedTemplates['templateName']?.addStages('stageName')
+     *
+     * @param config a record the names and configuraitons of the templates.
+     * @experimental
+     */
+    createNestedTemplates(config: Record<string, CiConfigurationOptions>): void;
+}

package/lib/gitlab/gitlab-configuration.js

@@ -0,0 +1,49 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitlabConfiguration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const configuration_1 = require("./configuration");
+const nested_configuration_1 = require("./nested-configuration");
+/**
+ * (experimental) A GitLab CI for the main `.gitlab-ci.yml` file.
+ *
+ * @experimental
+ */
+class GitlabConfiguration extends configuration_1.CiConfiguration {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        super(project, "gitlab-ci", options);
+        /**
+         * @experimental
+         */
+        this.nestedTemplates = {};
+    }
+    /**
+     * (experimental) Creates and adds nested templates to the includes of the main CI.
+     *
+     * Additionally adds their stages to the main CI if they are not already present.
+     * You can futher customize nested templates through the `nestedTemplates` property.
+     * E.g. gitlabConfig.nestedTemplates['templateName']?.addStages('stageName')
+     *
+     * @param config a record the names and configuraitons of the templates.
+     * @experimental
+     */
+    createNestedTemplates(config) {
+        for (const [name, options] of Object.entries(config)) {
+            if (this.nestedTemplates[name] !== undefined) {
+                throw new Error(`${this.name}: GitLab CI already contains template "${name}".`);
+            }
+            const template = new nested_configuration_1.NestedConfiguration(this.project, this, name, options);
+            this.nestedTemplates[template.name] = template;
+            this.addIncludes({ local: template.path });
+            this.addStages(...template.stages);
+        }
+    }
+}
+exports.GitlabConfiguration = GitlabConfiguration;
+_a = JSII_RTTI_SYMBOL_1;
+GitlabConfiguration[_a] = { fqn: "projen.gitlab.GitlabConfiguration", version: "0.49.2" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/gitlab/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./configuration";
+export * from "./configuration-model";
+export * from "./gitlab-configuration";
+export * from "./nested-configuration";

package/lib/gitlab/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./configuration"), exports);
+__exportStar(require("./configuration-model"), exports);
+__exportStar(require("./gitlab-configuration"), exports);
+__exportStar(require("./nested-configuration"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2l0bGFiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLGtEQUFnQztBQUNoQyx3REFBc0M7QUFDdEMseURBQXVDO0FBQ3ZDLHlEQUF1QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbmZpZ3VyYXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbmZpZ3VyYXRpb24tbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2dpdGxhYi1jb25maWd1cmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9uZXN0ZWQtY29uZmlndXJhdGlvblwiO1xuIl19

package/lib/gitlab/nested-configuration.d.ts

@@ -0,0 +1,26 @@
+import { CiConfigurationOptions } from ".";
+import { Project } from "../project";
+import { CiConfiguration } from "./configuration";
+import { GitlabConfiguration } from "./gitlab-configuration";
+/**
+ * (experimental) A GitLab CI for templates that are created and included in the `.gitlab-ci.yml` file.
+ *
+ * @experimental
+ */
+export declare class NestedConfiguration extends CiConfiguration {
+    /**
+     * @experimental
+     */
+    readonly parent: GitlabConfiguration;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, parent: GitlabConfiguration, name: string, options?: CiConfigurationOptions);
+    /**
+     * (experimental) Add stages to the Nested configuration and the main CI file if not already present.
+     *
+     * @param stages stages to add.
+     * @experimental
+     */
+    addStages(...stages: string[]): void;
+}

package/lib/gitlab/nested-configuration.js

@@ -0,0 +1,38 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedConfiguration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const configuration_1 = require("./configuration");
+/**
+ * (experimental) A GitLab CI for templates that are created and included in the `.gitlab-ci.yml` file.
+ *
+ * @experimental
+ */
+class NestedConfiguration extends configuration_1.CiConfiguration {
+    /**
+     * @experimental
+     */
+    constructor(project, parent, name, options) {
+        super(project, name, options);
+        this.parent = parent;
+    }
+    /**
+     * (experimental) Add stages to the Nested configuration and the main CI file if not already present.
+     *
+     * @param stages stages to add.
+     * @experimental
+     */
+    addStages(...stages) {
+        for (const stage of stages) {
+            if (!this.stages.includes(stage)) {
+                this.stages.push(stage);
+            }
+            this.parent.addStages(stage);
+        }
+    }
+}
+exports.NestedConfiguration = NestedConfiguration;
+_a = JSII_RTTI_SYMBOL_1;
+NestedConfiguration[_a] = { fqn: "projen.gitlab.NestedConfiguration", version: "0.49.2" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/gitpod.d.ts

@@ -1,7 +1,7 @@
-import { Component } from './component';
-import { IDevEnvironment, DevEnvironmentOptions, DevEnvironmentDockerImage } from './dev-env';
-import { Project } from './project';
-import { Task } from './task';
+import { Component } from "./component";
+import { IDevEnvironment, DevEnvironmentOptions, DevEnvironmentDockerImage } from "./dev-env";
+import { Project } from "./project";
+import { Task } from "./task";
 /**
  * (experimental) Configure how the terminal should be opened relative to the previous task.
  *