@ohos-ports/nx 17.3.2-beta.0

package/src/generators/testing-utils/create-tree-with-empty-workspace.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTreeWithEmptyV1Workspace = exports.createTreeWithEmptyWorkspace = void 0;
+const tree_1 = require("../tree");
+/**
+ * Creates a host for testing.
+ */
+function createTreeWithEmptyWorkspace(opts = {}) {
+    const tree = new tree_1.FsTree('/virtual', false);
+    return addCommonFiles(tree, opts.layout === 'apps-libs');
+}
+exports.createTreeWithEmptyWorkspace = createTreeWithEmptyWorkspace;
+/**
+ * @deprecated use createTreeWithEmptyWorkspace instead
+ */
+function createTreeWithEmptyV1Workspace() {
+    throw new Error('Use createTreeWithEmptyWorkspace instead of createTreeWithEmptyV1Workspace');
+}
+exports.createTreeWithEmptyV1Workspace = createTreeWithEmptyV1Workspace;
+function addCommonFiles(tree, addAppsAndLibsFolders) {
+    tree.write('./.prettierrc', JSON.stringify({ singleQuote: true }));
+    tree.write('/package.json', JSON.stringify({
+        name: '@proj/source',
+        dependencies: {},
+        devDependencies: {},
+    }));
+    tree.write('/nx.json', JSON.stringify({
+        affected: {
+            defaultBase: 'main',
+        },
+        targetDefaults: {
+            build: {
+                cache: true,
+            },
+            lint: {
+                cache: true,
+            },
+        },
+    }));
+    tree.write('/tsconfig.base.json', JSON.stringify({ compilerOptions: { paths: {} } }));
+    if (addAppsAndLibsFolders) {
+        tree.write('/apps/.gitignore', '');
+        tree.write('/libs/.gitignore', '');
+    }
+    return tree;
+}

package/src/generators/testing-utils/create-tree.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '../tree';
+/**
+ * Creates a host for testing.
+ */
+export declare function createTree(): Tree;

package/src/generators/testing-utils/create-tree.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTree = void 0;
+const tree_1 = require("../tree");
+/**
+ * Creates a host for testing.
+ */
+function createTree() {
+    return new tree_1.FsTree('/virtual', false);
+}
+exports.createTree = createTree;

package/src/generators/tree.d.ts

