@ohos-ports/nx 17.3.2-beta.0

package/src/native/index.d.ts

@@ -0,0 +1,192 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export class ExternalObject<T> {
+  readonly '': {
+    readonly '': unique symbol
+    [K: symbol]: T
+  }
+}
+/**
+ * Expands the given entries into a list of existing directories and files.
+ * This is used for copying outputs to and from the cache
+ */
+export function expandOutputs(directory: string, entries: Array<string>): Array<string>
+/**
+ * Expands the given outputs into a list of existing files.
+ * This is used when hashing outputs
+ */
+export function getFilesForOutputs(directory: string, entries: Array<string>): Array<string>
+export function remove(src: string): void
+export function copy(src: string, dest: string): void
+export function runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null): ChildProcess
+/**
+ * This allows us to run a pseudoterminal with a fake node ipc channel
+ * this makes it possible to be backwards compatible with the old implementation
+ */
+export function nxFork(id: string, forkScript: string, psuedoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, quiet: boolean): ChildProcess
+export function hashArray(input: Array<string>): string
+export function hashFile(file: string): string | null
+export function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
+/**
+ * Transfer the project graph from the JS world to the Rust world, so that we can pass the project graph via memory quicker
+ * This wont be needed once the project graph is created in Rust
+ */
+export function transferProjectGraph(projectGraph: ProjectGraph): ExternalObject<ProjectGraph>
+export interface ExternalNodeData {
+  version: string
+  hash?: string
+}
+export interface ExternalNode {
+  version: string
+  hash?: string
+}
+export interface Target {
+  executor?: string
+  inputs?: Array<JsInputs>
+  outputs?: Array<string>
+  options?: string
+  configurations?: string
+}
+export interface Project {
+  root: string
+  namedInputs?: Record<string, Array<JsInputs>>
+  tags?: Array<string>
+  targets: Record<string, Target>
+}
+export interface ProjectGraph {
+  nodes: Record<string, Project>
+  dependencies: Record<string, Array<string>>
+  externalNodes: Record<string, ExternalNode>
+}
+export interface HashDetails {
+  value: string
+  details: Record<string, string>
+}
+export interface HasherOptions {
+  selectivelyHashTsConfig: boolean
+}
+export interface Task {
+  id: string
+  target: TaskTarget
+  outputs: Array<string>
+  projectRoot?: string
+}
+export interface TaskTarget {
+  project: string
+  target: string
+  configuration?: string
+}
+export interface TaskGraph {
+  roots: Array<string>
+  tasks: Record<string, Task>
+  dependencies: Record<string, Array<string>>
+}
+export interface FileData {
+  file: string
+  hash: string
+}
+export interface InputsInput {
+  input: string
+  dependencies?: boolean
+  projects?: string | Array<string>
+}
+export interface FileSetInput {
+  fileset: string
+}
+export interface RuntimeInput {
+  runtime: string
+}
+export interface EnvironmentInput {
+  env: string
+}
+export interface ExternalDependenciesInput {
+  externalDependencies: Array<string>
+}
+export interface DepsOutputsInput {
+  dependentTasksOutputFiles: string
+  transitive?: boolean
+}
+/** Stripped version of the NxJson interface for use in rust */
+export interface NxJson {
+  namedInputs?: Record<string, Array<JsInputs>>
+}
+export const enum EventType {
+  delete = 'delete',
+  update = 'update',
+  create = 'create'
+}
+export interface WatchEvent {
+  path: string
+  type: EventType
+}
+/** Public NAPI error codes that are for Node */
+export const enum WorkspaceErrors {
+  ParseError = 'ParseError',
+  Generic = 'Generic'
+}
+export interface NxWorkspaceFiles {
+  projectFileMap: ProjectFiles
+  globalFiles: Array<FileData>
+  externalReferences?: NxWorkspaceFilesExternals
+}
+export interface NxWorkspaceFilesExternals {
+  projectFiles: ExternalObject<ProjectFiles>
+  globalFiles: ExternalObject<Array<FileData>>
+  allWorkspaceFiles: ExternalObject<Array<FileData>>
+}
+export interface UpdatedWorkspaceFiles {
+  fileMap: FileMap
+  externalReferences: NxWorkspaceFilesExternals
+}
+export interface FileMap {
+  projectFileMap: ProjectFiles
+  nonProjectFiles: Array<FileData>
+}
+export function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
+export class ChildProcess {
+  kill(): void
+  onExit(callback: (message: string) => void): void
+  onOutput(callback: (message: string) => void): void
+}
+export class ImportResult {
+  file: string
+  sourceProject: string
+  dynamicImportExpressions: Array<string>
+  staticImportExpressions: Array<string>
+}
+export class HashPlanner {
+  constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
+  getPlans(taskIds: Array<string>, taskGraph: TaskGraph): Record<string, string[]>
+  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph): JsExternal
+}
+export class TaskHasher {
+  constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<ProjectFiles>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, options?: HasherOptions | undefined | null)
+  hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, jsEnv: Record<string, string>): NapiDashMap
+}
+export class Watcher {
+  origin: string
+  /**
+   * Creates a new Watcher instance.
+   * Will always ignore the following directories:
+   * * .git/
+   * * node_modules/
+   * * .nx/
+   */
+  constructor(origin: string, additionalGlobs?: Array<string> | undefined | null, useIgnore?: boolean | undefined | null)
+  watch(callback: (err: string | null, events: WatchEvent[]) => void): void
+  stop(): Promise<void>
+}
+export class WorkspaceContext {
+  workspaceRoot: string
+  constructor(workspaceRoot: string, cacheDir: string)
+  getWorkspaceFiles(projectRootMap: Record<string, string>): NxWorkspaceFiles
+  glob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<string>
+  hashFilesMatchingGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): string
+  incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): Record<string, string>
+  updateProjectFiles(projectRootMappings: ProjectRootMappings, projectFiles: ExternalObject<ProjectFiles>, globalFiles: ExternalObject<Array<FileData>>, updatedFiles: Record<string, string>, deletedFiles: Array<string>): UpdatedWorkspaceFiles
+  allFileData(): Array<FileData>
+  getFilesInDirectory(directory: string): Array<string>
+}

