projen 0.34.13 → 0.34.17

package/node_modules/xmlbuilder2/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 19 Nov 2021 08:31:10 GMT
+ * Last updated: Tue, 23 Nov 2021 19:31:07 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`
 

package/node_modules/xmlbuilder2/node_modules/@types/node/fs.d.ts

@@ -260,6 +260,29 @@ declare module 'fs' {
          */
         readSync(): Dirent | null;
     }
+    /**
+     * Class: fs.StatWatcher
+     * @since v14.3.0, v12.20.0
+     * Extends `EventEmitter`
+     * A successful call to {@link watchFile} method will return a new fs.StatWatcher object.
+     */
+    export interface StatWatcher extends EventEmitter {
+        /**
+         * @since v14.3.0, v12.20.0
+         * When called, requests that the Node.js event loop not exit so long as the `fs.StatWatcher` is active.
+         * Calling `watcher.ref()` multiple times will have no effect.
+         * By default, all `fs.StatWatcher`` objects are "ref'ed", making it normally unnecessary to call `watcher.ref()`
+         * unless `watcher.unref()` had been called previously.
+         */
+        ref(): this;
+        /**
+         * @since v14.3.0, v12.20.0
+         * When called, the active `fs.StatWatcher`` object will not require the Node.js event loop to remain active.
+         * If there is no other activity keeping the event loop running, the process may exit before the `fs.StatWatcher`` object's callback is invoked.
+         * `Calling watcher.unref()` multiple times will have no effect.
+         */
+        unref(): this;
+    }
     export interface FSWatcher extends EventEmitter {
         /**
          * Stop watching for changes on the given `fs.FSWatcher`. Once stopped, the `fs.FSWatcher` object is no longer usable.
@@ -2784,21 +2807,34 @@ declare module 'fs' {
      * * the file is renamed and then renamed a second time back to its original name
      * @since v0.1.31
      */
+    export interface WatchFileOptions {
+        bigint?: boolean | undefined;
+        persistent?: boolean | undefined;
+        interval?: number | undefined;
+    }
     export function watchFile(
         filename: PathLike,
         options:
-            | {
-                  persistent?: boolean | undefined;
-                  interval?: number | undefined;
-              }
+            | (WatchFileOptions & {
+                  bigint?: false | undefined;
+              })
             | undefined,
         listener: (curr: Stats, prev: Stats) => void
-    ): void;
+    ): StatWatcher;
+    export function watchFile(
+        filename: PathLike,
+        options:
+            | (WatchFileOptions & {
+                  bigint: true;
+              })
+            | undefined,
+        listener: (curr: BigIntStats, prev: BigIntStats) => void
+    ): StatWatcher;
     /**
      * Watch for changes on `filename`. The callback `listener` will be called each time the file is accessed.
      * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
      */
-    export function watchFile(filename: PathLike, listener: (curr: Stats, prev: Stats) => void): void;
+    export function watchFile(filename: PathLike, listener: (curr: Stats, prev: Stats) => void): StatWatcher;
     /**
      * Stop watching for changes on `filename`. If `listener` is specified, only that
      * particular listener is removed. Otherwise, _all_ listeners are removed,

package/node_modules/xmlbuilder2/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.11.9",
+    "version": "16.11.10",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -225,6 +225,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "d38d785af313406345e5384ce39a1c5750b72c1893eb022dca68dc7f95f943cf",
+    "typesPublisherContentHash": "b24d5d157d742f1a54b5d70ed1c014862c87e0187063c31ed2038790f909f02d",
     "typeScriptVersion": "3.8"
 }

package/package.json

@@ -64,7 +64,7 @@
     "jsii-docgen": "^1.8.110",
     "jsii-pacmak": "^1.46.0",
     "json-schema": "^0.4.0",
-    "markmac": "^0.1.97",
+    "markmac": "^0.1.99",
     "npm-check-updates": "^11",
     "standard-version": "^9",
     "ts-jest": "^27.0.7",
@@ -111,7 +111,7 @@
   },
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "0.34.13",
+  "version": "0.34.17",
   "jest": {
     "testMatch": [
       "**/__tests__/**/*.ts?(x)",

