@callstack/brownfield-cli 3.0.0 → 3.1.0

package/src/navigation/runner.ts

@@ -0,0 +1,256 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { logger } from '@rock-js/tools';
+import {
+  DEFAULT_ANDROID_JAVA_PACKAGE,
+  getNavigationPackagePath,
+} from './config.js';
+import { parseNavigationSpec } from './parser.js';
+import { resolveNavigationSpecPath } from './spec-discovery.js';
+import {
+  generateIndexDts,
+  generateIndexTs,
+  generateTurboModuleSpec,
+  transpileWithConsumerBabel,
+} from './generators/ts.js';
+import {
+  generateObjCImplementation,
+  generateSwiftDelegate,
+} from './generators/ios.js';
+import {
+  generateKotlinDelegate,
+  generateKotlinModule,
+} from './generators/android.js';
+import { generateNavigationModels } from './generators/models.js';
+import type { GeneratedNavigationArtifacts } from './types.js';
+
+interface RunNavigationCodegenOptions {
+  specPath?: string;
+  dryRun?: boolean;
+  projectRoot?: string;
+}
+
+interface NavigationOutputPaths {
+  turboModuleSpec: string;
+  navigationTs: string;
+  commonjsIndexJs: string;
+  moduleIndexJs: string;
+  commonjsIndexDts: string;
+  moduleIndexDts: string;
+  swiftDelegate: string;
+  swiftModels: string;
+  objcImplementation: string;
+  kotlinDelegate: string;
+  kotlinModule: string;
+  kotlinModels: string;
+}
+
+function getOutputPaths(
+  packageRoot: string,
+  androidJavaPackageName: string
+): NavigationOutputPaths {
+  const androidPackagePathSegments = androidJavaPackageName.split('.');
+
+  return {
+    turboModuleSpec: path.join(packageRoot, 'src', 'NativeBrownfieldNavigation.ts'),
+    navigationTs: path.join(packageRoot, 'src', 'index.ts'),
+    commonjsIndexJs: path.join(packageRoot, 'lib', 'commonjs', 'index.js'),
+    moduleIndexJs: path.join(packageRoot, 'lib', 'module', 'index.js'),
+    commonjsIndexDts: path.join(
+      packageRoot,
+      'lib',
+      'typescript',
+      'commonjs',
+      'src',
+      'index.d.ts'
+    ),
+    moduleIndexDts: path.join(
+      packageRoot,
+      'lib',
+      'typescript',
+      'module',
+      'src',
+      'index.d.ts'
+    ),
+    swiftDelegate: path.join(
+      packageRoot,
+      'ios',
+      'BrownfieldNavigationDelegate.swift'
+    ),
+    swiftModels: path.join(packageRoot, 'ios', 'BrownfieldNavigationModels.swift'),
+    objcImplementation: path.join(
+      packageRoot,
+      'ios',
+      'NativeBrownfieldNavigation.mm'
+    ),
+    kotlinDelegate: path.join(
+      packageRoot,
+      'android',
+      'src',
+      'main',
+      'java',
+      ...androidPackagePathSegments,
+      'BrownfieldNavigationDelegate.kt'
+    ),
+    kotlinModule: path.join(
+      packageRoot,
+      'android',
+      'src',
+      'main',
+      'java',
+      ...androidPackagePathSegments,
+      'NativeBrownfieldNavigationModule.kt'
+    ),
+    kotlinModels: path.join(
+      packageRoot,
+      'android',
+      'src',
+      'main',
+      'java',
+      ...androidPackagePathSegments,
+      'BrownfieldNavigationModels.kt'
+    ),
+  };
+}
+
+function writeArtifacts(
+  paths: NavigationOutputPaths,
+  artifacts: GeneratedNavigationArtifacts
+): void {
+  fs.writeFileSync(paths.turboModuleSpec, artifacts.turboModuleSpec);
+  logger.success(`Generated ${paths.turboModuleSpec}`);
+
+  fs.writeFileSync(paths.navigationTs, artifacts.indexTs);
+  logger.success(`Generated ${paths.navigationTs}`);
+
+  fs.writeFileSync(paths.commonjsIndexJs, artifacts.indexJs);
+  logger.success(`Generated ${paths.commonjsIndexJs}`);
+
+  fs.writeFileSync(paths.moduleIndexJs, artifacts.indexJs);
+  logger.success(`Generated ${paths.moduleIndexJs}`);
+
+  fs.writeFileSync(paths.commonjsIndexDts, artifacts.indexDts);
+  logger.success(`Generated ${paths.commonjsIndexDts}`);
+
+  fs.writeFileSync(paths.moduleIndexDts, artifacts.indexDts);
+  logger.success(`Generated ${paths.moduleIndexDts}`);
+
+  fs.writeFileSync(paths.swiftDelegate, artifacts.swiftDelegate);
+  logger.success(`Generated ${paths.swiftDelegate}`);
+
+  if (artifacts.swiftModels) {
+    fs.writeFileSync(paths.swiftModels, artifacts.swiftModels);
+    logger.success(`Generated ${paths.swiftModels}`);
+  }
+
+  fs.writeFileSync(paths.objcImplementation, artifacts.objcImplementation);
+  logger.success(`Generated ${paths.objcImplementation}`);
+
+  fs.writeFileSync(paths.kotlinDelegate, artifacts.kotlinDelegate);
+  logger.success(`Generated ${paths.kotlinDelegate}`);
+
+  fs.writeFileSync(paths.kotlinModule, artifacts.kotlinModule);
+  logger.success(`Generated ${paths.kotlinModule}`);
+
+  if (artifacts.kotlinModels) {
+    fs.writeFileSync(paths.kotlinModels, artifacts.kotlinModels);
+    logger.success(`Generated ${paths.kotlinModels}`);
+  }
+}
+
+function printDryRun(
+  androidJavaPackageName: string,
+  artifacts: GeneratedNavigationArtifacts
+): void {
+  logger.info('\n--- Generated: src/NativeBrownfieldNavigation.ts ---\n');
+  logger.log(artifacts.turboModuleSpec);
+  logger.info('\n--- Generated: src/index.ts ---\n');
+  logger.log(artifacts.indexTs);
+  logger.info('\n--- Generated (Babel): lib/{commonjs,module}/index.js ---\n');
+  logger.log(artifacts.indexJs);
+  logger.info(
+    '\n--- Generated: lib/typescript/{commonjs,module}/src/index.d.ts ---\n'
+  );
+  logger.log(artifacts.indexDts);
+  logger.info('\n--- Generated: ios/BrownfieldNavigationDelegate.swift ---\n');
+  logger.log(artifacts.swiftDelegate);
+  if (artifacts.swiftModels) {
+    logger.info('\n--- Generated: ios/BrownfieldNavigationModels.swift ---\n');
+    logger.log(artifacts.swiftModels);
+  }
+  logger.info('\n--- Generated: ios/NativeBrownfieldNavigation.mm ---\n');
+  logger.log(artifacts.objcImplementation);
+  logger.info(
+    `\n--- Generated: android/src/main/java/${androidJavaPackageName.replaceAll('.', '/')}/BrownfieldNavigationDelegate.kt ---\n`
+  );
+  logger.log(artifacts.kotlinDelegate);
+  logger.info(
+    `\n--- Generated: android/src/main/java/${androidJavaPackageName.replaceAll('.', '/')}/NativeBrownfieldNavigationModule.kt ---\n`
+  );
+  logger.log(artifacts.kotlinModule);
+  if (artifacts.kotlinModels) {
+    logger.info(
+      `\n--- Generated: android/src/main/java/${androidJavaPackageName.replaceAll('.', '/')}/BrownfieldNavigationModels.kt ---\n`
+    );
+    logger.log(artifacts.kotlinModels);
+  }
+}
+
+export async function runNavigationCodegen({
+  specPath,
+  dryRun = false,
+  projectRoot = process.cwd(),
+}: RunNavigationCodegenOptions): Promise<void> {
+  const resolvedSpecPath = resolveNavigationSpecPath(specPath, projectRoot);
+  if (!fs.existsSync(resolvedSpecPath)) {
+    throw new Error(`Spec file not found: ${resolvedSpecPath}`);
+  }
+
+  logger.info(`Parsing spec file: ${resolvedSpecPath}`);
+  const methods = parseNavigationSpec(resolvedSpecPath);
+  if (methods.length === 0) {
+    throw new Error('No methods found in spec file');
+  }
+
+  logger.info(
+    `Found ${methods.length} method(s): ${methods.map((method) => method.name).join(', ')}`
+  );
+
+  const packageRoot = getNavigationPackagePath(projectRoot);
+  const androidJavaPackageName = DEFAULT_ANDROID_JAVA_PACKAGE;
+  const indexTs = generateIndexTs(methods);
+  const models = await generateNavigationModels({
+    specPath: resolvedSpecPath,
+    methods,
+    kotlinPackageName: androidJavaPackageName,
+  });
+
+  const artifacts: GeneratedNavigationArtifacts = {
+    turboModuleSpec: generateTurboModuleSpec(methods),
+    indexTs,
+    indexJs: transpileWithConsumerBabel(indexTs, projectRoot, packageRoot),
+    indexDts: generateIndexDts(methods),
+    swiftDelegate: generateSwiftDelegate(methods),
+    objcImplementation: generateObjCImplementation(methods),
+    kotlinDelegate: generateKotlinDelegate(methods, androidJavaPackageName),
+    kotlinModule: generateKotlinModule(methods, androidJavaPackageName),
+  };
+
+  if (models.modelTypeNames.length > 0) {
+    logger.info(
+      `Generating quicktype models for types: ${models.modelTypeNames.join(', ')}`
+    );
+    artifacts.swiftModels = models.swiftModels;
+    artifacts.kotlinModels = models.kotlinModels;
+  } else {
+    logger.info('No complex model types found; skipping quicktype model generation');
+  }
+
+  if (dryRun) {
+    printDryRun(androidJavaPackageName, artifacts);
+    return;
+  }
+
+  writeArtifacts(getOutputPaths(packageRoot, androidJavaPackageName), artifacts);
+}

