projen
Version:
CDK for software projects
231 lines • 23.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ObjectFile = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const file_1 = require("./file");
const json_patch_1 = require("./json-patch");
const util_1 = require("./util");
/**
* Represents an Object file.
*/
class ObjectFile extends file_1.FileBase {
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.ObjectFile", version: "0.103.12" };
/**
* The output object. This object can be mutated until the project is
* synthesized.
*/
obj;
/**
* An object to be merged on top of `obj` after the resolver is called
*/
rawOverrides;
/**
* Indicates if empty objects and arrays are omitted from the output object.
*/
omitEmpty;
/**
* patches to be applied to `obj` after the resolver is called
*/
patchOperations;
constructor(scope, filePath, options) {
super(scope, filePath, options);
this.obj = options.obj ?? {};
this.omitEmpty = options.omitEmpty ?? false;
this.rawOverrides = {};
this.patchOperations = [];
}
/**
* Adds an override to the synthesized object file.
*
* If the override is nested, separate each nested level using a dot (.) in the path parameter.
* If there is an array as part of the nesting, specify the index in the path.
*
* To include a literal `.` in the property name, prefix with a `\`. In most
* programming languages you will need to write this as `"\\."` because the
* `\` itself will need to be escaped.
*
* For example,
* ```typescript
* project.tsconfig.file.addOverride('compilerOptions.alwaysStrict', true);
* project.tsconfig.file.addOverride('compilerOptions.lib', ['dom', 'dom.iterable', 'esnext']);
* ```
* would add the overrides
* ```json
* "compilerOptions": {
* "alwaysStrict": true,
* "lib": [
* "dom",
* "dom.iterable",
* "esnext"
* ]
* ...
* }
* ...
* ```
*
* @param path - The path of the property, you can use dot notation to
* override values in complex types. Any intermediate keys
* will be created as needed.
* @param value - The value. Could be primitive or complex.
*/
addOverride(path, value) {
const parts = splitOnPeriods(path);
let curr = this.rawOverrides;
while (parts.length > 1) {
const key = parts.shift();
// if we can't recurse further or the previous value is not an
// object overwrite it with an object.
const isObject = curr[key] != null &&
typeof curr[key] === "object" &&
!Array.isArray(curr[key]);
if (!isObject) {
curr[key] = {};
}
curr = curr[key];
}
const lastKey = parts.shift();
curr[lastKey] = value;
}
/**
* Adds to an array in the synthesized object file.
*
* If the array is nested, separate each nested level using a dot (.) in the path parameter.
* If there is an array as part of the nesting, specify the index in the path.
*
* To include a literal `.` in the property name, prefix with a `\`. In most
* programming languages you will need to write this as `"\\."` because the
* `\` itself will need to be escaped.
*
* For example, with the following object file
* ```json
* "compilerOptions": {
* "exclude": ["node_modules"],
* "lib": ["es2020"]
* ...
* }
* ...
* ```
*
* ```typescript
* project.tsconfig.file.addToArray('compilerOptions.exclude', 'coverage');
* project.tsconfig.file.addToArray('compilerOptions.lib', 'dom', 'dom.iterable', 'esnext');
* ```
* would result in the following object file
* ```json
* "compilerOptions": {
* "exclude": ["node_modules", "coverage"],
* "lib": ["es2020", "dom", "dom.iterable", "esnext"]
* ...
* }
* ...
* ```
*
* @param path - The path of the property, you can use dot notation to
* att to arrays in complex types. Any intermediate keys
* will be created as needed.
* @param values - The values to add. Could be primitive or complex.
*/
addToArray(path, ...values) {
const parts = splitOnPeriods(path);
let curr = this.rawOverrides;
while (parts.length > 1) {
const key = parts.shift();
// if we can't recurse further or the previous value is not an
// object overwrite it with an object.
const isObject = curr[key] != null &&
typeof curr[key] === "object" &&
!Array.isArray(curr[key]);
if (!isObject) {
curr[key] = {};
}
curr = curr[key];
}
const lastKey = parts.shift();
if (Array.isArray(curr[lastKey])) {
curr[lastKey].push(...values);
}
else {
curr[lastKey] = {
__$APPEND: [...(curr[lastKey]?.__$APPEND ?? []), ...values],
};
}
}
/**
* Applies an RFC 6902 JSON-patch to the synthesized object file.
* See https://datatracker.ietf.org/doc/html/rfc6902 for more information.
*
* For example, with the following object file
* ```json
* "compilerOptions": {
* "exclude": ["node_modules"],
* "lib": ["es2020"]
* ...
* }
* ...
* ```
*
* ```typescript
* project.tsconfig.file.patch(JsonPatch.add("/compilerOptions/exclude/-", "coverage"));
* project.tsconfig.file.patch(JsonPatch.replace("/compilerOptions/lib", ["dom", "dom.iterable", "esnext"]));
* ```
* would result in the following object file
* ```json
* "compilerOptions": {
* "exclude": ["node_modules", "coverage"],
* "lib": ["dom", "dom.iterable", "esnext"]
* ...
* }
* ...
* ```
*
* @param patches - The patch operations to apply
*/
patch(...patches) {
this.patchOperations.push(patches);
}
/**
* Syntactic sugar for `addOverride(path, undefined)`.
* @param path The path of the value to delete
*/
addDeletionOverride(path) {
this.addOverride(path, undefined);
}
synthesizeContent(resolver) {
const obj = this.obj;
const resolved = resolver.resolve(obj, {
omitEmpty: this.omitEmpty,
}) ?? undefined;
if (resolved) {
(0, util_1.deepMerge)([resolved, this.rawOverrides], { destructive: true });
}
let patched = resolved;
for (const operation of this.patchOperations) {
patched = json_patch_1.JsonPatch.apply(patched, ...operation);
}
return patched ? JSON.stringify(patched, undefined, 2) : undefined;
}
}
exports.ObjectFile = ObjectFile;
/**
* Split on periods while processing escape characters \
*/
function splitOnPeriods(x) {
// Build this list in reverse because it's more convenient to get the "current"
// item by doing ret[0] than by ret[ret.length - 1].
const ret = [""];
for (let i = 0; i < x.length; i++) {
if (x[i] === "\\" && i + 1 < x.length) {
ret[0] += x[i + 1];
i++;
}
else if (x[i] === ".") {
ret.unshift("");
}
else {
ret[0] += x[i];
}
}
ret.reverse();
return ret;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-file.js","sourceRoot":"","sources":["../src/object-file.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IConstruct } from \"constructs\";\nimport type { FileBaseOptions, IResolver } from \"./file\";\nimport { FileBase } from \"./file\";\nimport { JsonPatch } from \"./json-patch\";\nimport { deepMerge } from \"./util\";\n\n/**\n * Options for `ObjectFile`.\n */\nexport interface ObjectFileOptions extends FileBaseOptions {\n  /**\n   * The object that will be serialized. You can modify the object's contents\n   * before synthesis.\n   *\n   * Serialization of the object is similar to JSON.stringify with few enhancements:\n   * - values that are functions will be called during synthesis and the result will be serialized - this allow to have lazy values.\n   * - `Set` will be converted to array\n   * - `Map` will be converted to a plain object ({ key: value, ... }})\n   * - `RegExp` without flags will be converted to string representation of the source\n   *\n   *  @default {} an empty object (use `file.obj` to mutate).\n   */\n  readonly obj?: any;\n\n  /**\n   * Omits empty objects and arrays.\n   * @default false\n   */\n  readonly omitEmpty?: boolean;\n}\n\n/**\n * Represents an Object file.\n */\nexport abstract class ObjectFile extends FileBase {\n  /**\n   * The output object. This object can be mutated until the project is\n   * synthesized.\n   */\n  private readonly obj: object;\n\n  /**\n   * An object to be merged on top of `obj` after the resolver is called\n   */\n  private readonly rawOverrides: object;\n\n  /**\n   * Indicates if empty objects and arrays are omitted from the output object.\n   */\n  public readonly omitEmpty: boolean;\n\n  /**\n   * patches to be applied to `obj` after the resolver is called\n   */\n  private readonly patchOperations: Array<JsonPatch[]>;\n\n  constructor(scope: IConstruct, filePath: string, options: ObjectFileOptions) {\n    super(scope, filePath, options);\n\n    this.obj = options.obj ?? {};\n    this.omitEmpty = options.omitEmpty ?? false;\n    this.rawOverrides = {};\n    this.patchOperations = [];\n  }\n\n  /**\n   * Adds an override to the synthesized object file.\n   *\n   * If the override is nested, separate each nested level using a dot (.) in the path parameter.\n   * If there is an array as part of the nesting, specify the index in the path.\n   *\n   * To include a literal `.` in the property name, prefix with a `\\`. In most\n   * programming languages you will need to write this as `\"\\\\.\"` because the\n   * `\\` itself will need to be escaped.\n   *\n   * For example,\n   * ```typescript\n   * project.tsconfig.file.addOverride('compilerOptions.alwaysStrict', true);\n   * project.tsconfig.file.addOverride('compilerOptions.lib', ['dom', 'dom.iterable', 'esnext']);\n   * ```\n   * would add the overrides\n   * ```json\n   * \"compilerOptions\": {\n   *   \"alwaysStrict\": true,\n   *   \"lib\": [\n   *     \"dom\",\n   *     \"dom.iterable\",\n   *     \"esnext\"\n   *   ]\n   *   ...\n   * }\n   * ...\n   * ```\n   *\n   * @param path - The path of the property, you can use dot notation to\n   *        override values in complex types. Any intermediate keys\n   *        will be created as needed.\n   * @param value - The value. Could be primitive or complex.\n   */\n  public addOverride(path: string, value: any) {\n    const parts = splitOnPeriods(path);\n    let curr: any = this.rawOverrides;\n\n    while (parts.length > 1) {\n      const key = parts.shift()!;\n\n      // if we can't recurse further or the previous value is not an\n      // object overwrite it with an object.\n      const isObject =\n        curr[key] != null &&\n        typeof curr[key] === \"object\" &&\n        !Array.isArray(curr[key]);\n      if (!isObject) {\n        curr[key] = {};\n      }\n\n      curr = curr[key];\n    }\n\n    const lastKey = parts.shift()!;\n    curr[lastKey] = value;\n  }\n\n  /**\n   * Adds to an array in the synthesized object file.\n   *\n   * If the array is nested, separate each nested level using a dot (.) in the path parameter.\n   * If there is an array as part of the nesting, specify the index in the path.\n   *\n   * To include a literal `.` in the property name, prefix with a `\\`. In most\n   * programming languages you will need to write this as `\"\\\\.\"` because the\n   * `\\` itself will need to be escaped.\n   *\n   * For example, with the following object file\n   * ```json\n   * \"compilerOptions\": {\n   *   \"exclude\": [\"node_modules\"],\n   *   \"lib\": [\"es2020\"]\n   *   ...\n   * }\n   * ...\n   * ```\n   *\n   * ```typescript\n   * project.tsconfig.file.addToArray('compilerOptions.exclude', 'coverage');\n   * project.tsconfig.file.addToArray('compilerOptions.lib', 'dom', 'dom.iterable', 'esnext');\n   * ```\n   * would result in the following object file\n   * ```json\n   * \"compilerOptions\": {\n   *   \"exclude\": [\"node_modules\", \"coverage\"],\n   *   \"lib\": [\"es2020\", \"dom\", \"dom.iterable\", \"esnext\"]\n   *   ...\n   * }\n   * ...\n   * ```\n   *\n   * @param path - The path of the property, you can use dot notation to\n   *        att to arrays in complex types. Any intermediate keys\n   *        will be created as needed.\n   * @param values - The values to add. Could be primitive or complex.\n   */\n  public addToArray(path: string, ...values: any) {\n    const parts = splitOnPeriods(path);\n    let curr: any = this.rawOverrides;\n\n    while (parts.length > 1) {\n      const key = parts.shift()!;\n\n      // if we can't recurse further or the previous value is not an\n      // object overwrite it with an object.\n      const isObject =\n        curr[key] != null &&\n        typeof curr[key] === \"object\" &&\n        !Array.isArray(curr[key]);\n      if (!isObject) {\n        curr[key] = {};\n      }\n\n      curr = curr[key];\n    }\n\n    const lastKey = parts.shift()!;\n    if (Array.isArray(curr[lastKey])) {\n      curr[lastKey].push(...values);\n    } else {\n      curr[lastKey] = {\n        __$APPEND: [...(curr[lastKey]?.__$APPEND ?? []), ...values],\n      };\n    }\n  }\n\n  /**\n   * Applies an RFC 6902 JSON-patch to the synthesized object file.\n   * See https://datatracker.ietf.org/doc/html/rfc6902 for more information.\n   *\n   * For example, with the following object file\n   * ```json\n   * \"compilerOptions\": {\n   *   \"exclude\": [\"node_modules\"],\n   *   \"lib\": [\"es2020\"]\n   *   ...\n   * }\n   * ...\n   * ```\n   *\n   * ```typescript\n   * project.tsconfig.file.patch(JsonPatch.add(\"/compilerOptions/exclude/-\", \"coverage\"));\n   * project.tsconfig.file.patch(JsonPatch.replace(\"/compilerOptions/lib\", [\"dom\", \"dom.iterable\", \"esnext\"]));\n   * ```\n   * would result in the following object file\n   * ```json\n   * \"compilerOptions\": {\n   *   \"exclude\": [\"node_modules\", \"coverage\"],\n   *   \"lib\": [\"dom\", \"dom.iterable\", \"esnext\"]\n   *   ...\n   * }\n   * ...\n   * ```\n   *\n   * @param patches - The patch operations to apply\n   */\n  public patch(...patches: JsonPatch[]) {\n    this.patchOperations.push(patches);\n  }\n\n  /**\n   * Syntactic sugar for `addOverride(path, undefined)`.\n   * @param path The path of the value to delete\n   */\n  public addDeletionOverride(path: string) {\n    this.addOverride(path, undefined);\n  }\n\n  protected synthesizeContent(resolver: IResolver): string | undefined {\n    const obj = this.obj;\n\n    const resolved =\n      resolver.resolve(obj, {\n        omitEmpty: this.omitEmpty,\n      }) ?? undefined;\n\n    if (resolved) {\n      deepMerge([resolved, this.rawOverrides], { destructive: true });\n    }\n\n    let patched = resolved;\n    for (const operation of this.patchOperations) {\n      patched = JsonPatch.apply(patched, ...operation);\n    }\n    return patched ? JSON.stringify(patched, undefined, 2) : undefined;\n  }\n}\n\n/**\n * Split on periods while processing escape characters \\\n */\nfunction splitOnPeriods(x: string): string[] {\n  // Build this list in reverse because it's more convenient to get the \"current\"\n  // item by doing ret[0] than by ret[ret.length - 1].\n  const ret = [\"\"];\n  for (let i = 0; i < x.length; i++) {\n    if (x[i] === \"\\\\\" && i + 1 < x.length) {\n      ret[0] += x[i + 1];\n      i++;\n    } else if (x[i] === \".\") {\n      ret.unshift(\"\");\n    } else {\n      ret[0] += x[i];\n    }\n  }\n\n  ret.reverse();\n  return ret;\n}\n"]}