@jjrawlins/cdk-git-tagger 0.0.0

package/node_modules/mock-fs/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "mock-fs",
+  "description": "A configurable mock file system.  You know, for testing.",
+  "version": "5.4.1",
+  "main": "lib/index.js",
+  "homepage": "https://github.com/tschaub/mock-fs",
+  "author": {
+    "name": "Tim Schaub",
+    "url": "http://tschaub.net/"
+  },
+  "keywords": [
+    "mock",
+    "fs",
+    "test",
+    "fixtures",
+    "file system",
+    "memory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/tschaub/mock-fs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tschaub/mock-fs/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint benchmarks lib test tasks",
+    "pretest": "npm run lint",
+    "test": "mocha --recursive test"
+  },
+  "eslintConfig": {
+    "extends": "tschaub",
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "env": {
+      "es2020": true
+    },
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "endOfLine": "auto",
+          "singleQuote": true,
+          "bracketSpacing": false,
+          "quoteProps": "preserve"
+        }
+      ]
+    }
+  },
+  "devDependencies": {
+    "chai": "^4.3.4",
+    "eslint": "^8.21.0",
+    "eslint-config-tschaub": "^14.1.2",
+    "mocha": "^10.7.3",
+    "rimraf": "^6.0.1",
+    "semver": "^7.3.5"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  }
+}

package/node_modules/mock-fs/readme.md