package/rfcs/github-project-settings.md

@@ -0,0 +1,95 @@
+# External GitHub Repository Settings (RFC #1014)
+
+> **Author**: [@eladb](https://github.com/eladb), **Status**: Draft
+
+Projen is great for managing project-related configuration that is modeled in
+files within the git repository. Much of GitHub's configuration (such as issue
+templates, workflows, etc) is managed through files under `.github` and to that
+extend, projen lends itself well to maintain these files.
+
+However, there are some GitHub repository settings that are not managed through
+files in the repos. These include things like branch protection rules,
+auto-merge options, and most noteable are repository secrets. Projen heavily
+relies on repository secrets for things like publishing tokens.
+
+When maintaining many projects, manaing publishing secrets becomes a major
+burden. It is also error prone and has potential security implications. Ideally
+these secrets should be managed by tooling and not by humans.
+
+GitHub offers some support for centrally managing secrets but these require
+organization-level permissions which are not always available.
+
+## README (working backwards)
+
+Let’s say we have a JSII project. By default, it does not publish to PyPI. Let's
+add Python publishing to our project.
+
+First, we need edit your `projenrc.js` file and add the `publishToPyPi` setting.
+Additionally, set the `secrets` option to tell Projen to retrieve secrets from
+AWS Secrets Manager (in the future other secret sources will be supported):
+
+```js
+const projen = require('projen');
+
+const project = new projen.JsiiProject({
+  // ...
+  
+  secrets: projen.Secrets.fromAwsSecretsManager('arn:aws:secretsmanager:us-east-1:111111111111:secret:projen-publishing-tokens'),
+  publishToPyPi: {
+    distName: 'foo-bar',
+    module: 'foo_bar',
+  },
+});
+```
+
+> NOTE: not sure I like the union-like API, but we can debate that later.
+
+Now, as usual, execute `npx projen`.
+
+Under the hood, projen uses `gh secret list` to check if your repo has the
+desired secrets. If not, it will retrieve them from AWS Secrets Manager and
+store them in your repository via the GitHub API.
+
+```shell
+$ npx projen
+Synthesizing project...
+Storing TWINE_USERNAME from arn:aws:secretsmanager:us-east-1:111111111111:secret:projen-publishing-tokens
+Storing TWINE_PASSWORD from arn:aws:secretsmanager:us-east-1:111111111111:secret:projen-publishing-tokens
+Done
+```
+
+_not sure that’s feasible:_ You will also notice that your
+`.github/workflows/release.yml` workflow was updated and now includes a check
+that verifeis that your repository has the desired secrets. This is sort of an
+"anti-tamper check" for external settings. If your repository does not have the
+needed secerts, an error will be displayed with instructions on how to store
+them.
+
+A similar approach can be taken to configure other non-source-code repository
+settings such as branch protection rules:
+
+```js
+# this should be the default probably
+project.addBranchProtection(project.defaultBranch);
+```
+
+Similarly, during synth, given the proper credentials, projen can actually setup
+the project to align with the definition and a workflow on the default branch
+can be used to ensure that the project is compliant.
+
+**Prerequisites:** For this to work, you'll need your development box to have
+GitHub CLI installed and logged in, as well as default AWS credentials with
+access to a secret called `projen-publishing-token` secret in `us-east-1` (as
+defined by the ARN specified under `secrets`). Projen expects to find a field by
+the same name as the secret name (e.g. `TWINE_USERNAME` and `TWINE_PASSWORD`)
+stored in JSON format in the secret. Secrets can be stored using the AWS CLI or
+via the AWS Console.
+
+In the future we can offer a CLI command to store secrets:
+
+```shell
+$ projen secrets store TWINE_USERNAME "Boom"
+$ projen secrets store TWINE_PASSWORD "Bam"
+```
+
+Something like that.