@catladder/cli 1.144.0 → 1.145.0

package/dist/pipeline/src/deploy/types/kubernetes.d.ts

@@ -0,0 +1,355 @@
+import type { AllowUnknownProps, DeployConfigBase } from "./base";
+export type DeployConfigKubernetesClusterGCloud = {
+    type: "gcloud";
+    /**
+     * gcoud name of the cluster
+     */
+    name: string;
+    /**
+     * google cloud project id
+     */
+    projectId: string;
+    /**
+     * region
+     */
+    region: string;
+    /**
+     * domain of the cluster, for canonical domains without custom host (e.g. review and dev apps)
+     */
+    domainCanonical?: string;
+};
+export type DeployConfigKubernetesCluster = DeployConfigKubernetesClusterGCloud;
+export type KubernetesAutoscaleMetricResourceTarget = {
+    type: "Utilization";
+    averageUtilization: number;
+} | {
+    type: "AverageValue";
+    averageValue: number | string;
+};
+export type KubernetesAutoscaleMetric = {
+    type: "Resource";
+    resource: {
+        name: "cpu" | "memory";
+        target: KubernetesAutoscaleMetricResourceTarget;
+    };
+};
+export type KubernetesAutoscale = {
+    minReplicas: number;
+    maxReplicas: number;
+    /**
+     * declare a number of metrics (at least one). Usually you would use cpu as a metric
+     */
+    metrics: KubernetesAutoscaleMetric[];
+};
+export type KubernetesResourcesDef = {
+    limits?: {
+        cpu?: string;
+        memory?: string;
+    };
+    requests?: {
+        cpu?: string;
+        memory?: string;
+    };
+};
+type KubernetesHealthDef = {
+    httpGet?: {
+        path?: string;
+        port?: number;
+        httpHeaders?: {
+            name: string;
+            value: string;
+        }[];
+        failureThreshold?: number;
+        timeoutSeconds?: number;
+        periodSeconds?: number;
+        successThreshold?: number;
+    };
+};
+export type KubernetesUpdateStrategy = {
+    rollingUpdate: {
+        /**
+         * how many pods can be created additionally to the target number
+         * can be absolute number or percentage.
+         * defaults to 1 (kube default is 25%)
+         */
+        maxSurge: number | string;
+        /**
+         * how many pods are allowed to be unavailable
+         * can be absolute number or percentage
+         * defaults to 0 (kube default is 25%)
+         */
+        maxUnavailable: number | string;
+    };
+    type: "RollingUpdate";
+};
+export type KubernetesWorkerDef = {
+    enabled: boolean;
+    /**
+     * which command to run. defaults to `yarn start`
+     */
+    command?: string;
+    resources?: KubernetesResourcesDef;
+    service?: {
+        enabled?: boolean;
+    };
+    /**
+     * if the same livenessProbe as the application should be used, defaults to `true`
+     */
+    livenessProbe?: boolean;
+};
+type KubernetesTolerationExists = {
+    operator: "Exists";
+};
+type KubernetesTolerationEqual = {
+    operator: "Equal";
+    value: string;
+};
+export type KubernetesToleration = {
+    key: string;
+    effect: "NoSchedule" | "PreferNoSchedule" | "NoExecute";
+} & (KubernetesTolerationEqual | KubernetesTolerationExists);
+export type DeployConfigMongodbBase = {
+    enabled?: boolean;
+    dbName?: string;
+    persistence?: {
+        /**
+         * set premium-rwo for ssd
+         */
+        storageClass?: "standard-rwo" | "premium-rwo";
+        /**
+         * size of the volume, defaults to 8Gi
+         */
+        size?: string;
+    };
+    resources?: KubernetesResourcesDef;
+    tolerations?: KubernetesToleration[];
+};
+export type KubernetesRedirect = {
+    /**
+     * the domain to redirect from
+     */
+    host: string;
+    /**
+     * optional path to redirect from, defaults to `/`
+     */
+    path?: string;
+    /**
+     * optional nginx config snippet, defaults to a 301 redirect to the environment host name name with the request path appended
+     *
+     * important: to get a literal `$` use `$$` to prevent variable expansion by gitlab
+     * see https://docs.gitlab.com/ee/ci/variables/#use-the--character-in-cicd-variables
+     */
+    rule?: string;
+};
+export type DeployConfigMongodbStandalone = {
+    architecture: "standalone";
+};
+export type DeployConfigMongodbReplicaset = {
+    architecture: "replicaset";
+    /**
+     * defaults to 2
+     */
+    replicaCount?: number;
+};
+export type DeployConfigMongodb = DeployConfigMongodbBase & (DeployConfigMongodbStandalone | DeployConfigMongodbReplicaset);
+/**
+ * @deprecated use config with instanceConnectionName
+ */
+type DeployConfigKubernetesValuesCloudSQLLegacy = {
+    enabled: boolean;
+    /**
+     * @deprecated use config with instanceConnectionName
+     */
+    instanceId?: string;
+    /**
+     * @deprecated use config with instanceConnectionName
+     */
+    projectId?: string;
+    /**
+     * @deprecated use config with instanceConnectionName
+     */
+    region?: string;
+    /**
+     * @deprecated use type "unmanaged".
+     *
+     * Be aware that "unmanaged" is not fully backward compatible with "legacy".
+     *
+     *
+     */
+    type?: "legacy";
+};
+export type DeployConfigKubernetesValuesCloudSQLUnmanaged = {
+    enabled: boolean;
+    instanceConnectionName: string;
+    /**
+     * the recommended type for the config.
+     *
+     * this mode is similar to cloudrun and declares fully-qualified db names including env.
+     *
+     * This makes it easier to share db instances across envs and dbs
+     */
+    type: "unmanaged";
+    /**
+     * the database username, defaults to "postgres"
+     */
+    dbUser?: string;
+    /**
+     * the prefix of the database, the full db name is this plus the environment slug prefix plus the componentName
+     *
+     * defaults to customerName-appName
+     */
+    dbNamePrefix?: string | false;
+    /**
+     * the base name of the db, defaults to the componentName
+     */
+    dbBaseName?: string;
+};
+export type DeployConfigKubernetesValuesCloudSQL = DeployConfigKubernetesValuesCloudSQLLegacy | DeployConfigKubernetesValuesCloudSQLUnmanaged;
+export type DeployConfigKubernetesValues = AllowUnknownProps<{
+    /**
+     * enable cloudsql db. Currently you have to manually set it up
+     */
+    cloudsql?: DeployConfigKubernetesValuesCloudSQL;
+    /**
+     * enable mongodb. The mongodb is deployed using a helm chart.
+     * See https://github.com/bitnami/charts/tree/master/bitnami/mongodb
+     */
+    mongodb?: DeployConfigMongodb;
+    /**
+     * enable mailhog. Mailhog is a virtual mail server that catches all outgoing mailsl and show them in a mailbox.
+     * This is great for development as it prevents to accidentially send out real emails and helps with debugging outgoing mails.
+     *
+     * It will automaticaly inject a MAIL_URL env var.
+     *
+     * Turn it of for production.
+     */
+    mailhog?: {
+        enabled: boolean;
+    };
+    /**
+     * post-install/upgrade jobs. These use the app image and have all env vars available.
+     * Typically used for migrations and seeds
+     */
+    jobs?: Record<string, false | AllowUnknownProps<{
+        /**
+         * the command to execute
+         */
+        command: string;
+        /**
+         * comma-separated list of helm hooks, see https://helm.sh/docs/topics/charts_hooks/
+         *
+         * defaults to post-install,post-upgrade
+         */
+        hook?: string;
+    }>>;
+    /**
+     * cronjobs that run periodically. These use the app image have all env vars available.
+     */
+    cronjobs?: Record<string, false | AllowUnknownProps<{
+        schedule: string;
+        command: string;
+        concurrencyPolicy?: "Forbid" | "Allow" | "Replace";
+    }>>;
+    /**
+     * configuration for the application ("Deployment" in kubernetes)
+     */
+    application?: false | AllowUnknownProps<{
+        /**
+         * command to start, defaults to build's startCommand
+         */
+        command?: string;
+        /**
+         * enable, disable app deployment, defaults to true
+         */
+        enabled?: boolean;
+        /**
+         * redirects
+         */
+        redirects?: KubernetesRedirect[];
+        /**
+         * Host aliases
+         */
+        hostAliases?: string[];
+        /**
+         * how many pods will be started
+         */
+        replicas?: number;
+        /**
+         * autoscale the pods horizontally
+         */
+        autoscale?: KubernetesAutoscale;
+        /**
+         * the update strategy, see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#rolling-update-deployment
+         */
+        updateStrategy?: KubernetesUpdateStrategy;
+        /**
+         * kubernetes resources
+         */
+        resources?: KubernetesResourcesDef;
+        healthRoute?: string;
+        startupProbe?: KubernetesHealthDef;
+        readinessProbe?: KubernetesHealthDef;
+        livenessProbe?: KubernetesHealthDef;
+        /**
+         * specify a worker. A worker is a separate deployment that runs continously in the background.
+         * The worker pod can use the same entry point as the app or a different one (specify command).
+         * It has the same environment variables as the application and an additional IS_WORKER="true" variable
+         */
+        worker?: KubernetesWorkerDef;
+        /**
+         * kubernetes resources for jobs and cronjobs
+         */
+        jobDefaults?: {
+            resources: KubernetesResourcesDef;
+        };
+    }>;
+    /**
+     * load secrets from other components.
+     * Use this only in cases where the secret is not known on pipeline-time
+     * and only if the component is also in the same cluster.
+     *
+     * a typical case is reusing mongo_url from other component
+     *
+     * also make sure that the other component deploys first
+     *
+     * in all other cases use normal env var handling
+     */
+    secretsFromOtherComponent?: {
+        [envVar: string]: string;
+    };
+    /**
+     * map another services internal endpoint into a env var.
+     */
+    mapServiceUrlToEnv?: {
+        [envVar: string]: string;
+    };
+    /**
+     * Mount secrets as files in the filesystem.
+     * These secrets are still available as env vars, but will contain the path of the file instead
+     *
+     * @deprecated this will be removed in the future, because its very niche and not used
+     */
+    secretsAsFile?: string[];
+}>;
+export type DeployConfigKubernetes = {
+    type: "kubernetes";
+    /**
+     * cluster config to use.
+     */
+    cluster: DeployConfigKubernetesCluster;
+    /**
+     * prints out debug info (helm --debug)
+     */
+    debug?: boolean;
+    additionalHelmArgs?: string[];
+    /**
+     * values to configure the app
+     */
+    values?: DeployConfigKubernetesValues;
+    /**
+     * Custom Helm chart location.
+     * Not recommended to use.
+     */
+    chartName?: string;
+} & DeployConfigBase;
+export {};

