@catladder/cli 1.144.1 → 1.146.0

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

@@ -0,0 +1,200 @@
+import type { DeployConfigBase } from "./base";
+export type Gcloudregion = "asia-east1" | "asia-northeast1" | "asia-northeast2" | "europe-north1" | "europe-southwest1" | "europe-west1" | "europe-west4" | "europe-west8" | "europe-west9" | "me-west1" | "us-central1" | "us-east1" | "us-east4" | "us-east5" | "us-south1" | "us-west1" | "asia-east2" | "asia-northeast3" | "asia-southeast1" | "asia-southeast2" | "asia-south1" | "asia-south2" | "australia-southeast1" | "australia-southeast2" | "europe-central2" | "europe-west2" | "europe-west3" | "europe-west6" | "northamerica-northeast1" | "northamerica-northeast2" | "southamerica-east1" | "southamerica-west1" | "us-west2" | "us-west3" | "us-west4";
+export type DeployConfigCloudRunCloudSql = {
+    type: "unmanaged";
+    instanceConnectionName: string;
+    /**
+     * 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;
+    /**
+     * whether to delete the database if the environment is stopped
+     * defaults to true for review envs, to false for every other environment
+     */
+    deleteDatabaseOnStop?: boolean;
+    /**
+     * format of the `DATABASE_URL` environment variable
+     *
+     * the options are:
+     * - prisma: adds [required but ignored hostname](https://www.prisma.io/docs/orm/overview/databases/postgresql#connecting-via-sockets):
+     *   `postgresql://$DB_USER:$DB_PASSWORD@localhost/$DB_NAME?host=/cloudsql/$CLOUD_SQL_INSTANCE_CONNECTION_NAME`
+     * - rails: percent-encodes the socket in the host part
+     *   `postgresql://$DB_USER:$DB_PASSWORD@%2Fcloudsql%2FprojectId%3Aregion%3Ainstancename/$DB_NAME?`
+     * - jdbc: for use with Google Cloud SQL Connector for Java
+     *   `jdbc:postgresql:///$DB_NAME?cloudSqlInstance=$CLOUD_SQL_INSTANCE_CONNECTION_NAME&socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=$DB_USER&password=$DB_PASSWORD`
+     *
+     * defaults to prisma
+     */
+    dbConnectionStringFormat?: "prisma" | "rails" | "jdbc";
+    /**
+     * add additional query params to the database connection string
+     */
+    dbAdditionalQueryParams?: Record<string, string | number> & {
+        /**
+         * set to 0 for prisma in review or dev apps where you reset the db occasionally without restarting any server
+         */
+        statement_cache_size?: number;
+    };
+};
+type Memory = `${number}${"M" | "G" | "Mi" | "Gi"}`;
+type Cpu = 1 | 2 | 4 | 6 | 8;
+export type DeployConfigCloudRunService = {
+    /**
+     * command / entrypoint, fallsback to buildConfig.startcommand
+     */
+    command?: string | string[];
+    /**
+     * how many instances to keep around when there are no requests. defaults to 0.
+     * Set to 1 for workers
+     */
+    minInstances?: number;
+    /**
+     * maximum amount of instances. Defaults to 100
+     */
+    maxInstances?: number;
+    /**
+     * set to true to allways allocate cpu, e.g. for workers. Careful that this is expensive, unless you get really regularly requests!
+     */
+    noCpuThrottling?: true;
+    /**
+     * whether to allow public access without authentification (defaults to true)
+     */
+    allowUnauthenticated?: boolean;
+    /**
+     * whether to expose the service to the internet.
+     *
+     * The options are:
+     * - all: expose to the internet and internal traffic
+     * - internal: only expose to internal traffic
+     * - internal-and-cloud-load-balancing: expose to internal traffic and cloud load balancing
+     *
+     * Defaults to "all"
+     */
+    ingress?: "all" | "internal" | "internal-and-cloud-load-balancing";
+    /**
+     * CPU limit.
+     */
+    cpu?: Cpu;
+    /**
+     * memory limit. Defaults to 512MB
+     */
+    memory?: Memory;
+    /**
+     *
+     * set the execution environment.
+     *
+     * see https://cloud.google.com/run/docs/about-execution-environments
+     *
+     * defaults to gen1 according to gcloud
+     */
+    executionEnvironment?: "gen2" | "gen1";
+} & DeployConfigCloudRunWithVolumes;
+export type DeployConfigCloudRunJobBase = {
+    /**
+     * command
+     */
+    command: string | string[];
+    /**
+     * custom image to use. Defaults to the image from the build
+     */
+    image?: string;
+    /**
+     * CPU limit of the job.
+     */
+    cpu?: Cpu;
+    /**
+     * memory limit of the job, defaults to 512Mi
+     */
+    memory?: `${number}${"M" | "G" | "Mi" | "Gi"}`;
+    /**
+     * timeout of job, defaults to 10 minutes
+     *
+     * you can specify something like 10m30s
+     */
+    timeout?: string;
+    /**
+     * number of tasks that may run concurrently, defaults to 1
+     */
+    parallelism?: number;
+} & DeployConfigCloudRunWithVolumes;
+type Minute = string;
+type Hour = string;
+type DayOfMonth = string;
+type DayOfWeek = string;
+type Month = string;
+export type DeployConfigCloudRunJobWithSchedule = DeployConfigCloudRunJobBase & {
+    when: "schedule";
+    schedule: `${Minute} ${Hour} ${DayOfMonth} ${Month} ${DayOfWeek}`;
+    /**
+     * Max number of retries of the cloud scheduler.
+     * Note: the task itself is never retried.
+     *
+     * defaults to 0 (no retries)
+     */
+    maxRetryAttempts?: 0 | 1 | 2 | 3 | 4 | 5;
+};
+export type DeployConfigCloudRunJobNormal = DeployConfigCloudRunJobBase & {
+    when: "manual" | "preDeploy" | "postDeploy" | "preStop" | "postStop";
+};
+export type DeployConfigCloudRunWithVolumes = {
+    /**
+     * adds volumes to the service. This is an experimental feature and requires beta gcloud.
+     * sets executionEnvironment to gen2 automatically, since that is required
+     */
+    volumes?: DeployConfigCloudRunVolumes;
+};
+export type DeployConfigCloudRunJob = DeployConfigCloudRunJobNormal | DeployConfigCloudRunJobWithSchedule;
+export type DeployConfigCloudRun = {
+    /**
+     * cloud run deployment.
+     *
+     * This will deploy a cloud run service. You can optionally define one-time and scheduled jobs running on cloud run
+     *
+     * Requires that cloud run is enabled on the project, as well as cloud run api and artifacts registry.
+     */
+    type: "google-cloudrun";
+    /**
+     * the google cloud porject id
+     */
+    projectId: string;
+    /**
+     * the region. Set to europe-west6 for switzerland
+     */
+    region: Gcloudregion;
+    /**
+     * whether to enable the service, defaults to true
+     */
+    service?: boolean | DeployConfigCloudRunService;
+    /**
+     * deploy additional services with different entry points.
+     */
+    additionalServices?: {
+        [name: string]: DeployConfigCloudRunService;
+    };
+    jobs?: {
+        [name: string]: DeployConfigCloudRunJob | false | null;
+    };
+    /**
+     * add cloudSql
+     */
+    cloudSql?: DeployConfigCloudRunCloudSql | false;
+    debug?: boolean;
+} & DeployConfigBase;
+export type DeployConfigCloudRunVolumes = Record<string, DeployConfigCloudRunVolume>;
+export type DeployConfigCloudRunVolume = {
+    type: "cloud-storage";
+    bucket: string;
+    mountPath: string;
+    readonly?: boolean;
+};
+export {};

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

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

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

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

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

