extracted buildModuleSchema in parser-common.js

Author: dakshbhardwaj

packages/react-native-codegen/src/parsers/parsers-commons.js

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @flow strict
+ * @flow strict-local
  */
 
 'use strict';
@@ -26,6 +26,63 @@ const {
 import type {ParserType} from './errors';
 
 const invariant = require('invariant');
+const {
+  getTypes,
+  isModuleRegistryCall,
+  resolveTypeAnnotation,
+} = require('./flow/utils');
+const {
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfModuleInterfaceIsMisnamed,
+  throwIfModuleInterfaceNotFound,
+  throwIfModuleTypeIsUnsupported,
+  throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfMoreThanOneModuleRegistryCalls,
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfUntypedModule,
+  throwIfUnusedModuleInterfaceParserError,
+  throwIfWrongNumberOfCallExpressionArgs,
+} = require('./error-utils');
+const {verifyPlatforms, visit} = require('./utils');
+const {
+  IncorrectModuleRegistryCallArgumentTypeParserError,
+  UnnamedFunctionParamParserError,
+  UnsupportedFunctionParamTypeAnnotationParserError,
+} = require('./errors');
+import type {
+  NamedShape,
+  NativeModuleAliasMap,
+  NativeModuleArrayTypeAnnotation,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleParamTypeAnnotation,
+  NativeModulePropertyShape,
+} from '../CodegenSchema';
+import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
+import {
+  UnsupportedArrayElementTypeAnnotationParserError,
+  UnsupportedEnumDeclarationParserError,
+  UnsupportedGenericParserError,
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+  UnsupportedTypeAnnotationParserError,
+} from './errors';
+import {
+  emitBoolean,
+  emitDouble,
+  emitFunction,
+  emitInt32,
+  emitNumber,
+  emitObject,
+  emitPromise,
+  emitRootTag,
+  emitString,
+  emitStringish,
+  emitVoid,
+  typeAliasResolution,
+} from './parsers-primitives';
+import {throwIfPropertyValueTypeIsUnsupported} from './error-utils';
+import {nullGuard} from './parsers-utils';
+import type {Parser} from './parser';
 
 function wrapModuleSchema(
   nativeModuleSchema: NativeModuleSchema,
@@ -155,11 +212,192 @@ function emitUnionTypeAnnotation(
   });
 }
 
+function buildModuleSchema(
+  hasteModuleName: string,
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  ast: $FlowFixMe,
+  tryParse: ParserErrorCapturer,
+  language: ParserType,
+  parser: Parser,
+): NativeModuleSchema {
+  const types = getTypes(ast);
+
+  const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
+    //$FlowFixMe
+    isModuleInterface,
+  );
+
+  throwIfModuleInterfaceNotFound(
+    moduleSpecs.length,
+    hasteModuleName,
+    ast,
+    language,
+  );
+
+  throwIfMoreThanOneModuleInterfaceParserError(
+    hasteModuleName,
+    moduleSpecs,
+    language,
+  );
+
+  const [moduleSpec] = moduleSpecs;
+
+  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
+
+  // Parse Module Names
+  const moduleName = tryParse((): string => {
+    const callExpressions = [];
+    visit(ast, {
+      CallExpression(node) {
+        if (isModuleRegistryCall(node)) {
+          callExpressions.push(node);
+        }
+      },
+    });
+
+    throwIfUnusedModuleInterfaceParserError(
+      hasteModuleName,
+      moduleSpec,
+      callExpressions,
+      language,
+    );
+
+    throwIfMoreThanOneModuleRegistryCalls(
+      hasteModuleName,
+      callExpressions,
+      callExpressions.length,
+      language,
+    );
+
+    const [callExpression] = callExpressions;
+    const typeParams =
+      language === 'TypeScript'
+        ? callExpression.typeParameters
+        : callExpression.typeArguments;
+    const methodName = callExpression.callee.property.name;
+    const callExpressionArgumentType =
+      language === 'TypeScript' ? 'StringLiteral' : 'Literal';
+
+    throwIfWrongNumberOfCallExpressionArgs(
+      hasteModuleName,
+      callExpression,
+      methodName,
+      callExpression.arguments.length,
+      language,
+    );
+
+    if (callExpression.arguments[0].type !== callExpressionArgumentType) {
+      const {type} = callExpression.arguments[0];
+      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
+        hasteModuleName,
+        callExpression.arguments[0],
+        methodName,
+        type,
+        language,
+      );
+    }
+
+    const $moduleName = callExpression.arguments[0].value;
+
+    throwIfUntypedModule(
+      typeParams,
+      hasteModuleName,
+      callExpression,
+      methodName,
+      $moduleName,
+      language,
+    );
+
+    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
+      hasteModuleName,
+      typeParams,
+      methodName,
+      $moduleName,
+      language,
+    );
+
+    return $moduleName;
+  });
+
+  const moduleNames = moduleName == null ? [] : [moduleName];
+
+  // Some module names use platform suffix to indicate platform-exclusive modules.
+  // Eventually this should be made explicit in the Flow type itself.
+  // Also check the hasteModuleName for platform suffix.
+  // Note: this shape is consistent with ComponentSchema.
+  const {cxxOnly, excludedPlatforms} = verifyPlatforms(
+    hasteModuleName,
+    moduleNames,
+  );
+
+  let filteredModuleSpec;
+  if (language === 'TypeScript') {
+    filteredModuleSpec = moduleSpec.body.body.filter(
+      property =>
+        property.type === 'TSMethodSignature' ||
+        property.type === 'TSPropertySignature',
+    );
+  } else {
+    filteredModuleSpec = moduleSpec.body.properties.filter(
+      property => property.type === 'ObjectTypeProperty',
+    );
+  }
+
+  // $FlowFixMe[missing-type-arg]
+  return filteredModuleSpec
+    .map<?{
+      aliasMap: NativeModuleAliasMap,
+      propertyShape: NativeModulePropertyShape,
+    }>(property => {
+      const aliasMap: {...NativeModuleAliasMap} = {};
+
+      return tryParse(() => ({
+        aliasMap: aliasMap,
+        // $FlowFixMe
+        propertyShape: buildPropertySchema(
+          hasteModuleName,
+          property,
+          types,
+          aliasMap,
+          tryParse,
+          cxxOnly,
+          language,
+          parser,
+        ),
+      }));
+    })
+    .filter(Boolean)
+    .reduce(
+      (moduleSchema: NativeModuleSchema, {aliasMap, propertyShape}) => {
+        return {
+          type: 'NativeModule',
+          aliases: {...moduleSchema.aliases, ...aliasMap},
+          spec: {
+            properties: [...moduleSchema.spec.properties, propertyShape],
+          },
+          moduleNames: moduleSchema.moduleNames,
+          excludedPlatforms: moduleSchema.excludedPlatforms,
+        };
+      },
+      {
+        type: 'NativeModule',
+        aliases: {},
+        spec: {properties: []},
+        moduleNames: moduleNames,
+        excludedPlatforms:
+          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
+      },
+    );
+}
+
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
   wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   emitMixedTypeAnnotation,
   emitUnionTypeAnnotation,
+  buildModuleSchema,
 };