@storm-software/workspace-tools
Version:
Tools for managing a Storm workspace, including various Nx generators and executors for common development tasks.
389 lines (365 loc) • 15.9 kB
JavaScript
;Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
var _chunkXZ6L6OXJjs = require('./chunk-XZ6L6OXJ.js');
var _chunkD2PV33E5js = require('./chunk-D2PV33E5.js');
var _chunkUHTWNVEZjs = require('./chunk-UHTWNVEZ.js');
// src/plugins/rust/cargo-toml.ts
var _devkit = require('@nx/devkit');
var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
var _fs = require('fs');
var _path = require('path');
var _projectgraph = require('nx/src/config/project-graph');
var name = "storm-software/rust";
var description = "Plugin for parsing Cargo.toml files";
var DefaultCargoPluginProfileMap = {
development: "dev",
production: "prod"
};
var createNodesV2 = [
"*/**/Cargo.toml",
async (configFiles, options, context) => {
return await _devkit.createNodesFromFiles.call(void 0,
(configFile, options2, context2) => {
try {
const profiles = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _ => _.profiles]), () => ( {}));
const includeApps = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _2 => _2.includeApps]), () => ( true));
const toolchain = _optionalChain([options2, 'optionalAccess', _3 => _3.toolchain]);
const skipDocs = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _4 => _4.skipDocs]), () => ( false));
const metadata = _chunkD2PV33E5js.cargoMetadata.call(void 0, );
if (!metadata) {
return {};
}
const { packages: cargoPackages } = metadata;
const externalNodes = {};
const projects = {};
const profs = {
...DefaultCargoPluginProfileMap,
...profiles
};
const configurations = Object.keys(profs).reduce((ret, key) => {
ret[key] = {
profile: profs[key]
};
return ret;
}, {});
const cargoPackageMap = cargoPackages.reduce((acc, p) => {
if (!acc.has(p.name)) {
acc.set(p.name, p);
}
return acc;
}, /* @__PURE__ */ new Map());
for (const cargoPackage of cargoPackages) {
if (!_chunkD2PV33E5js.isExternal.call(void 0, cargoPackage, context2.workspaceRoot)) {
const root = _chunkXZ6L6OXJjs.getRoot.call(void 0, _path.dirname.call(void 0, configFile), context2);
const project = {
root,
name: cargoPackage.name
};
if (_fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, root, "project.json"))) {
const projectJson = _devkit.readJsonFile.call(void 0,
_devkit.joinPathFragments.call(void 0, root, "project.json")
);
if (projectJson) {
Object.keys(projectJson).forEach((key) => {
if (!project[key]) {
project[key] = projectJson[key];
}
});
}
}
if (includeApps === false && project.projectType === "application") {
continue;
}
const targets = {
"lint-markdown": {
cache: true,
outputs: ["{projectRoot}/**/*.md", "{projectRoot}/**/*.mdx"],
inputs: [
"linting",
"{projectRoot}/**/*.md",
"{projectRoot}/**/*.mdx"
],
dependsOn: ["^lint-markdown"],
executor: "nx:run-commands",
options: {
command: 'pnpm exec markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/recommended.markdownlint-cli2.jsonc" --fix'
}
},
"lint-ls": {
cache: true,
inputs: ["linting", "rust", "^production"],
dependsOn: ["^lint-ls"],
options: {
command: 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" ',
color: true
}
},
lint: {
cache: true,
inputs: ["linting", "rust", "^production"],
dependsOn: ["lint-ls", "lint-markdown", "^lint"],
executor: "@storm-software/workspace-tools:cargo-clippy",
options: {
toolchain,
fix: false
},
defaultConfiguration: "development",
configurations
},
check: {
cache: true,
inputs: ["linting", "rust", "^production"],
dependsOn: ["lint", "^check"],
executor: "@storm-software/workspace-tools:cargo-check",
options: {
toolchain
},
defaultConfiguration: "development",
configurations
},
"format-readme": {
cache: true,
inputs: [
"linting",
"documentation",
"{projectRoot}/{README.md,package.json,Cargo.toml,executors.json,generators.json}"
],
outputs: ["{projectRoot}/README.md"],
dependsOn: ["^format-readme"],
executor: "nx:run-commands",
options: {
command: 'pnpm exec storm-git readme --templates="tools/readme-templates" --project="{projectName}"'
}
},
"format-toml": {
cache: true,
inputs: ["linting", "{projectRoot}/**/*.toml"],
outputs: ["{projectRoot}/**/*.toml"],
dependsOn: ["^format-toml"],
executor: "nx:run-commands",
options: {
command: 'pnpm exec taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.toml" '
}
},
"format-clippy": {
cache: true,
inputs: ["linting", "rust", "^production"],
dependsOn: ["^format-clippy"],
executor: "@storm-software/workspace-tools:cargo-clippy",
options: {
toolchain,
fix: true
},
defaultConfiguration: "development",
configurations
},
format: {
cache: true,
inputs: ["linting", "documentation", "rust", "^production"],
dependsOn: [
"format-readme",
"format-clippy",
"format-toml",
"^format"
],
executor: "@storm-software/workspace-tools:cargo-format",
options: {
toolchain,
fix: true
},
defaultConfiguration: "development",
configurations
},
clean: {
cache: true,
inputs: ["rust", "^production"],
outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
executor: "nx:run-commands",
options: {
command: `pnpm exec rimraf dist/{projectRoot}/target`,
color: true,
cwd: "{workspaceRoot}"
}
},
build: {
cache: true,
inputs: ["rust", "^production"],
dependsOn: ["build-base", "^build"],
executor: "@storm-software/workspace-tools:cargo-build",
outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
options: {
toolchain
},
defaultConfiguration: "development",
configurations
},
rebuild: {
cache: false,
inputs: ["rust", "^production"],
dependsOn: ["clean", "build-base", "^build"],
executor: "@storm-software/workspace-tools:cargo-build",
outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
options: {
toolchain
},
defaultConfiguration: "development",
configurations
},
test: {
cache: true,
inputs: ["testing", "rust", "^production"],
dependsOn: ["build", "^test"],
executor: "@monodon/rust:test",
outputs: ["{options.target-dir}"],
options: {
"target-dir": `{workspaceRoot}/dist/{projectRoot}/target`
},
defaultConfiguration: "development",
configurations
}
};
if (skipDocs != true) {
targets.docs = {
cache: true,
inputs: ["linting", "documentation", "^production"],
dependsOn: ["format-readme", "lint-docs", "^docs"],
outputs: [`{workspaceRoot}/dist/{projectRoot}/docs`],
executor: "@storm-software/workspace-tools:cargo-doc",
options: {
toolchain
},
defaultConfiguration: "production",
configurations
};
}
if (cargoPackage.publish === null || cargoPackage.publish === void 0 || cargoPackage.publish === true || Array.isArray(cargoPackage.publish) && cargoPackage.publish.length > 0) {
_chunkUHTWNVEZjs.addProjectTag.call(void 0,
project,
_chunkUHTWNVEZjs.ProjectTagConstants.Registry.TAG_ID,
_chunkUHTWNVEZjs.ProjectTagConstants.Registry.CARGO,
{ overwrite: true }
);
targets["nx-release-publish"] = {
cache: true,
inputs: [
"linting",
"testing",
"documentation",
"rust",
"^production"
],
dependsOn: ["build", "^nx-release-publish"],
executor: "@storm-software/workspace-tools:cargo-publish",
options: {
packageRoot: root
},
defaultConfiguration: "production",
configurations
};
}
_chunkUHTWNVEZjs.addProjectTag.call(void 0,
project,
_chunkUHTWNVEZjs.ProjectTagConstants.Language.TAG_ID,
_chunkUHTWNVEZjs.ProjectTagConstants.Language.RUST,
{ overwrite: true }
);
_chunkUHTWNVEZjs.setDefaultProjectTags.call(void 0, project, name);
projects[root] = _defu2.default.call(void 0,
{
targets,
release: {
version: {
versionActions: "@storm-software/workspace-tools/release/rust-version-actions"
}
}
},
project
);
}
for (const dep of cargoPackage.dependencies) {
if (_chunkD2PV33E5js.isExternal.call(void 0, dep, context2.workspaceRoot)) {
const externalDepName = `cargo:${dep.name}`;
if (!_optionalChain([externalNodes, 'optionalAccess', _5 => _5[externalDepName]])) {
externalNodes[externalDepName] = {
type: "cargo",
name: externalDepName,
data: {
packageName: dep.name,
version: _nullishCoalesce(_optionalChain([cargoPackageMap, 'access', _6 => _6.get, 'call', _7 => _7(dep.name), 'optionalAccess', _8 => _8.version]), () => ( "0.0.0"))
}
};
}
}
}
}
return {
projects,
externalNodes
};
} catch (e) {
console.error("An error occurred in the Storm Rust Nx plugin.");
console.error(e);
throw new Error("An error occurred in the Storm Rust Nx plugin.", {
cause: e
});
}
},
configFiles,
options,
context
);
}
];
var createDependencies = (options, context) => {
console.debug(
`[storm-software/rust]: Creating dependencies using cargo metadata.`
);
const metadata = _chunkD2PV33E5js.cargoMetadata.call(void 0, );
if (!_optionalChain([metadata, 'optionalAccess', _9 => _9.packages])) {
console.debug(
`[storm-software/rust]: Unable to find cargo metadata. Skipping dependency creation.`
);
return [];
}
const dependencies = [];
for (const pkg of metadata.packages) {
if (context.projects[pkg.name]) {
for (const deps of pkg.dependencies) {
if (!metadata.packages.find((p) => p.name === deps.name)) {
console.debug(
`[storm-software/rust]: Dependency ${deps.name} not found in the cargo metadata.`
);
continue;
}
if (context.projects[deps.name]) {
dependencies.push(
createDependency(context, pkg, deps.name, _projectgraph.DependencyType.static)
);
} else {
const externalDepName = `cargo:${deps.name}`;
if (externalDepName in (_nullishCoalesce(context.externalNodes, () => ( {})))) {
dependencies.push(
createDependency(
context,
pkg,
externalDepName,
_projectgraph.DependencyType.static
)
);
}
}
}
}
}
return dependencies;
};
function createDependency(context, pkg, depName, type) {
const dependency = {
type,
source: pkg.name,
target: depName,
sourceFile: pkg.manifest_path.replace(/\\/g, "/").replace(context.workspaceRoot.replace(/\\/g, "/"), "").replace(/^\//, "")
};
_devkit.validateDependency.call(void 0, dependency, context);
return dependency;
}
exports.name = name; exports.description = description; exports.DefaultCargoPluginProfileMap = DefaultCargoPluginProfileMap; exports.createNodesV2 = createNodesV2; exports.createDependencies = createDependencies;