package/src/navigation/spec-discovery.ts

@@ -0,0 +1,25 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { DEFAULT_SPEC_FILENAME } from './config.js';
+
+export function resolveNavigationSpecPath(
+  specPath: string | undefined,
+  projectRoot: string
+): string {
+  if (specPath) {
+    return path.isAbsolute(specPath)
+      ? specPath
+      : path.resolve(projectRoot, specPath);
+  }
+
+  return path.resolve(projectRoot, DEFAULT_SPEC_FILENAME);
+}
+
+export function isNavigationSpecPresent(
+  specPath: string | undefined,
+  projectRoot: string = process.cwd()
+): boolean {
+  const resolvedSpecPath = resolveNavigationSpecPath(specPath, projectRoot);
+  return fs.existsSync(resolvedSpecPath);
+}

package/src/navigation/types.ts

@@ -0,0 +1,25 @@
+export interface MethodParam {
+  name: string;
+  type: string;
+  optional: boolean;
+}
+
+export interface MethodSignature {
+  name: string;
+  params: MethodParam[];
+  returnType: string;
+  isAsync: boolean;
+}
+
+export interface GeneratedNavigationArtifacts {
+  turboModuleSpec: string;
+  indexTs: string;
+  indexJs: string;
+  indexDts: string;
+  swiftDelegate: string;
+  objcImplementation: string;
+  kotlinDelegate: string;
+  kotlinModule: string;
+  swiftModels?: string;
+  kotlinModels?: string;
+}