package/dist/pipeline/src/deploy/types/kubernetes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=kubernetes.js.map

package/dist/pipeline/src/deploy/types/kubernetes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kubernetes.js","sourceRoot":"","sources":["../../../../../../pipeline/src/deploy/types/kubernetes.ts"],"names":[],"mappings":""}

package/dist/pipeline/src/deploy/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Config, Context } from "../types";
+import type { DeployConfigKubernetesCluster } from "./types";
+export declare const getFullKubernetesClusterName: (cluster: DeployConfigKubernetesCluster) => string;
+export declare const getKubernetesNamespace: (config: Pick<Config, "customerName" | "appName">, env: string) => string;
+export declare const contextIsStoppable: (context: Context) => boolean;

package/dist/pipeline/src/deploy/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextIsStoppable = exports.getKubernetesNamespace = exports.getFullKubernetesClusterName = void 0;
+var types_1 = require("./types");
+var getFullKubernetesClusterName = function (cluster) {
+    if (cluster.type === "gcloud") {
+        return "gke_".concat(cluster.projectId, "_").concat(cluster.region, "_").concat(cluster.name);
+    }
+};
+exports.getFullKubernetesClusterName = getFullKubernetesClusterName;
+var getKubernetesNamespace = function (config, env) {
+    return "".concat(config.customerName, "-").concat(config.appName, "-").concat(env);
+};
+exports.getKubernetesNamespace = getKubernetesNamespace;
+var contextIsStoppable = function (context) {
+    var deployConfig = context.componentConfig.deploy;
+    if ((0, types_1.isOfDeployType)(deployConfig, "kubernetes")) {
+        return true;
+    }
+    if ((0, types_1.isOfDeployType)(deployConfig, "google-cloudrun")) {
+        return true;
+    }
+    if ((0, types_1.isOfDeployType)(deployConfig, "custom") && deployConfig.stopScript) {
+        return true;
+    }
+    return false;
+};
+exports.contextIsStoppable = contextIsStoppable;
+//# sourceMappingURL=utils.js.map

