expo-modules-autolinking 0.0.3 → 0.3.2

package/scripts/ios/project_integrator.rb

@@ -0,0 +1,102 @@
+
+module Expo
+  module ProjectIntegrator
+    include Pod
+
+    # Integrates targets in the project and generates modules providers.
+    def self.integrate_targets_in_project(targets, project)
+      # Find the targets that use expo modules and need the modules provider
+      targets_with_modules_provider = targets.select do |target|
+        autolinking_manager = target.target_definition.autolinking_manager
+        autolinking_manager.present?
+      end
+
+      # Find existing PBXGroup for modules providers.
+      generated_group = modules_providers_group(project, targets_with_modules_provider.any?)
+
+      # Return early when the modules providers group has not been auto-created in the line above.
+      return if generated_group.nil?
+
+      # Remove existing groups for targets without modules provider.
+      generated_group.groups.each do |group|
+        # Remove the group if there is no target for this group.
+        if targets.none? { |target| target.target_definition.name == group.name && targets_with_modules_provider.include?(target) }
+          recursively_remove_group(group)
+        end
+      end
+
+      targets_with_modules_provider.sort_by(&:name).each do |target|
+        # The user target name (without `Pods-` prefix which is a part of `target.name`)
+        target_name = target.target_definition.name
+
+        UI.message '- Generating the provider for ' << target_name.green << ' target' do
+          # PBXNativeTarget of the user target
+          native_target = project.native_targets.find { |native_target| native_target.name == target_name }
+
+          # Shorthand ref for the autolinking manager.
+          autolinking_manager = target.target_definition.autolinking_manager
+
+          # Absolute path to `Pods/Target Support Files/<pods target name>/<modules provider file>` within the project path
+          modules_provider_path = File.join(target.support_files_dir, autolinking_manager.modules_provider_name)
+
+          # Run `expo-modules-autolinking` command to generate the file
+          autolinking_manager.generate_package_list(target_name, modules_provider_path)
+
+          # PBXGroup for generated files per target
+          generated_target_group = generated_group.find_subpath(target_name, true)
+
+          # PBXGroup uses relative paths, so we need to strip the absolute path
+          modules_provider_relative_path = Pathname.new(modules_provider_path).relative_path_from(generated_target_group.real_path).to_s
+
+          if generated_target_group.find_file_by_path(modules_provider_relative_path).nil?
+            # Create new PBXFileReference if the modules provider is not in the group yet
+            modules_provider_file_reference = generated_target_group.new_file(modules_provider_path)
+
+            if native_target.source_build_phase.files_references.find { |ref| ref.present? && ref.path == modules_provider_relative_path }.nil?
+              # Put newly created PBXFileReference to the source files of the native target
+              native_target.add_file_references([modules_provider_file_reference])
+              project.mark_dirty!
+            end
+          end
+        end
+      end
+
+      # Remove the generated group if it has nothing left inside
+      if targets_with_modules_provider.empty?
+        recursively_remove_group(generated_group)
+      end
+    end
+
+    def self.recursively_remove_group(group)
+      return if group.nil?
+
+      UI.message '- Removing ' << group.name.green << ' group' do
+        group.recursive_children.each do |child|
+          UI.message ' - Removing a reference to ' << child.name.green
+          child.remove_from_project
+        end
+
+        group.remove_from_project
+        group.project.mark_dirty!
+      end
+    end
+
+    # CocoaPods doesn't properly remove file references from the build phase
+    # They appear as nils and it's safe to just delete them from native targets
+    def self.remove_nils_from_source_files(project)
+      project.native_targets.each do |native_target|
+        native_target.source_build_phase.files.each do |build_file|
+          next unless build_file.file_ref.nil?
+
+          build_file.remove_from_project
+          project.mark_dirty!
+        end
+      end
+    end
+
+    def self.modules_providers_group(project, autocreate = false)
+      project.main_group.find_subpath(Constants::GENERATED_GROUP_NAME, autocreate)
+    end
+
+  end # module ExpoAutolinkingExtension
+end # module Expo

package/src/ExpoModuleConfig.ts