@@ -0,0 +1,290 @@
+[![Build Status](https://github.com/tschaub/mock-fs/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/tschaub/mock-fs/actions?workflow=Test)
+
+# `mock-fs`
+
+The `mock-fs` module allows Node's built-in [`fs` module](http://nodejs.org/api/fs.html) to be backed temporarily by an in-memory, mock file system.  This lets you run tests against a set of mock files and directories instead of lugging around a bunch of test fixtures.
+
+## Example
+
+The code below makes it so the `fs` module is temporarily backed by a mock file system with a few files and directories.
+
+```js
+const mock = require('mock-fs');
+
+mock({
+  'path/to/fake/dir': {
+    'some-file.txt': 'file content here',
+    'empty-dir': {/** empty directory */}
+  },
+  'path/to/some.png': Buffer.from([8, 6, 7, 5, 3, 0, 9]),
+  'some/other/path': {/** another empty directory */}
+});
+```
+
+When you are ready to restore the `fs` module (so that it is backed by your real file system), call [`mock.restore()`](#mockrestore). Note that calling this may be **mandatory** in some cases. See [istanbuljs/nyc#324](https://github.com/istanbuljs/nyc/issues/324#issuecomment-234018654)
+
+```js
+// after a test runs
+mock.restore();
+```
+
+## Upgrading to version 4
+
+Instead of overriding all methods of the built-in `fs` module, the library now overrides `process.binding('fs')`.  The purpose of this change is to avoid conflicts with other libraries that override `fs` methods (e.g. `graceful-fs`) and to make it possible to work with multiple Node releases without maintaining copied and slightly modified versions of Node's `fs` module.
+
+Breaking changes:
+
+ * The `mock.fs()` function has been removed.  This returned an object with `fs`-like methods without overriding the built-in `fs` module.
+ * The object created by `fs.Stats` is no longer an instance of `fs.Stats` (though it has all the same properties and methods).
+ * Lazy `require()` do not use the real filesystem.
+ * Tests are no longer run in Node < 4.
+
+Some of these breaking changes may be restored in a future release.
+
+## Docs
+
+### <a id='mockconfigoptions'>`mock(config, options)`</a>
+
+Configure the `fs` module so it is backed by an in-memory file system.
+
+Calling `mock` sets up a mock file system with two directories by default: `process.cwd()` and `os.tmpdir()` (or `os.tmpDir()` for older Node).  When called with no arguments, just these two directories are created.  When called with a `config` object, additional files, directories, and symlinks are created.  To avoid creating a directory for `process.cwd()` and `os.tmpdir()`, see the [`options`](#options) below.
+
+Property names of the `config` object are interpreted as relative paths to resources (relative from `process.cwd()`).  Property values of the `config` object are interpreted as content or configuration for the generated resources.
+
+*Note that paths should always use forward slashes (`/`) - even on Windows.*
+
+### <a id='options'>`options`</a>
+
+The second (optional) argument may include the properties below.
+
+ * `createCwd` - `boolean` Create a directory for `process.cwd()`.  This is `true` by default.
+ * `createTmp` - `boolean` Create a directory for `os.tmpdir()`.  This is `true` by default.
+
+### Loading real files & directories
+
+You can load real files and directories into the mock system using `mock.load()`
+
+#### Notes
+
+- All stat information is duplicated (dates, permissions, etc) 
+- By default, all files are lazy-loaded, unless you specify the `{lazy: false}` option
+
+#### <a id='mappingoptions'>options</a>
+
+| Option    | Type    | Default | Description |
+| --------- | ------- | ------- | ------------
+| lazy      | boolean | true    | File content isn't loaded until explicitly read
+| recursive | boolean | true    | Load all files and directories recursively
+ 
+#### `mock.load(path, options)`
+
+```js
+mock({
+  // Lazy-load file
+  'my-file.txt': mock.load(path.resolve(__dirname, 'assets/special-file.txt')),
+  
+  // Pre-load js file
+  'ready.js': mock.load(path.resolve(__dirname, 'scripts/ready.js'), {lazy: false}),
+
+  // Recursively loads all node_modules
+  'node_modules': mock.load(path.resolve(__dirname, '../node_modules')),
+
+  // Creates a directory named /tmp with only the files in /tmp/special_tmp_files (no subdirectories), pre-loading all content
+  '/tmp': mock.load('/tmp/special_tmp_files', {recursive: false, lazy:false}),
+
+  'fakefile.txt': 'content here'
+});
+```
+
+### Creating files
+
+When `config` property values are a `string` or `Buffer`, a file is created with the provided content.  For example, the following configuration creates a single file with string content (in addition to the two default directories).
+```js
+mock({
+  'path/to/file.txt': 'file content here'
+});
+```
+
+To create a file with additional properties (owner, permissions, atime, etc.), use the [`mock.file()`](#mockfileproperties) function described below.
+
+### <a id='mockfileproperties'>`mock.file(properties)`</a>
+
+Create a factory for new files.  Supported properties:
+
+ * **content** - `string|Buffer` File contents.
+ * **mode** - `number` File mode (permission and sticky bits).  Defaults to `0666`.
+ * **uid** - `number` The user id.  Defaults to `process.getuid()`.
+ * **gid** - `number` The group id.  Defaults to `process.getgid()`.
+ * **atime** - `Date` The last file access time.  Defaults to `new Date()`.  Updated when file contents are accessed.
+ * **ctime** - `Date` The last file change time.  Defaults to `new Date()`.  Updated when file owner or permissions change.
+ * **mtime** - `Date` The last file modification time.  Defaults to `new Date()`.  Updated when file contents change.
+ * **birthtime** - `Date` The time of file creation.  Defaults to `new Date()`.
+
+To create a mock filesystem with a very old file named `foo`, you could do something like this:
+```js
+mock({
+  foo: mock.file({
+    content: 'file content here',
+    ctime: new Date(1),
+    mtime: new Date(1)
+  })
+});
+```
+
+Note that if you want to create a file with the default properties, you can provide a `string` or `Buffer` directly instead of calling `mock.file()`.
+
+### Creating directories
+
+When `config` property values are an `Object`, a directory is created.  The structure of the object is the same as the `config` object itself.  So an empty directory can be created with a simple object literal (`{}`).  The following configuration creates a directory containing two files (in addition to the two default directories):
+```js
+// note that this could also be written as
+// mock({'path/to/dir': { /** config */ }})
+mock({
+  path: {
+    to: {
+      dir: {
+        file1: 'text content',
+        file2: Buffer.from([1, 2, 3, 4])
+      }
+    }
+  }
+});
+```
+
+To create a directory with additional properties (owner, permissions, atime, etc.), use the [`mock.directory()`](mockdirectoryproperties) function described below.
+
+### <a id='mockdirectoryproperties'>`mock.directory(properties)`</a>
+
+Create a factory for new directories.  Supported properties:
+
+ * **mode** - `number` Directory mode (permission and sticky bits).  Defaults to `0777`.
+ * **uid** - `number` The user id.  Defaults to `process.getuid()`.
+ * **gid** - `number` The group id.  Defaults to `process.getgid()`.
+ * **atime** - `Date` The last directory access time.  Defaults to `new Date()`.
+ * **ctime** - `Date` The last directory change time.  Defaults to `new Date()`.  Updated when owner or permissions change.
+ * **mtime** - `Date` The last directory modification time.  Defaults to `new Date()`.  Updated when an item is added, removed, or renamed.
+ * **birthtime** - `Date` The time of directory creation.  Defaults to `new Date()`.
+ * **items** - `Object` Directory contents.  Members will generate additional files, directories, or symlinks.
+
+To create a mock filesystem with a directory with the relative path `some/dir` that has a mode of `0755` and two child files, you could do something like this:
+```js
+mock({
+  'some/dir': mock.directory({
+    mode: 0755,
+    items: {
+      file1: 'file one content',
+      file2: Buffer.from([8, 6, 7, 5, 3, 0, 9])
+    }
+  })
+});
+```
+
+Note that if you want to create a directory with the default properties, you can provide an `Object` directly instead of calling `mock.directory()`.
+
+### Creating symlinks
+
+Using a `string` or a `Buffer` is a shortcut for creating files with default properties.  Using an `Object` is a shortcut for creating a directory with default properties.  There is no shortcut for creating symlinks.  To create a symlink, you need to call the [`mock.symlink()`](#mocksymlinkproperties) function described below.
+
+### <a id='mocksymlinkproperties'>`mock.symlink(properties)`</a>
+
+Create a factory for new symlinks.  Supported properties:
+
+ * **path** - `string` Path to the source (required).
+ * **mode** - `number` Symlink mode (permission and sticky bits).  Defaults to `0666`.
+ * **uid** - `number` The user id.  Defaults to `process.getuid()`.
+ * **gid** - `number` The group id.  Defaults to `process.getgid()`.
+ * **atime** - `Date` The last symlink access time.  Defaults to `new Date()`.
+ * **ctime** - `Date` The last symlink change time.  Defaults to `new Date()`.
+ * **mtime** - `Date` The last symlink modification time.  Defaults to `new Date()`.
+ * **birthtime** - `Date` The time of symlink creation.  Defaults to `new Date()`.
+
+To create a mock filesystem with a file and a symlink, you could do something like this:
+```js
+mock({
+  'some/dir': {
+    'regular-file': 'file contents',
+    'a-symlink': mock.symlink({
+      path: 'regular-file'
+    })
+  }
+});
+```
+
+### Restoring the file system
+
+### <a id='mockrestore'>`mock.restore()`</a>
+
+Restore the `fs` binding to the real file system.  This undoes the effect of calling `mock()`.  Typically, you would set up a mock file system before running a test and restore the original after.  Using a test runner with `beforeEach` and `afterEach` hooks, this might look like the following:
+
+```js
+beforeEach(function() {
+  mock({
+    'fake-file': 'file contents'
+  });
+});
+afterEach(mock.restore);
+```
+
+### Bypassing the mock file system
+
+#### <a id='mockbypass'>`mock.bypass(fn)`</a>
+
+Execute calls to the real filesystem with mock.bypass()
+
+```js
+// This file exists only on the real FS, not on the mocked FS
+const realFilePath = '/path/to/real/file.txt';
+const myData = mock.bypass(() => fs.readFileSync(realFilePath, 'utf-8'));
+```
+
+If you pass an asynchronous function or a promise-returning function to `bypass()`, a promise will be returned.
+
+#### <a id='bypassasync'>Async Warning</a>
+
+Asynchronous calls are supported, however, they are not recommended as they could produce unintended consequences if 
+anything else tries to access the mocked filesystem before they've completed.
+
+```js
+async function getFileInfo(fileName) {
+  return await mock.bypass(async () => {
+    const stats = await fs.promises.stat(fileName);
+    const data = await fs.promises.readFile(fileName);
+    return {stats, data};
+  });
+}
+```
+
+## Install
+
+Using `npm`:
+
+```
+npm install mock-fs --save-dev
+```
+
+## Caveats
+
+When you require `mock-fs`, Node's own `fs` module is patched to allow the binding to the underlying file system to be swapped out.  If you require `mock-fs` *before* any other modules that modify `fs` (e.g. `graceful-fs`), the mock should behave as expected.
+
+**Note** `mock-fs` is not compatible with `graceful-fs@3.x` but works with `graceful-fs@4.x`.
+
+Mock file access is controlled based on file mode where `process.getuid()` and `process.getgid()` are available (POSIX systems).  On other systems (e.g. Windows) the file mode has no effect.
+
+Tested on Linux, OSX, and Windows using Node 16 through 18.  Check the tickets for a list of [known issues](https://github.com/tschaub/mock-fs/issues).
+
+### Using with Jest Snapshot Testing
+
+`.toMatchSnapshot` in [Jest](https://jestjs.io/docs/en/snapshot-testing) uses `fs` to load existing snapshots.
+If `mockFs` is active, Jest isn't able to load existing snapshots. In such case it accepts all snapshots
+without diffing the old ones, which breaks the concept of snapshot testing.
+
+Calling `mock.restore()` in `afterEach` is too late and it's necessary to call it before snapshot matching:
+
+```js
+const actual = testedFunction()
+mock.restore()
+expect(actual).toMatchSnapshot()
+```
+
+Note: it's safe to call `mock.restore` multiple times, so it can still be called in `afterEach` and then manually
+in test cases which use snapshot testing.

package/package.json

@@ -0,0 +1,163 @@
+{
+  "name": "@jjrawlins/cdk-git-tagger",
+  "description": "CDK Aspect to tag resources with git metadata.  This provides a nice connection between the construct and the git repository.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jjrawlins/cdk-git-tagger.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:go": "npx projen package:go",
+    "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
+    "post-compile": "npx projen post-compile",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Jayson Rawlins",
+    "email": "JaysonJ.Rawlins@gmail.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^29.5.12",
+    "@types/mock-fs": "^4.13.4",
+    "@types/node": "^18",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "aws-cdk": "2.99.0",
+    "commit-and-tag-version": "^12",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "jest": "^29.7.0",
+    "jest-junit": "^16",
+    "jsii": "~5.7.0",
+    "jsii-diff": "^1.97.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.97.0",
+    "jsii-rosetta": "~5.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.99.0",
+    "constructs": "^10.4.2"
+  },
+  "dependencies": {
+    "aws-cdk-lib": "2.99.0",
+    "constructs": "10.4.2",
+    "mock-fs": "^5.4.1",
+    "projen": "^0.91.6"
+  },
+  "bundledDependencies": [
+    "mock-fs"
+  ],
+  "keywords": [
+    "cdk",
+    "git",
+    "metadata",
+    "tag",
+    "tagger"
+  ],
+  "engines": {
+    "node": ">= 18.18.0"
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "moduleNameMapper": {
+      "^aws-cdk-lib/(.*)$": "<rootDir>/node_modules/aws-cdk-lib/$1"
+    },
+    "moduleDirectories": [
+      "node_modules"
+    ],
+    "testEnvironment": "node",
+    "transformIgnorePatterns": [
+      "node_modules/(?!(aws-cdk-lib)/)"
+    ],
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "python": {
+        "distName": "jjrawlins.cdk-git-tagger",
+        "module": "jjrawlins.cdk_git_tagger"
+      },
+      "go": {
+        "moduleName": "github.com/jjrawlins/cdk-git-tagger"
+      }
+    },
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}