@@ -0,0 +1,128 @@
+/// <reference types="node" />
+/// <reference types="@types/node/ts4.8/fs" />
+/// <reference types="node" />
+import type { Mode } from 'fs';
+/**
+ * Options to set when writing a file in the Virtual file system tree.
+ */
+export interface TreeWriteOptions {
+    /**
+     * Permission to be granted on the file, given as a string (e.g `755`) or octal integer (e.g `0o755`).
+     * The logical OR operator can be used to separate multiple permissions.
+     * See https://nodejs.org/api/fs.html#fs_file_modes
+     */
+    mode?: Mode;
+}
+/**
+ * Virtual file system tree.
+ */
+export interface Tree {
+    /**
+     * Root of the workspace. All paths are relative to this.
+     */
+    root: string;
+    /**
+     * Read the contents of a file.
+     * @param filePath A path to a file.
+     */
+    read(filePath: string): Buffer | null;
+    /**
+     * Read the contents of a file as string.
+     * @param filePath A path to a file.
+     * @param encoding the encoding for the result
+     */
+    read(filePath: string, encoding: BufferEncoding): string | null;
+    /**
+     * Update the contents of a file or create a new file.
+     */
+    write(filePath: string, content: Buffer | string, options?: TreeWriteOptions): void;
+    /**
+     * Check if a file exists.
+     */
+    exists(filePath: string): boolean;
+    /**
+     * Delete the file.
+     */
+    delete(filePath: string): void;
+    /**
+     * Rename the file or the folder.
+     */
+    rename(from: string, to: string): void;
+    /**
+     * Check if this is a file or not.
+     */
+    isFile(filePath: string): boolean;
+    /**
+     * Returns the list of children of a folder.
+     */
+    children(dirPath: string): string[];
+    /**
+     * Returns the list of currently recorded changes.
+     */
+    listChanges(): FileChange[];
+    /**
+     * Changes permissions of a file.
+     * @param filePath A path to a file.
+     * @param mode The permission to be granted on the file, given as a string (e.g `755`) or octal integer (e.g `0o755`).
+     * See https://nodejs.org/api/fs.html#fs_file_modes.
+     */
+    changePermissions(filePath: string, mode: Mode): void;
+}
+/**
+ * Description of a file change in the Nx virtual file system/
+ */
+export interface FileChange {
+    /**
+     * Path relative to the workspace root
+     */
+    path: string;
+    /**
+     * Type of change: 'CREATE' | 'DELETE' | 'UPDATE'
+     */
+    type: 'CREATE' | 'DELETE' | 'UPDATE';
+    /**
+     * The content of the file or null in case of delete.
+     */
+    content: Buffer | null;
+    /**
+     * Options to set on the file being created or updated.
+     */
+    options?: TreeWriteOptions;
+}
+export declare class FsTree implements Tree {
+    readonly root: string;
+    private readonly isVerbose;
+    private readonly logOperationId?;
+    private recordedChanges;
+    /**
+     * Signifies if operations on the tree instance
+     * are allowed. Set to false after changes are written
+     * to disk, to prevent someone trying to use the tree to update
+     * files when the tree is no longer effective.
+     */
+    private locked;
+    constructor(root: string, isVerbose: boolean, logOperationId?: string);
+    read(filePath: string): Buffer | null;
+    read(filePath: string, encoding: BufferEncoding): string | null;
+    write(filePath: string, content: Buffer | string, options?: TreeWriteOptions): void;
+    overwrite(filePath: string, content: Buffer | string, options?: TreeWriteOptions): void;
+    delete(filePath: string): void;
+    exists(filePath: string): boolean;
+    rename(from: string, to: string): void;
+    isFile(filePath: string): boolean;
+    children(dirPath: string): string[];
+    listChanges(): FileChange[];
+    changePermissions(filePath: string, mode: Mode): void;
+    lock(): void;
+    private assertUnlocked;
+    private normalize;
+    private fsReadDir;
+    private fsIsFile;
+    private fsReadFile;
+    private fsExists;
+    private filesForDir;
+    private directChildrenOfDir;
+    private rp;
+}
+export declare function flushChanges(root: string, fileChanges: FileChange[]): void;
+export declare function printChanges(fileChanges: FileChange[], indent?: string): void;

