@routineless/nx-aws-cdk
Version:
Nx plugin for AWS CDK
138 lines • 5.52 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveDependencies = exports.dependenciesReducer = exports.getPackageVersion = exports.getPackageName = void 0;
const js_1 = require("@nx/js");
const fs_1 = require("fs");
const path_1 = require("path");
const trie_1 = require("../../../utils/trie");
const workspace_1 = require("../../../utils/workspace");
const getPackageName = (node) => {
return isInternalProjectNode(node.node) ? node.name : node.node.data.packageName;
};
exports.getPackageName = getPackageName;
const getPackageVersion = (node) => {
if (!isInternalProjectNode(node.node))
return node.node.data.version;
const packageJsonPath = (0, path_1.join)(node.node.data.root, 'package.json');
if (!(0, fs_1.existsSync)(packageJsonPath)) {
return '0.0.0';
}
const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
return packageJson.version;
};
exports.getPackageVersion = getPackageVersion;
const dependenciesReducer = (acc, dep) => {
if (isInternalProjectNode(dep.node)) {
acc.internal.push(dep);
}
else {
acc.external.push(dep);
}
return acc;
};
exports.dependenciesReducer = dependenciesReducer;
const resolveDependencies = (context, graph, options) => {
const { includeInternal, thirdParty } = options;
const internalDepsPackageNameResolver = getInternalDepsPackageNameResolver(context);
const deps = new Map();
const excluded = new Map();
const externalPatternTrie = new trie_1.PatternTrie(options.external);
const recur = (dep, includeInternal, thirdParty) => {
//dep name will be different from node name because node name does not include npm scope
// @org/package -> dep name
// package -> node name
// external packages has same name and node name prefixed wih npm:
// node name should be used to get the node from the graph
let depName = dep.name;
if (isInternalProjectNode(dep)) {
depName = internalDepsPackageNameResolver(dep);
}
const buildableProjectNode = {
name: depName,
outputs: [],
node: dep,
};
if (deps.has(depName))
return;
if (isExcluded(buildableProjectNode, includeInternal, thirdParty, externalPatternTrie)) {
excluded.set(depName, buildableProjectNode);
return;
}
deps.set(depName, buildableProjectNode);
const nodeName = dep.name;
const allDeps = graph.dependencies[nodeName] || [];
const { externalDeps, internalDeps } = allDeps.reduce(dependenciesNodesReduced(graph), {
externalDeps: [],
internalDeps: [],
});
for (const transitiveDep of [...externalDeps, ...internalDeps]) {
recur(transitiveDep, includeInternal, thirdParty);
}
};
const projectDeps = graph.dependencies[context.projectName] || [];
const { externalDeps, internalDeps } = projectDeps.reduce(dependenciesNodesReduced(graph), {
externalDeps: [],
internalDeps: [],
});
const helperDependencies = Array.from((0, js_1.getHelperDependenciesFromProjectGraph)(context.root, context.projectName, graph)
.reduce((acc, dep) => acc.add(dep.target), new Set())
.values())
.map((helperName) => graph.externalNodes?.[helperName])
.filter((helperNode) => helperNode);
for (const projDep of [...externalDeps, ...internalDeps, ...helperDependencies]) {
recur(projDep, includeInternal, thirdParty);
}
return {
resolved: Array.from(deps.values()),
excluded: Array.from(excluded.values()),
};
};
exports.resolveDependencies = resolveDependencies;
const getInternalDepsPackageNameResolver = (context) => {
// "paths": {
// "@routineless/cdk": ["packages/cdk/src/index.ts"],
// "@routineless/nx-aws-cdk": ["packages/nx-aws-cdk/src/*"]
// }
const tsConfigPaths = (0, workspace_1.getTsConfigCompilerPaths)(context);
const sourcePathsAliasMap = new Map();
const sourcePathsTrie = new trie_1.PatternTrie();
for (const [alias, paths] of Object.entries(tsConfigPaths)) {
for (const path of paths) {
sourcePathsAliasMap.set(path, alias);
sourcePathsTrie.add(path);
}
}
return (node) => {
const tsConfigApplicablePaths = sourcePathsTrie.getAll(node.data.root);
if (tsConfigApplicablePaths[0]) {
return sourcePathsAliasMap.get(tsConfigApplicablePaths[0]);
}
return node.name;
};
};
const dependenciesNodesReduced = (graph) => {
return (acc, node) => {
const external = graph.externalNodes?.[node.target];
if (external) {
acc.externalDeps.push(external);
return acc;
}
const internal = graph.nodes[node.target];
if (internal)
acc.internalDeps.push(internal);
return acc;
};
};
const isInternalProjectNode = (node) => {
return node.type === 'lib';
};
const isExcluded = (dep, includeInternal, thirdParty, external) => {
if (isInternalProjectNode(dep.node) && !includeInternal)
return true;
if (!isInternalProjectNode(dep.node) && !thirdParty)
return true;
// resolve node package name to check external
const packageName = dep.name.replace('npm:', '');
return external.has(packageName);
};
//# sourceMappingURL=dependencies.js.map