@callstack/brownfield-cli 3.0.0-rc.2 → 3.1.0

package/src/navigation/generators/android.ts

@@ -0,0 +1,127 @@
+import type { MethodSignature } from '../types.js';
+
+const TS_TO_KOTLIN_TYPE: Record<string, string> = {
+  string: 'String',
+  number: 'Double',
+  boolean: 'Boolean',
+  void: 'Unit',
+  Object: 'ReadableMap',
+};
+
+function mapTsTypeToKotlin(tsType: string, optional: boolean = false): string {
+  if (tsType.startsWith('Promise<')) {
+    const inner = tsType.slice(8, -1);
+    return mapTsTypeToKotlin(inner, optional);
+  }
+
+  const mapped = TS_TO_KOTLIN_TYPE[tsType];
+  if (mapped) {
+    return optional ? `${mapped}?` : mapped;
+  }
+
+  return optional ? 'Any?' : 'Any';
+}
+
+export function generateKotlinDelegate(
+  methods: MethodSignature[],
+  kotlinPackageName: string
+): string {
+  const methodSignatures = methods
+    .map((method) => {
+      const params = method.params
+        .map(
+          (param) =>
+            `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`
+        )
+        .join(', ');
+      const returnType =
+        method.returnType === 'void'
+          ? ''
+          : `: ${mapTsTypeToKotlin(method.returnType, false)}`;
+      return `  fun ${method.name}(${params})${returnType}`;
+    })
+    .join('\n');
+
+  return `package ${kotlinPackageName}
+
+interface BrownfieldNavigationDelegate {
+${methodSignatures}
+}
+`;
+}
+
+export function generateKotlinModule(
+  methods: MethodSignature[],
+  kotlinPackageName: string
+): string {
+  const hasAsyncMethod = methods.some((method) => method.isAsync);
+  const hasObjectType = methods.some(
+    (method) =>
+      method.returnType.includes('Object') ||
+      method.params.some((param) => param.type === 'Object')
+  );
+
+  const methodImplementations = methods
+    .map((method) =>
+      method.isAsync
+        ? generateAsyncKotlinMethod(method)
+        : generateSyncKotlinMethod(method)
+    )
+    .join('\n\n');
+
+  return `package ${kotlinPackageName}
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod${
+    hasAsyncMethod ? '\nimport com.facebook.react.bridge.Promise' : ''
+  }${hasObjectType ? '\nimport com.facebook.react.bridge.ReadableMap' : ''}
+
+class NativeBrownfieldNavigationModule(
+  reactContext: ReactApplicationContext
+) : NativeBrownfieldNavigationSpec(reactContext) {
+${methodImplementations}
+
+  companion object {
+    const val NAME = "NativeBrownfieldNavigation"
+  }
+}
+`;
+}
+
+function generateSyncKotlinMethod(method: MethodSignature): string {
+  const params = method.params
+    .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+    .join(', ');
+  const args = method.params.map((param) => param.name).join(', ');
+
+  const signature = `  @ReactMethod\n  override fun ${method.name}(${params})${
+    method.returnType === 'void'
+      ? ''
+      : `: ${mapTsTypeToKotlin(method.returnType, false)}`
+  }`;
+
+  if (method.returnType === 'void') {
+    return `${signature} {
+    BrownfieldNavigationManager.getDelegate().${method.name}(${args})
+  }`;
+  }
+
+  return `${signature} {
+    return BrownfieldNavigationManager.getDelegate().${method.name}(${args})
+  }`;
+}
+
+function generateAsyncKotlinMethod(method: MethodSignature): string {
+  const paramsWithTypes = method.params
+    .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+    .join(', ');
+  const params =
+    paramsWithTypes.length > 0
+      ? `${paramsWithTypes}, promise: Promise`
+      : 'promise: Promise';
+
+  return `  @ReactMethod
+  override fun ${method.name}(${params}) {
+    promise.reject("not_implemented", "${method.name} is not implemented")
+  }`;
+}

