@expo-harmony/expo-modules-autolinking 55.0.25-harmony.1

package/src/harmony/materialize.ts

@@ -0,0 +1,382 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+
+import { HarmonyAutolinkingError } from '../errors';
+import type {
+  ArkTsModulePackage,
+  BuildType,
+  FixedHvigorBuildDescriptor,
+  MaterializedLocalSource,
+  MaterializeLocalSourceOptions,
+  ModuleArtifactDescriptor,
+  ModuleSource,
+  RnohMetadata,
+} from '../types';
+import { compareText, isPathInside, normalizeSlashes, resolveInsideAsync, sanitizeOutput } from '../utilities/values';
+import { publishArtifactsAsync } from './transaction/publish';
+
+const DefaultBuildTimeoutMs = 10 * 60_000;
+const DefaultOutputLimit = 64 * 1024;
+const HarmonyProjectPath = 'harmony';
+const HarmonyBuildOutputPath = 'library/build/default/outputs/default/library.har';
+
+interface FixedBuildStep {
+  readonly id: 'ohpm-install' | 'hvigor-build';
+  readonly label: string;
+  readonly executable: string;
+  readonly cwd: string;
+  readonly args: ReadonlyArray<string>;
+}
+
+interface MaterializeModuleArtifactOptions {
+  readonly packageName: string;
+  readonly packageRoot: string;
+  readonly source: ModuleSource;
+  readonly buildType: BuildType;
+  readonly arkTs?: ArkTsModulePackage;
+  readonly rnoh: RnohMetadata;
+}
+
+function materializationError(
+  code: string,
+  message: string,
+  options: MaterializeModuleArtifactOptions,
+  details?: unknown
+): never {
+  throw new HarmonyAutolinkingError(code, message, {
+    packageName: options.packageName,
+    stage: 'artifact-materialize',
+    details,
+  });
+}
+
+function createFixedHvigorBuildDescriptor(
+  projectPath: string,
+  buildType: BuildType
+): FixedHvigorBuildDescriptor {
+  return {
+    executable: 'hvigorw',
+    cwd: projectPath,
+    args: [
+      '--mode', 'module',
+      '-p', 'module=library@default',
+      '-p', 'product=default',
+      '-p', `buildMode=${buildType}`,
+      '--no-daemon',
+      'assembleHar',
+    ],
+  };
+}
+
+async function isNonEmptyRegularHarAsync(
+  harPath: string,
+  allowedRoot: string,
+  packageName: string
+): Promise<boolean> {
+  const root = path.resolve(allowedRoot);
+  const target = path.resolve(harPath);
+  if (!isPathInside(root, target)) {
+    throw new HarmonyAutolinkingError(
+      'UNSAFE_SOURCE_ARTIFACT',
+      'Harmony HAR path must stay inside its expected package or project root.',
+      { packageName, stage: 'artifact-materialize' }
+    );
+  }
+
+  let stat;
+  try {
+    stat = await fs.promises.lstat(target);
+  } catch (cause) {
+    if ((cause as NodeJS.ErrnoException).code === 'ENOENT') return false;
+    throw new HarmonyAutolinkingError(
+      'UNSAFE_SOURCE_ARTIFACT',
+      'Harmony HAR could not be checked safely.',
+      { cause, packageName, stage: 'artifact-materialize' }
+    );
+  }
+  if (stat.isSymbolicLink() || !stat.isFile()) {
+    throw new HarmonyAutolinkingError(
+      'UNSAFE_SOURCE_ARTIFACT',
+      'Harmony HAR must be a regular non-symlink file.',
+      { packageName, stage: 'artifact-materialize' }
+    );
+  }
+
+  const [realRoot, realTarget] = await Promise.all([
+    fs.promises.realpath(root),
+    fs.promises.realpath(target),
+  ]);
+  if (!isPathInside(realRoot, realTarget)) {
+    throw new HarmonyAutolinkingError(
+      'UNSAFE_SOURCE_ARTIFACT',
+      'Harmony HAR resolves outside its expected package or project root.',
+      { packageName, stage: 'artifact-materialize' }
+    );
+  }
+  return stat.size > 0;
+}
+
+async function validateBundledArtifactsAsync(
+  options: MaterializeModuleArtifactOptions
+): Promise<ModuleArtifactDescriptor> {
+  const harPaths = [...new Set([
+    ...options.rnoh.harPaths,
+    ...(options.arkTs ? [options.arkTs.harPath] : []),
+  ])].sort(compareText);
+  for (const relative of harPaths) {
+    const harPath = path.resolve(options.packageRoot, relative);
+    if (!await isNonEmptyRegularHarAsync(harPath, options.packageRoot, options.packageName)) {
+      materializationError(
+        'SOURCE_ARTIFACT_NOT_PUBLISHED',
+        `${options.packageName} has a missing or empty Harmony HAR.`,
+        options,
+        { harPath: relative }
+      );
+    }
+  }
+  return { kind: 'bundled', harPaths };
+}
+
+async function materializeModuleArtifactAsync(
+  options: MaterializeModuleArtifactOptions
+): Promise<ModuleArtifactDescriptor> {
+  const localArkTs = options.source === 'nativeModulesDir' && options.arkTs;
+  if (!localArkTs && (
+    options.rnoh.harPaths.length > 0
+    || options.arkTs
+  )) {
+    return validateBundledArtifactsAsync(options);
+  }
+
+  if (!localArkTs) {
+    return { kind: 'bundled', harPaths: [] };
+  }
+
+  const packageRoot = await fs.promises.realpath(options.packageRoot);
+  const sourceRoot = await resolveInsideAsync(packageRoot, HarmonyProjectPath, 'Harmony source project', {
+    packageName: options.packageName,
+    type: 'directory',
+  });
+  const outputPath = await resolveInsideAsync(sourceRoot, HarmonyBuildOutputPath, 'Harmony build output', {
+    packageName: options.packageName,
+    mustExist: false,
+  });
+  return {
+    kind: 'local-source',
+    outputPath,
+    materialized: false,
+    build: createFixedHvigorBuildDescriptor(sourceRoot, options.buildType),
+  };
+}
+
+function appendBounded(current: string, chunk: Buffer, limit: number): string {
+  if (current.length >= limit) return current;
+  return current + chunk.toString('utf8').slice(0, limit - current.length);
+}
+
+function fixedLocalSourceBuildSteps(build: FixedHvigorBuildDescriptor): ReadonlyArray<FixedBuildStep> {
+  return [
+    {
+      id: 'ohpm-install',
+      label: 'OHPM dependency install',
+      executable: 'ohpm',
+      cwd: build.cwd,
+      args: ['install', '--all'],
+    },
+    {
+      id: 'hvigor-build',
+      label: 'Hvigor build',
+      ...build,
+    },
+  ];
+}
+
+function resolveFixedBuildStep(step: FixedBuildStep, env: NodeJS.ProcessEnv): FixedBuildStep {
+  if (step.id === 'ohpm-install') {
+    return env.HARMONY_OHPM ? { ...step, executable: env.HARMONY_OHPM } : step;
+  }
+
+  const configured = env.HARMONY_HVIGORW;
+  if (configured) {
+    return /\.(?:c|m)?js$/iu.test(configured)
+      ? { ...step, executable: env.HARMONY_NODE || process.execPath, args: [configured, ...step.args] }
+      : { ...step, executable: configured };
+  }
+
+  return step;
+}
+
+async function runFixedBuildStepAsync(
+  step: FixedBuildStep,
+  packageName: string,
+  options: Pick<MaterializeLocalSourceOptions, 'env' | 'outputLimit' | 'timeoutMs'>
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? DefaultBuildTimeoutMs;
+  const outputLimit = options.outputLimit ?? DefaultOutputLimit;
+  const stage = `artifact-materialize:${step.id}`;
+  const env = { ...process.env, ...options.env };
+  const resolvedStep = resolveFixedBuildStep(step, env);
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0
+    || !Number.isInteger(outputLimit) || outputLimit <= 0) {
+    throw new HarmonyAutolinkingError(
+      'INVALID_OPTIONS',
+      'timeoutMs and outputLimit must be positive integers.',
+      { packageName, stage }
+    );
+  }
+
+  const result = await new Promise<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    output: string;
+    timedOut: boolean;
+  }>((resolve, reject) => {
+    let output = '';
+    let timedOut = false;
+    let settled = false;
+    let killTimer: NodeJS.Timeout | undefined;
+    let child;
+    try {
+      child = spawn(resolvedStep.executable, [...resolvedStep.args], {
+        cwd: step.cwd,
+        env,
+        shell: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (cause) {
+      reject(cause);
+      return;
+    }
+    child.stdout.on('data', (chunk: Buffer) => {
+      output = appendBounded(output, chunk, outputLimit);
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      output = appendBounded(output, chunk, outputLimit);
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+      killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
+      killTimer.unref?.();
+    }, timeoutMs);
+    timeout.unref?.();
+    child.on('error', (cause) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+      reject(cause);
+    });
+    child.on('close', (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+      resolve({ code, signal, output, timedOut });
+    });
+  }).catch((cause) => {
+    throw new HarmonyAutolinkingError(
+      'SOURCE_BUILD_FAILED',
+      `Unable to execute the fixed ${step.label} for local Harmony source at ${step.cwd}.`,
+      { cause, packageName, stage }
+    );
+  });
+
+  if (result.code !== 0 || result.signal || result.timedOut) {
+    const reason = result.timedOut
+      ? 'timed out'
+      : result.signal ? `was terminated by ${result.signal}` : `exited with code ${result.code}`;
+    const output = sanitizeOutput(result.output, [step.cwd], outputLimit);
+    throw new HarmonyAutolinkingError(
+      'SOURCE_BUILD_FAILED',
+      `Fixed ${step.label} ${reason}${output ? `: ${output}` : '.'}`,
+      { packageName, stage }
+    );
+  }
+}
+
+async function materializeLocalSourceAsync(
+  options: MaterializeLocalSourceOptions
+): Promise<MaterializedLocalSource> {
+  const module = options.module;
+  if (module.source !== 'nativeModulesDir' || module.artifact.kind !== 'local-source') {
+    throw new HarmonyAutolinkingError(
+      'INVALID_OPTIONS',
+      `${module.packageName} is not a nativeModulesDir local-source module.`,
+      { packageName: module.packageName, stage: 'artifact-materialize' }
+    );
+  }
+  const artifact = module.artifact;
+  const projectRoot = await fs.promises.realpath(options.projectRoot);
+  const packageRoot = await fs.promises.realpath(module.packageRoot);
+  if (!isPathInside(projectRoot, packageRoot)) {
+    throw new HarmonyAutolinkingError(
+      'UNSAFE_SOURCE_ARTIFACT',
+      'Harmony local modules must live inside the application project root.',
+      { packageName: module.packageName, stage: 'artifact-materialize' }
+    );
+  }
+  if (!module.arkTs) {
+    throw new HarmonyAutolinkingError(
+      'INVALID_METADATA',
+      `${module.packageName} local-source descriptor has no derived ArkTS package.`,
+      { packageName: module.packageName, stage: 'artifact-materialize' }
+    );
+  }
+  const harPath = await resolveInsideAsync(
+    packageRoot,
+    module.arkTs.harPath,
+    'Harmony materialized HAR path',
+    { packageName: module.packageName, mustExist: false }
+  );
+
+  for (const step of fixedLocalSourceBuildSteps(artifact.build)) {
+    await runFixedBuildStepAsync(step, module.packageName, options);
+  }
+  const outputReady = await isNonEmptyRegularHarAsync(
+    artifact.outputPath,
+    artifact.build.cwd,
+    module.packageName
+  );
+  if (!outputReady) {
+    throw new HarmonyAutolinkingError(
+      'SOURCE_BUILD_FAILED',
+      `Hvigor did not produce a non-empty HAR at ${normalizeSlashes(path.relative(packageRoot, artifact.outputPath))}.`,
+      { packageName: module.packageName, stage: 'artifact-materialize' }
+    );
+  }
+
+  await publishArtifactsAsync({
+    allowedRoot: projectRoot,
+    lockPath: path.join(projectRoot, '.expo/harmony/module-materialize.lock'),
+    files: [{ source: artifact.outputPath, target: harPath }],
+  });
+  if (!await isNonEmptyRegularHarAsync(harPath, packageRoot, module.packageName)) {
+    throw new HarmonyAutolinkingError(
+      'SOURCE_BUILD_FAILED',
+      'Harmony HAR materialization produced a missing or empty file.',
+      { packageName: module.packageName, stage: 'artifact-materialize' }
+    );
+  }
+  return {
+    packageName: module.packageName,
+    harPath,
+  };
+}
+
+async function materializeLocalSourcesAsync(
+  modules: ReadonlyArray<MaterializeLocalSourceOptions['module']>,
+  options: Omit<MaterializeLocalSourceOptions, 'module'>
+): Promise<ReadonlyArray<MaterializedLocalSource>> {
+  const results = [];
+  for (const module of [...modules].sort((left, right) => compareText(left.packageName, right.packageName))) {
+    results.push(await materializeLocalSourceAsync({ ...options, module }));
+  }
+  return results;
+}
+
+export {
+  materializeLocalSourcesAsync,
+  materializeModuleArtifactAsync,
+};

package/src/harmony/ohpm/dependencies.ts

@@ -0,0 +1,59 @@
+import path from 'node:path';
+
+import { resolveRnohMetadata } from '../rnoh/packageMetadata';
+import { normalizeSlashes } from '../../utilities/values';
+
+function collectOhpmDeps(descriptors) {
+  const dependencies = new Map();
+
+  for (const descriptor of descriptors) {
+    if (!descriptor.arkTs) continue;
+    dependencies.set(descriptor.arkTs.ohPackageName, {
+      descriptor,
+      mapping: {
+        harPath: descriptor.arkTs.harPath,
+        ohPackageName: descriptor.arkTs.ohPackageName,
+      },
+    });
+  }
+
+  for (const descriptor of descriptors.filter(item => item.rnoh.harPaths.length > 0)) {
+    for (const mapping of resolveRnohMetadata(descriptor).harMappings) {
+      dependencies.set(mapping.ohPackageName, { descriptor, mapping });
+    }
+  }
+
+  return [...dependencies.values()].sort((left, right) => {
+    return left.mapping.ohPackageName.localeCompare(right.mapping.ohPackageName, 'en');
+  });
+}
+
+function resolveOhpmSpecifier(
+  descriptor,
+  mapping,
+  options: { harmonyProjectPath?: string; nodeModulesPath?: string } = {}
+) {
+  if (options.harmonyProjectPath) {
+    const packageRoot = options.nodeModulesPath
+      ? path.join(options.nodeModulesPath, ...descriptor.packageName.split('/'))
+      : descriptor.packageLinkPath;
+    const target = path.join(packageRoot, ...mapping.harPath.split('/'));
+    const relative = normalizeSlashes(path.relative(options.harmonyProjectPath, target));
+    return relative.startsWith('.') ? relative : `./${relative}`;
+  }
+  return mapping.version || descriptor.packageVersion;
+}
+
+function normalizeLocalOhpmSpecifier(specifier) {
+  if (typeof specifier !== 'string' || !specifier) return null;
+  if (path.isAbsolute(specifier) || path.win32.isAbsolute(specifier) || !/^\.\.?[\\/]/u.test(specifier)) {
+    return null;
+  }
+  return normalizeSlashes(specifier);
+}
+
+export {
+  collectOhpmDeps,
+  resolveOhpmSpecifier,
+  normalizeLocalOhpmSpecifier,
+};

package/src/harmony/persistence/canonicalize.ts

@@ -0,0 +1,156 @@
+import path from 'node:path';
+
+import JSON5 from 'json5';
+
+import type {
+  CanonicalizeAutolinkingArtifactsOptions,
+  CanonicalizedAutolinkingArtifacts,
+  Manifest,
+} from '../../types';
+import { HarmonyAutolinkingError } from '../../errors';
+import { ohpmDependenciesFromManifest, validateManifest } from '../manifest';
+import { isObject, isPathInside, stringifyJson } from '../../utilities/values';
+
+interface CanonicalizeOhpmManifestOptions {
+  previousManagedOhpmPackageNames?: ReadonlyArray<string>;
+  requireManagedEntries?: boolean;
+  harmonyProjectPath?: string;
+  nodeModulesPath?: string;
+  errorCode?: string;
+  stage?: string;
+}
+
+function requireProjectRoot(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !path.isAbsolute(value)) {
+    throw new HarmonyAutolinkingError('INVALID_OPTIONS', `${field} must be an absolute path.`, { stage: 'canonicalization' });
+  }
+  return path.resolve(value);
+}
+
+function rebaseProjectPath(value: string, fromRoot: string, toRoot: string): string {
+  if (!path.isAbsolute(value) || !isPathInside(fromRoot, value)) return value;
+  return path.join(toRoot, path.relative(fromRoot, value));
+}
+
+function canonicalizeAutolinkingManifest(
+  manifest: unknown,
+  options: { generatedProjectRoot: string; canonicalProjectRoot: string }
+): { manifest: Manifest; source: string } {
+  const generatedProjectRoot = requireProjectRoot(options.generatedProjectRoot, 'generatedProjectRoot');
+  const canonicalProjectRoot = requireProjectRoot(options.canonicalProjectRoot, 'canonicalProjectRoot');
+  const validated = validateManifest(manifest);
+  const canonical = {
+    ...validated,
+    modules: validated.modules.map(module => ({
+      ...module,
+      packageRoot: rebaseProjectPath(module.packageRoot, generatedProjectRoot, canonicalProjectRoot),
+      packageLinkPath: rebaseProjectPath(module.packageLinkPath, generatedProjectRoot, canonicalProjectRoot),
+    })),
+  } as Manifest;
+
+  return {
+    manifest: canonical,
+    source: stringifyJson(canonical),
+  };
+}
+
+function canonicalizeOhpmManifest(
+  source: string,
+  manifest: Manifest,
+  options: CanonicalizeOhpmManifestOptions = {}
+): { manifest: Readonly<Record<string, unknown>>; source: string } {
+  const errorCode = options.errorCode || 'INVALID_OPTIONS';
+  const stage = options.stage || 'canonicalization';
+  let candidate;
+  try {
+    candidate = JSON5.parse(source);
+  } catch (cause) {
+    throw new HarmonyAutolinkingError(errorCode, 'harmony/oh-package.json5 must contain a JSON5 object.', { cause, stage });
+  }
+
+  if (!isObject(candidate)) {
+    throw new HarmonyAutolinkingError(errorCode, 'harmony/oh-package.json5 must contain a JSON5 object.', { stage });
+  }
+
+  for (const field of ['dependencies', 'overrides']) {
+    if (candidate[field] !== undefined && !isObject(candidate[field])) {
+      throw new HarmonyAutolinkingError(errorCode, `harmony/oh-package.json5 ${field} must be an object.`, { stage });
+    }
+  }
+
+  const specifiers = ohpmDependenciesFromManifest(manifest, {
+    harmonyProjectPath: options.harmonyProjectPath,
+    nodeModulesPath: options.nodeModulesPath,
+  });
+  const currentNames = Object.keys(specifiers).sort((left, right) => left.localeCompare(right, 'en'));
+  const managedNames = new Set([
+    ...(options.previousManagedOhpmPackageNames || []),
+    ...currentNames,
+  ]);
+
+  if (options.requireManagedEntries) {
+    for (const field of ['dependencies', 'overrides']) {
+      if (!isObject(candidate[field])) {
+        throw new HarmonyAutolinkingError(
+          errorCode,
+          `harmony/oh-package.json5 ${field} must be an object.`,
+          { stage }
+        );
+      }
+      for (const packageName of currentNames) {
+        if (!Object.hasOwn(candidate[field], packageName)) {
+          throw new HarmonyAutolinkingError(
+            errorCode,
+            `RNOH omitted the managed ${field} entry for ${packageName}.`,
+            { stage, details: { packageName, field } }
+          );
+        }
+      }
+    }
+  }
+
+  for (const field of ['dependencies', 'overrides']) {
+    const values = { ...(candidate[field] || {}) };
+    for (const packageName of managedNames) delete values[packageName];
+    for (const packageName of currentNames) values[packageName] = specifiers[packageName];
+    candidate[field] = values;
+  }
+
+  return {
+    manifest: candidate,
+    source: `${JSON5.stringify(candidate, null, 2)}\n`,
+  };
+}
+
+function canonicalizeAutolinkingArtifacts(
+  options: CanonicalizeAutolinkingArtifactsOptions
+): CanonicalizedAutolinkingArtifacts {
+  let parsedManifest;
+  try {
+    parsedManifest = JSON.parse(options.manifestSource);
+  } catch (cause) {
+    throw new HarmonyAutolinkingError(
+      'INVALID_MANIFEST',
+      'Harmony autolinking manifest must contain valid JSON.',
+      { cause, stage: 'canonicalization' }
+    );
+  }
+
+  const canonicalManifest = canonicalizeAutolinkingManifest(parsedManifest, options);
+  const canonicalOhpm = canonicalizeOhpmManifest(
+    options.ohPackageSource,
+    canonicalManifest.manifest,
+    { requireManagedEntries: true, harmonyProjectPath: options.harmonyProjectPath }
+  );
+
+  return {
+    manifest: canonicalManifest.manifest,
+    manifestSource: canonicalManifest.source,
+    ohPackageSource: canonicalOhpm.source,
+  };
+}
+
+export {
+  canonicalizeAutolinkingArtifacts,
+  canonicalizeOhpmManifest,
+};