package/dist/pipeline/src/deploy/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../pipeline/src/deploy/utils.ts"],"names":[],"mappings":";;;AAEA,iCAAyC;AAElC,IAAM,4BAA4B,GAAG,UAC1C,OAAsC;IAEtC,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,cAAO,OAAO,CAAC,SAAS,cAAI,OAAO,CAAC,MAAM,cAAI,OAAO,CAAC,IAAI,CAAE,CAAC;IACtE,CAAC;AACH,CAAC,CAAC;AANW,QAAA,4BAA4B,gCAMvC;AAEK,IAAM,sBAAsB,GAAG,UACpC,MAAgD,EAChD,GAAW;IAEX,OAAO,UAAG,MAAM,CAAC,YAAY,cAAI,MAAM,CAAC,OAAO,cAAI,GAAG,CAAE,CAAC;AAC3D,CAAC,CAAC;AALW,QAAA,sBAAsB,0BAKjC;AAEK,IAAM,kBAAkB,GAAG,UAAC,OAAgB;IACjD,IAAM,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC;IACpD,IAAI,IAAA,sBAAc,EAAC,YAAY,EAAE,YAAY,CAAC,EAAE,CAAC;QAC/C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,IAAA,sBAAc,EAAC,YAAY,EAAE,iBAAiB,CAAC,EAAE,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,IAAA,sBAAc,EAAC,YAAY,EAAE,QAAQ,CAAC,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QACtE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAdW,QAAA,kBAAkB,sBAc7B"}

