2023-12-10 20:10:54 +03:00
|
|
|
{
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"namedInputs": {
|
2024-05-03 15:59:09 +03:00
|
|
|
"default": ["{projectRoot}/**/*"],
|
|
|
|
|
"excludeStories": [
|
|
|
|
|
"default",
|
|
|
|
|
"!{projectRoot}/.storybook/*",
|
|
|
|
|
"!{projectRoot}/**/tsconfig.storybook.json",
|
|
|
|
|
"!{projectRoot}/**/*.stories.(ts|tsx)",
|
|
|
|
|
"!{projectRoot}/**/__stories__/*"
|
|
|
|
|
],
|
|
|
|
|
"excludeTests": [
|
|
|
|
|
"default",
|
|
|
|
|
"!{projectRoot}/**/jest.config.(js|ts)",
|
|
|
|
|
"!{projectRoot}/**/tsconfig.spec.json",
|
|
|
|
|
"!{projectRoot}/**/*.test.(ts|tsx)",
|
|
|
|
|
"!{projectRoot}/**/*.spec.(ts|tsx)",
|
|
|
|
|
"!{projectRoot}/**/__tests__/*"
|
|
|
|
|
],
|
|
|
|
|
"production": [
|
|
|
|
|
"default",
|
|
|
|
|
"excludeStories",
|
|
|
|
|
"excludeTests",
|
|
|
|
|
"!{projectRoot}/**/__mocks__/*",
|
|
|
|
|
"!{projectRoot}/**/testing/*"
|
|
|
|
|
]
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
},
|
2023-12-10 20:10:54 +03:00
|
|
|
"targetDefaults": {
|
|
|
|
|
"build": {
|
|
|
|
|
"cache": true,
|
2024-05-03 15:59:09 +03:00
|
|
|
"inputs": ["^production", "production"],
|
2024-03-13 16:21:18 +03:00
|
|
|
"dependsOn": ["^build"]
|
2024-01-29 12:17:12 +03:00
|
|
|
},
|
|
|
|
|
"start": {
|
|
|
|
|
"cache": true,
|
2024-08-26 17:35:09 +03:00
|
|
|
"dependsOn": ["^build"]
|
2023-12-10 20:10:54 +03:00
|
|
|
},
|
|
|
|
|
"lint": {
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"executor": "@nx/eslint:lint",
|
|
|
|
|
"cache": true,
|
|
|
|
|
"outputs": ["{options.outputFile}"],
|
|
|
|
|
"options": {
|
|
|
|
|
"eslintConfig": "{projectRoot}/.eslintrc.cjs",
|
|
|
|
|
"cache": true,
|
|
|
|
|
"cacheLocation": "{workspaceRoot}/.cache/eslint",
|
|
|
|
|
"ignorePath": "{workspaceRoot}/.gitignore"
|
|
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"ci": { "cacheStrategy": "content" },
|
|
|
|
|
"fix": { "fix": true }
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
"fmt": {
|
|
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"cache": true,
|
|
|
|
|
"options": {
|
|
|
|
|
"cwd": "{projectRoot}",
|
|
|
|
|
"command": "prettier {args.files} --check --cache {args.cache} --cache-location {args.cacheLocation} --write {args.write} --cache-strategy {args.cacheStrategy}",
|
|
|
|
|
"cache": true,
|
|
|
|
|
"cacheLocation": "../../.cache/prettier/{projectRoot}",
|
|
|
|
|
"cacheStrategy": "metadata",
|
|
|
|
|
"write": false
|
|
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"ci": { "cacheStrategy": "content" },
|
|
|
|
|
"fix": { "write": true }
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
"typecheck": {
|
|
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"cache": true,
|
|
|
|
|
"options": {
|
|
|
|
|
"cwd": "{projectRoot}",
|
|
|
|
|
"command": "tsc -b tsconfig.json --incremental"
|
|
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"watch": { "watch": true }
|
|
|
|
|
}
|
2023-12-10 20:10:54 +03:00
|
|
|
},
|
|
|
|
|
"test": {
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"executor": "@nx/jest:jest",
|
2024-01-29 12:17:12 +03:00
|
|
|
"cache": true,
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"dependsOn": ["^build"],
|
2024-05-03 15:59:09 +03:00
|
|
|
"inputs": [
|
|
|
|
|
"^default",
|
|
|
|
|
"excludeStories",
|
|
|
|
|
"{workspaceRoot}/jest.preset.js"
|
|
|
|
|
],
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"outputs": ["{projectRoot}/coverage"],
|
|
|
|
|
"options": {
|
|
|
|
|
"jestConfig": "{projectRoot}/jest.config.ts",
|
|
|
|
|
"coverage": true,
|
|
|
|
|
"coverageReporters": ["text-summary"],
|
|
|
|
|
"cacheDirectory": "../../.cache/jest/{projectRoot}"
|
|
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"ci": {
|
|
|
|
|
"ci": true,
|
|
|
|
|
"maxWorkers": 3
|
|
|
|
|
},
|
|
|
|
|
"coverage": { "coverageReporters": ["lcov", "text"] },
|
|
|
|
|
"watch": { "watch": true }
|
|
|
|
|
}
|
2023-12-10 20:10:54 +03:00
|
|
|
},
|
2024-01-29 12:17:12 +03:00
|
|
|
"test:e2e": {
|
|
|
|
|
"cache": true,
|
2024-03-13 16:21:18 +03:00
|
|
|
"dependsOn": ["^build"]
|
2024-01-04 01:07:25 +03:00
|
|
|
},
|
2024-04-04 16:38:01 +03:00
|
|
|
"storybook:build": {
|
2024-05-07 22:05:45 +03:00
|
|
|
"executor": "nx:run-commands",
|
2024-04-04 16:38:01 +03:00
|
|
|
"cache": true,
|
2024-04-12 16:30:48 +03:00
|
|
|
"dependsOn": ["^build"],
|
2024-05-03 15:59:09 +03:00
|
|
|
"inputs": ["^default", "excludeTests"],
|
2024-05-08 12:51:09 +03:00
|
|
|
"outputs": ["{projectRoot}/{options.output-dir}"],
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"options": {
|
2024-05-07 22:05:45 +03:00
|
|
|
"cwd": "{projectRoot}",
|
2024-10-20 21:20:19 +03:00
|
|
|
"command": "VITE_DISABLE_ESLINT_CHECKER=true storybook build",
|
2024-05-07 22:05:45 +03:00
|
|
|
"output-dir": "storybook-static",
|
|
|
|
|
"config-dir": ".storybook"
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
}
|
2024-04-04 16:38:01 +03:00
|
|
|
},
|
2024-06-30 21:02:13 +03:00
|
|
|
"storybook:serve:dev": {
|
2024-05-07 22:05:45 +03:00
|
|
|
"executor": "nx:run-commands",
|
2024-04-04 16:38:01 +03:00
|
|
|
"cache": true,
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"dependsOn": ["^build"],
|
|
|
|
|
"options": {
|
2024-05-07 22:05:45 +03:00
|
|
|
"cwd": "{projectRoot}",
|
|
|
|
|
"command": "storybook dev",
|
|
|
|
|
"config-dir": ".storybook"
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
}
|
|
|
|
|
},
|
2024-06-30 21:02:13 +03:00
|
|
|
"storybook:serve:static": {
|
2024-05-07 22:05:45 +03:00
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"dependsOn": ["storybook:build"],
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"options": {
|
2024-05-07 22:05:45 +03:00
|
|
|
"cwd": "{projectRoot}",
|
|
|
|
|
"command": "npx http-server {args.staticDir} -a={args.host} --port={args.port} --silent={args.silent}",
|
|
|
|
|
"staticDir": "storybook-static",
|
|
|
|
|
"host": "localhost",
|
|
|
|
|
"port": 6006,
|
|
|
|
|
"silent": true
|
2024-05-03 15:59:09 +03:00
|
|
|
}
|
|
|
|
|
},
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"storybook:test": {
|
|
|
|
|
"executor": "nx:run-commands",
|
2024-05-03 15:59:09 +03:00
|
|
|
"cache": true,
|
|
|
|
|
"inputs": ["^default", "excludeTests"],
|
|
|
|
|
"outputs": ["{projectRoot}/coverage/storybook"],
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"options": {
|
2024-05-03 15:59:09 +03:00
|
|
|
"cwd": "{projectRoot}",
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
"commands": [
|
2024-05-03 15:59:09 +03:00
|
|
|
"test-storybook --url http://localhost:{args.port} --maxWorkers=3 --coverage --coverageDirectory={args.coverageDir}",
|
|
|
|
|
"nx storybook:coverage {projectName} --coverageDir={args.coverageDir}"
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
],
|
2024-05-02 17:15:36 +03:00
|
|
|
"parallel": false,
|
2024-05-03 15:59:09 +03:00
|
|
|
"coverageDir": "coverage/storybook",
|
|
|
|
|
"port": 6006
|
|
|
|
|
}
|
|
|
|
|
},
|
2024-06-30 21:02:13 +03:00
|
|
|
"storybook:test:no-coverage": {
|
Generic Profiling story to wrap any component (#5341)
This PR introduces a Profiling feature for our story book tests.
It also implements a new CI job : front-sb-test-performance, that only
runs stories suffixed with `.perf.stories.tsx`
## How it works
It allows to wrap any component into an array of React Profiler
components that will run tests many times to have the most replicable
average render time possible.
It is simply used by calling the new `getProfilingStory` util.
Internally it creates a defined number of tests, separated by an
arbitrary waiting time to allow the CPU to give more stable results.
It will do 3 warm-up and 3 finishing runs of tests because the first and
last renders are always a bit erratic, so we want to measure only the
runs in-between.
On the UI side it gives a table of results :
<img width="515" alt="image"
src="https://github.com/twentyhq/twenty/assets/26528466/273d2d91-26da-437a-890e-778cb6c1f993">
On the programmatic side, it stores the result in a div that can then be
parsed by the play fonction of storybook, to expect a defined threshold.
```tsx
play: async ({ canvasElement }) => {
await findByTestId(
canvasElement,
'profiling-session-finished',
{},
{ timeout: 60000 },
);
const profilingReport = getProfilingReportFromDocument(canvasElement);
if (!isDefined(profilingReport)) {
return;
}
const p95result = profilingReport?.total.p95;
expect(
p95result,
`Component render time is more than p95 threshold (${p95ThresholdInMs}ms)`,
).toBeLessThan(p95ThresholdInMs);
},
```
2024-05-15 14:50:02 +03:00
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"inputs": ["^default", "excludeTests"],
|
|
|
|
|
"options": {
|
|
|
|
|
"cwd": "{projectRoot}",
|
|
|
|
|
"commands": [
|
2024-07-13 23:30:11 +03:00
|
|
|
"test-storybook --url http://localhost:{args.port} --maxWorkers=2"
|
Generic Profiling story to wrap any component (#5341)
This PR introduces a Profiling feature for our story book tests.
It also implements a new CI job : front-sb-test-performance, that only
runs stories suffixed with `.perf.stories.tsx`
## How it works
It allows to wrap any component into an array of React Profiler
components that will run tests many times to have the most replicable
average render time possible.
It is simply used by calling the new `getProfilingStory` util.
Internally it creates a defined number of tests, separated by an
arbitrary waiting time to allow the CPU to give more stable results.
It will do 3 warm-up and 3 finishing runs of tests because the first and
last renders are always a bit erratic, so we want to measure only the
runs in-between.
On the UI side it gives a table of results :
<img width="515" alt="image"
src="https://github.com/twentyhq/twenty/assets/26528466/273d2d91-26da-437a-890e-778cb6c1f993">
On the programmatic side, it stores the result in a div that can then be
parsed by the play fonction of storybook, to expect a defined threshold.
```tsx
play: async ({ canvasElement }) => {
await findByTestId(
canvasElement,
'profiling-session-finished',
{},
{ timeout: 60000 },
);
const profilingReport = getProfilingReportFromDocument(canvasElement);
if (!isDefined(profilingReport)) {
return;
}
const p95result = profilingReport?.total.p95;
expect(
p95result,
`Component render time is more than p95 threshold (${p95ThresholdInMs}ms)`,
).toBeLessThan(p95ThresholdInMs);
},
```
2024-05-15 14:50:02 +03:00
|
|
|
],
|
|
|
|
|
"port": 6006
|
|
|
|
|
}
|
|
|
|
|
},
|
2024-06-30 21:02:13 +03:00
|
|
|
"storybook:coverage": {
|
|
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"cache": true,
|
|
|
|
|
"inputs": [
|
|
|
|
|
"^default",
|
|
|
|
|
"excludeTests",
|
|
|
|
|
"{projectRoot}/coverage/storybook/coverage-storybook.json"
|
|
|
|
|
],
|
|
|
|
|
"outputs": [
|
|
|
|
|
"{projectRoot}/coverage/storybook",
|
|
|
|
|
"!{projectRoot}/coverage/storybook/coverage-storybook.json"
|
|
|
|
|
],
|
|
|
|
|
"options": {
|
|
|
|
|
"command": "npx nyc report --reporter={args.reporter} --reporter=text-summary -t {args.coverageDir} --report-dir {args.coverageDir} --check-coverage --cwd={projectRoot}",
|
|
|
|
|
"coverageDir": "coverage/storybook",
|
|
|
|
|
"reporter": "lcov"
|
|
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"text": { "reporter": "text" }
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
"storybook:serve-and-test:static": {
|
2024-05-03 15:59:09 +03:00
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"options": {
|
|
|
|
|
"commands": [
|
2024-06-30 21:02:13 +03:00
|
|
|
"npx concurrently --kill-others --success=first -n SB,TEST 'nx storybook:serve:static {projectName} --port={args.port}' 'npx wait-on tcp:{args.port} && nx storybook:test {projectName} --port={args.port}'"
|
2024-05-03 15:59:09 +03:00
|
|
|
],
|
Generic Profiling story to wrap any component (#5341)
This PR introduces a Profiling feature for our story book tests.
It also implements a new CI job : front-sb-test-performance, that only
runs stories suffixed with `.perf.stories.tsx`
## How it works
It allows to wrap any component into an array of React Profiler
components that will run tests many times to have the most replicable
average render time possible.
It is simply used by calling the new `getProfilingStory` util.
Internally it creates a defined number of tests, separated by an
arbitrary waiting time to allow the CPU to give more stable results.
It will do 3 warm-up and 3 finishing runs of tests because the first and
last renders are always a bit erratic, so we want to measure only the
runs in-between.
On the UI side it gives a table of results :
<img width="515" alt="image"
src="https://github.com/twentyhq/twenty/assets/26528466/273d2d91-26da-437a-890e-778cb6c1f993">
On the programmatic side, it stores the result in a div that can then be
parsed by the play fonction of storybook, to expect a defined threshold.
```tsx
play: async ({ canvasElement }) => {
await findByTestId(
canvasElement,
'profiling-session-finished',
{},
{ timeout: 60000 },
);
const profilingReport = getProfilingReportFromDocument(canvasElement);
if (!isDefined(profilingReport)) {
return;
}
const p95result = profilingReport?.total.p95;
expect(
p95result,
`Component render time is more than p95 threshold (${p95ThresholdInMs}ms)`,
).toBeLessThan(p95ThresholdInMs);
},
```
2024-05-15 14:50:02 +03:00
|
|
|
"port": 6006
|
|
|
|
|
}
|
|
|
|
|
},
|
2024-06-30 21:02:13 +03:00
|
|
|
"storybook:serve-and-test:static:performance": {
|
Generic Profiling story to wrap any component (#5341)
This PR introduces a Profiling feature for our story book tests.
It also implements a new CI job : front-sb-test-performance, that only
runs stories suffixed with `.perf.stories.tsx`
## How it works
It allows to wrap any component into an array of React Profiler
components that will run tests many times to have the most replicable
average render time possible.
It is simply used by calling the new `getProfilingStory` util.
Internally it creates a defined number of tests, separated by an
arbitrary waiting time to allow the CPU to give more stable results.
It will do 3 warm-up and 3 finishing runs of tests because the first and
last renders are always a bit erratic, so we want to measure only the
runs in-between.
On the UI side it gives a table of results :
<img width="515" alt="image"
src="https://github.com/twentyhq/twenty/assets/26528466/273d2d91-26da-437a-890e-778cb6c1f993">
On the programmatic side, it stores the result in a div that can then be
parsed by the play fonction of storybook, to expect a defined threshold.
```tsx
play: async ({ canvasElement }) => {
await findByTestId(
canvasElement,
'profiling-session-finished',
{},
{ timeout: 60000 },
);
const profilingReport = getProfilingReportFromDocument(canvasElement);
if (!isDefined(profilingReport)) {
return;
}
const p95result = profilingReport?.total.p95;
expect(
p95result,
`Component render time is more than p95 threshold (${p95ThresholdInMs}ms)`,
).toBeLessThan(p95ThresholdInMs);
},
```
2024-05-15 14:50:02 +03:00
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"options": {
|
|
|
|
|
"commands": [
|
2024-06-30 21:02:13 +03:00
|
|
|
"npx concurrently --kill-others --success=first -n SB,TEST 'nx storybook:serve:dev {projectName} --configuration=performance --port={args.port}' 'npx wait-on tcp:{args.port} && nx storybook:test:no-coverage {projectName} --port={args.port} --configuration=performance'"
|
Generic Profiling story to wrap any component (#5341)
This PR introduces a Profiling feature for our story book tests.
It also implements a new CI job : front-sb-test-performance, that only
runs stories suffixed with `.perf.stories.tsx`
## How it works
It allows to wrap any component into an array of React Profiler
components that will run tests many times to have the most replicable
average render time possible.
It is simply used by calling the new `getProfilingStory` util.
Internally it creates a defined number of tests, separated by an
arbitrary waiting time to allow the CPU to give more stable results.
It will do 3 warm-up and 3 finishing runs of tests because the first and
last renders are always a bit erratic, so we want to measure only the
runs in-between.
On the UI side it gives a table of results :
<img width="515" alt="image"
src="https://github.com/twentyhq/twenty/assets/26528466/273d2d91-26da-437a-890e-778cb6c1f993">
On the programmatic side, it stores the result in a div that can then be
parsed by the play fonction of storybook, to expect a defined threshold.
```tsx
play: async ({ canvasElement }) => {
await findByTestId(
canvasElement,
'profiling-session-finished',
{},
{ timeout: 60000 },
);
const profilingReport = getProfilingReportFromDocument(canvasElement);
if (!isDefined(profilingReport)) {
return;
}
const p95result = profilingReport?.total.p95;
expect(
p95result,
`Component render time is more than p95 threshold (${p95ThresholdInMs}ms)`,
).toBeLessThan(p95ThresholdInMs);
},
```
2024-05-15 14:50:02 +03:00
|
|
|
],
|
2024-05-02 17:15:36 +03:00
|
|
|
"port": 6006
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
"chromatic": {
|
|
|
|
|
"executor": "nx:run-commands",
|
|
|
|
|
"options": {
|
|
|
|
|
"cwd": "{projectRoot}",
|
2024-05-22 12:18:16 +03:00
|
|
|
"commands": [
|
|
|
|
|
{
|
2024-06-30 21:02:13 +03:00
|
|
|
"command": "nx storybook:build {projectName}",
|
2024-05-22 12:18:16 +03:00
|
|
|
"forwardAllArgs": false
|
|
|
|
|
},
|
|
|
|
|
"cross-var chromatic --project-token=$CHROMATIC_PROJECT_TOKEN --storybook-build-dir=storybook-static {args.ci}"
|
|
|
|
|
],
|
|
|
|
|
"parallel": false
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"ci": {
|
2024-05-15 23:54:51 +03:00
|
|
|
"ci": "--exit-zero-on-changes"
|
chore: use Nx affected tasks in CI (#5110)
Closes #5097
- Uses "nx affected" to detect what projects need to be checked in the
current PR (for now, `ci-front` and `ci-server` workflows only).
- Caches results of certain tasks (`lint`, `typecheck`, `test`,
`storybook:build`) when a PR pipeline runs. The next runs of the same
PR's pipeline will then be able to reuse the PR's task cache to execute
tasks faster.
- Caches Yarn's cache folder to install dependencies faster in CI jobs.
- Rewrites the node modules cache/install steps as a custom, reusable
Github action.
- Distributes `ci-front` jobs with a "matrix" strategy.
- Sets common tasks config at the root `nx.json`. For instance, to
activate the `typecheck` task in a project, add `typecheck: {}` to its
`project.json` and it'll use the default config set in `nx.json` for the
`typecheck` task. Options can be overridden in each individual
`project.json` if needed.
- Adds "scope" tags to some projects: `scope:frontend`, `scope:backend`,
`scope:shared`. An eslint rule ensures that `scope:frontend` only
depends on `scope:frontent` or `scope:shared` projects, same for
`scope:backend`. These tags are used by `nx affected` to filter projects
by scope and generates different task cache keys according to the
requested scope.
- Enables checks for twenty-emails in the `ci-server` workflow.
2024-04-30 17:28:25 +03:00
|
|
|
}
|
|
|
|
|
}
|
2024-04-04 16:38:01 +03:00
|
|
|
},
|
2024-01-04 01:07:25 +03:00
|
|
|
"@nx/jest:jest": {
|
|
|
|
|
"cache": true,
|
2024-05-03 15:59:09 +03:00
|
|
|
"inputs": [
|
|
|
|
|
"^default",
|
|
|
|
|
"excludeStories",
|
|
|
|
|
"{workspaceRoot}/jest.preset.js"
|
|
|
|
|
],
|
2024-01-04 01:07:25 +03:00
|
|
|
"options": {
|
|
|
|
|
"passWithNoTests": true
|
|
|
|
|
},
|
|
|
|
|
"configurations": {
|
|
|
|
|
"ci": {
|
|
|
|
|
"ci": true,
|
|
|
|
|
"codeCoverage": true
|
|
|
|
|
}
|
|
|
|
|
}
|
2024-01-29 12:17:12 +03:00
|
|
|
},
|
2024-04-01 14:16:50 +03:00
|
|
|
"@nx/eslint:lint": {
|
2024-01-29 12:17:12 +03:00
|
|
|
"cache": true,
|
2024-04-01 14:16:50 +03:00
|
|
|
"inputs": [
|
|
|
|
|
"default",
|
|
|
|
|
"{workspaceRoot}/.eslintrc.js",
|
|
|
|
|
"{workspaceRoot}/tools/eslint-rules/**/*"
|
|
|
|
|
]
|
2024-04-04 13:30:49 +03:00
|
|
|
},
|
|
|
|
|
"@nx/vite:test": {
|
|
|
|
|
"cache": true,
|
|
|
|
|
"inputs": ["default", "^default"]
|
|
|
|
|
},
|
|
|
|
|
"@nx/vite:build": {
|
|
|
|
|
"cache": true,
|
|
|
|
|
"dependsOn": ["^build"],
|
|
|
|
|
"inputs": ["default", "^default"]
|
2023-12-10 20:10:54 +03:00
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
"installation": {
|
2024-04-24 12:53:53 +03:00
|
|
|
"version": "18.3.3"
|
2024-01-29 12:17:12 +03:00
|
|
|
},
|
|
|
|
|
"generators": {
|
|
|
|
|
"@nx/react": {
|
|
|
|
|
"application": {
|
2024-04-04 16:38:01 +03:00
|
|
|
"style": "@emotion/styled",
|
|
|
|
|
"linter": "eslint",
|
|
|
|
|
"bundler": "vite",
|
|
|
|
|
"compiler": "swc",
|
|
|
|
|
"unitTestRunner": "jest",
|
|
|
|
|
"projectNameAndRootFormat": "derived"
|
2024-01-29 12:17:12 +03:00
|
|
|
},
|
|
|
|
|
"library": {
|
2024-04-04 16:38:01 +03:00
|
|
|
"style": "@emotion/styled",
|
|
|
|
|
"linter": "eslint",
|
|
|
|
|
"bundler": "vite",
|
|
|
|
|
"compiler": "swc",
|
|
|
|
|
"unitTestRunner": "jest",
|
|
|
|
|
"projectNameAndRootFormat": "derived"
|
|
|
|
|
},
|
|
|
|
|
"component": {
|
|
|
|
|
"style": "@emotion/styled"
|
2024-01-29 12:17:12 +03:00
|
|
|
}
|
|
|
|
|
}
|
2024-03-13 16:21:18 +03:00
|
|
|
},
|
|
|
|
|
"tasksRunnerOptions": {
|
|
|
|
|
"default": {
|
|
|
|
|
"options": {
|
2024-04-04 13:30:49 +03:00
|
|
|
"cacheableOperations": ["storybook:build"]
|
2024-03-13 16:21:18 +03:00
|
|
|
}
|
|
|
|
|
}
|
2024-04-01 14:16:50 +03:00
|
|
|
},
|
|
|
|
|
"useInferencePlugins": false,
|
|
|
|
|
"defaultBase": "main"
|
2024-03-13 16:21:18 +03:00
|
|
|
}
|
