projen 0.70.2 → 0.70.4

package/lib/.types-compat/ts3.9/lib/dependencies.d.ts

@@ -0,0 +1,160 @@
+import { Component } from "./component";
+import { Project } from "./project";
+/**
+ * The `Dependencies` component is responsible to track the list of dependencies
+ * a project has, and then used by project types as the model for rendering
+ * project-specific dependency manifests such as the dependencies section
+ * `package.json` files.
+ *
+ * To add a dependency you can use a project-type specific API such as
+ * `nodeProject.addDeps()` or use the generic API of `project.deps`:
+ */
+export declare class Dependencies extends Component {
+    /**
+     * The project-relative path of the deps manifest file.
+     */
+    static readonly MANIFEST_FILE: string;
+    /**
+     * Returns the coordinates of a dependency spec.
+     *
+     * Given `foo@^3.4.0` returns `{ name: "foo", version: "^3.4.0" }`.
+     * Given `bar@npm:@bar/legacy` returns `{ name: "bar", version: "npm:@bar/legacy" }`.
+     */
+    static parseDependency(spec: string): DependencyCoordinates;
+    private readonly _deps;
+    /**
+     * Adds a dependencies component to the project.
+     * @param project The parent project
+     */
+    constructor(project: Project);
+    /**
+     * A copy of all dependencies recorded for this project.
+     *
+     * The list is sorted by type->name->version
+     */
+    get all(): Dependency[];
+    /**
+     * Returns a dependency by name.
+     *
+     * Fails if there is no dependency defined by that name or if `type` is not
+     * provided and there is more then one dependency type for this dependency.
+     *
+     * @param name The name of the dependency
+     * @param type The dependency type. If this dependency is defined only for a
+     * single type, this argument can be omitted.
+     *
+     * @returns a copy (cannot be modified)
+     */
+    getDependency(name: string, type?: DependencyType): Dependency;
+    /**
+     * Returns a dependency by name.
+     *
+     * Returns `undefined` if there is no dependency defined by that name or if
+     * `type` is not provided and there is more then one dependency type for this
+     * dependency.
+     *
+     * @param name The name of the dependency
+     * @param type The dependency type. If this dependency is defined only for a
+     * single type, this argument can be omitted.
+     *
+     * @returns a copy (cannot be modified) or undefined if there is no match
+     */
+    tryGetDependency(name: string, type?: DependencyType): Dependency | undefined;
+    /**
+     * Adds a dependency to this project.
+     * @param spec The dependency spec in the format `MODULE[@VERSION]` where
+     * `MODULE` is the package-manager-specific module name and `VERSION` is an
+     * optional semantic version requirement (e.g. `^3.4.0`).
+     * @param type The type of the dependency.
+     */
+    addDependency(spec: string, type: DependencyType, metadata?: {
+        [key: string]: any;
+    }): Dependency;
+    /**
+     * Removes a dependency.
+     * @param name The name of the module to remove (without the version)
+     * @param type The dependency type. This is only required if there the
+     * dependency is defined for multiple types.
+     */
+    removeDependency(name: string, type?: DependencyType): void;
+    private tryGetDependencyIndex;
+    private toJson;
+}
+export interface DepsManifest {
+    /**
+     * All dependencies of this module.
+     */
+    readonly dependencies: Dependency[];
+}
+/**
+ * Coordinates of the dependency (name and version).
+ */
+export interface DependencyCoordinates {
+    /**
+     * The package manager name of the dependency (e.g. `leftpad` for npm).
+     *
+     * NOTE: For package managers that use complex coordinates (like Maven), we
+     * will codify it into a string somehow.
+     */
+    readonly name: string;
+    /**
+     * Semantic version version requirement.
+     *
+     * @default - requirement is managed by the package manager (e.g. npm/yarn).
+     */
+    readonly version?: string;
+}
+/**
+ * Represents a project dependency.
+ */
+export interface Dependency extends DependencyCoordinates {
+    /**
+     * Which type of dependency this is (runtime, build-time, etc).
+     */
+    readonly type: DependencyType;
+    /**
+     * Additional JSON metadata associated with the dependency (package manager
+     * specific).
+     * @default {}
+     */
+    readonly metadata?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Type of dependency.
+ */
+export declare enum DependencyType {
+    /**
+     * The dependency is required for the program/library during runtime.
+     */
+    RUNTIME = "runtime",
+    /**
+     * The dependency is required at runtime but expected to be installed by the
+     * consumer.
+     */
+    PEER = "peer",
+    /**
+     * The dependency is bundled and shipped with the module, so consumers are not
+     * required to install it.
+     */
+    BUNDLED = "bundled",
+    /**
+     * The dependency is required to run the `build` task.
+     */
+    BUILD = "build",
+    /**
+     * The dependency is required to run the `test` task.
+     */
+    TEST = "test",
+    /**
+     * The dependency is required for development (e.g. IDE plugins).
+     */
+    DEVENV = "devenv",
+    /**
+     * Transient dependency that needs to be overwritten.
+     *
+     * Available for Node packages
+     */
+    OVERRIDE = "override"
+}

package/lib/.types-compat/ts3.9/lib/dev-env.d.ts

@@ -0,0 +1,80 @@
+import { Task } from "./task";
+/**
+ * Base options for configuring a container-based development environment.
+ */
+export interface DevEnvironmentOptions {
+    /**
+     * A Docker image or Dockerfile for the container.
+     */
+    readonly dockerImage?: DevEnvironmentDockerImage;
+    /**
+     * An array of tasks that should be run when the container starts.
+     */
+    readonly tasks?: Task[];
+    /**
+     * An array of ports that should be exposed from the container.
+     */
+    readonly ports?: string[];
+    /**
+     * An array of extension IDs that specify the extensions that should be
+     * installed inside the container when it is created.
+     */
+    readonly vscodeExtensions?: string[];
+}
+/**
+ * Options for specifying the Docker image of the container.
+ */
+export declare class DevEnvironmentDockerImage {
+    /**
+     * A publicly available Docker image.
+     * @example 'ubuntu:latest'
+     * @param image a Docker image
+     */
+    static fromImage(image: string): DevEnvironmentDockerImage;
+    /**
+     * The relative path of a Dockerfile that defines the container contents.
+     * @example '.gitpod.Docker'
+     * @param dockerFile a relative path
+     */
+    static fromFile(dockerFile: string): DevEnvironmentDockerImage;
+    /**
+     * A publicly available Docker image.
+     */
+    readonly image?: string;
+    /**
+     * The relative path of a Dockerfile that defines the container contents.
+     */
+    readonly dockerFile?: string;
+    private constructor();
+}
+/**
+ * Abstract interface for container-based development environments, such as
+ * Gitpod and GitHub Codespaces.
+ */
+export interface IDevEnvironment {
+    /**
+     * Add a custom Docker image or Dockerfile for the container.
+     *
+     * @param image The Docker image
+     */
+    addDockerImage(image: DevEnvironmentDockerImage): void;
+    /**
+     * Adds tasks to run when the container starts.
+     *
+     * @param tasks The new tasks
+     */
+    addTasks(...tasks: Task[]): void;
+    /**
+     * Adds ports that should be exposed (forwarded) from the container.
+     *
+     * @param ports The new ports
+     */
+    addPorts(...ports: string[]): void;
+    /**
+     * Adds a list of VSCode extensions that should be automatically installed
+     * in the container.
+     *
+     * @param extensions The extension IDs
+     */
+    addVscodeExtensions(...extensions: string[]): void;
+}

package/lib/.types-compat/ts3.9/lib/docker-compose/docker-compose-network.d.ts

@@ -0,0 +1,103 @@
+/**
+ * IPAM subnet configuration
+ */
+export interface DockerComposeNetworkIpamSubnetConfig {
+    /**
+     * Subnet in CIDR format that represents a network segment
+     * @default - value is not provided
+     */
+    readonly subnet?: string;
+}
+/**
+ * IPAM configuration
+ */
+export interface DockerComposeNetworkIpamConfig {
+    /**
+     * Driver to use for custom IPAM config.
+     * @default - value is not provided
+     */
+    readonly driver?: string;
+    /**
+     * A list with zero or more config blocks specifying custom IPAM configuration.
+     * @default - value is not provided
+     */
+    readonly config?: DockerComposeNetworkIpamSubnetConfig[];
+}
+/**
+ * Network configuration
+ */
+export interface DockerComposeNetworkConfig {
+    /**
+     * Driver to use for the network
+     * @default - value is not provided
+     */
+    readonly driver?: string;
+    /**
+     * Options for the configured driver. Those options are driver-dependent - consult the driver’s documentation for more information
+     * @default - value is not provided
+     */
+    readonly driverOpts?: object;
+    /**
+     * Set to true to indicate that the network is a bridge network.
+     * @default - unset
+     */
+    readonly bridge?: boolean;
+    /**
+     * Set to true to indicate that the network is an overlay network.
+     * @default - unset
+     */
+    readonly overlay?: boolean;
+    /**
+     * Set to true to indicate that the network is externally created.
+     * @default - unset, indicating that docker-compose creates the network
+     */
+    readonly external?: boolean;
+    /**
+     * Set to true to indicate that standalone containers can attach to this network, in addition to services.
+     * @default - unset
+     */
+    readonly attachable?: boolean;
+    /**
+     * Specify custom IPAM config.
+     * @default - unset
+     */
+    readonly ipam?: DockerComposeNetworkIpamConfig;
+    /**
+     * Set to true to indicate that you want to create an externally isolated overlay network
+     * @default - unset
+     */
+    readonly internal?: boolean;
+    /**
+     * Attach labels to the network
+     * @default - unset
+     */
+    readonly labels?: string[];
+    /**
+     * Name of the network for when the network name isn't going to work in YAML.
+     * @default - unset, indicating that docker-compose creates networks as usual
+     */
+    readonly name?: string;
+}
+/**
+ * Network binding information.
+ */
+export interface IDockerComposeNetworkBinding {
+    /**
+     * Binds the requested network to the docker-compose network configuration and
+     * provide mounting instructions for synthesis.
+     * @param networkConfig the network configuration
+     * @returns the service name
+     */
+    bind(networkConfig: IDockerComposeNetworkConfig): string;
+}
+/**
+ * Storage for network configuration.
+ */
+export interface IDockerComposeNetworkConfig {
+    /**
+     * Add network configuration to the repository.
+     * @param networkName
+     * @param configuration
+     */
+    addNetworkConfiguration(networkName: string, configuration: DockerComposeNetworkConfig): void;
+}

package/lib/.types-compat/ts3.9/lib/docker-compose/docker-compose-port.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Options for port mappings.
+ */
+export interface DockerComposePortMappingOptions {
+    /**
+     * Port mapping protocol.
+     * @default DockerComposeProtocol.TCP
+     */
+    readonly protocol?: DockerComposeProtocol;
+}
+/**
+ * A service port mapping
+ */
+export interface DockerComposeServicePort {
+    /**
+     * Published port number
+     */
+    readonly published: number;
+    /**
+     * Target port number
+     */
+    readonly target: number;
+    /**
+     * Network protocol
+     */
+    readonly protocol: DockerComposeProtocol;
+    /**
+     * Port mapping mode.
+     */
+    readonly mode: string;
+}
+/**
+ * Network protocol for port mapping
+ */
+export declare enum DockerComposeProtocol {
+    /**
+     * TCP protocol
+     */
+    TCP = "tcp",
+    /**
+     * UDP protocol
+     */
+    UDP = "udp"
+}

package/lib/.types-compat/ts3.9/lib/docker-compose/docker-compose-render.d.ts

@@ -0,0 +1,2 @@
+import { DockerComposeService } from "./docker-compose-service";
+export declare function renderDockerComposeFile(serviceDescriptions: Record<string, DockerComposeService>, version: string): object;

package/lib/.types-compat/ts3.9/lib/docker-compose/docker-compose-service.d.ts

@@ -0,0 +1,155 @@
+import { DockerComposeBuild } from "./docker-compose";
+import { IDockerComposeNetworkBinding } from "./docker-compose-network";
+import { DockerComposePortMappingOptions, DockerComposeServicePort } from "./docker-compose-port";
+import { IDockerComposeVolumeBinding } from "./docker-compose-volume";
+/**
+ * An interface providing the name of a docker compose service.
+ */
+export interface IDockerComposeServiceName {
+    /**
+     * The name of the docker compose service.
+     */
+    readonly serviceName: string;
+}
+/**
+ * A docker-compose service.
+ */
+export declare class DockerComposeService implements IDockerComposeServiceName {
+    /**
+     * Name of the service.
+     */
+    readonly serviceName: string;
+    /**
+     * Docker image.
+     */
+    readonly image?: string;
+    /**
+     * Docker image build instructions.
+     */
+    readonly imageBuild?: DockerComposeBuild;
+    /**
+     * Command to run in the container.
+     */
+    readonly command?: string[];
+    /**
+     * Entrypoint to run in the container.
+     */
+    readonly entrypoint?: string[];
+    /**
+     * Other services that this service depends on.
+     */
+    readonly dependsOn: IDockerComposeServiceName[];
+    /**
+     * Volumes mounted in the container.
+     */
+    readonly volumes: IDockerComposeVolumeBinding[];
+    /**
+     * Networks mounted in the container.
+     */
+    readonly networks: IDockerComposeNetworkBinding[];
+    /**
+     * Published ports.
+     */
+    readonly ports: DockerComposeServicePort[];
+    /**
+     * Environment variables.
+     */
+    readonly environment: Record<string, string>;
+    /**
+     * Attached labels.
+     */
+    readonly labels: Record<string, string>;
+    constructor(serviceName: string, serviceDescription: DockerComposeServiceDescription);
+    /**
+     * Add a port mapping
+     * @param publishedPort Published port number
+     * @param targetPort Container's port number
+     * @param options Port mapping options
+     */
+    addPort(publishedPort: number, targetPort: number, options?: DockerComposePortMappingOptions): void;
+    /**
+     * Add an environment variable
+     * @param name environment variable name
+     * @param value value of the environment variable
+     */
+    addEnvironment(name: string, value: string): void;
+    /**
+     * Make the service depend on another service.
+     * @param serviceName
+     */
+    addDependsOn(serviceName: IDockerComposeServiceName): void;
+    /**
+     * Add a volume to the service.
+     * @param volume
+     */
+    addVolume(volume: IDockerComposeVolumeBinding): void;
+    /**
+     * Add a network to the service.
+     * @param network
+     */
+    addNetwork(network: IDockerComposeNetworkBinding): void;
+    /**
+     * Add a label
+     * @param name environment variable name
+     * @param value value of the environment variable
+     */
+    addLabel(name: string, value: string): void;
+}
+/**
+ * Description of a docker-compose.yml service.
+ */
+export interface DockerComposeServiceDescription {
+    /**
+     * Use a docker image.
+     * Note: You must specify either `build` or `image` key.
+     * @see imageBuild
+     */
+    readonly image?: string;
+    /**
+     * Build a docker image.
+     * Note: You must specify either `imageBuild` or `image` key.
+     * @see image
+     */
+    readonly imageBuild?: DockerComposeBuild;
+    /**
+     * Provide a command to the docker container.
+     * @default - use the container's default command
+     */
+    readonly command?: string[];
+    /**
+     * Entrypoint to run in the container.
+     */
+    readonly entrypoint?: string[];
+    /**
+     * Names of other services this service depends on.
+     * @default - no dependencies
+     */
+    readonly dependsOn?: IDockerComposeServiceName[];
+    /**
+     * Mount some volumes into the service.
+     * Use one of the following to create volumes:
+     * @see DockerCompose.bindVolume() to mount a host path
+     * @see DockerCompose.namedVolume() to create & mount a named volume
+     */
+    readonly volumes?: IDockerComposeVolumeBinding[];
+    /**
+     * Add some networks to the service.
+     * @see DockerCompose.network() to create & mount a named network
+     */
+    readonly networks?: IDockerComposeNetworkBinding[];
+    /**
+     * Map some ports.
+     * @default - no ports are mapped
+     */
+    readonly ports?: DockerComposeServicePort[];
+    /**
+     * Add environment variables.
+     * @default - no environment variables are provided
+     */
+    readonly environment?: Record<string, string>;
+    /**
+     * Add labels.
+     * @default - no labels are provided
+     */
+    readonly labels?: Record<string, string>;
+}

package/lib/.types-compat/ts3.9/lib/docker-compose/docker-compose-volume.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Volume configuration
+ */
+export interface DockerComposeVolumeConfig {
+    /**
+     * Driver to use for the volume
+     * @default - value is not provided
+     */
+    readonly driver?: string;
+    /**
+     * Options to provide to the driver.
+     */
+    readonly driverOpts?: Record<string, string>;
+    /**
+     * Set to true to indicate that the volume is externally created.
+     * @default - unset, indicating that docker-compose creates the volume
+     */
+    readonly external?: boolean;
+    /**
+     * Name of the volume for when the volume name isn't going to work in YAML.
+     * @default - unset, indicating that docker-compose creates volumes as usual
+     */
+    readonly name?: string;
+}
+/**
+ * Volume binding information.
+ */
+export interface IDockerComposeVolumeBinding {
+    /**
+     * Binds the requested volume to the docker-compose volume configuration and
+     * provide mounting instructions for synthesis.
+     * @param volumeConfig the volume configuration
+     * @returns mounting instructions for the service.
+     */
+    bind(volumeConfig: IDockerComposeVolumeConfig): DockerComposeVolumeMount;
+}
+/**
+ * Storage for volume configuration.
+ */
+export interface IDockerComposeVolumeConfig {
+    /**
+     * Add volume configuration to the repository.
+     * @param volumeName
+     * @param configuration
+     */
+    addVolumeConfiguration(volumeName: string, configuration: DockerComposeVolumeConfig): void;
+}
+/**
+ * Service volume mounting information.
+ */
+export interface DockerComposeVolumeMount {
+    /**
+     * Type of volume.
+     */
+    readonly type: string;
+    /**
+     * Volume source
+     */
+    readonly source: string;
+    /**
+     * Volume target
+     */
+    readonly target: string;
+}