package/dist/pipeline/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./pipeline";
+export * from "./types";
+export * from "./rules";
+export * from "./runner";
+export * from "./config";
+export * from "./context";
+export * from "./build";
+export * from "./deploy";
+export * from "./utils/writeFiles";

package/dist/pipeline/src/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pipeline"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./runner"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./build"), exports);
+__exportStar(require("./deploy"), exports);
+__exportStar(require("./utils/writeFiles"), exports);
+//# sourceMappingURL=index.js.map

package/dist/pipeline/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../pipeline/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,0CAAwB;AACxB,0CAAwB;AACxB,2CAAyB;AACzB,2CAAyB;AACzB,4CAA0B;AAC1B,0CAAwB;AACxB,2CAAyB;AACzB,qDAAmC"}

package/dist/pipeline/src/packageInfos.d.ts

@@ -0,0 +1,2 @@
+declare const ownPkg: any;
+export default ownPkg;

package/dist/pipeline/src/packageInfos.js

@@ -0,0 +1,12 @@
+"use strict";
+// we can't import the package.json directly, because the bundling process will inline it
+// but the version is only set during deployement, when its already bundled
+// instead we need to use require.main.path to get the path of the main module, which is actually the file in the bin
+// this will point to the root package.json
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = ((_a = require.main) === null || _a === void 0 ? void 0 : _a.path) + "/../package.json";
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+var ownPkg = require(path);
+exports.default = ownPkg;
+//# sourceMappingURL=packageInfos.js.map

package/dist/pipeline/src/packageInfos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageInfos.js","sourceRoot":"","sources":["../../../../pipeline/src/packageInfos.ts"],"names":[],"mappings":";AAAA,yFAAyF;AACzF,2EAA2E;AAC3E,qHAAqH;AACrH,2CAA2C;;;AAE3C,IAAM,IAAI,GAAG,CAAA,MAAA,OAAO,CAAC,IAAI,0CAAE,IAAI,IAAG,kBAAkB,CAAC;AACrD,8DAA8D;AAC9D,IAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE7B,kBAAe,MAAM,CAAC"}

package/dist/pipeline/src/pipeline/createAllJobs.d.ts

@@ -0,0 +1,12 @@
+import type { CatladderJobWithContext, Config, PipelineTrigger, PipelineType } from "../types";
+export type AllCatladderJobs = {
+    [componentName: string]: {
+        [env: string]: Array<CatladderJobWithContext>;
+    };
+};
+export type AllJobsContext = {
+    config: Config;
+    trigger: PipelineTrigger;
+    pipelineType: PipelineType;
+};
+export declare const createAllJobs: ({ config, trigger, pipelineType, }: AllJobsContext) => Promise<AllCatladderJobs>;

