projen 0.0.0

package/lib/docker-compose.js

@@ -0,0 +1,308 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerComposeProtocol = exports.DockerComposeService = exports.DockerCompose = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("./component");
+const util_1 = require("./util");
+const yaml_1 = require("./yaml");
+/**
+ * (experimental) Create a docker-compose YAML file.
+ *
+ * @experimental
+ */
+class DockerCompose extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, props) {
+        var _c;
+        super(project);
+        const nameSuffix = (props === null || props === void 0 ? void 0 : props.nameSuffix) ? `${props.nameSuffix}.yml` : 'yml';
+        new yaml_1.YamlFile(project, `docker-compose.${nameSuffix}`, {
+            committed: true,
+            readonly: true,
+            obj: () => this._synthesizeDockerCompose(),
+        });
+        if ((props === null || props === void 0 ? void 0 : props.schemaVersion) && !parseFloat(props.schemaVersion)) {
+            throw Error('Version tag needs to be a number');
+        }
+        this.version = (props === null || props === void 0 ? void 0 : props.schemaVersion) ? props.schemaVersion : '3.3';
+        this.services = {};
+        // Add the services provided via the constructor argument.
+        const initialServices = (_c = props === null || props === void 0 ? void 0 : props.services) !== null && _c !== void 0 ? _c : {};
+        for (const [name, serviceDescription] of Object.entries(initialServices)) {
+            this.addService(name, serviceDescription);
+        }
+    }
+    /**
+     * (experimental) Depends on a service name.
+     *
+     * @experimental
+     */
+    static serviceName(serviceName) {
+        return {
+            serviceName,
+        };
+    }
+    /**
+     * (experimental) Create a port mapping.
+     *
+     * @param publishedPort Published port number.
+     * @param targetPort Container's port number.
+     * @param options Port mapping options.
+     * @experimental
+     */
+    static portMapping(publishedPort, targetPort, options) {
+        var _c;
+        const protocol = (_c = options === null || options === void 0 ? void 0 : options.protocol) !== null && _c !== void 0 ? _c : DockerComposeProtocol.TCP;
+        return {
+            target: targetPort,
+            published: publishedPort,
+            protocol: protocol,
+            mode: 'host',
+        };
+    }
+    /**
+     * (experimental) Create a bind volume that binds a host path to the target path in the container.
+     *
+     * @param sourcePath Host path name.
+     * @param targetPath Target path name.
+     * @experimental
+     */
+    static bindVolume(sourcePath, targetPath) {
+        return {
+            bind(_volumeInfo) {
+                return {
+                    type: 'bind',
+                    source: sourcePath,
+                    target: targetPath,
+                };
+            },
+        };
+    }
+    /**
+     * (experimental) Create a named volume and mount it to the target path.
+     *
+     * If you use this
+     * named volume in several services, the volume will be shared. In this
+     * case, the volume configuration of the first-provided options are used.
+     *
+     * @param volumeName Name of the volume.
+     * @param targetPath Target path.
+     * @param options volume configuration (default: docker compose defaults).
+     * @experimental
+     */
+    static namedVolume(volumeName, targetPath, options = {}) {
+        return {
+            bind(volumeInfo) {
+                volumeInfo.addVolumeConfiguration(volumeName, options);
+                return {
+                    type: 'volume',
+                    source: volumeName,
+                    target: targetPath,
+                };
+            },
+        };
+    }
+    /**
+     * (experimental) Add a service to the docker-compose file.
+     *
+     * @param serviceName name of the service.
+     * @param description a service description.
+     * @experimental
+     */
+    addService(serviceName, description) {
+        const service = new DockerComposeService(serviceName, description);
+        this.services[serviceName] = service;
+        return service;
+    }
+    /**
+     * @internal
+     */
+    _synthesizeDockerCompose() {
+        if (Object.keys(this.services).length === 0) {
+            throw new Error('DockerCompose requires at least one service');
+        }
+        return renderDockerComposeFile(this.services, this.version);
+    }
+}
+exports.DockerCompose = DockerCompose;
+_a = JSII_RTTI_SYMBOL_1;
+DockerCompose[_a] = { fqn: "projen.DockerCompose", version: "0.46.8" };
+/**
+ * (experimental) A docker-compose service.
+ *
+ * @experimental
+ */
+class DockerComposeService {
+    /**
+     * @experimental
+     */
+    constructor(serviceName, serviceDescription) {
+        var _c, _d, _e, _f;
+        if ((!serviceDescription.imageBuild && !serviceDescription.image)
+            || (serviceDescription.imageBuild && serviceDescription.image)) {
+            throw new Error(`A service ${serviceName} requires exactly one of a \`imageBuild\` or \`image\` key`);
+        }
+        this.serviceName = serviceName;
+        this.command = serviceDescription.command;
+        this.image = serviceDescription.image;
+        this.imageBuild = serviceDescription.imageBuild;
+        this.dependsOn = (_c = serviceDescription.dependsOn) !== null && _c !== void 0 ? _c : [];
+        this.volumes = (_d = serviceDescription.volumes) !== null && _d !== void 0 ? _d : [];
+        this.ports = (_e = serviceDescription.ports) !== null && _e !== void 0 ? _e : [];
+        this.environment = (_f = serviceDescription.environment) !== null && _f !== void 0 ? _f : {};
+    }
+    /**
+     * (experimental) Add a port mapping.
+     *
+     * @param publishedPort Published port number.
+     * @param targetPort Container's port number.
+     * @param options Port mapping options.
+     * @experimental
+     */
+    addPort(publishedPort, targetPort, options) {
+        var _c;
+        (_c = this.ports) === null || _c === void 0 ? void 0 : _c.push(DockerCompose.portMapping(publishedPort, targetPort, options));
+    }
+    /**
+     * (experimental) Add an environment variable.
+     *
+     * @param name environment variable name.
+     * @param value value of the environment variable.
+     * @experimental
+     */
+    addEnvironment(name, value) {
+        this.environment[name] = value;
+    }
+    /**
+     * (experimental) Make the service depend on another service.
+     *
+     * @experimental
+     */
+    addDependsOn(serviceName) {
+        this.dependsOn.push(serviceName);
+    }
+    /**
+     * (experimental) Add a volume to the service.
+     *
+     * @experimental
+     */
+    addVolume(volume) {
+        this.volumes.push(volume);
+    }
+}
+exports.DockerComposeService = DockerComposeService;
+_b = JSII_RTTI_SYMBOL_1;
+DockerComposeService[_b] = { fqn: "projen.DockerComposeService", version: "0.46.8" };
+/**
+ * (experimental) Network protocol for port mapping.
+ *
+ * @experimental
+ */
+var DockerComposeProtocol;
+(function (DockerComposeProtocol) {
+    DockerComposeProtocol["TCP"] = "tcp";
+    DockerComposeProtocol["UDP"] = "udp";
+})(DockerComposeProtocol = exports.DockerComposeProtocol || (exports.DockerComposeProtocol = {}));
+function renderDockerComposeFile(serviceDescriptions, version) {
+    var _c, _d;
+    // Record volume configuration
+    const volumeConfig = {};
+    const volumeInfo = {
+        addVolumeConfiguration(volumeName, configuration) {
+            if (!volumeConfig[volumeName]) {
+                // First volume configuration takes precedence.
+                volumeConfig[volumeName] = configuration;
+            }
+        },
+    };
+    // Render service configuration
+    const services = {};
+    for (const [serviceName, serviceDescription] of Object.entries(serviceDescriptions !== null && serviceDescriptions !== void 0 ? serviceDescriptions : {})) {
+        // Resolve the names of each dependency and check that they exist.
+        // Note: They may not exist if the user made a mistake when referencing a
+        // service by name via `DockerCompose.serviceName()`.
+        // @see DockerCompose.serviceName
+        const dependsOn = Array();
+        for (const dependsOnServiceName of (_c = serviceDescription.dependsOn) !== null && _c !== void 0 ? _c : []) {
+            const resolvedServiceName = dependsOnServiceName.serviceName;
+            if (resolvedServiceName === serviceName) {
+                throw new Error(`Service ${serviceName} cannot depend on itself`);
+            }
+            if (!serviceDescriptions[resolvedServiceName]) {
+                throw new Error(`Unable to resolve service named ${resolvedServiceName} for ${serviceName}`);
+            }
+            dependsOn.push(resolvedServiceName);
+        }
+        // Give each volume binding a chance to bind any necessary volume
+        // configuration and provide volume mount information for the service.
+        const volumes = [];
+        for (const volumeBinding of (_d = serviceDescription.volumes) !== null && _d !== void 0 ? _d : []) {
+            volumes.push(volumeBinding.bind(volumeInfo));
+        }
+        // Create and store the service configuration, taking care not to create
+        // object members with undefined values.
+        services[serviceName] = {
+            ...getObjectWithKeyAndValueIfValueIsDefined('image', serviceDescription.image),
+            ...getObjectWithKeyAndValueIfValueIsDefined('build', serviceDescription.imageBuild),
+            ...getObjectWithKeyAndValueIfValueIsDefined('command', serviceDescription.command),
+            ...(Object.keys(serviceDescription.environment).length > 0 ? { environment: serviceDescription.environment } : {}),
+            ...(serviceDescription.ports.length > 0 ? { ports: serviceDescription.ports } : {}),
+            ...(dependsOn.length > 0 ? { dependsOn } : {}),
+            ...(volumes.length > 0 ? { volumes } : {}),
+        };
+    }
+    // Explicit with the type here because the decamelize step after this wipes
+    // out types.
+    const input = {
+        version,
+        services,
+        ...(Object.keys(volumeConfig).length > 0 ? { volumes: volumeConfig } : {}),
+    };
+    // Change most keys to snake case.
+    return util_1.decamelizeKeysRecursively(input, {
+        shouldDecamelize: shouldDecamelizeDockerComposeKey,
+        separator: '_',
+    });
+}
+/**
+ * Returns `{ [key]: value }` if `value` is defined, otherwise returns `{}` so
+ * that object spreading can be used to generate a peculiar interface.
+ * @param key
+ * @param value
+ */
+function getObjectWithKeyAndValueIfValueIsDefined(key, value) {
+    return value !== undefined ? { [key]: value } : {};
+}
+/**
+ * Determines whether the key at the given path should be decamelized.
+ * Largely, all keys should be snake cased. But, there are some
+ * exceptions for user-provided names for services, volumes, and
+ * environment variables.
+ *
+ * @param path
+ */
+function shouldDecamelizeDockerComposeKey(path) {
+    const poundPath = path.join('#');
+    // Does not decamelize user's names.
+    // services.namehere:
+    // volumes.namehere:
+    if (/^(services|volumes)#[^#]+$/.test(poundPath)) {
+        return false;
+    }
+    // Does not decamelize environment variables
+    // services.namehere.environment.*
+    if (/^services#[^#]+#environment#/.test(poundPath)) {
+        return false;
+    }
+    // Does not decamelize build arguments
+    // services.namehere.build.args.*
+    if (/^services#[^#]+#build#args#/.test(poundPath)) {
+        return false;
+    }
+    // Otherwise, let it all decamelize.
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"docker-compose.js","sourceRoot":"","sources":["../src/docker-compose.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component } from './component';\nimport { Project } from './project';\nimport { decamelizeKeysRecursively } from './util';\nimport { YamlFile } from './yaml';\n\n                                   \nexport interface DockerComposeProps {\n                                                                                                                                                             \n  readonly nameSuffix?: string;\n\n                                                                           \n  readonly schemaVersion?: string;\n\n                                      \n  readonly services?: Record<string, DockerComposeServiceDescription>;\n}\n\n                                     \nexport interface DockerComposePortMappingOptions {\n                                                                               \n  readonly protocol?: DockerComposeProtocol;\n}\n\n                                             \nexport class DockerCompose extends Component {\n                                           \n  static serviceName(serviceName: string): IDockerComposeServiceName {\n    return {\n      serviceName,\n    };\n  }\n\n                                                                                                                                                                               \n  static portMapping(publishedPort: number, targetPort: number, options?: DockerComposePortMappingOptions): DockerComposeServicePort {\n    const protocol = options?.protocol ?? DockerComposeProtocol.TCP;\n\n    return {\n      target: targetPort,\n      published: publishedPort,\n      protocol: protocol,\n      mode: 'host',\n    };\n  }\n\n                                                                                                                                                                               \n  static bindVolume(sourcePath: string, targetPath: string): IDockerComposeVolumeBinding {\n    return {\n      bind(_volumeInfo: IDockerComposeVolumeConfig): DockerComposeVolumeMount {\n        return {\n          type: 'bind',\n          source: sourcePath,\n          target: targetPath,\n        };\n      },\n    };\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                           \n  static namedVolume(volumeName: string, targetPath: string, options: DockerComposeVolumeConfig = {}): IDockerComposeVolumeBinding {\n    return {\n      bind(volumeInfo: IDockerComposeVolumeConfig): DockerComposeVolumeMount {\n        volumeInfo.addVolumeConfiguration(volumeName, options);\n\n        return {\n          type: 'volume',\n          source: volumeName,\n          target: targetPath,\n        };\n      },\n    };\n  }\n\n  private readonly services: Record<string, DockerComposeService>;\n  private readonly version: string;\n\n  constructor(project: Project, props?: DockerComposeProps) {\n    super(project);\n\n    const nameSuffix = props?.nameSuffix ? `${props!.nameSuffix}.yml` : 'yml';\n    new YamlFile(project, `docker-compose.${nameSuffix}`, {\n      committed: true,\n      readonly: true,\n      obj: () => this._synthesizeDockerCompose(),\n    });\n\n    if (props?.schemaVersion && !parseFloat(props.schemaVersion)) {\n      throw Error('Version tag needs to be a number');\n    }\n    this.version = props?.schemaVersion ? props.schemaVersion : '3.3';\n    this.services = {};\n\n    // Add the services provided via the constructor argument.\n    const initialServices = props?.services ?? {};\n    for (const [name, serviceDescription] of Object.entries(initialServices)) {\n      this.addService(name, serviceDescription);\n    }\n  }\n\n                                                                                                                                                    \n  public addService(serviceName: string, description: DockerComposeServiceDescription): DockerComposeService {\n    const service = new DockerComposeService(serviceName, description);\n    this.services[serviceName] = service;\n    return service;\n  }\n\n  /**\n   * @internal\n   */\n  _synthesizeDockerCompose(): object {\n    if (Object.keys(this.services).length === 0) {\n      throw new Error('DockerCompose requires at least one service');\n    }\n\n    return renderDockerComposeFile(this.services, this.version);\n  }\n}\n\n                                                                       \nexport interface IDockerComposeServiceName {\n                                                        \n  readonly serviceName: string;\n}\n\n                                                       \nexport interface DockerComposeServiceDescription {\n                                                                                                                    \n  readonly image?: string;\n\n                                                                                                                      \n  readonly imageBuild?: DockerComposeBuild;\n\n                                                                                                               \n  readonly command?: string[];\n\n                                                                                                 \n  readonly dependsOn?: IDockerComposeServiceName[];\n\n                                                                                                                                                                                                                                       \n  readonly volumes?: IDockerComposeVolumeBinding[];\n\n                                                                    \n  readonly ports?: DockerComposeServicePort[];\n\n                                                                                                 \n  readonly environment?: Record<string, string>;\n}\n\n                                    \nexport class DockerComposeService implements IDockerComposeServiceName {\n                                     \n  public readonly serviceName: string;\n\n                              \n  public readonly image?: string;\n\n                                                 \n  public readonly imageBuild?: DockerComposeBuild;\n\n                                                 \n  public readonly command?: string[];\n\n                                                             \n  public readonly dependsOn: IDockerComposeServiceName[];\n\n                                                  \n  public readonly volumes: IDockerComposeVolumeBinding[];\n\n                                 \n  public readonly ports: DockerComposeServicePort[];\n\n                                       \n  public readonly environment: Record<string, string>;\n\n  constructor(serviceName: string, serviceDescription: DockerComposeServiceDescription) {\n    if ((!serviceDescription.imageBuild && !serviceDescription.image)\n      || (serviceDescription.imageBuild && serviceDescription.image)) {\n      throw new Error(`A service ${serviceName} requires exactly one of a \\`imageBuild\\` or \\`image\\` key`);\n    }\n\n    this.serviceName = serviceName;\n    this.command = serviceDescription.command;\n    this.image = serviceDescription.image;\n    this.imageBuild = serviceDescription.imageBuild;\n    this.dependsOn = serviceDescription.dependsOn ?? [];\n    this.volumes = serviceDescription.volumes ?? [];\n    this.ports = serviceDescription.ports ?? [];\n    this.environment = serviceDescription.environment ?? {};\n  }\n\n                                                                                                                                                                           \n  public addPort(publishedPort: number, targetPort: number, options?: DockerComposePortMappingOptions) {\n    this.ports?.push(DockerCompose.portMapping(publishedPort, targetPort, options));\n  }\n\n                                                                                                                                           \n  public addEnvironment(name: string, value: string) {\n    this.environment[name] = value;\n  }\n\n                                                                                    \n  public addDependsOn(serviceName: IDockerComposeServiceName) {\n    this.dependsOn.push(serviceName);\n  }\n\n                                                                \n  public addVolume(volume: IDockerComposeVolumeBinding) {\n    this.volumes.push(volume);\n  }\n}\n\n                                 \nexport interface DockerComposeServicePort {\n                                      \n  readonly published: number;\n\n                                   \n  readonly target: number;\n\n                                 \n  readonly protocol: DockerComposeProtocol;\n\n                                   \n  readonly mode: string;\n}\n\n                                            \nexport enum DockerComposeProtocol {\n                             \n  TCP = 'tcp',\n\n                             \n  UDP = 'udp',\n}\n\n                                                       \nexport interface DockerComposeBuild {\n                                                \n  readonly context: string;\n\n                                                                       \n  readonly dockerfile?: string;\n\n                                                              \n  readonly args?: Record<string, string>;\n}\n\n                               \nexport interface DockerComposeVolumeConfig {\n                                                                                   \n  readonly driver?: string;\n\n                                                  \n  readonly driverOpts?: Record<string, string>;\n\n                                                                                                                                                        \n  readonly external?: boolean;\n\n                                                                                                                                                                        \n  readonly name?: string;\n}\n\n                                      \nexport interface IDockerComposeVolumeBinding {\n                                                                                                                                                                                                                                                   \n  bind(volumeConfig: IDockerComposeVolumeConfig): DockerComposeVolumeMount;\n}\n\n                                            \nexport interface IDockerComposeVolumeConfig {\n                                                                                                             \n  addVolumeConfiguration(volumeName: string, configuration: DockerComposeVolumeConfig): void;\n}\n\n                                               \nexport interface DockerComposeVolumeMount {\n                                \n  readonly type: string;\n\n                              \n  readonly source: string;\n\n                              \n  readonly target: string;\n}\n\n/**\n * Structure of a docker compose file before we decamelize.\n * @internal\n */\ninterface DockerComposeFileSchema {\n  version: string;\n  services: Record<string, DockerComposeFileServiceSchema>;\n  volumes?: Record<string, DockerComposeVolumeConfig>;\n}\n\n/**\n * Structure of a docker compose file's service before we decamelize.\n * @internal\n */\ninterface DockerComposeFileServiceSchema {\n  readonly dependsOn?: string[];\n  readonly build?: DockerComposeBuild;\n  readonly image?: string;\n  readonly command?: string[];\n  readonly volumes?: DockerComposeVolumeMount[];\n  readonly ports?: DockerComposeServicePort[];\n  readonly environment?: Record<string, string>;\n}\n\nfunction renderDockerComposeFile(serviceDescriptions: Record<string, DockerComposeService>, version: string): object {\n  // Record volume configuration\n  const volumeConfig: Record<string, DockerComposeVolumeConfig> = {};\n  const volumeInfo: IDockerComposeVolumeConfig = {\n    addVolumeConfiguration(volumeName: string, configuration: DockerComposeVolumeConfig) {\n      if (!volumeConfig[volumeName]) {\n        // First volume configuration takes precedence.\n        volumeConfig[volumeName] = configuration;\n      }\n    },\n  };\n\n  // Render service configuration\n  const services: Record<string, DockerComposeFileServiceSchema> = {};\n  for (const [serviceName, serviceDescription] of Object.entries(serviceDescriptions ?? {})) {\n    // Resolve the names of each dependency and check that they exist.\n    // Note: They may not exist if the user made a mistake when referencing a\n    // service by name via `DockerCompose.serviceName()`.\n    // @see DockerCompose.serviceName\n    const dependsOn = Array<string>();\n    for (const dependsOnServiceName of serviceDescription.dependsOn ?? []) {\n      const resolvedServiceName = dependsOnServiceName.serviceName;\n      if (resolvedServiceName === serviceName) {\n        throw new Error(`Service ${serviceName} cannot depend on itself`);\n      }\n      if (!serviceDescriptions[resolvedServiceName]) {\n        throw new Error(`Unable to resolve service named ${resolvedServiceName} for ${serviceName}`);\n      }\n\n      dependsOn.push(resolvedServiceName);\n    }\n\n    // Give each volume binding a chance to bind any necessary volume\n    // configuration and provide volume mount information for the service.\n    const volumes: DockerComposeVolumeMount[] = [];\n    for (const volumeBinding of serviceDescription.volumes ?? []) {\n      volumes.push(volumeBinding.bind(volumeInfo));\n    }\n\n    // Create and store the service configuration, taking care not to create\n    // object members with undefined values.\n    services[serviceName] = {\n      ...getObjectWithKeyAndValueIfValueIsDefined('image', serviceDescription.image),\n      ...getObjectWithKeyAndValueIfValueIsDefined('build', serviceDescription.imageBuild),\n      ...getObjectWithKeyAndValueIfValueIsDefined('command', serviceDescription.command),\n      ...(Object.keys(serviceDescription.environment).length > 0 ? { environment: serviceDescription.environment } : {}),\n      ...(serviceDescription.ports.length > 0 ? { ports: serviceDescription.ports } : {}),\n      ...(dependsOn.length > 0 ? { dependsOn } : {}),\n      ...(volumes.length > 0 ? { volumes } : {}),\n    };\n  }\n\n  // Explicit with the type here because the decamelize step after this wipes\n  // out types.\n  const input: DockerComposeFileSchema = {\n    version,\n    services,\n    ...(Object.keys(volumeConfig).length > 0 ? { volumes: volumeConfig } : {}),\n  };\n\n  // Change most keys to snake case.\n  return decamelizeKeysRecursively(input, {\n    shouldDecamelize: shouldDecamelizeDockerComposeKey,\n    separator: '_',\n  });\n}\n\n/**\n * Returns `{ [key]: value }` if `value` is defined, otherwise returns `{}` so\n * that object spreading can be used to generate a peculiar interface.\n * @param key\n * @param value\n */\nfunction getObjectWithKeyAndValueIfValueIsDefined<K extends string, T>(key: K, value: T): { K: T } | {} {\n  return value !== undefined ? { [key]: value } : {};\n}\n\n/**\n * Determines whether the key at the given path should be decamelized.\n * Largely, all keys should be snake cased. But, there are some\n * exceptions for user-provided names for services, volumes, and\n * environment variables.\n *\n * @param path\n */\nfunction shouldDecamelizeDockerComposeKey(path: string[]) {\n  const poundPath = path.join('#');\n\n  // Does not decamelize user's names.\n  // services.namehere:\n  // volumes.namehere:\n  if (/^(services|volumes)#[^#]+$/.test(poundPath)) {\n    return false;\n  }\n\n  // Does not decamelize environment variables\n  // services.namehere.environment.*\n  if (/^services#[^#]+#environment#/.test(poundPath)) {\n    return false;\n  }\n\n  // Does not decamelize build arguments\n  // services.namehere.build.args.*\n  if (/^services#[^#]+#build#args#/.test(poundPath)) {\n    return false;\n  }\n\n  // Otherwise, let it all decamelize.\n  return true;\n}\n"]}

