projen
Version:
CDK for software projects
252 lines • 30.9 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.FutureComponent = exports.Component = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const constructs_1 = require("constructs");
const constructs_2 = require("./util/constructs");
const autoIds = new WeakMap();
const componentId = (scope) => {
const nextId = (autoIds.get(scope) ?? 0) + 1;
autoIds.set(scope, nextId);
return `AutoId${nextId}`;
};
/**
* Represents a project component.
* @param project
* @param id Unique id of the component. If not provided, an unstable AutoId is generated.
*/
class Component extends constructs_1.Construct {
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.Component", version: "0.103.12" };
/**
* Test whether the given construct is a component.
*/
static isComponent(x) {
return (0, constructs_2.isComponent)(x);
}
project;
constructor(scope, id) {
super(scope, id || `${new.target.name}#${componentId(scope)}`);
(0, constructs_2.tagAsComponent)(this);
this.node.addMetadata("type", "component");
this.node.addMetadata("construct", new.target.name);
this.project = (0, constructs_2.findClosestProject)(scope, new.target.name);
}
/**
* Called before synthesis.
*/
preSynthesize() { }
/**
* Synthesizes files to the project output directory.
*/
synthesize() { }
/**
* Called after synthesis. Order is *not* guaranteed.
*/
postSynthesize() { }
/**
* Called once, right after `synthesize()`, only when the project is created for the first time.
*
* It does not run on later `projen` invocations. It only fires for `projen new` (or `Projects.createProject`).
* Use it for deterministic, one-off file generation. Order across components is not guaranteed.
*
* @param initProject Details about how the project was created, e.g. its type and the original CLI args.
*/
projectCreation(initProject) {
initProject;
}
/**
* Called once, right after `postSynthesize()`, only when the project is created for the first time.
*
* It does not run on later `projen` invocations. It only fires for `projen new` (or `Projects.createProject`).
* It is also skipped when post-synthesis steps are disabled, e.g. `--no-post` or `PROJEN_DISABLE_POST`.
* Use it for one-off setup that can be turned off by the user, like running a task to give the user immediate
* feedback on their new project. Order across components is not guaranteed.
*
* @param initProject Details about how the project was created, e.g. its type and the original CLI args.
*/
postProjectCreation(initProject) {
initProject;
}
}
exports.Component = Component;
/**
* Internal flag key read by the detached-guard proxy. A symbol so it never
* collides with a real (string-keyed) member and is always readable through the
* guard (symbol access is never blocked).
*/
const FUTURE_ATTACHED = Symbol.for("projen.future.attached");
/**
* The members a detached future component is allowed to expose. Reading anything
* else before attach throws. (`copy` is the copyable capability method a
* copyable subclass adds, per the `recreate()` convention.)
*/
const DETACHED_ALLOWLIST = new Set([
"attach",
"tryAttach",
"attached",
"copy",
"constructor",
"toString",
]);
/**
* Wrap a freshly constructed {@link FutureComponent} in a guard proxy.
*
* Two jobs:
*
* 1. Block use before attach. While detached, any property read outside
* {@link DETACHED_ALLOWLIST} (and outside symbol keys, which always pass so
* `instanceof`, jsii and inspection keep working) throws instead of silently
* returning shadow-tree state.
* 2. "Drop" itself on attach. Once attached, the guard is a transparent
* pass-through: a single boolean check, then `Reflect`. Every method it
* returns is bound to the *real* target, so the moment you call one method
* the work continues on the bare object with no further proxy traps.
*
* Only `get` is guarded. `set` is intentionally left open so a subclass
* constructor can assign its own fields (e.g. `this.options = options`).
*/
function guardDetached(target) {
const boundCache = new Map();
const handler = {
get(t, prop) {
// never present as a thenable, or `await futureComponent` would hang/throw
if (prop === "then") {
return undefined;
}
const attached = t[FUTURE_ATTACHED] === true;
const allowed = attached || typeof prop !== "string" || DETACHED_ALLOWLIST.has(prop);
if (!allowed) {
const name = t.newTargetName ?? t.constructor.name;
throw new Error(`Cannot access '${String(prop)}' on ${name}: a future component is ` +
`not usable until it is attached. Call attach(scope) first, or pass ` +
`it to a Project which attaches it for you.`);
}
// bind functions to the *real* target so that, once invoked, all internal
// `this` access happens on the bare object with no proxy involvement.
const value = Reflect.get(t, prop, t);
if (typeof value === "function") {
let bound = boundCache.get(prop);
if (!bound) {
bound = value.bind(t);
boundCache.set(prop, bound);
}
return bound;
}
return value;
},
};
return new Proxy(target, handler);
}
/**
* A {@link Component} that is created *detached* from any project and attached
* to one later via {@link FutureComponent.attach}.
*
* Like a regular component, but constructed without a project. It improves on a
* naive deferred component in three ways:
*
* - Use-before-attach is an error, not a silent footgun. The constructor hands
* the caller a guard proxy; touching `project`, `node`, `synthesize()` or any
* subclass feature before `attach()` throws.
* - No global shadow-tree leak. Each instance gets its own throwaway shadow
* root, so detached components never share an id counter and the root becomes
* garbage once the component is reparented on attach.
* - `attach()` returns the unwrapped component, so callers can opt out of the
* proxy entirely.
*
* The constructor takes no arguments (`super()`). A subclass that needs options
* captures them itself, reading the local parameter inside its constructor - NOT
* `this.options`, which the guard blocks until attach.
*
* ```ts
* class Worker extends FutureComponent {
* private readonly options: WorkerOptions;
* constructor(options: WorkerOptions = {}) {
* super();
* this.options = options; // set: allowed
* }
* protected init() {
* // this.project is available here
* }
* }
*
* const w = new Worker({ retries: 3 });
* // w.project; // throws: not attached yet
* const real = w.attach(project); // reparents, runs init(), returns the bare instance
* ```
*/
class FutureComponent extends Component {
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.FutureComponent", version: "0.103.12" };
newTargetName;
attachedState = false;
constructor() {
// Each future component gets its OWN shadow root. Unlike a single global
// shadow tree, detached components never collide on an id counter, and the
// root is collected once we reparent on attach().
const shadow = new constructs_1.RootConstruct();
(0, constructs_2.tagAsProject)(shadow);
super(shadow);
this.newTargetName = new.target.name;
// Hand the caller a guarded proxy. `this` here is still the bare object;
// returning it makes the proxy the instance seen by `new`. Because the base
// constructor returns an object, subclass constructors transparently adopt
// the proxy as their `this` too.
return guardDetached(this);
}
/**
* Whether `attach()` has been called. A convenience for tests/introspection;
* prefer `tryAttach()` over reading this and branching.
*/
get attached() {
return this.attachedState;
}
/**
* Project-dependent setup. Runs once, from `attach()`, when `this.project` is
* finally available.
*/
init() { }
/**
* Attach the component to a scope. Only now does it become usable.
*
* Returns the real, unwrapped component (not the proxy). A component may be
* attached exactly once; attaching an already-attached component throws (copy
* it first to attach a variant elsewhere). Use `tryAttach()` if you don't care
* whether it has already been attached.
*/
attach(scope, id) {
if (this.attachedState) {
throw new Error(`${this.newTargetName} is already attached to '${this.project.node.path}'. ` +
`Use \`tryAttach\` or \`copy\` it to attach a variant.`);
}
// constructs has no public reparent, so build a fresh node on the real
// scope. The per-instance shadow root and its original node become an
// unreachable island and are collected.
this.node = new constructs_1.Node(this, scope, id ?? componentId(scope));
// The component already carries the component tag (set by the base
// constructor, which is idempotent against the same object); re-add the
// metadata to the new node and resolve the real project.
this.node.addMetadata("type", "component");
this.node.addMetadata("construct", this.newTargetName);
this.project = (0, constructs_2.findClosestProject)(scope, this.newTargetName);
this.attachedState = true;
// Flip the guard into transparent pass-through for any proxy handles the
// caller still holds. Symbol key, so the guard can always read it.
this[FUTURE_ATTACHED] = true;
// project is now available, run project-dependent setup
this.init();
// hand back the bare object so the caller can drop the proxy entirely
return this;
}
/**
* Attach the component if it isn't already, without caring *where*.
*
* Unlike `attach()`, never throws on an already-attached component: if attached
* anywhere at all, the existing instance is returned and `scope` is ignored.
* Use `attach()` when attaching to a specific scope is part of your contract
* and a pre-existing attachment elsewhere would be a bug.
*/
tryAttach(scope, id) {
return this.attachedState ? this : this.attach(scope, id);
}
}
exports.FutureComponent = FutureComponent;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IConstruct } from \"constructs\";\nimport { Construct, Node, RootConstruct } from \"constructs\";\nimport type { InitProject, Project } from \"./project\";\nimport {\n  isComponent,\n  findClosestProject,\n  tagAsComponent,\n  tagAsProject,\n} from \"./util/constructs\";\n\nconst autoIds = new WeakMap<IConstruct, number>();\nconst componentId = (scope: IConstruct) => {\n  const nextId = (autoIds.get(scope) ?? 0) + 1;\n  autoIds.set(scope, nextId);\n  return `AutoId${nextId}`;\n};\n\n/**\n * Represents a project component.\n * @param project\n * @param id Unique id of the component. If not provided, an unstable AutoId is generated.\n */\nexport class Component extends Construct {\n  /**\n   * Test whether the given construct is a component.\n   */\n  public static isComponent(x: any): x is Component {\n    return isComponent(x);\n  }\n\n  public readonly project: Project;\n\n  constructor(scope: IConstruct, id?: string) {\n    super(scope, id || `${new.target.name}#${componentId(scope)}`);\n    tagAsComponent(this);\n    this.node.addMetadata(\"type\", \"component\");\n    this.node.addMetadata(\"construct\", new.target.name);\n\n    this.project = findClosestProject(scope, new.target.name);\n  }\n\n  /**\n   * Called before synthesis.\n   */\n  public preSynthesize() {}\n\n  /**\n   * Synthesizes files to the project output directory.\n   */\n  public synthesize() {}\n\n  /**\n   * Called after synthesis. Order is *not* guaranteed.\n   */\n  public postSynthesize() {}\n\n  /**\n   * Called once, right after `synthesize()`, only when the project is created for the first time.\n   *\n   * It does not run on later `projen` invocations. It only fires for `projen new` (or `Projects.createProject`).\n   * Use it for deterministic, one-off file generation. Order across components is not guaranteed.\n   *\n   * @param initProject Details about how the project was created, e.g. its type and the original CLI args.\n   */\n  public projectCreation(initProject: InitProject) {\n    initProject;\n  }\n\n  /**\n   * Called once, right after `postSynthesize()`, only when the project is created for the first time.\n   *\n   * It does not run on later `projen` invocations. It only fires for `projen new` (or `Projects.createProject`).\n   * It is also skipped when post-synthesis steps are disabled, e.g. `--no-post` or `PROJEN_DISABLE_POST`.\n   * Use it for one-off setup that can be turned off by the user, like running a task to give the user immediate\n   * feedback on their new project. Order across components is not guaranteed.\n   *\n   * @param initProject Details about how the project was created, e.g. its type and the original CLI args.\n   */\n  public postProjectCreation(initProject: InitProject) {\n    initProject;\n  }\n}\n\n/**\n * Internal flag key read by the detached-guard proxy. A symbol so it never\n * collides with a real (string-keyed) member and is always readable through the\n * guard (symbol access is never blocked).\n */\nconst FUTURE_ATTACHED = Symbol.for(\"projen.future.attached\");\n\n/**\n * The members a detached future component is allowed to expose. Reading anything\n * else before attach throws. (`copy` is the copyable capability method a\n * copyable subclass adds, per the `recreate()` convention.)\n */\nconst DETACHED_ALLOWLIST = new Set<PropertyKey>([\n  \"attach\",\n  \"tryAttach\",\n  \"attached\",\n  \"copy\",\n  \"constructor\",\n  \"toString\",\n]);\n\n/**\n * Wrap a freshly constructed {@link FutureComponent} in a guard proxy.\n *\n * Two jobs:\n *\n * 1. Block use before attach. While detached, any property read outside\n *    {@link DETACHED_ALLOWLIST} (and outside symbol keys, which always pass so\n *    `instanceof`, jsii and inspection keep working) throws instead of silently\n *    returning shadow-tree state.\n * 2. \"Drop\" itself on attach. Once attached, the guard is a transparent\n *    pass-through: a single boolean check, then `Reflect`. Every method it\n *    returns is bound to the *real* target, so the moment you call one method\n *    the work continues on the bare object with no further proxy traps.\n *\n * Only `get` is guarded. `set` is intentionally left open so a subclass\n * constructor can assign its own fields (e.g. `this.options = options`).\n */\nfunction guardDetached<T extends object>(target: T): T {\n  const boundCache = new Map<PropertyKey, (...args: any[]) => any>();\n  const handler: ProxyHandler<T> = {\n    get(t, prop) {\n      // never present as a thenable, or `await futureComponent` would hang/throw\n      if (prop === \"then\") {\n        return undefined;\n      }\n\n      const attached = (t as any)[FUTURE_ATTACHED] === true;\n      const allowed =\n        attached || typeof prop !== \"string\" || DETACHED_ALLOWLIST.has(prop);\n\n      if (!allowed) {\n        const name = (t as any).newTargetName ?? t.constructor.name;\n        throw new Error(\n          `Cannot access '${String(prop)}' on ${name}: a future component is ` +\n            `not usable until it is attached. Call attach(scope) first, or pass ` +\n            `it to a Project which attaches it for you.`,\n        );\n      }\n\n      // bind functions to the *real* target so that, once invoked, all internal\n      // `this` access happens on the bare object with no proxy involvement.\n      const value = Reflect.get(t, prop, t);\n      if (typeof value === \"function\") {\n        let bound = boundCache.get(prop);\n        if (!bound) {\n          bound = (value as (...args: any[]) => any).bind(t);\n          boundCache.set(prop, bound);\n        }\n        return bound;\n      }\n      return value;\n    },\n  };\n  return new Proxy(target, handler);\n}\n\n/**\n * Make a specific property writable again.\n */\ntype WriteableProp<T, K extends keyof T> = Omit<T, K> & {\n  -readonly [P in K]: T[P];\n};\n\n/**\n * A {@link Component} that is created *detached* from any project and attached\n * to one later via {@link FutureComponent.attach}.\n *\n * Like a regular component, but constructed without a project. It improves on a\n * naive deferred component in three ways:\n *\n * - Use-before-attach is an error, not a silent footgun. The constructor hands\n *   the caller a guard proxy; touching `project`, `node`, `synthesize()` or any\n *   subclass feature before `attach()` throws.\n * - No global shadow-tree leak. Each instance gets its own throwaway shadow\n *   root, so detached components never share an id counter and the root becomes\n *   garbage once the component is reparented on attach.\n * - `attach()` returns the unwrapped component, so callers can opt out of the\n *   proxy entirely.\n *\n * The constructor takes no arguments (`super()`). A subclass that needs options\n * captures them itself, reading the local parameter inside its constructor - NOT\n * `this.options`, which the guard blocks until attach.\n *\n * ```ts\n * class Worker extends FutureComponent {\n *   private readonly options: WorkerOptions;\n *   constructor(options: WorkerOptions = {}) {\n *     super();\n *     this.options = options; // set: allowed\n *   }\n *   protected init() {\n *     // this.project is available here\n *   }\n * }\n *\n * const w = new Worker({ retries: 3 });\n * // w.project;                  // throws: not attached yet\n * const real = w.attach(project); // reparents, runs init(), returns the bare instance\n * ```\n */\nexport abstract class FutureComponent extends Component {\n  private readonly newTargetName: string;\n  private attachedState = false;\n\n  constructor() {\n    // Each future component gets its OWN shadow root. Unlike a single global\n    // shadow tree, detached components never collide on an id counter, and the\n    // root is collected once we reparent on attach().\n    const shadow = new RootConstruct();\n    tagAsProject(shadow);\n    super(shadow);\n\n    this.newTargetName = new.target.name;\n\n    // Hand the caller a guarded proxy. `this` here is still the bare object;\n    // returning it makes the proxy the instance seen by `new`. Because the base\n    // constructor returns an object, subclass constructors transparently adopt\n    // the proxy as their `this` too.\n    return guardDetached(this);\n  }\n\n  /**\n   * Whether `attach()` has been called. A convenience for tests/introspection;\n   * prefer `tryAttach()` over reading this and branching.\n   */\n  public get attached(): boolean {\n    return this.attachedState;\n  }\n\n  /**\n   * Project-dependent setup. Runs once, from `attach()`, when `this.project` is\n   * finally available.\n   */\n  protected init(): void {}\n\n  /**\n   * Attach the component to a scope. Only now does it become usable.\n   *\n   * Returns the real, unwrapped component (not the proxy). A component may be\n   * attached exactly once; attaching an already-attached component throws (copy\n   * it first to attach a variant elsewhere). Use `tryAttach()` if you don't care\n   * whether it has already been attached.\n   */\n  public attach(scope: IConstruct, id?: string) {\n    if (this.attachedState) {\n      throw new Error(\n        `${this.newTargetName} is already attached to '${this.project.node.path}'. ` +\n          `Use \\`tryAttach\\` or \\`copy\\` it to attach a variant.`,\n      );\n    }\n    // constructs has no public reparent, so build a fresh node on the real\n    // scope. The per-instance shadow root and its original node become an\n    // unreachable island and are collected.\n    (this as WriteableProp<this, \"node\">).node = new Node(\n      this,\n      scope,\n      id ?? componentId(scope),\n    );\n\n    // The component already carries the component tag (set by the base\n    // constructor, which is idempotent against the same object); re-add the\n    // metadata to the new node and resolve the real project.\n    this.node.addMetadata(\"type\", \"component\");\n    this.node.addMetadata(\"construct\", this.newTargetName);\n    (this as WriteableProp<this, \"project\">).project = findClosestProject(\n      scope,\n      this.newTargetName,\n    );\n\n    this.attachedState = true;\n    // Flip the guard into transparent pass-through for any proxy handles the\n    // caller still holds. Symbol key, so the guard can always read it.\n    (this as any)[FUTURE_ATTACHED] = true;\n\n    // project is now available, run project-dependent setup\n    this.init();\n\n    // hand back the bare object so the caller can drop the proxy entirely\n    return this;\n  }\n\n  /**\n   * Attach the component if it isn't already, without caring *where*.\n   *\n   * Unlike `attach()`, never throws on an already-attached component: if attached\n   * anywhere at all, the existing instance is returned and `scope` is ignored.\n   * Use `attach()` when attaching to a specific scope is part of your contract\n   * and a pre-existing attachment elsewhere would be a bug.\n   */\n  public tryAttach(scope: IConstruct, id?: string) {\n    return this.attachedState ? this : this.attach(scope, id);\n  }\n}\n"]}