package/src/navigation/generators/ios.ts

@@ -0,0 +1,169 @@
+import type { MethodSignature } from '../types.js';
+
+const TS_TO_OBJC_TYPE: Record<string, string> = {
+  string: 'NSString *',
+  number: 'double',
+  boolean: 'BOOL',
+  void: 'void',
+  Object: 'NSDictionary *',
+};
+
+const TS_TO_SWIFT_TYPE: Record<string, string> = {
+  string: 'String',
+  number: 'Double',
+  boolean: 'Bool',
+  void: 'Void',
+  Object: '[String: Any]',
+};
+
+function mapTsTypeToObjC(tsType: string, nullable: boolean = false): string {
+  if (tsType.startsWith('Promise<')) {
+    return 'void';
+  }
+
+  const mapped = TS_TO_OBJC_TYPE[tsType];
+  if (mapped) {
+    if (nullable && mapped.includes('*')) {
+      return mapped.replace(' *', ' * _Nullable');
+    }
+    return mapped;
+  }
+
+  return nullable ? 'id _Nullable' : 'id';
+}
+
+function mapTsTypeToSwift(tsType: string, optional: boolean = false): string {
+  if (tsType.startsWith('Promise<')) {
+    const inner = tsType.slice(8, -1);
+    return mapTsTypeToSwift(inner, optional);
+  }
+
+  const mapped = TS_TO_SWIFT_TYPE[tsType];
+  if (mapped) {
+    return optional ? `${mapped}?` : mapped;
+  }
+
+  return optional ? 'Any?' : 'Any';
+}
+
+export function generateSwiftDelegate(methods: MethodSignature[]): string {
+  const protocolMethods = methods
+    .map((method) => {
+      const params = method.params
+        .map((param, index) => {
+          const swiftType = mapTsTypeToSwift(param.type, param.optional);
+          const label = index === 0 ? '_' : param.name;
+          return `${label} ${param.name}: ${swiftType}`;
+        })
+        .join(', ');
+
+      const returnType =
+        method.returnType === 'void'
+          ? ''
+          : ` -> ${mapTsTypeToSwift(method.returnType, false)}`;
+
+      return `    @objc func ${method.name}(${params})${returnType}`;
+    })
+    .join('\n');
+
+  return `import Foundation
+
+@objc public protocol BrownfieldNavigationDelegate: AnyObject {
+${protocolMethods}
+}
+`;
+}
+
+export function generateObjCImplementation(methods: MethodSignature[]): string {
+  const methodImplementations = methods
+    .map((method) =>
+      method.isAsync ? generateAsyncObjCMethod(method) : generateSyncObjCMethod(method)
+    )
+    .join('\n\n');
+
+  return `#import "NativeBrownfieldNavigation.h"
+
+#if __has_include("BrownfieldNavigation/BrownfieldNavigation-Swift.h")
+#import "BrownfieldNavigation/BrownfieldNavigation-Swift.h"
+#else
+#import "BrownfieldNavigation-Swift.h"
+#endif
+
+@implementation NativeBrownfieldNavigation
+
+${methodImplementations}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeBrownfieldNavigationSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"NativeBrownfieldNavigation";
+}
+
+@end
+`;
+}
+
+function generateSyncObjCMethod(method: MethodSignature): string {
+  const { name, params, returnType } = method;
+
+  let signature = `- (${mapTsTypeToObjC(returnType)})${name}`;
+  if (params.length > 0) {
+    signature += params
+      .map((param, index) => {
+        const prefix = index === 0 ? ':' : ` ${param.name}:`;
+        return `${prefix}(${mapTsTypeToObjC(param.type, param.optional)})${param.name}`;
+      })
+      .join('');
+  }
+
+  let delegateCall = `[[[BrownfieldNavigationManager shared] getDelegate] ${name}`;
+  if (params.length > 0) {
+    delegateCall += params
+      .map((param, index) => {
+        const label = index === 0 ? '' : param.name;
+        return `${label}:${param.name}`;
+      })
+      .join(' ');
+  }
+  delegateCall += ']';
+
+  const returnPrefix = returnType === 'void' ? '' : 'return ';
+
+  return `${signature} {
+    ${returnPrefix}${delegateCall};
+}`;
+}
+
+function generateAsyncObjCMethod(method: MethodSignature): string {
+  const { name, params } = method;
+
+  let signature = `- (void)${name}`;
+  const allParams: Array<{ name: string; type: string; optional: boolean }> = [
+    ...params,
+    { name: 'resolve', type: 'RCTPromiseResolveBlock', optional: false },
+    { name: 'reject', type: 'RCTPromiseRejectBlock', optional: false },
+  ];
+
+  signature += ':';
+  signature += allParams
+    .map((param, index) => {
+      const prefix = index === 0 ? '' : param.name;
+      const type =
+        param.type === 'RCTPromiseResolveBlock'
+          ? 'RCTPromiseResolveBlock'
+          : param.type === 'RCTPromiseRejectBlock'
+            ? 'RCTPromiseRejectBlock'
+            : mapTsTypeToObjC(param.type, param.optional);
+      return `${prefix}(${type})${param.name}`;
+    })
+    .join(' ');
+
+  return `${signature} {
+    reject(@"not_implemented", @"${name} is not implemented", nil);
+}`;
+}

