projen 0.0.0

package/lib/dependencies.js

@@ -0,0 +1,219 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyType = exports.Dependencies = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const common_1 = require("./common");
+const component_1 = require("./component");
+const json_1 = require("./json");
+/**
+ * (experimental) 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`:
+ *
+ * @experimental
+ */
+class Dependencies extends component_1.Component {
+    /**
+     * (experimental) Adds a dependencies component to the project.
+     *
+     * @param project The parent project.
+     * @experimental
+     */
+    constructor(project) {
+        super(project);
+        this._deps = new Array();
+        // this is not really required at the moment, but actually quite useful as a
+        // checked-in source of truth for dependencies and will potentially be
+        // valuable in the future for CLI tools.
+        new json_1.JsonFile(project, Dependencies.MANIFEST_FILE, {
+            omitEmpty: true,
+            obj: () => this.toJson(),
+        });
+    }
+    /**
+     * (experimental) 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" }`.
+     *
+     * @experimental
+     */
+    static parseDependency(spec) {
+        const scope = spec.startsWith('@');
+        if (scope) {
+            spec = spec.substr(1);
+        }
+        const [module, ...version] = spec.split('@');
+        const name = scope ? `@${module}` : module;
+        if (version.length == 0) {
+            return { name };
+        }
+        else {
+            return { name, version: version === null || version === void 0 ? void 0 : version.join('@') };
+        }
+    }
+    /**
+     * (experimental) A copy of all dependencies recorded for this project.
+     *
+     * The list is sorted by type->name->version
+     *
+     * @experimental
+     */
+    get all() {
+        return [...this._deps].sort(compareDeps).map(normalizeDep);
+    }
+    /**
+     * (experimental) 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.
+     * @returns a copy (cannot be modified)
+     * @experimental
+     */
+    getDependency(name, type) {
+        const dep = this.tryGetDependency(name, type);
+        if (!dep) {
+            const msg = type
+                ? `there is no ${type} dependency defined on "${name}"`
+                : `there is no dependency defined on "${name}"`;
+            throw new Error(msg);
+        }
+        return dep;
+    }
+    /**
+     * (experimental) 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.
+     * @returns a copy (cannot be modified) or undefined if there is no match
+     * @experimental
+     */
+    tryGetDependency(name, type) {
+        const idx = this.tryGetDependencyIndex(name, type);
+        if (idx === -1) {
+            return undefined;
+        }
+        return {
+            ...normalizeDep(this._deps[idx]),
+        };
+    }
+    /**
+     * (experimental) 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.
+     * @experimental
+     */
+    addDependency(spec, type, metadata = {}) {
+        this.project.logger.debug(`${type}-dep ${spec}`);
+        const dep = {
+            ...Dependencies.parseDependency(spec),
+            type,
+            metadata,
+        };
+        const existingDepIndex = this.tryGetDependencyIndex(dep.name, type);
+        if (existingDepIndex !== -1) {
+            this.project.logger.debug(`updating existing ${dep.type}-dep ${dep.name} with more specific version/metadata`);
+            this._deps[existingDepIndex] = dep;
+        }
+        else {
+            this._deps.push(dep);
+        }
+        return dep;
+    }
+    /**
+     * (experimental) Removes a dependency.
+     *
+     * @param name The name of the module to remove (without the version).
+     * @param type The dependency type.
+     * @experimental
+     */
+    removeDependency(name, type) {
+        const removeIndex = this.tryGetDependencyIndex(name, type);
+        if (removeIndex === -1) {
+            return;
+        }
+        this._deps.splice(removeIndex, 1);
+    }
+    tryGetDependencyIndex(name, type) {
+        const deps = this._deps.filter(d => d.name === name);
+        if (deps.length === 0) {
+            return -1; // not found
+        }
+        if (!type) {
+            if (deps.length > 1) {
+                throw new Error(`"${name}" is defined for multiple dependency types: ${deps.map(d => d.type).join(',')}. Please specify dependency type`);
+            }
+            type = deps[0].type;
+        }
+        return this._deps.findIndex(dep => dep.name === name && dep.type === type);
+    }
+    toJson() {
+        if (this._deps.length === 0) {
+            return undefined;
+        }
+        return {
+            dependencies: this._deps.sort(compareDeps).map(normalizeDep),
+        };
+    }
+}
+exports.Dependencies = Dependencies;
+_a = JSII_RTTI_SYMBOL_1;
+Dependencies[_a] = { fqn: "projen.Dependencies", version: "0.46.8" };
+/**
+ * (experimental) The project-relative path of the deps manifest file.
+ *
+ * @experimental
+ */
+Dependencies.MANIFEST_FILE = path.posix.join(common_1.PROJEN_DIR, 'deps.json');
+function normalizeDep(d) {
+    const obj = {};
+    for (const [k, v] of Object.entries(d)) {
+        if (v == undefined) {
+            continue;
+        }
+        if (typeof (v) === 'object' && Object.keys(v).length === 0) {
+            continue;
+        }
+        if (Array.isArray(v) && v.length === 0) {
+            continue;
+        }
+        obj[k] = v;
+    }
+    return obj;
+}
+function compareDeps(d1, d2) {
+    return specOf(d1).localeCompare(specOf(d2));
+    function specOf(dep) {
+        let spec = dep.type + ':' + dep.name;
+        if (dep.version) {
+            spec += '@' + dep.version;
+        }
+        return spec;
+    }
+}
+/**
+ * (experimental) Type of dependency.
+ *
+ * @experimental
+ */
+var DependencyType;
+(function (DependencyType) {
+    DependencyType["RUNTIME"] = "runtime";
+    DependencyType["PEER"] = "peer";
+    DependencyType["BUNDLED"] = "bundled";
+    DependencyType["BUILD"] = "build";
+    DependencyType["TEST"] = "test";
+    DependencyType["DEVENV"] = "devenv";
+})(DependencyType = exports.DependencyType || (exports.DependencyType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependencies.js","sourceRoot":"","sources":["../src/dependencies.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { PROJEN_DIR } from './common';\nimport { Component } from './component';\nimport { JsonFile } from './json';\nimport { Project } from './project';\n\n                                                                                                                                                                                                                                                                                                                                                                                                                      \nexport class Dependencies extends Component {\n                                                                     \n  public static readonly MANIFEST_FILE = path.posix.join(PROJEN_DIR, 'deps.json');\n\n                                                                                                                                                                                                                                 \n  public static parseDependency(spec: string): DependencyCoordinates {\n    const scope = spec.startsWith('@');\n    if (scope) {\n      spec = spec.substr(1);\n    }\n\n    const [module, ...version] = spec.split('@');\n    const name = scope ? `@${module}` : module;\n    if (version.length == 0) {\n      return { name };\n    } else {\n      return { name, version: version?.join('@') };\n    }\n  }\n\n  private readonly _deps = new Array<Dependency>();\n\n                                                                                                     \n  constructor(project: Project) {\n    super(project);\n\n    // this is not really required at the moment, but actually quite useful as a\n    // checked-in source of truth for dependencies and will potentially be\n    // valuable in the future for CLI tools.\n    new JsonFile(project, Dependencies.MANIFEST_FILE, {\n      omitEmpty: true,\n      obj: () => this.toJson(),\n    });\n  }\n\n                                                                                                                          \n  public get all(): Dependency[] {\n    return [...this._deps].sort(compareDeps).map(normalizeDep);\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                              \n  public getDependency(name: string, type?: DependencyType): Dependency {\n    const dep = this.tryGetDependency(name, type);\n    if (!dep) {\n      const msg = type\n        ? `there is no ${type} dependency defined on \"${name}\"`\n        : `there is no dependency defined on \"${name}\"`;\n\n      throw new Error(msg);\n    }\n\n    return dep;\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \n  public tryGetDependency(name: string, type?: DependencyType): Dependency | undefined {\n    const idx = this.tryGetDependencyIndex(name, type);\n    if (idx === -1) {\n      return undefined;\n    }\n\n    return {\n      ...normalizeDep(this._deps[idx]),\n    };\n  }\n\n                                                                                                                                                                                                                                                                                                                      \n  public addDependency(spec: string, type: DependencyType, metadata: { [key: string]: any } = { }): Dependency {\n    this.project.logger.debug(`${type}-dep ${spec}`);\n\n    const dep: Dependency = {\n      ...Dependencies.parseDependency(spec),\n      type,\n      metadata,\n    };\n\n    const existingDepIndex = this.tryGetDependencyIndex(dep.name, type);\n\n    if (existingDepIndex !== -1) {\n      this.project.logger.debug(`updating existing ${dep.type}-dep ${dep.name} with more specific version/metadata`);\n      this._deps[existingDepIndex] = dep;\n    } else {\n      this._deps.push(dep);\n    }\n\n    return dep;\n  }\n\n                                                                                                                                                                                                                                      \n  public removeDependency(name: string, type?: DependencyType) {\n    const removeIndex = this.tryGetDependencyIndex(name, type);\n    if (removeIndex === -1) {\n      return;\n    }\n\n    this._deps.splice(removeIndex, 1);\n  }\n\n  private tryGetDependencyIndex(name: string, type?: DependencyType): number {\n    const deps = this._deps.filter(d => d.name === name);\n    if (deps.length === 0) {\n      return -1; // not found\n    }\n\n    if (!type) {\n      if (deps.length > 1) {\n        throw new Error(`\"${name}\" is defined for multiple dependency types: ${deps.map(d => d.type).join(',')}. Please specify dependency type`);\n      }\n\n      type = deps[0].type;\n    }\n\n    return this._deps.findIndex(dep => dep.name === name && dep.type === type);\n  }\n\n  private toJson(): DepsManifest | undefined {\n    if (this._deps.length === 0) { return undefined; }\n    return {\n      dependencies: this._deps.sort(compareDeps).map(normalizeDep),\n    };\n  }\n}\n\nfunction normalizeDep(d: Dependency) {\n  const obj: any = { };\n  for (const [k, v] of Object.entries(d)) {\n    if (v == undefined) {continue;}\n    if (typeof(v) === 'object' && Object.keys(v).length === 0) {continue;}\n    if (Array.isArray(v) && v.length === 0) {continue;}\n    obj[k] = v;\n  }\n\n  return obj;\n}\n\nfunction compareDeps(d1: Dependency, d2: Dependency) {\n  return specOf(d1).localeCompare(specOf(d2));\n\n  function specOf(dep: Dependency) {\n    let spec = dep.type + ':' + dep.name;\n    if (dep.version) {\n      spec += '@' + dep.version;\n    }\n    return spec;\n  }\n}\n\nexport interface DepsManifest {\n                                                 \n  readonly dependencies: Dependency[];\n}\n\n                                                            \nexport interface DependencyCoordinates {\n                                                                                                                                                                                                                   \n  readonly name: string;\n\n                                                                                                                                          \n  readonly version?: string;\n}\n\n                                           \nexport interface Dependency extends DependencyCoordinates {\n\n                                                                             \n  readonly type: DependencyType;\n\n                                                                                                                          \n  readonly metadata?: { [key: string]: any };\n}\n\n                              \nexport enum DependencyType {\n                                                                                   \n  RUNTIME = 'runtime',\n\n                                                                                                         \n  PEER = 'peer',\n\n                                                                                                                         \n  BUNDLED = 'bundled',\n\n                                                                    \n  BUILD = 'build',\n\n                                                                   \n  TEST = 'test',\n\n                                                                               \n  DEVENV = 'devenv',\n}\n"]}

package/lib/dev-env.d.ts

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

package/lib/dev-env.js

@@ -0,0 +1,41 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevEnvironmentDockerImage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * (experimental) Options for specifying the Docker image of the container.
+ *
+ * @experimental
+ */
+class DevEnvironmentDockerImage {
+    constructor() { }
+    /**
+     * (experimental) A publicly available Docker image.
+     *
+     * @param image a Docker image.
+     * @experimental
+     * @example
+     *
+     * 'ubuntu:latest'
+     */
+    static fromImage(image) {
+        return { image };
+    }
+    /**
+     * (experimental) The relative path of a Dockerfile that defines the container contents.
+     *
+     * @param dockerFile a relative path.
+     * @experimental
+     * @example
+     *
+     * '.gitpod.Docker'
+     */
+    static fromFile(dockerFile) {
+        return { dockerFile };
+    }
+}
+exports.DevEnvironmentDockerImage = DevEnvironmentDockerImage;
+_a = JSII_RTTI_SYMBOL_1;
+DevEnvironmentDockerImage[_a] = { fqn: "projen.DevEnvironmentDockerImage", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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