package/lib/file.d.ts

@@ -0,0 +1,141 @@
+import { Component } from './component';
+import { Project } from './project';
+/**
+ * @experimental
+ */
+export interface FileBaseOptions {
+    /**
+     * (experimental) Indicates whether this file should be committed to git or ignored.
+     *
+     * By
+     * default, all generated files are committed and anti-tamper is used to
+     * protect against manual modifications.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly committed?: boolean;
+    /**
+     * (experimental) Update the project's .gitignore file.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly editGitignore?: boolean;
+    /**
+     * (experimental) Whether the generated file should be readonly.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly readonly?: boolean;
+    /**
+     * (experimental) Whether the generated file should be marked as executable.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly executable?: boolean;
+}
+/**
+ * @experimental
+ */
+export declare abstract class FileBase extends Component {
+    /**
+     * (experimental) The marker to embed in files in order to identify them as projen files.
+     *
+     * This marker is used to prune these files before synthesis.
+     *
+     * @experimental
+     */
+    static readonly PROJEN_MARKER: string;
+    /**
+     * (experimental) The file path, relative to the project root.
+     *
+     * @experimental
+     */
+    readonly path: string;
+    /**
+     * (experimental) Indicates if the file should be read-only or read-write.
+     *
+     * @experimental
+     */
+    readonly: boolean;
+    /**
+     * (experimental) Indicates if the file should be marked as executable.
+     *
+     * @experimental
+     */
+    executable: boolean;
+    /**
+     * (experimental) The absolute path of this file.
+     *
+     * @experimental
+     */
+    readonly absolutePath: string;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, filePath: string, options?: FileBaseOptions);
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @param resolver Call `resolver.resolve(obj)` on any objects in order to resolve token functions.
+     * @returns the content to synthesize or undefined to skip the file
+     * @experimental
+     */
+    protected abstract synthesizeContent(resolver: IResolver): string | undefined;
+    /**
+     * (experimental) Writes the file to the project's output directory.
+     *
+     * @experimental
+     */
+    synthesize(): void;
+}
+/**
+ * (experimental) API for resolving tokens when synthesizing file content.
+ *
+ * @experimental
+ */
+export interface IResolver {
+    /**
+     * (experimental) Given a value (object/string/array/whatever, looks up any functions inside the object and returns an object where all functions are called.
+     *
+     * @param value The value to resolve.
+     * @experimental
+     * @package options Resolve options
+     */
+    resolve(value: any, options?: ResolveOptions): any;
+}
+/**
+ * (experimental) Resolve options.
+ *
+ * @experimental
+ */
+export interface ResolveOptions {
+    /**
+     * (experimental) Omits empty arrays and objects.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly omitEmpty?: boolean;
+    /**
+     * (experimental) Context arguments.
+     *
+     * @default []
+     * @experimental
+     */
+    readonly args?: any[];
+}
+/**
+ * @experimental
+ */
+export interface IResolvable {
+    /**
+     * (experimental) Resolves and returns content.
+     *
+     * @experimental
+     */
+    toJSON(): any;
+}