package/src/navigation/generators/models.ts

@@ -0,0 +1,170 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  FetchingJSONSchemaStore,
+  InputData,
+  JSONSchemaInput,
+  quicktype,
+} from 'quicktype-core';
+import { schemaForTypeScriptSources } from 'quicktype-typescript-input';
+
+import type { MethodSignature } from '../types.js';
+
+export interface NavigationModelsOptions {
+  specPath: string;
+  methods: MethodSignature[];
+  kotlinPackageName: string;
+}
+
+export interface GeneratedNavigationModels {
+  swiftModels?: string;
+  kotlinModels?: string;
+  modelTypeNames: string[];
+}
+
+const SKIP_TYPE_TOKENS = new Set([
+  'Array',
+  'Date',
+  'Map',
+  'Object',
+  'Promise',
+  'ReadonlyArray',
+  'Record',
+  'Set',
+  'any',
+  'boolean',
+  'false',
+  'null',
+  'number',
+  'object',
+  'string',
+  'true',
+  'undefined',
+  'unknown',
+  'void',
+]);
+
+function collectReferencedTypes(methods: MethodSignature[]): Set<string> {
+  const referenced = new Set<string>();
+
+  for (const method of methods) {
+    const typeTexts = [
+      method.returnType,
+      ...method.params.map((param) => param.type),
+    ];
+    for (const typeText of typeTexts) {
+      const matches = typeText.match(/\b[A-Za-z_]\w*\b/g);
+      if (!matches) {
+        continue;
+      }
+      for (const match of matches) {
+        if (!SKIP_TYPE_TOKENS.has(match)) {
+          referenced.add(match);
+        }
+      }
+    }
+  }
+
+  return referenced;
+}
+
+async function generateModelsForLanguage({
+  typeNames,
+  schema,
+  lang,
+  kotlinPackageName,
+}: {
+  typeNames: string[];
+  schema: object;
+  lang: 'swift' | 'kotlin';
+  kotlinPackageName: string;
+}): Promise<string> {
+  const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+
+  for (const typeName of typeNames) {
+    const rootSchema = JSON.parse(JSON.stringify(schema)) as {
+      $ref?: string;
+    };
+    rootSchema.$ref = `#/definitions/${typeName}`;
+
+    await schemaInput.addSource({
+      name: typeName,
+      schema: JSON.stringify(rootSchema),
+    });
+  }
+
+  const inputData = new InputData();
+  inputData.addInput(schemaInput);
+
+  const rendererOptions =
+    lang === 'swift'
+      ? {
+          'access-level': 'public',
+          'mutable-properties': 'true',
+          initializers: 'false',
+          'swift-5-support': 'true',
+        }
+      : {
+          framework: 'just-types',
+          package: kotlinPackageName,
+        };
+
+  const { lines } = await quicktype({
+    inputData,
+    lang,
+    rendererOptions,
+  });
+
+  return lines.join('\n');
+}
+
+export async function generateNavigationModels({
+  specPath,
+  methods,
+  kotlinPackageName,
+}: NavigationModelsOptions): Promise<GeneratedNavigationModels> {
+  const absoluteSpecPath = path.resolve(process.cwd(), specPath);
+
+  if (!fs.existsSync(absoluteSpecPath)) {
+    throw new Error(`Spec file not found: ${absoluteSpecPath}`);
+  }
+
+  const schemaData = schemaForTypeScriptSources([absoluteSpecPath]);
+  if (!schemaData.schema) {
+    throw new Error('Failed to generate schema from TypeScript spec');
+  }
+
+  const parsedSchema = JSON.parse(schemaData.schema) as {
+    definitions?: Record<string, unknown>;
+  };
+  const referencedTypes = collectReferencedTypes(methods);
+  const definitions = parsedSchema.definitions ?? {};
+  const modelTypeNames = [...referencedTypes].filter((typeName) =>
+    Object.hasOwn(definitions, typeName)
+  );
+
+  if (modelTypeNames.length === 0) {
+    return { modelTypeNames: [] };
+  }
+
+  const [swiftModels, kotlinModels] = await Promise.all([
+    generateModelsForLanguage({
+      typeNames: modelTypeNames,
+      schema: parsedSchema,
+      lang: 'swift',
+      kotlinPackageName,
+    }),
+    generateModelsForLanguage({
+      typeNames: modelTypeNames,
+      schema: parsedSchema,
+      lang: 'kotlin',
+      kotlinPackageName,
+    }),
+  ]);
+
+  return {
+    swiftModels,
+    kotlinModels,
+    modelTypeNames,
+  };
+}