@@ -0,0 +1,38 @@
+import { RawExpoModuleConfig, SupportedPlatform } from './types';
+
+/**
+ * A class that wraps the raw config (`expo-module.json` or `unimodule.json`).
+ */
+export class ExpoModuleConfig {
+  constructor(readonly rawConfig: RawExpoModuleConfig) {}
+
+  /**
+   * Whether the module supports given platform.
+   */
+  supportsPlatform(platform: SupportedPlatform): boolean {
+    return this.rawConfig.platforms?.includes(platform) ?? false;
+  }
+
+  /**
+   * Returns a list of names of Swift native modules classes to put to the generated modules provider file.
+   */
+  iosModulesClassNames() {
+    return this.rawConfig.ios?.modulesClassNames ?? [];
+  }
+
+  /**
+   * Returns serializable raw config.
+   */
+  toJSON(): RawExpoModuleConfig {
+    return this.rawConfig;
+  }
+}
+
+/**
+ * Reads the config at given path and returns the config wrapped by `ExpoModuleConfig` class.
+ */
+export function requireAndResolveExpoModuleConfig(path: string): ExpoModuleConfig {
+  // TODO: Validate the raw config against a schema.
+  // TODO: Support for `*.js` files, not only static `*.json`.
+  return new ExpoModuleConfig(require(path) as RawExpoModuleConfig);
+}

package/src/autolinking.ts

@@ -2,8 +2,10 @@ import chalk from 'chalk';
 import glob from 'fast-glob';
 import findUp from 'find-up';
 import fs from 'fs-extra';
+import { createRequire } from 'module';
 import path from 'path';
 
