Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
function runTest(testFn: Function, obj: JsonValue, indent: number): string {
const content = JSON.stringify(obj, null, indent);
tree.create(filePath, content);
const ast = parseJsonAst(content);
const rec = tree.beginUpdate(filePath);
testFn(rec, ast);
tree.commitUpdate(rec);
const result = tree.readContent(filePath);
// Clean up the tree by deleting the file.
tree.delete(filePath);
return result;
}
apps.forEach((app: AppConfig, idx: number) => {
const testTsConfig = app.testTsconfig || defaults.testTsConfig;
const tsSpecConfigPath = join(normalize(app.root || ''), testTsConfig);
const buffer = host.read(tsSpecConfigPath);
if (!buffer) {
return;
}
const tsCfgAst = parseJsonAst(buffer.toString(), JsonParseMode.Loose);
if (tsCfgAst.kind != 'object') {
throw new SchematicsException('Invalid tsconfig. Was expecting an object');
}
const filesAstNode = findPropertyInAstObject(tsCfgAst, 'files');
if (filesAstNode && filesAstNode.kind != 'array') {
throw new SchematicsException('Invalid tsconfig "files" property; expected an array.');
}
const recorder = host.beginUpdate(tsSpecConfigPath);
const polyfills = app.polyfills || defaults.polyfills;
if (!filesAstNode) {
// Do nothing if the files array does not exist. This means exclude or include are
// set and we shouldn't mess with that.
} else {
return (tree: Tree, context: SchematicContext) => {
const packageJsonPath = './package.json';
let packageJsonContent = tree.read(packageJsonPath);
if (!verifyPackageJson(tree, context, packageJsonContent)) {
return;
}
const parsedDevDependencies = JSON.parse(packageJsonContent.toString('utf-8')).devDependencies;
if (!parsedDevDependencies) {
return;
}
const packageJsonAst = parseJsonAst(packageJsonContent.toString('utf-8'));
if (packageJsonAst.kind !== 'object') {
throw new Error('Invalid "package.json" file.');
}
const dependencyToken = getJsonToken(packageJsonAst, 'devDependencies');
if (dependencyToken) {
const currentDevDependencies = Object.keys(parsedDevDependencies);
const recorder = tree.beginUpdate(packageJsonPath);
const dependenciesToInsert = [];
// analyze the devDependencies and add only the missing ones
for (const dep of DEV_DEPENDENCIES) {
if (currentDevDependencies.indexOf(dep.name) === -1) {
dependenciesToInsert.push(dep);
}
return;
}
const tsConfigPath = serverTarget.options.tsConfig;
if (!tsConfigPath || typeof tsConfigPath !== 'string') {
// No tsconfig path
return;
}
const configBuffer = host.read(tsConfigPath);
if (!configBuffer) {
throw new SchematicsException(`Could not find (${tsConfigPath})`);
}
const content = configBuffer.toString();
const tsConfigAst = parseJsonAst(content, JsonParseMode.Loose);
if (!tsConfigAst || tsConfigAst.kind !== 'object') {
throw new SchematicsException(`Invalid JSON AST Object (${tsConfigPath})`);
}
const filesAstNode = findPropertyInAstObject(tsConfigAst, 'files');
const serverFilePath = stripTsExtension(options.serverFileName) + '.ts';
if (
filesAstNode &&
filesAstNode.kind === 'array' &&
!filesAstNode.elements.some(({ text }) => text === serverFilePath)) {
const recorder = host.beginUpdate(tsConfigPath);
appendValueInAstArray(
recorder,
filesAstNode,
function readTsLintConfig(host: Tree, path: string): JsonAstObject {
const buffer = host.read(path);
if (!buffer) {
throw new SchematicsException(`Could not read ${path}.`);
}
const config = parseJsonAst(buffer.toString(), JsonParseMode.Loose);
if (config.kind !== 'object') {
throw new SchematicsException(`Invalid ${path}. Was expecting an object.`);
}
return config;
}
return (host: Tree, context: SchematicContext) => {
const tsConfigPath = '/tsconfig.json';
const buffer = host.read(tsConfigPath);
if (!buffer) {
return;
}
const tsCfgAst = parseJsonAst(buffer.toString(), JsonParseMode.Loose);
if (tsCfgAst.kind !== 'object') {
throw new SchematicsException('Invalid root tsconfig. Was expecting an object');
}
const compilerOptionsAstNode = findPropertyInAstObject(tsCfgAst, 'compilerOptions');
if (!compilerOptionsAstNode || compilerOptionsAstNode.kind != 'object') {
throw new SchematicsException(
'Invalid root tsconfig "compilerOptions" property; expected an object.',
);
}
if (
findPropertyInAstObject(compilerOptionsAstNode, 'baseUrl') &&
findPropertyInAstObject(compilerOptionsAstNode, 'module')
) {
return host;
return (host: Tree, context: SchematicContext) => {
const name = options.name !;
const workspacePath = getWorkspacePath(host);
if (!workspacePath) {
throw new Error('Could not find angular.json');
}
const workspaceContent = host.read(workspacePath);
if (!workspaceContent) {
throw new Error('Failed to read angular.json content');
}
const workspaceJsonAst = parseJsonAst(workspaceContent.toString()) as JsonAstObject;
const projects = findPropertyInAstObject(workspaceJsonAst, 'projects');
if (!projects) {
throw new SchematicsException('Expect projects in angular.json to be an Object');
}
const project = findPropertyInAstObject(projects as JsonAstObject, name);
if (!project) {
throw new SchematicsException(`Expected projects to contain ${name}`);
}
const recorder = host.beginUpdate(workspacePath);
const indent = 8;
const architect =
findPropertyInAstObject(project as JsonAstObject, 'architect') as JsonAstObject;
replacePropertyInAstObject(
recorder, architect, 'build', {
builder: '@angular/bazel:build',
options: {