package/src/navigation/generators/ts.ts

@@ -0,0 +1,123 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import type { MethodSignature } from '../types.js';
+
+export function generateTurboModuleSpec(methods: MethodSignature[]): string {
+  const methodSignatures = methods
+    .map((method) => {
+      const params = method.params
+        .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+        .join(', ');
+      return `  ${method.name}(${params}): ${method.returnType};`;
+    })
+    .join('\n');
+
+  return `import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+${methodSignatures}
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeBrownfieldNavigation'
+);
+`;
+}
+
+export function generateIndexTs(methods: MethodSignature[]): string {
+  const functionImplementations = methods
+    .map((method) => {
+      const params = method.params
+        .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+        .join(', ');
+      const args = method.params.map((param) => param.name).join(', ');
+      const returnType = method.returnType === 'void' ? '' : `: ${method.returnType}`;
+
+      if (method.isAsync) {
+        return `  ${method.name}: async (${params})${returnType} => {
+    return NativeBrownfieldNavigation.${method.name}(${args});
+  }`;
+      }
+
+      return `  ${method.name}: (${params})${returnType} => {
+    NativeBrownfieldNavigation.${method.name}(${args});
+  }`;
+    })
+    .join(',\n');
+
+  return `import NativeBrownfieldNavigation from './NativeBrownfieldNavigation';
+
+const BrownfieldNavigation = {
+${functionImplementations},
+};
+
+export default BrownfieldNavigation;
+`;
+}
+
+export function transpileWithConsumerBabel(
+  tsCode: string,
+  projectRoot: string,
+  packageRoot: string
+): string {
+  const nodeRequire = createRequire(path.join(projectRoot, 'package.json'));
+  const moduleCandidates = [projectRoot, packageRoot];
+
+  function resolveOrThrow(moduleName: string): string {
+    for (const modulePath of moduleCandidates) {
+      try {
+        return nodeRequire.resolve(moduleName, { paths: [modulePath] });
+      } catch {
+        // Continue with remaining candidates.
+      }
+    }
+
+    throw new Error(
+      `Could not resolve "${moduleName}". Install it in your app devDependencies.`
+    );
+  }
+
+  const babelCorePath = resolveOrThrow('@babel/core');
+  const rnPresetPath = resolveOrThrow('@react-native/babel-preset');
+  const babelCore = nodeRequire(babelCorePath) as {
+    transformSync: (
+      source: string,
+      options: Record<string, unknown>
+    ) => { code?: string | null } | null;
+  };
+
+  const transformed = babelCore.transformSync(tsCode, {
+    filename: 'index.ts',
+    babelrc: false,
+    configFile: false,
+    comments: false,
+    compact: true,
+    minified: true,
+    presets: [[rnPresetPath, {}]],
+  });
+
+  if (!transformed?.code) {
+    throw new Error('Babel transpilation failed for generated index.ts');
+  }
+
+  return transformed.code;
+}
+
+export function generateIndexDts(methods: MethodSignature[]): string {
+  const methodSignatures = methods
+    .map((method) => {
+      const params = method.params
+        .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+        .join(', ');
+      return `  ${method.name}: (${params}) => ${method.returnType};`;
+    })
+    .join('\n');
+
+  return `declare const BrownfieldNavigation: {
+${methodSignatures}
+};
+
+export default BrownfieldNavigation;
+`;
+}