package/src/native/index.js

@@ -0,0 +1,289 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim();
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'nx.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.android-arm64.node')
+          } else {
+            nativeBinding = require('@nx/nx-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'nx.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@nx/nx-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@nx/nx-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@nx/nx-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@nx/nx-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'nx.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nx.darwin-universal.node')
+      } else {
+        nativeBinding = require('@nx/nx-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'nx.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.darwin-x64.node')
+          } else {
+            nativeBinding = require('@nx/nx-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@nx/nx-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'nx.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./nx.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@nx/nx-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@nx/nx-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@nx/nx-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@nx/nx-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'nx.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./nx.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@nx/nx-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.linux-arm-gnueabihf.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('@nx/nx-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  case 'openharmony':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'nx.openharmony-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./nx.openharmony-arm64.node')
+          } else {
+            nativeBinding = require('@ohos-ports/nx-openharmony-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on openharmony: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { expandOutputs, getFilesForOutputs, remove, copy, ChildProcess, runCommand, nxFork, hashArray, hashFile, ImportResult, findImports, transferProjectGraph, HashPlanner, TaskHasher, EventType, Watcher, WorkspaceContext, WorkspaceErrors, testOnlyTransferFileMap } = nativeBinding
+
+module.exports.expandOutputs = expandOutputs
+module.exports.getFilesForOutputs = getFilesForOutputs
+module.exports.remove = remove
+module.exports.copy = copy
+module.exports.ChildProcess = ChildProcess
+module.exports.runCommand = runCommand
+module.exports.nxFork = nxFork
+module.exports.hashArray = hashArray
+module.exports.hashFile = hashFile
+module.exports.ImportResult = ImportResult
+module.exports.findImports = findImports
+module.exports.transferProjectGraph = transferProjectGraph
+module.exports.HashPlanner = HashPlanner
+module.exports.TaskHasher = TaskHasher
+module.exports.EventType = EventType
+module.exports.Watcher = Watcher
+module.exports.WorkspaceContext = WorkspaceContext
+module.exports.WorkspaceErrors = WorkspaceErrors
+module.exports.testOnlyTransferFileMap = testOnlyTransferFileMap

package/src/native/transform-objects.d.ts

@@ -0,0 +1,3 @@
+import { ProjectGraph } from '../config/project-graph';
+import { ProjectGraph as RustProjectGraph } from './index';
+export declare function transformProjectGraphForRust(graph: ProjectGraph): RustProjectGraph;

package/src/native/transform-objects.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformProjectGraphForRust = void 0;
+function transformProjectGraphForRust(graph) {
+    const dependencies = {};
+    const nodes = {};
+    const externalNodes = {};
+    for (const [projectName, projectNode] of Object.entries(graph.nodes)) {
+        const targets = {};
+        for (const [targetName, targetConfig] of Object.entries(projectNode.data.targets ?? {})) {
+            targets[targetName] = {
+                executor: targetConfig.executor,
+                inputs: targetConfig.inputs,
+                outputs: targetConfig.outputs,
+                options: JSON.stringify(targetConfig.options),
+                configurations: JSON.stringify(targetConfig.configurations),
+            };
+        }
+        nodes[projectName] = {
+            root: projectNode.data.root,
+            namedInputs: projectNode.data.namedInputs,
+            targets,
+            tags: projectNode.data.tags,
+        };
+        if (graph.dependencies[projectName]) {
+            dependencies[projectName] = [];
+            for (const dep of graph.dependencies[projectName]) {
+                dependencies[projectName].push(dep.target);
+            }
+        }
+    }
+    for (const [projectName, externalNode] of Object.entries(graph.externalNodes ?? {})) {
+        externalNodes[projectName] = {
+            hash: externalNode.data.hash,
+            version: externalNode.data.version,
+        };
+        if (graph.dependencies[projectName]) {
+            dependencies[projectName] = [];
+            for (const dep of graph.dependencies[projectName]) {
+                dependencies[projectName].push(dep.target);
+            }
+        }
+    }
+    return {
+        nodes,
+        externalNodes,
+        dependencies,
+    };
+}
+exports.transformProjectGraphForRust = transformProjectGraphForRust;

package/src/nx-cloud/debug-logger.d.ts

@@ -0,0 +1 @@
+export declare function debugLog(...args: any[]): void;

package/src/nx-cloud/debug-logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = void 0;
+function debugLog(...args) {
+    if (process.env['NX_VERBOSE_LOGGING'] === 'true') {
+        console.log('[NX CLOUD]', ...args);
+    }
+}
+exports.debugLog = debugLog;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.d.ts

@@ -0,0 +1,8 @@
+import { Tree } from '../../../generators/tree';
+interface ConnectToNxCloudOptions {
+    analytics: boolean;
+    installationSource: string;
+    hideFormatLogs?: boolean;
+}
+export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions): Promise<() => void>;
+export default connectToNxCloud;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToNxCloud = void 0;
+const child_process_1 = require("child_process");
+const node_url_1 = require("node:url");
+const output_1 = require("../../../utils/output");
+const json_1 = require("../../../generators/utils/json");
+const nx_json_1 = require("../../../generators/utils/nx-json");
+const format_changed_files_with_prettier_if_available_1 = require("../../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+function printCloudConnectionDisabledMessage() {
+    output_1.output.error({
+        title: `Connections to Nx Cloud are disabled for this workspace`,
+        bodyLines: [
+            `This was an intentional decision by someone on your team.`,
+            `Nx Cloud cannot and will not be enabled.`,
+            ``,
+            `To allow connections to Nx Cloud again, remove the 'neverConnectToCloud'`,
+            `property in nx.json.`,
+        ],
+    });
+}
+function getRootPackageName(tree) {
+    let packageJson;
+    try {
+        packageJson = (0, json_1.readJson)(tree, 'package.json');
+    }
+    catch (e) { }
+    return packageJson?.name ?? 'my-workspace';
+}
+function removeTrailingSlash(apiUrl) {
+    return apiUrl[apiUrl.length - 1] === '/'
+        ? apiUrl.substr(0, apiUrl.length - 1)
+        : apiUrl;
+}
+function getNxInitDate() {
+    try {
+        const nxInitIso = (0, child_process_1.execSync)('git log --diff-filter=A --follow --format=%aI -- nx.json | tail -1', { stdio: 'pipe' })
+            .toString()
+            .trim();
+        const nxInitDate = new Date(nxInitIso);
+        return nxInitDate.toISOString();
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function createNxCloudWorkspace(workspaceName, installationSource, nxInitDate) {
+    const apiUrl = removeTrailingSlash(process.env.NX_CLOUD_API || process.env.NRWL_API || `https://cloud.nx.app`);
+    const response = await require('axios').post(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
+        workspaceName,
+        installationSource,
+        nxInitDate,
+    });
+    if (response.data.message) {
+        throw new Error(response.data.message);
+    }
+    return response.data;
+}
+function printSuccessMessage(url) {
+    let host = 'nx.app';
+    try {
+        host = new node_url_1.URL(url).host;
+    }
+    catch (e) { }
+    output_1.output.note({
+        title: `Remote caching via Nx Cloud has been enabled`,
+        bodyLines: [
+            `In addition to the caching, Nx Cloud provides config-free distributed execution,`,
+            `UI for viewing complex runs and GitHub integration. Learn more at https://nx.app`,
+            ``,
+            `Your workspace is currently unclaimed. Run details from unclaimed workspaces can be viewed on ${host} by anyone`,
+            `with the link. Claim your workspace at the following link to restrict access.`,
+            ``,
+            `${url}`,
+        ],
+    });
+}
+function addNxCloudOptionsToNxJson(tree, nxJson, token) {
+    nxJson ??= {
+        extends: 'nx/presets/npm.json',
+    };
+    nxJson.nxCloudAccessToken = token;
+    const overrideUrl = process.env.NX_CLOUD_API || process.env.NRWL_API;
+    if (overrideUrl) {
+        nxJson.nxCloudUrl = overrideUrl;
+    }
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+}
+async function connectToNxCloud(tree, schema) {
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    if (nxJson?.neverConnectToCloud) {
+        return () => {
+            printCloudConnectionDisabledMessage();
+        };
+    }
+    else {
+        // TODO: Change to using loading light client when that is enabled by default
+        const r = await createNxCloudWorkspace(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+        addNxCloudOptionsToNxJson(tree, nxJson, r.token);
+        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+            silent: schema.hideFormatLogs,
+        });
+        return () => printSuccessMessage(r.url);
+    }
+}
+exports.connectToNxCloud = connectToNxCloud;
+exports.default = connectToNxCloud;

package/src/nx-cloud/generators/connect-to-nx-cloud/schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "id": "NxCloudInit",
+  "title": "Add Nx Cloud Configuration to the workspace",
+  "description": "Connect a workspace to Nx Cloud.",
+  "type": "object",
+  "cli": "nx",
+  "properties": {
+    "analytics": {
+      "type": "boolean",
+      "description": "Anonymously store hashed machine ID for task runs",
+      "default": false
+    },
+    "installationSource": {
+      "type": "string",
+      "description": "Name of Nx Cloud installation invoker (ex. user, add-nx-to-monorepo, create-nx-workspace, nx-upgrade",
+      "default": "user"
+    },
+    "hideFormatLogs": {
+      "type": "boolean",
+      "description": "Hide formatting logs",
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": false,
+  "required": []
+}