package/lib/file.js

@@ -0,0 +1,75 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const _resolve_1 = require("./_resolve");
+const common_1 = require("./common");
+const component_1 = require("./component");
+const util_1 = require("./util");
+/**
+ * @experimental
+ */
+class FileBase extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, filePath, options = {}) {
+        var _b, _c, _d, _e;
+        super(project);
+        this.readonly = (_b = options.readonly) !== null && _b !== void 0 ? _b : true;
+        this.executable = (_c = options.executable) !== null && _c !== void 0 ? _c : false;
+        this.path = filePath;
+        const globPattern = `/${this.path}`;
+        const committed = (_d = options.committed) !== null && _d !== void 0 ? _d : true;
+        if (committed && filePath !== '.gitattributes') {
+            project.root.annotateGenerated(`/${filePath}`);
+        }
+        this.absolutePath = path.resolve(project.outdir, filePath);
+        // verify file path is unique within project tree
+        const existing = project.root.tryFindFile(this.absolutePath);
+        if (existing && existing !== this) {
+            throw new Error(`there is already a file under ${path.relative(project.root.outdir, this.absolutePath)}`);
+        }
+        const editGitignore = (_e = options.editGitignore) !== null && _e !== void 0 ? _e : true;
+        if (editGitignore) {
+            this.project.addGitIgnore(`${committed ? '!' : ''}${globPattern}`);
+        }
+        else {
+            if (options.committed != null) {
+                throw new Error('"gitignore" is disabled, so it does not make sense to specify "committed"');
+            }
+        }
+    }
+    /**
+     * (experimental) Writes the file to the project's output directory.
+     *
+     * @experimental
+     */
+    synthesize() {
+        const outdir = this.project.outdir;
+        const filePath = path.join(outdir, this.path);
+        const resolver = { resolve: (obj, options) => _resolve_1.resolve(obj, options) };
+        const content = this.synthesizeContent(resolver);
+        if (content === undefined) {
+            return; // skip
+        }
+        util_1.writeFile(filePath, content, {
+            readonly: this.readonly,
+            executable: this.executable,
+        });
+    }
+}
+exports.FileBase = FileBase;
+_a = JSII_RTTI_SYMBOL_1;
+FileBase[_a] = { fqn: "projen.FileBase", version: "0.46.8" };
+/**
+ * (experimental) The marker to embed in files in order to identify them as projen files.
+ *
+ * This marker is used to prune these files before synthesis.
+ *
+ * @experimental
+ */
+FileBase.PROJEN_MARKER = `${common_1.PROJEN_MARKER}. To modify, edit ${common_1.PROJEN_RC} and run "npx projen".`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.js","sourceRoot":"","sources":["../src/file.ts"],"names":[],"mappings":";;;;;AAAA,6BAA6B;AAC7B,yCAAqC;AACrC,qCAAoD;AACpD,2CAAwC;AAExC,iCAAmC;;;;AAgBnC,MAAsB,QAAS,SAAQ,qBAAS;;;;IAgB9C,YAAY,OAAgB,EAAE,QAAgB,EAAE,UAA2B,EAAG;;QAC5E,KAAK,CAAC,OAAO,CAAC,CAAC;QAGf,IAAI,CAAC,QAAQ,SAAG,OAAO,CAAC,QAAQ,mCAAI,IAAI,CAAC;QACzC,IAAI,CAAC,UAAU,SAAG,OAAO,CAAC,UAAU,mCAAI,KAAK,CAAC;QAC9C,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;QAErB,MAAM,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QACpC,MAAM,SAAS,SAAG,OAAO,CAAC,SAAS,mCAAI,IAAI,CAAC;QAC5C,IAAI,SAAS,IAAI,QAAQ,KAAK,gBAAgB,EAAE;YAC9C,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,QAAQ,EAAE,CAAC,CAAC;SAChD;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAE3D,iDAAiD;QACjD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC7D,IAAI,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE;YACjC,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;SAC3G;QAED,MAAM,aAAa,SAAG,OAAO,CAAC,aAAa,mCAAI,IAAI,CAAC;QACpD,IAAI,aAAa,EAAE;YACjB,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,WAAW,EAAE,CAAC,CAAC;SACpE;aAAM;YACL,IAAI,OAAO,CAAC,SAAS,IAAI,IAAI,EAAE;gBAC7B,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAC;aAC9F;SACF;IACH,CAAC;;;;;;IAMM,UAAU;QACf,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,QAAQ,GAAc,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,kBAAO,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,CAAC;QACjF,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACjD,IAAI,OAAO,KAAK,SAAS,EAAE;YACzB,OAAO,CAAC,OAAO;SAChB;QACD,gBAAS,CAAC,QAAQ,EAAE,OAAO,EAAE;YAC3B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC,CAAC;IACL,CAAC;;AAhEH,4BAiEC;;;;;;;;;;AA/DwB,sBAAa,GAAG,GAAG,sBAAa,qBAAqB,kBAAS,wBAAwB,CAAC","sourcesContent":["import * as path from 'path';\nimport { resolve } from './_resolve';\nimport { PROJEN_MARKER, PROJEN_RC } from './common';\nimport { Component } from './component';\nimport { Project } from './project';\nimport { writeFile } from './util';\n\nexport interface FileBaseOptions {\n                                                                                                                                                                                                                                    \n  readonly committed?: boolean;\n\n                                                                        \n  readonly editGitignore?: boolean;\n\n                                                                                       \n  readonly readonly?: boolean;\n\n                                                                                                    \n  readonly executable?: boolean;\n}\n\nexport abstract class FileBase extends Component {\n                                                                                                                                                        \n  public static readonly PROJEN_MARKER = `${PROJEN_MARKER}. To modify, edit ${PROJEN_RC} and run \"npx projen\".`;\n\n                                                             \n  public readonly path: string;\n\n                                                                         \n  public readonly: boolean;\n\n                                                                     \n  public executable: boolean;\n\n                                                \n  public readonly absolutePath: string;\n\n  constructor(project: Project, filePath: string, options: FileBaseOptions = { }) {\n    super(project);\n\n\n    this.readonly = options.readonly ?? true;\n    this.executable = options.executable ?? false;\n    this.path = filePath;\n\n    const globPattern = `/${this.path}`;\n    const committed = options.committed ?? true;\n    if (committed && filePath !== '.gitattributes') {\n      project.root.annotateGenerated(`/${filePath}`);\n    }\n\n    this.absolutePath = path.resolve(project.outdir, filePath);\n\n    // verify file path is unique within project tree\n    const existing = project.root.tryFindFile(this.absolutePath);\n    if (existing && existing !== this) {\n      throw new Error(`there is already a file under ${path.relative(project.root.outdir, this.absolutePath)}`);\n    }\n\n    const editGitignore = options.editGitignore ?? true;\n    if (editGitignore) {\n      this.project.addGitIgnore(`${committed ? '!' : ''}${globPattern}`);\n    } else {\n      if (options.committed != null) {\n        throw new Error('\"gitignore\" is disabled, so it does not make sense to specify \"committed\"');\n      }\n    }\n  }\n\n                                                                                                                                                                                                                                                                                   \n  protected abstract synthesizeContent(resolver: IResolver): string | undefined;\n\n                                                                  \n  public synthesize() {\n    const outdir = this.project.outdir;\n    const filePath = path.join(outdir, this.path);\n    const resolver: IResolver = { resolve: (obj, options) => resolve(obj, options) };\n    const content = this.synthesizeContent(resolver);\n    if (content === undefined) {\n      return; // skip\n    }\n    writeFile(filePath, content, {\n      readonly: this.readonly,\n      executable: this.executable,\n    });\n  }\n}\n\n                                                                   \nexport interface IResolver {\n                                                                                                                                                                                                                                              \n  resolve(value: any, options?: ResolveOptions): any;\n}\n\n                           \nexport interface ResolveOptions {\n                                                                    \n  readonly omitEmpty?: boolean;\n\n                                                    \n  readonly args?: any[];\n}\n\nexport interface IResolvable {\n                                              \n  toJSON(): any;\n}\n"]}

package/lib/gitattributes.d.ts

@@ -0,0 +1,29 @@
+import { IResolver, FileBase } from './file';
+import { Project } from './project';
+/**
+ * (experimental) Assign attributes to file names in a git repository.
+ *
+ * @see https://git-scm.com/docs/gitattributes
+ * @experimental
+ */
+export declare class GitAttributesFile extends FileBase {
+    private readonly attributes;
+    /**
+     * @experimental
+     */
+    constructor(project: Project);
+    /**
+     * (experimental) Maps a set of attributes to a set of files.
+     *
+     * @param glob Glob pattern to match files in the repo.
+     * @param attributes Attributes to assign to these files.
+     * @experimental
+     */
+    addAttributes(glob: string, ...attributes: string[]): void;
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    protected synthesizeContent(_: IResolver): string | undefined;
+}