+import { requireAndResolveExpoModuleConfig } from './ExpoModuleConfig';
 import {
   GenerateOptions,
   ModuleDescriptor,
@@ -13,8 +15,24 @@ import {
   SearchResults,
 } from './types';
 
-// TODO: Rename to `expo-module.json`
-const EXPO_MODULE_CONFIG_FILENAME = 'unimodule.json';
+// Names of the config files. From lowest to highest priority.
+const EXPO_MODULE_CONFIG_FILENAMES = ['unimodule.json', 'expo-module.config.json'];
+
+/**
+ * Path to the `package.json` of the closest project in the current working dir.
+ */
+const projectPackageJsonPath = findUp.sync('package.json', { cwd: process.cwd() }) as string;
+
+// This won't happen in usual scenarios, but we need to unwrap the optional path :)
+if (!projectPackageJsonPath) {
+  throw new Error(`Couldn't find "package.json" up from path "${process.cwd()}"`);
+}
+
+/**
+ * Custom `require` that resolves from the current working dir instead of this script path.
+ * **Requires Node v12.2.0**
+ */
+const projectRequire = createRequire(projectPackageJsonPath);
 
 /**
  * Resolves autolinking search paths. If none is provided, it accumulates all node_modules when
@@ -25,17 +43,10 @@ export async function resolveSearchPathsAsync(
   cwd: string
 ): Promise<string[]> {
   return searchPaths && searchPaths.length > 0
-    ? searchPaths.map(searchPath => path.resolve(cwd, searchPath))
+    ? searchPaths.map((searchPath) => path.resolve(cwd, searchPath))
     : await findDefaultPathsAsync(cwd);
 }
 
-/**
- * Finds project's package.json and returns its path.
- */
-export async function findPackageJsonPathAsync(): Promise<string | null> {
-  return (await findUp('package.json', { cwd: process.cwd() })) ?? null;
-}
-
 /**
  * Looks up for workspace's `node_modules` paths.
  */
@@ -59,19 +70,32 @@ export async function findModulesAsync(providedOptions: SearchOptions): Promise<
   const results: SearchResults = {};
 
   for (const searchPath of options.searchPaths) {
-    const paths = await glob(
-      [`*/${EXPO_MODULE_CONFIG_FILENAME}`, `@*/*/${EXPO_MODULE_CONFIG_FILENAME}`],
-      {
-        cwd: searchPath,
-      }
+    const bracedFilenames = '{' + EXPO_MODULE_CONFIG_FILENAMES.join(',') + '}';
+    const paths = await glob([`*/${bracedFilenames}`, `@*/*/${bracedFilenames}`], {
+      cwd: searchPath,
+    });
+
+    // If the package has multiple configs (e.g. `unimodule.json` and `expo-module.config.json` during the transition time)
+    // then we want to give `expo-module.config.json` the priority.
+    const uniqueConfigPaths: string[] = Object.values(
+      paths.reduce<Record<string, string>>((acc, configPath) => {
+        const dirname = path.dirname(configPath);
+
+        if (!acc[dirname] || configPriority(configPath) > configPriority(acc[dirname])) {
+          acc[dirname] = configPath;
+        }
+        return acc;
+      }, {})
     );
 
-    for (const packageConfigPath of paths) {
+    for (const packageConfigPath of uniqueConfigPaths) {
       const packagePath = await fs.realpath(path.join(searchPath, path.dirname(packageConfigPath)));
-      const packageConfig = require(path.join(packagePath, EXPO_MODULE_CONFIG_FILENAME));
+      const expoModuleConfig = requireAndResolveExpoModuleConfig(
+        path.join(packagePath, path.basename(packageConfigPath))
+      );
       const { name, version } = require(path.join(packagePath, 'package.json'));
 
-      if (options.exclude?.includes(name) || !packageConfig.platforms?.includes(options.platform)) {
+      if (options.exclude?.includes(name) || !expoModuleConfig.supportsPlatform(options.platform)) {
         continue;
       }
 
@@ -82,8 +106,12 @@ export async function findModulesAsync(providedOptions: SearchOptions): Promise<
 
       if (!results[name]) {
         // The revision that was found first will be the main one.
-        // An array of duplicates is needed only here.
-        results[name] = { ...currentRevision, duplicates: [] };
+        // An array of duplicates and the config are needed only here.
+        results[name] = {
+          ...currentRevision,
+          config: expoModuleConfig,
+          duplicates: [],
+        };
       } else if (
         results[name].path !== packagePath &&
         results[name].duplicates?.every(({ path }) => path !== packagePath)
@@ -92,7 +120,69 @@ export async function findModulesAsync(providedOptions: SearchOptions): Promise<
       }
     }
   }
-  return results;
+
+  // It doesn't make much sense to strip modules if there is only one search path.
+  // Workspace root usually doesn't specify all its dependencies (see Expo Go),
+  // so in this case we should link everything.
+  if (options.searchPaths.length <= 1) {
+    return results;
+  }
+  return filterToProjectDependencies(results);
+}
+
+/**
+ * Filters out packages that are not the dependencies of the project.
+ */
+function filterToProjectDependencies(results: SearchResults) {
+  const filteredResults: SearchResults = {};
+  const visitedPackages = new Set<string>();
+
+  // Helper for traversing the dependency hierarchy.
+  function visitPackage(packageJsonPath: string) {
+    const packageJson = require(packageJsonPath);
+
+    // Prevent getting into the recursive loop.
+    if (visitedPackages.has(packageJson.name)) {
+      return;
+    }
+    visitedPackages.add(packageJson.name);
+
+    // Iterate over the dependencies to find transitive modules.
+    for (const dependencyName in packageJson.dependencies) {
+      const dependencyResult = results[dependencyName];
+
+      if (!filteredResults[dependencyName]) {
+        let dependencyPackageJsonPath: string;
+
+        if (dependencyResult) {
+          filteredResults[dependencyName] = dependencyResult;
+          dependencyPackageJsonPath = path.join(dependencyResult.path, 'package.json');
+        } else {
+          try {
+            dependencyPackageJsonPath = projectRequire.resolve(`${dependencyName}/package.json`);
+          } catch (error) {
+            // Some packages don't include package.json in its `exports` field,
+            // but none of our packages do that, so it seems fine to just ignore that type of error.
+            // Related issue: https://github.com/react-native-community/cli/issues/1168
+            if (error.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+              console.warn(
+                chalk.yellow(`⚠️  Cannot resolve the path to "${dependencyName}" package.`)
+              );
+            }
+            continue;
+          }
+        }
+
+        // Visit the dependency package.
+        visitPackage(dependencyPackageJsonPath);
+      }
+    }
+  }
+
+  // Visit project's package.
+  visitPackage(projectPackageJsonPath);
+
+  return filteredResults;
 }
 
 /**
@@ -104,8 +194,7 @@ export async function findModulesAsync(providedOptions: SearchOptions): Promise<
 export async function mergeLinkingOptionsAsync<OptionsType extends SearchOptions>(
   providedOptions: OptionsType
 ): Promise<OptionsType> {
-  const packageJsonPath = await findPackageJsonPathAsync();
-  const packageJson = packageJsonPath ? require(packageJsonPath) : {};
+  const packageJson = require(projectPackageJsonPath);
   const baseOptions = packageJson.expo?.autolinking;
   const platformOptions = providedOptions.platform && baseOptions?.[providedOptions.platform];
   const finalOptions = Object.assign(
@@ -126,7 +215,7 @@ export async function mergeLinkingOptionsAsync<OptionsType extends SearchOptions
  */
 export function verifySearchResults(searchResults: SearchResults): number {
   const cwd = process.cwd();
-  const relativePath: (pkg: PackageRevision) => string = pkg => path.relative(cwd, pkg.path);
+  const relativePath: (pkg: PackageRevision) => string = (pkg) => path.relative(cwd, pkg.path);
   let counter = 0;
 
   for (const moduleName in searchResults) {
@@ -198,3 +287,10 @@ export async function generatePackageListAsync(
     );
   }
 }
+
+/**
+ * Returns the priority of the config at given path. Higher number means higher priority.
+ */
+function configPriority(fullpath: string): number {
+  return EXPO_MODULE_CONFIG_FILENAMES.indexOf(path.basename(fullpath));
+}

package/src/index.ts

@@ -28,6 +28,11 @@ function registerSearchCommand<OptionsType extends SearchOptions>(
       'Package names to exclude when looking up for modules.',
       (value, previous) => (previous ?? []).concat(value)
     )
+    .option(
+      '-p, --platform [platform]',
+      'The platform that the resulting modules must support. Available options: "ios", "android"',
+      'ios'
+    )
     .action(async (searchPaths, providedOptions) => {
       const options = await mergeLinkingOptionsAsync<OptionsType>({
         ...providedOptions,
@@ -45,21 +50,21 @@ function registerResolveCommand<OptionsType extends ResolveOptions>(
   commandName: string,
   fn: (search: SearchResults, options: OptionsType) => any
 ) {
-  return registerSearchCommand<OptionsType>(commandName, fn).option(
-    '-p, --platform [platform]',
-    'The platform that the resulted modules must support. Available options: "ios", "android"',
-    'ios'
-  );
+  return registerSearchCommand<OptionsType>(commandName, fn);
 }
 
-module.exports = async function(args: string[]) {
+module.exports = async function (args: string[]) {
   // Searches for available expo modules.
-  registerSearchCommand('search', async results => {
-    console.log(require('util').inspect(results, false, null, true));
-  });
+  registerSearchCommand<SearchOptions & { json?: boolean }>('search', async (results, options) => {
+    if (options.json) {
+      console.log(JSON.stringify(results));
+    } else {
+      console.log(require('util').inspect(results, false, null, true));
+    }
+  }).option<boolean>('-j, --json', 'Output results in the plain JSON format.', () => true, false);
 
   // Checks whether there are no resolving issues in the current setup.
-  registerSearchCommand('verify', results => {
+  registerSearchCommand('verify', (results) => {
     const numberOfDuplicates = verifySearchResults(results);
     if (!numberOfDuplicates) {
       console.log('✅ Everything is fine!');

package/src/platforms/android.ts

@@ -31,6 +31,12 @@ export async function resolveModuleAsync(
     cwd: revision.path,
     ignore: ['**/node_modules/**'],
   });
+
+  // Just in case where the module doesn't have its own `build.gradle`.
+  if (!buildGradleFile) {
+    return null;
+  }
+
   const sourceDir = path.dirname(path.join(revision.path, buildGradleFile));
 
   return {
@@ -46,20 +52,27 @@ async function generatePackageListFileContentAsync(
   modules: ModuleDescriptor[],
   namespace: string
 ): Promise<string> {
-  const packagesClasses = await findAndroidPackagesAsync(modules);
+  // TODO: Instead of ignoring `expo` here, make the package class paths configurable from `expo-module.config.json`.
+  const packagesClasses = await findAndroidPackagesAsync(
+    modules.filter((module) => module.packageName !== 'expo')
+  );
 
   return `package ${namespace};
 
 import java.util.Arrays;
 import java.util.List;
-import org.unimodules.core.interfaces.Package;
+import expo.modules.core.interfaces.Package;
 
 public class ExpoModulesPackageList {
-  public List<Package> getPackageList() {
-    return Arrays.<Package>asList(
-${packagesClasses.map(packageClass => `      new ${packageClass}()`).join(',\n')}
+  private static class LazyHolder {
+    static final List<Package> packagesList = Arrays.<Package>asList(
+${packagesClasses.map((packageClass) => `      new ${packageClass}()`).join(',\n')}
     );
   }
+
+  public static List<Package> getPackageList() {
+    return LazyHolder.packagesList;
+  }
 }
 `;
 }
@@ -68,7 +81,7 @@ async function findAndroidPackagesAsync(modules: ModuleDescriptor[]): Promise<st
   const classes: string[] = [];
 
   await Promise.all(
-    modules.map(async module => {
+    modules.map(async (module) => {
       const files = await glob('src/**/*Package.{java,kt}', {
         cwd: module.sourceDir,
       });
@@ -76,10 +89,16 @@ async function findAndroidPackagesAsync(modules: ModuleDescriptor[]): Promise<st
       for (const file of files) {
         const fileContent = await fs.readFile(path.join(module.sourceDir, file), 'utf8');
 
+        const packageRegex = (() => {
+          if (process.env.EXPO_SHOULD_USE_LEGACY_PACKAGE_INTERFACE) {
+            return /\bimport\s+org\.unimodules\.core\.(interfaces\.Package|BasePackage)\b/;
+          } else {
+            return /\bimport\s+expo\.modules\.core\.(interfaces\.Package|BasePackage)\b/;
+          }
+        })();
+
         // Very naive check to skip non-expo packages
-        if (
-          !/\bimport\s+org\.unimodules\.core\.(interfaces\.Package|BasePackage)\b/.test(fileContent)
-        ) {
+        if (!packageRegex.test(fileContent)) {
           continue;
         }
 

package/src/platforms/ios.ts

@@ -1,4 +1,5 @@
 import glob from 'fast-glob';
+import fs from 'fs-extra';
 import path from 'path';
 
 import { ModuleDescriptor, PackageRevision, SearchOptions } from '../types';
@@ -27,5 +28,49 @@ export async function resolveModuleAsync(
     podName,
     podspecDir,
     flags: options.flags,
+    modulesClassNames: revision.config?.iosModulesClassNames(),
   };
 }
+
+/**
+ * Generates Swift file that contains all autolinked Swift packages.
+ */
+export async function generatePackageListAsync(
+  modules: ModuleDescriptor[],
+  targetPath: string
+): Promise<void> {
+  const className = path.basename(targetPath, path.extname(targetPath));
+  const generatedFileContent = await generatePackageListFileContentAsync(modules, className);
+
+  await fs.outputFile(targetPath, generatedFileContent);
+}
+
+/**
+ * Generates the string to put into the generated package list.
+ */
+async function generatePackageListFileContentAsync(
+  modules: ModuleDescriptor[],
+  className: string
+): Promise<string> {
+  const modulesToProvide = modules.filter((module) => module.modulesClassNames.length > 0);
+  const pods = modulesToProvide.map((module) => module.podName);
+  const classNames = [].concat(...modulesToProvide.map((module) => module.modulesClassNames));
+
+  return `/**
+ * Automatically generated by expo-modules-autolinking.
+ *
+ * This autogenerated class provides a list of classes of native Expo modules,
+ * but only these that are written in Swift and use the new API for creating Expo modules.
+ */
+
+import ExpoModulesCore
+${pods.map((podName) => `import ${podName}\n`).join('')}
+@objc(${className})
+public class ${className}: ModulesProvider {
+  public override func getModuleClasses() -> [AnyModule.Type] {
+    return [${classNames.map((className) => `\n      ${className}.self`).join(',')}
+    ]
+  }
+}
+`;
+}

package/src/types.ts

@@ -1,4 +1,6 @@
-export type SupportedPlatform = 'ios' | 'android';
+import { ExpoModuleConfig } from './ExpoModuleConfig';
+
+export type SupportedPlatform = 'ios' | 'android' | 'web';
 
 export interface SearchOptions {
   // Available in the CLI
@@ -17,13 +19,14 @@ export interface ResolveOptions extends SearchOptions {
 
 export interface GenerateOptions extends ResolveOptions {
   target: string;
-  namespace: string;
+  namespace?: string;
   empty?: boolean;
 }
 
 export type PackageRevision = {
   path: string;
   version: string;
+  config?: ExpoModuleConfig;
   duplicates?: PackageRevision[];
 };
 
@@ -32,3 +35,23 @@ export type SearchResults = {
 };
 
 export type ModuleDescriptor = Record<string, any>;
+
+/**
+ * Represents a raw config from `expo-module.json`.
+ */
+export interface RawExpoModuleConfig {
+  /**
+   * An array of supported platforms.
+   */
+  platforms?: SupportedPlatform[];
+
+  /**
+   * iOS-specific config.
+   */
+  ios?: {
+    /**
+     * Names of Swift native modules classes to put to the generated modules provider file.
+     */
+    modulesClassNames?: string[];
+  };
+}