package/dist/pipeline/src/pipeline/createAllJobs.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAllJobs = void 0;
+var config_1 = require("../config");
+var createJobsForComponent_1 = require("./createJobsForComponent");
+var createAllJobs = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var _c, _d;
+    var config = _b.config, trigger = _b.trigger, pipelineType = _b.pipelineType;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _d = (_c = Object).fromEntries;
+                return [4 /*yield*/, Promise.all(Object.keys(config.components).map(function (componentName) { return __awaiter(void 0, void 0, void 0, function () {
+                        var envs, _a, _b, _c;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    envs = (0, config_1.getAllEnvsByTrigger)(config, componentName, trigger);
+                                    _a = [componentName];
+                                    _c = (_b = Object).fromEntries;
+                                    return [4 /*yield*/, Promise.all(envs.map(function (env) { return __awaiter(void 0, void 0, void 0, function () {
+                                            var _a;
+                                            return __generator(this, function (_b) {
+                                                switch (_b.label) {
+                                                    case 0:
+                                                        _a = [env];
+                                                        return [4 /*yield*/, (0, createJobsForComponent_1.createJobsForComponent)({
+                                                                config: config,
+                                                                componentName: componentName,
+                                                                env: env,
+                                                                trigger: trigger,
+                                                                pipelineType: pipelineType,
+                                                            })];
+                                                    case 1: return [2 /*return*/, _a.concat([
+                                                            _b.sent()
+                                                        ])];
+                                                }
+                                            });
+                                        }); }))];
+                                case 1: return [2 /*return*/, _a.concat([
+                                        _c.apply(_b, [_d.sent()])
+                                    ])];
+                            }
+                        });
+                    }); }))];
+            case 1: return [2 /*return*/, _d.apply(_c, [_e.sent()])];
+        }
+    });
+}); };
+exports.createAllJobs = createAllJobs;
+//# sourceMappingURL=createAllJobs.js.map

package/dist/pipeline/src/pipeline/createAllJobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAllJobs.js","sourceRoot":"","sources":["../../../../../pipeline/src/pipeline/createAllJobs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oCAAgD;AAOhD,mEAAkE;AAc3D,IAAM,aAAa,GAAG,iEAAO,EAInB;;QAHf,MAAM,YAAA,EACN,OAAO,aAAA,EACP,YAAY,kBAAA;;;;gBAEL,KAAA,CAAA,KAAA,MAAM,CAAA,CAAC,WAAW,CAAA;gBACvB,qBAAM,OAAO,CAAC,GAAG,CACf,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,UAAO,aAAa;;;;;oCAC/C,IAAI,GAAG,IAAA,4BAAmB,EAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;0CAE/D,aAAa;oCACb,KAAA,CAAA,KAAA,MAAM,CAAA,CAAC,WAAW,CAAA;oCAChB,qBAAM,OAAO,CAAC,GAAG,CACf,IAAI,CAAC,GAAG,CAAC,UAAO,GAAG;;;;;8DACjB,GAAG;wDAEH,qBAAM,IAAA,+CAAsB,EAAC;gEAC3B,MAAM,QAAA;gEACN,aAAa,eAAA;gEACb,GAAG,KAAA;gEACH,OAAO,SAAA;gEACP,YAAY,cAAA;6DACb,CAAC,EAAA;4DAToB;4DAGtB,SAME;4DACH;;;6CAAA,CAAC,CACH,EAAA;wCAfL;wCAEE,cACE,SAYC,EACF;wCACD;;;yBACH,CAAC,CACH,EAAA;oBAvBH,sBAAO,cACL,SAsBC,EACF,EAAC;;;KACH,CAAC;AA9BW,QAAA,aAAa,iBA8BxB"}

package/dist/pipeline/src/pipeline/createChildPipeline.d.ts

@@ -0,0 +1,3 @@
+import type { Pipeline } from "../types";
+import type { Config, PipelineTrigger } from "../types/config";
+export declare const createChildPipeline: <T extends "gitlab">(pipelineType: T, trigger: PipelineTrigger, config: Config) => Promise<Pipeline<T>>;