@@ -0,0 +1,22 @@
+import type { DeployConfigCustom } from "./custom";
+import type { DeployConfigDockerTag } from "./dockerTag";
+import type { DeployConfigCloudRun } from "./googleCloudRun";
+import type { DeployConfigKubernetes } from "./kubernetes";
+export * from "./custom";
+export * from "./googleCloudRun";
+export * from "./kubernetes";
+export * from "./dockerTag";
+export type DeployConfig = DeployConfigKubernetes | DeployConfigCustom | DeployConfigCloudRun | DeployConfigDockerTag;
+export type DeployConfigType = DeployConfig["type"];
+export type DeployConfigGeneric<T extends DeployConfigType> = Extract<DeployConfig, {
+    type: T;
+}>;
+export declare const isOfDeployType: <T extends ("custom" | "kubernetes" | "dockerTag" | "google-cloudrun")[]>(t: DeployConfig | false, ...types: T) => t is Extract<DeployConfigCustom, {
+    type: T[number];
+}> | Extract<DeployConfigDockerTag, {
+    type: T[number];
+}> | Extract<DeployConfigCloudRun, {
+    type: T[number];
+}> | Extract<DeployConfigKubernetes, {
+    type: T[number];
+}>;

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

@@ -0,0 +1,30 @@
+"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 });
+exports.isOfDeployType = void 0;
+__exportStar(require("./custom"), exports);
+__exportStar(require("./googleCloudRun"), exports);
+__exportStar(require("./kubernetes"), exports);
+__exportStar(require("./dockerTag"), exports);
+var isOfDeployType = function (t) {
+    var types = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        types[_i - 1] = arguments[_i];
+    }
+    return t && types.includes(t.type);
+};
+exports.isOfDeployType = isOfDeployType;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../pipeline/src/deploy/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAKA,2CAAyB;AACzB,mDAAiC;AACjC,+CAA6B;AAC7B,8CAA4B;AAcrB,IAAM,cAAc,GAAG,UAC5B,CAAuB;IACvB,eAAW;SAAX,UAAW,EAAX,qBAAW,EAAX,IAAW;QAAX,8BAAW;;IAEX,OAAO,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC,CAAC;AALW,QAAA,cAAc,kBAKzB"}

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";