package/src/navigation/helpers/runNavigationCodegenIfApplicable.ts

@@ -0,0 +1,17 @@
+import { isNavigationInstalled } from '../config.js';
+import { isNavigationSpecPresent } from '../spec-discovery.js';
+import { runNavigationCodegen } from '../runner.js';
+
+export async function runNavigationCodegenIfApplicable(
+  projectRoot: string,
+  specPath?: string
+): Promise<{ hasNavigation: boolean; hasSpec: boolean }> {
+  const hasNavigation = isNavigationInstalled(projectRoot);
+  const hasSpec = hasNavigation && isNavigationSpecPresent(specPath, projectRoot);
+
+  if (hasSpec) {
+    await runNavigationCodegen({ specPath, projectRoot });
+  }
+
+  return { hasNavigation, hasSpec };
+}

package/src/navigation/index.ts

@@ -0,0 +1,10 @@
+import { styleText } from 'node:util';
+
+import * as Commands from './commands/index.js';
+
+export const groupName = `${styleText(['bold', 'blueBright'], '@callstack/brownfield-navigation')}${styleText('whiteBright', ' - native codegen utilities for Brownfield Navigation')}`;
+
+export { Commands };
+export type * from './types.js';
+export * from './runner.js';
+export default Commands;

package/src/navigation/parser.ts

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import { Project } from 'ts-morph';
+
+import type { MethodParam, MethodSignature } from './types.js';
+
+export function parseNavigationSpec(specPath: string): MethodSignature[] {
+  if (!fs.existsSync(specPath)) {
+    throw new Error(`Spec file not found: ${specPath}`);
+  }
+
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const sourceFile = project.addSourceFileAtPath(specPath);
+  const specInterface =
+    sourceFile.getInterface('BrownfieldNavigationSpec') ??
+    sourceFile.getInterface('Spec');
+
+  if (!specInterface) {
+    throw new Error(
+      'Could not find BrownfieldNavigationSpec or Spec interface in spec file'
+    );
+  }
+
+  return specInterface.getMethods().map((method): MethodSignature => {
+    const name = method.getName();
+    const params: MethodParam[] = method.getParameters().map((param) => {
+      const typeNode = param.getTypeNode();
+      return {
+        name: param.getName(),
+        type: typeNode?.getText() ?? 'unknown',
+        optional: param.isOptional(),
+      };
+    });
+    const returnTypeNode = method.getReturnTypeNode();
+    const returnType = returnTypeNode?.getText() ?? 'void';
+
+    return {
+      name,
+      params,
+      returnType,
+      isAsync: returnType.startsWith('Promise<'),
+    };
+  });
+}