package/dist/pipeline/src/pipeline/createChildPipeline.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChildPipeline = void 0;
+var rules_1 = require("../rules");
+var createAllJobs_1 = require("./createAllJobs");
+var getPipelineStages_1 = require("./getPipelineStages");
+var createGitlabJobs_1 = require("./gitlab/createGitlabJobs");
+var createGitlabPipeline_1 = require("./gitlab/createGitlabPipeline");
+var createChildPipeline = function (pipelineType, trigger, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var jobs, stages, gitlabJobs;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, createAllJobs_1.createAllJobs)({
+                    config: config,
+                    trigger: trigger,
+                    pipelineType: pipelineType,
+                })];
+            case 1:
+                jobs = _a.sent();
+                stages = (0, getPipelineStages_1.getPipelineStages)(config);
+                if (!(pipelineType === "gitlab")) return [3 /*break*/, 3];
+                return [4 /*yield*/, (0, createGitlabJobs_1.createGitlabJobs)(jobs)];
+            case 2:
+                gitlabJobs = _a.sent();
+                return [2 /*return*/, (0, createGitlabPipeline_1.createGitlabPipelineWithDefaults)({
+                        workflow: {
+                            rules: rules_1.RULES_ALWAYS,
+                        },
+                        stages: stages,
+                        jobs: Object.fromEntries(gitlabJobs.map(function (_a) {
+                            var gitlabJob = _a.gitlabJob, name = _a.name;
+                            return [name, gitlabJob];
+                        })),
+                    })];
+            case 3: throw new Error("".concat(pipelineType, " is not supported"));
+        }
+    });
+}); };
+exports.createChildPipeline = createChildPipeline;
+//# sourceMappingURL=createChildPipeline.js.map

package/dist/pipeline/src/pipeline/createChildPipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChildPipeline.js","sourceRoot":"","sources":["../../../../../pipeline/src/pipeline/createChildPipeline.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kCAAwC;AAIxC,iDAAgD;AAChD,yDAAwD;AACxD,8DAA6D;AAC7D,sEAAiF;AAE1E,IAAM,mBAAmB,GAAG,UACjC,YAAe,EACf,OAAwB,EACxB,MAAc;;;;oBAED,qBAAM,IAAA,6BAAa,EAAC;oBAC/B,MAAM,QAAA;oBACN,OAAO,SAAA;oBACP,YAAY,cAAA;iBACb,CAAC,EAAA;;gBAJI,IAAI,GAAG,SAIX;gBACI,MAAM,GAAG,IAAA,qCAAiB,EAAC,MAAM,CAAC,CAAC;qBAErC,CAAA,YAAY,KAAK,QAAQ,CAAA,EAAzB,wBAAyB;gBACR,qBAAM,IAAA,mCAAgB,EAAC,IAAI,CAAC,EAAA;;gBAAzC,UAAU,GAAG,SAA4B;gBAC/C,sBAAO,IAAA,uDAAgC,EAAC;wBACtC,QAAQ,EAAE;4BACR,KAAK,EAAE,oBAAY;yBACpB;wBACD,MAAM,QAAA;wBACN,IAAI,EAAE,MAAM,CAAC,WAAW,CACtB,UAAU,CAAC,GAAG,CAAC,UAAC,EAAmB;gCAAjB,SAAS,eAAA,EAAE,IAAI,UAAA;4BAAO,OAAA,CAAC,IAAI,EAAE,SAAS,CAAC;wBAAjB,CAAiB,CAAC,CAC3D;qBACF,CAAgB,EAAC;oBAEpB,MAAM,IAAI,KAAK,CAAC,UAAG,YAAY,sBAAmB,CAAC,CAAC;;;KACrD,CAAC;AAzBW,QAAA,mBAAmB,uBAyB9B"}

package/dist/pipeline/src/pipeline/createJobsForComponent.d.ts

@@ -0,0 +1,3 @@
+import type { CreateContextContext } from "../context";
+import type { CatladderJobWithContext } from "../types/context";
+export declare const createJobsForComponent: (contextContext: Omit<CreateContextContext, "packageManagerInfo">) => Promise<Array<CatladderJobWithContext>>;