package/src/generators/tree.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printChanges = exports.flushChanges = exports.FsTree = void 0;
+const fs_extra_1 = require("fs-extra");
+const logger_1 = require("../utils/logger");
+const output_1 = require("../utils/output");
+const path_1 = require("path");
+const chalk = require("chalk");
+class FsTree {
+    constructor(root, isVerbose, logOperationId) {
+        this.root = root;
+        this.isVerbose = isVerbose;
+        this.logOperationId = logOperationId;
+        this.recordedChanges = {};
+        /**
+         * Signifies if operations on the tree instance
+         * are allowed. Set to false after changes are written
+         * to disk, to prevent someone trying to use the tree to update
+         * files when the tree is no longer effective.
+         */
+        this.locked = false;
+    }
+    read(filePath, encoding) {
+        filePath = this.normalize(filePath);
+        try {
+            let content;
+            if (this.recordedChanges[this.rp(filePath)]) {
+                content = this.recordedChanges[this.rp(filePath)].content;
+            }
+            else {
+                content = this.fsReadFile(filePath);
+            }
+            return encoding ? content.toString(encoding) : content;
+        }
+        catch (e) {
+            if (this.isVerbose) {
+                logger_1.logger.error(e);
+            }
+            return null;
+        }
+    }
+    write(filePath, content, options) {
+        this.assertUnlocked();
+        filePath = this.normalize(filePath);
+        // Remove any recorded changes where a parent directory has been
+        // deleted when writing a new file within the directory.
+        let parent = (0, path_1.dirname)(this.rp(filePath));
+        while (parent !== '.') {
+            if (this.recordedChanges[parent]?.isDeleted) {
+                delete this.recordedChanges[parent];
+            }
+            parent = (0, path_1.dirname)(parent);
+        }
+        if (this.fsExists(this.rp(filePath)) &&
+            Buffer.from(content).equals(this.fsReadFile(filePath))) {
+            // Remove recorded change because the file has been restored to it's original contents
+            delete this.recordedChanges[this.rp(filePath)];
+            return;
+        }
+        try {
+            this.recordedChanges[this.rp(filePath)] = {
+                content: Buffer.from(content),
+                isDeleted: false,
+                options,
+            };
+        }
+        catch (e) {
+            if (this.isVerbose) {
+                logger_1.logger.error(e);
+            }
+        }
+    }
+    overwrite(filePath, content, options) {
+        filePath = this.normalize(filePath);
+        this.write(filePath, content, options);
+    }
+    delete(filePath) {
+        this.assertUnlocked();
+        filePath = this.normalize(filePath);
+        if (this.filesForDir(this.rp(filePath)).length > 0) {
+            this.filesForDir(this.rp(filePath)).forEach((f) => (this.recordedChanges[f] = { content: null, isDeleted: true }));
+        }
+        this.recordedChanges[this.rp(filePath)] = {
+            content: null,
+            isDeleted: true,
+        };
+        // Delete directory when is not root and there are no children
+        if (filePath !== '' &&
+            this.children((0, path_1.dirname)(this.rp(filePath))).length < 1) {
+            this.delete((0, path_1.dirname)(this.rp(filePath)));
+        }
+    }
+    exists(filePath) {
+        filePath = this.normalize(filePath);
+        try {
+            if (this.recordedChanges[this.rp(filePath)]) {
+                return !this.recordedChanges[this.rp(filePath)].isDeleted;
+            }
+            else if (this.filesForDir(this.rp(filePath)).length > 0) {
+                return true;
+            }
+            else {
+                return this.fsExists(filePath);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    rename(from, to) {
+        this.assertUnlocked();
+        from = this.normalize(from);
+        to = this.normalize(to);
+        if (from === to) {
+            return;
+        }
+        if (this.isFile(from)) {
+            const content = this.read(this.rp(from));
+            this.write(this.rp(to), content);
+            this.delete(this.rp(from));
+        }
+        else {
+            for (const child of this.children(from)) {
+                this.rename((0, path_1.join)(from, child), (0, path_1.join)(to, child));
+            }
+        }
+    }
+    isFile(filePath) {
+        filePath = this.normalize(filePath);
+        try {
+            if (this.recordedChanges[this.rp(filePath)]) {
+                return !this.recordedChanges[this.rp(filePath)].isDeleted;
+            }
+            else {
+                return this.fsIsFile(filePath);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    children(dirPath) {
+        dirPath = this.normalize(dirPath);
+        let res = this.fsReadDir(dirPath);
+        res = [...res, ...this.directChildrenOfDir(this.rp(dirPath))];
+        res = res.filter((q) => {
+            const r = this.recordedChanges[this.normalize((0, path_1.join)(this.rp(dirPath), q))];
+            return !r?.isDeleted;
+        });
+        // Dedupe
+        return Array.from(new Set(res));
+    }
+    listChanges() {
+        const res = [];
+        Object.keys(this.recordedChanges).forEach((f) => {
+            if (this.recordedChanges[f].isDeleted) {
+                if (this.fsExists(f)) {
+                    res.push({ path: f, type: 'DELETE', content: null });
+                }
+            }
+            else {
+                if (this.fsExists(f)) {
+                    res.push({
+                        path: f,
+                        type: 'UPDATE',
+                        content: this.recordedChanges[f].content,
+                        options: this.recordedChanges[f].options,
+                    });
+                }
+                else {
+                    res.push({
+                        path: f,
+                        type: 'CREATE',
+                        content: this.recordedChanges[f].content,
+                        options: this.recordedChanges[f].options,
+                    });
+                }
+            }
+        });
+        return res;
+    }
+    changePermissions(filePath, mode) {
+        this.assertUnlocked();
+        filePath = this.normalize(filePath);
+        const filePathChangeKey = this.rp(filePath);
+        if (this.recordedChanges[filePathChangeKey]) {
+            if (this.recordedChanges[filePathChangeKey].isDeleted) {
+                throw new Error(`Cannot change permissions of deleted file ${filePath}.`);
+            }
+            this.recordedChanges[filePathChangeKey].options = { mode };
+        }
+        else if (!this.fsExists(filePath)) {
+            throw new Error(`Cannot change permissions of non-existing file ${filePath}.`);
+        }
+        else if (!this.fsIsFile(filePath)) {
+            // To fully support directories we'd need to change how we store
+            // changes to keep a record of directories so we can associate
+            // permissions to them.
+            throw new Error(`Cannot change permissions of non-file ${filePath}.`);
+        }
+        else {
+            this.recordedChanges[filePathChangeKey] = {
+                content: this.fsReadFile(filePath),
+                isDeleted: false,
+                options: { mode },
+            };
+        }
+    }
+    // Marks FsTree as final.
+    lock() {
+        this.locked = true;
+    }
+    assertUnlocked() {
+        if (this.locked) {
+            output_1.output.error({
+                title: `File changes have already been written to disk. Further changes were attempted ${this.logOperationId ? ` while running ${this.logOperationId}.` : '.'}`,
+                bodyLines: [
+                    'The file system can no longer be modified. This commonly happens when a generator attempts to make further changes in its callback, or an asynchronous operation is still running after the generator completes.',
+                ],
+            });
+            throw new Error('Tree changed after commit to disk.');
+        }
+    }
+    normalize(path) {
+        return (0, path_1.relative)(this.root, (0, path_1.join)(this.root, path)).split(path_1.sep).join('/');
+    }
+    fsReadDir(dirPath) {
+        try {
+            return (0, fs_extra_1.readdirSync)((0, path_1.join)(this.root, dirPath));
+        }
+        catch {
+            return [];
+        }
+    }
+    fsIsFile(filePath) {
+        const stat = (0, fs_extra_1.statSync)((0, path_1.join)(this.root, filePath));
+        return stat.isFile();
+    }
+    fsReadFile(filePath) {
+        return (0, fs_extra_1.readFileSync)((0, path_1.join)(this.root, filePath));
+    }
+    fsExists(filePath) {
+        try {
+            const stat = (0, fs_extra_1.statSync)((0, path_1.join)(this.root, filePath));
+            return stat.isFile() || stat.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    filesForDir(path) {
+        return Object.keys(this.recordedChanges).filter((f) => f.startsWith(`${path}/`) && !this.recordedChanges[f].isDeleted);
+    }
+    directChildrenOfDir(path) {
+        const res = {};
+        if (path === '') {
+            return Object.keys(this.recordedChanges).map((file) => file.split('/')[0]);
+        }
+        Object.keys(this.recordedChanges).forEach((f) => {
+            if (f.startsWith(`${path}/`)) {
+                // Remove the current folder's path from the directory
+                const file = f.substring(path.length + 1);
+                // Split the path on segments, and take the first one
+                const basePath = file.split('/')[0];
+                // Mark it as a child of the current directory
+                res[basePath] = true;
+            }
+        });
+        return Object.keys(res);
+    }
+    rp(pp) {
+        return pp.startsWith('/') ? pp.substring(1) : pp;
+    }
+}
+exports.FsTree = FsTree;
+function flushChanges(root, fileChanges) {
+    fileChanges.forEach((f) => {
+        const fpath = (0, path_1.join)(root, f.path);
+        if (f.type === 'CREATE') {
+            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(fpath));
+            (0, fs_extra_1.writeFileSync)(fpath, f.content);
+            if (f.options?.mode)
+                (0, fs_extra_1.chmodSync)(fpath, f.options.mode);
+        }
+        else if (f.type === 'UPDATE') {
+            (0, fs_extra_1.writeFileSync)(fpath, f.content);
+            if (f.options?.mode)
+                (0, fs_extra_1.chmodSync)(fpath, f.options.mode);
+        }
+        else if (f.type === 'DELETE') {
+            (0, fs_extra_1.removeSync)(fpath);
+        }
+    });
+}
+exports.flushChanges = flushChanges;
+function printChanges(fileChanges, indent = '') {
+    fileChanges.forEach((f) => {
+        if (f.type === 'CREATE') {
+            console.log(`${indent}${chalk.green('CREATE')} ${f.path}`);
+        }
+        else if (f.type === 'UPDATE') {
+            console.log(`${indent}${chalk.white('UPDATE')} ${f.path}`);
+        }
+        else if (f.type === 'DELETE') {
+            console.log(`${indent}${chalk.yellow('DELETE')} ${f.path}`);
+        }
+    });
+}
+exports.printChanges = printChanges;

package/src/generators/utils/glob.d.ts

@@ -0,0 +1,11 @@
+import { Tree } from '../tree';
+/**
+ * Performs a tree-aware glob search on the files in a workspace. Able to find newly
+ * created files and hides deleted files before the updates are committed to disk.
+ * Paths should be unix-style with forward slashes.
+ *
+ * @param tree The file system tree
+ * @param patterns A list of glob patterns
+ * @returns Normalized paths in the workspace that match the provided glob patterns.
+ */
+export declare function glob(tree: Tree, patterns: string[]): string[];

package/src/generators/utils/glob.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.glob = void 0;
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../../utils/globs");
+const workspace_context_1 = require("../../utils/workspace-context");
+/**
+ * Performs a tree-aware glob search on the files in a workspace. Able to find newly
+ * created files and hides deleted files before the updates are committed to disk.
+ * Paths should be unix-style with forward slashes.
+ *
+ * @param tree The file system tree
+ * @param patterns A list of glob patterns
+ * @returns Normalized paths in the workspace that match the provided glob patterns.
+ */
+function glob(tree, patterns) {
+    const matches = new Set((0, workspace_context_1.globWithWorkspaceContext)(tree.root, patterns));
+    const combinedGlob = (0, globs_1.combineGlobPatterns)(patterns);
+    const matcher = minimatch_1.minimatch.makeRe(combinedGlob);
+    if (!matcher) {
+        throw new Error('Invalid glob pattern: ' + combinedGlob);
+    }
+    for (const change of tree.listChanges()) {
+        if (change.type !== 'UPDATE' && matcher.test(change.path)) {
+            if (change.type === 'CREATE') {
+                matches.add(change.path);
+            }
+            else if (change.type === 'DELETE') {
+                matches.delete(change.path);
+            }
+        }
+    }
+    return Array.from(matches);
+}
+exports.glob = glob;

package/src/generators/utils/json.d.ts

@@ -0,0 +1,28 @@
+import type { Tree } from '../tree';
+import type { JsonParseOptions, JsonSerializeOptions } from '../../utils/json';
+/**
+ * Reads a json file, removes all comments and parses JSON.
+ *
+ * @param tree - file system tree
+ * @param path - file path
+ * @param options - Optional JSON Parse Options
+ */
+export declare function readJson<T extends object = any>(tree: Tree, path: string, options?: JsonParseOptions): T;
+/**
+ * Writes a JSON value to the file system tree
+
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param value Serializable value to write
+ * @param options Optional JSON Serialize Options
+ */
+export declare function writeJson<T extends object = object>(tree: Tree, path: string, value: T, options?: JsonSerializeOptions): void;
+/**
+ * Updates a JSON value to the file system tree
+ *
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param updater Function that maps the current value of a JSON document to a new value to be written to the document
+ * @param options Optional JSON Parse and Serialize Options
+ */
+export declare function updateJson<T extends object = any, U extends object = T>(tree: Tree, path: string, updater: (value: T) => U, options?: JsonParseOptions & JsonSerializeOptions): void;

package/src/generators/utils/json.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJson = exports.writeJson = exports.readJson = void 0;
+const json_1 = require("../../utils/json");
+/**
+ * Reads a json file, removes all comments and parses JSON.
+ *
+ * @param tree - file system tree
+ * @param path - file path
+ * @param options - Optional JSON Parse Options
+ */
+function readJson(tree, path, options) {
+    if (!tree.exists(path)) {
+        throw new Error(`Cannot find ${path}`);
+    }
+    try {
+        return (0, json_1.parseJson)(tree.read(path, 'utf-8'), options);
+    }
+    catch (e) {
+        throw new Error(`Cannot parse ${path}: ${e.message}`);
+    }
+}
+exports.readJson = readJson;
+/**
+ * Writes a JSON value to the file system tree
+
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param value Serializable value to write
+ * @param options Optional JSON Serialize Options
+ */
+function writeJson(tree, path, value, options) {
+    tree.write(path, (0, json_1.serializeJson)(value, options));
+}
+exports.writeJson = writeJson;
+/**
+ * Updates a JSON value to the file system tree
+ *
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param updater Function that maps the current value of a JSON document to a new value to be written to the document
+ * @param options Optional JSON Parse and Serialize Options
+ */
+function updateJson(tree, path, updater, options) {
+    const updatedValue = updater(readJson(tree, path, options));
+    writeJson(tree, path, updatedValue, options);
+}
+exports.updateJson = updateJson;

package/src/generators/utils/nx-json.d.ts

@@ -0,0 +1,11 @@
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { Tree } from '../tree';
+/**
+ * @deprecated You must pass a {@link Tree}
+ */
+export declare function readNxJson(): NxJsonConfiguration | null;
+export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
+/**
+ * Update nx.json
+ */
+export declare function updateNxJson(tree: Tree, nxJson: NxJsonConfiguration): void;