@callstack/brownfield-cli 3.7.0 → 3.8.1

package/src/navigation/generators/models.ts

@@ -8,12 +8,13 @@ import {
 } from 'quicktype-core';
 import { schemaForTypeScriptSources } from 'quicktype-typescript-input';
 
-import type { MethodSignature } from '../types.js';
+import type { MethodSignature, ModelDefinition } from '../types.js';
 
 export interface NavigationModelsOptions {
   specPath: string;
   methods: MethodSignature[];
   kotlinPackageName: string;
+  modelDefinitions?: ModelDefinition[];
 }
 
 export interface GeneratedNavigationModels {
@@ -102,6 +103,8 @@ async function generateModelsForLanguage({
           'access-level': 'public',
           'mutable-properties': 'true',
           initializers: 'false',
+          'struct-or-class': 'class',
+          'objective-c-support': 'true',
           'swift-5-support': 'true',
         }
       : {
@@ -122,6 +125,7 @@ export async function generateNavigationModels({
   specPath,
   methods,
   kotlinPackageName,
+  modelDefinitions = [],
 }: NavigationModelsOptions): Promise<GeneratedNavigationModels> {
   const absoluteSpecPath = path.resolve(process.cwd(), specPath);
 
@@ -162,9 +166,321 @@ export async function generateNavigationModels({
     }),
   ]);
 
+  const swiftModelConversions = generateSwiftModelConversionExtensions(
+    modelDefinitions,
+    modelTypeNames
+  );
+  const kotlinModelConversions = generateKotlinModelConversionExtensions(
+    modelDefinitions,
+    modelTypeNames
+  );
+
   return {
-    swiftModels,
-    kotlinModels,
+    swiftModels: swiftModelConversions
+      ? `${swiftModels}\n\n${swiftModelConversions}`
+      : swiftModels,
+    kotlinModels: kotlinModelConversions
+      ? `${ensureKotlinReadableMapImport(kotlinModels)}\n\n${kotlinModelConversions}`
+      : kotlinModels,
     modelTypeNames,
   };
 }
+
+function ensureKotlinReadableMapImport(kotlinModels: string): string {
+  const importLine = 'import com.facebook.react.bridge.ReadableMap';
+  if (kotlinModels.includes(importLine)) {
+    return kotlinModels;
+  }
+
+  const packageMatch = kotlinModels.match(/^package[^\n]*\n/);
+  if (!packageMatch) {
+    return `${importLine}\n${kotlinModels}`;
+  }
+
+  const packageLine = packageMatch[0];
+  const rest = kotlinModels.slice(packageLine.length);
+  return `${packageLine}\n${importLine}\n${rest}`;
+}
+
+function generateSwiftModelConversionExtensions(
+  modelDefinitions: ModelDefinition[],
+  modelTypeNames: string[]
+): string {
+  const modelDefinitionsByLookupName = buildModelDefinitionsByLookupName(
+    modelDefinitions
+  );
+  const conversionModelNames = collectConversionModelNames(
+    modelDefinitionsByLookupName,
+    modelTypeNames
+  );
+
+  return conversionModelNames
+    .map((modelName) => {
+      const definition = modelDefinitionsByLookupName.get(modelName);
+      if (!definition) {
+        return '';
+      }
+
+      const sortedFields = [...definition.fields].sort((a, b) =>
+        a.name.localeCompare(b.name)
+      );
+      if (sortedFields.length === 0) {
+        return '';
+      }
+
+      const args = sortedFields
+        .map(
+          (field) =>
+            `${field.name}: ${mapDictionaryValueToSwiftExpression(
+              field.name,
+              field.type,
+              field.optional
+            )}`
+        )
+        .join(', ');
+
+      return `@objc public extension ${modelName} {
+    static func fromDictionary(_ value: NSDictionary) -> ${modelName} {
+        return ${modelName}(${args})
+    }
+}`;
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function mapDictionaryValueToSwiftExpression(
+  fieldName: string,
+  fieldType: string,
+  optional: boolean
+): string {
+  const parsedType = parseFieldType(fieldType);
+  const normalizedFieldType = parsedType.normalizedType;
+  const valueAccess = `value["${fieldName}"]`;
+  const allowsNil = optional || parsedType.nullable;
+  if (normalizedFieldType === 'string') {
+    return allowsNil ? `${valueAccess} as? String` : `${valueAccess} as! String`;
+  }
+  if (normalizedFieldType === 'number') {
+    return allowsNil
+      ? `(${valueAccess} as? NSNumber)?.doubleValue`
+      : `(${valueAccess} as! NSNumber).doubleValue`;
+  }
+  if (normalizedFieldType === 'boolean') {
+    return allowsNil
+      ? `(${valueAccess} as? NSNumber)?.boolValue`
+      : `(${valueAccess} as! NSNumber).boolValue`;
+  }
+  if (normalizedFieldType === 'string[]') {
+    return allowsNil ? `${valueAccess} as? [String]` : `${valueAccess} as! [String]`;
+  }
+
+  if (isSimpleTypeReference(normalizedFieldType)) {
+    const nestedModelType = resolveNestedModelTypeName(normalizedFieldType);
+    return allowsNil
+      ? `(${valueAccess} as? NSDictionary).map(${nestedModelType}.fromDictionary)`
+      : `${nestedModelType}.fromDictionary(${valueAccess} as! NSDictionary)`;
+  }
+
+  return `fatalError("Unsupported TypeScript field type '${escapeSwiftStringLiteral(normalizedFieldType)}' for field '${escapeSwiftStringLiteral(fieldName)}' in Swift conversion. Consider using 'Any' or a custom converter.")`;
+}
+
+function generateKotlinModelConversionExtensions(
+  modelDefinitions: ModelDefinition[],
+  modelTypeNames: string[]
+): string {
+  const modelDefinitionsByLookupName = buildModelDefinitionsByLookupName(
+    modelDefinitions
+  );
+  const conversionModelNames = collectConversionModelNames(
+    modelDefinitionsByLookupName,
+    modelTypeNames
+  );
+  let usesStringArrayHelper = false;
+
+  const conversionFunctions = conversionModelNames
+    .map((modelName) => {
+      const definition = modelDefinitionsByLookupName.get(modelName);
+      if (!definition) {
+        return '';
+      }
+
+      const sortedFields = [...definition.fields].sort((a, b) =>
+        a.name.localeCompare(b.name)
+      );
+      if (sortedFields.length === 0) {
+        return '';
+      }
+
+      const args = sortedFields
+        .map((field) => {
+          const fieldExpression = mapReadableMapFieldExpression(
+            'value',
+            field.name,
+            field.type,
+            field.optional
+          );
+          if (fieldExpression.includes('readStringArray(')) {
+            usesStringArrayHelper = true;
+          }
+          return `${field.name} = ${fieldExpression}`;
+        })
+        .join(', ');
+
+      return `fun to${modelName}(value: ReadableMap): ${modelName} {
+    return ${modelName}(${args})
+}`;
+    })
+    .filter(Boolean)
+    .join('\n\n');
+
+  if (!usesStringArrayHelper) {
+    return conversionFunctions;
+  }
+
+  const stringArrayHelper = `private fun readStringArray(value: ReadableMap, key: String, required: Boolean): List<String>? {
+    if (!value.hasKey(key) || value.isNull(key)) {
+        if (required) error("Missing required array field '$key'")
+        return null
+    }
+    val array = value.getArray(key) ?: return null
+    return array.toArrayList().map {
+        it as? String ?: error("Expected string elements for array field '$key'")
+    }
+}`;
+
+  return conversionFunctions
+    ? `${conversionFunctions}\n\n${stringArrayHelper}`
+    : stringArrayHelper;
+}
+
+function mapReadableMapFieldExpression(
+  mapName: string,
+  fieldName: string,
+  fieldType: string,
+  optional: boolean
+): string {
+  const parsedType = parseFieldType(fieldType);
+  const normalizedFieldType = parsedType.normalizedType;
+  const allowsNull = optional || parsedType.nullable;
+  if (normalizedFieldType === 'string') {
+    return allowsNull
+      ? `${mapName}.getString("${fieldName}")`
+      : `${mapName}.getString("${fieldName}")!!`;
+  }
+  if (normalizedFieldType === 'number') {
+    return allowsNull
+      ? `if (${mapName}.hasKey("${fieldName}") && !${mapName}.isNull("${fieldName}")) ${mapName}.getDouble("${fieldName}") else null`
+      : `${mapName}.getDouble("${fieldName}")`;
+  }
+  if (normalizedFieldType === 'boolean') {
+    return allowsNull
+      ? `if (${mapName}.hasKey("${fieldName}") && !${mapName}.isNull("${fieldName}")) ${mapName}.getBoolean("${fieldName}") else null`
+      : `${mapName}.getBoolean("${fieldName}")`;
+  }
+  if (normalizedFieldType === 'string[]') {
+    return allowsNull
+      ? `readStringArray(${mapName}, "${fieldName}", false)`
+      : `readStringArray(${mapName}, "${fieldName}", true)!!`;
+  }
+  if (isSimpleTypeReference(normalizedFieldType)) {
+    const nestedModelType = resolveNestedModelTypeName(normalizedFieldType);
+    return allowsNull
+      ? `${mapName}.getMap("${fieldName}")?.let { to${nestedModelType}(it) }`
+      : `to${nestedModelType}(${mapName}.getMap("${fieldName}")!!)`;
+  }
+  return `error("Unsupported TypeScript field type '${escapeKotlinStringLiteral(normalizedFieldType)}' for field '${escapeKotlinStringLiteral(fieldName)}' in Kotlin conversion. Consider using 'Any' or a custom converter.")`;
+}
+
+function isSimpleTypeReference(typeName: string): boolean {
+  return /^[A-Za-z_]\w*$/.test(typeName);
+}
+
+function escapeSwiftStringLiteral(value: string): string {
+  return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+
+function escapeKotlinStringLiteral(value: string): string {
+  return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+
+function parseFieldType(fieldType: string): {
+  normalizedType: string;
+  nullable: boolean;
+} {
+  const unionTypes = fieldType
+    .split('|')
+    .map((part) => part.trim())
+    .filter(Boolean);
+  const nullable = unionTypes.includes('null') || unionTypes.includes('undefined');
+  const nonNullableTypes = unionTypes.filter(
+    (part) => part !== 'null' && part !== 'undefined'
+  );
+  const normalizedType =
+    nonNullableTypes.length === 1 ? nonNullableTypes[0] : fieldType.trim();
+  return { normalizedType, nullable };
+}
+
+function resolveNestedModelTypeName(typeName: string): string {
+  if (typeName.endsWith('Type') && typeName.length > 'Type'.length) {
+    return typeName.slice(0, -'Type'.length);
+  }
+  return typeName;
+}
+
+function buildModelDefinitionsByLookupName(
+  modelDefinitions: ModelDefinition[]
+): Map<string, ModelDefinition> {
+  const definitionsByLookupName = new Map<string, ModelDefinition>();
+  for (const definition of modelDefinitions) {
+    if (!definitionsByLookupName.has(definition.name)) {
+      definitionsByLookupName.set(definition.name, definition);
+    }
+    const nestedName = resolveNestedModelTypeName(definition.name);
+    if (
+      nestedName !== definition.name &&
+      !definitionsByLookupName.has(nestedName)
+    ) {
+      definitionsByLookupName.set(nestedName, definition);
+    }
+  }
+  return definitionsByLookupName;
+}
+
+function collectConversionModelNames(
+  modelDefinitionsByLookupName: Map<string, ModelDefinition>,
+  modelTypeNames: string[]
+): string[] {
+  const queue = [...modelTypeNames];
+  const visited = new Set<string>();
+  const orderedModelNames: string[] = [];
+
+  while (queue.length > 0) {
+    const modelName = queue.shift();
+    if (!modelName || visited.has(modelName)) {
+      continue;
+    }
+    visited.add(modelName);
+
+    const definition = modelDefinitionsByLookupName.get(modelName);
+    if (!definition) {
+      continue;
+    }
+    orderedModelNames.push(modelName);
+
+    for (const field of definition.fields) {
+      const parsedFieldType = parseFieldType(field.type);
+      if (!isSimpleTypeReference(parsedFieldType.normalizedType)) {
+        continue;
+      }
+      const nestedModelName = resolveNestedModelTypeName(
+        parsedFieldType.normalizedType
+      );
+      if (!visited.has(nestedModelName)) {
+        queue.push(nestedModelName);
+      }
+    }
+  }
+
+  return orderedModelNames;
+}

package/src/navigation/generators/ts.ts

@@ -1,21 +1,52 @@
 import path from 'node:path';
 import { createRequire } from 'node:module';
 
-import type { MethodSignature } from '../types.js';
+import type { MethodSignature, TypeDeclaration } from '../types.js';
 
-export function generateTurboModuleSpec(methods: MethodSignature[]): string {
+interface TurboSpecGenerationOptions {
+  modelTypeNames?: string[];
+}
+
+function mapTypeForTurboSpec(
+  typeText: string,
+  options: TurboSpecGenerationOptions
+): string {
+  if (typeText.startsWith('Promise<')) {
+    const inner = typeText.slice(8, -1);
+    return `Promise<${mapTypeForTurboSpec(inner, options)}>`;
+  }
+
+  if (options.modelTypeNames?.includes(typeText)) {
+    return 'Object';
+  }
+
+  return typeText;
+}
+
+export function generateTurboModuleSpec(
+  methods: MethodSignature[],
+  referencedTypeDeclarations: TypeDeclaration[] = [],
+  options: TurboSpecGenerationOptions = {}
+): string {
   const methodSignatures = methods
     .map((method) => {
       const params = method.params
-        .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+        .map(
+          (param) =>
+            `${param.name}${param.optional ? '?' : ''}: ${mapTypeForTurboSpec(param.type, options)}`
+        )
         .join(', ');
-      return `  ${method.name}(${params}): ${method.returnType};`;
+      return `  ${method.name}(${params}): ${mapTypeForTurboSpec(method.returnType, options)};`;
     })
     .join('\n');
+  const typeDeclarationsBlock =
+    referencedTypeDeclarations.length === 0
+      ? ''
+      : `${referencedTypeDeclarations.map((entry) => entry.declaration).join('\n\n')}\n\n`;
 
   return `import { TurboModuleRegistry, type TurboModule } from 'react-native';
 
-export interface Spec extends TurboModule {
+${typeDeclarationsBlock}export interface Spec extends TurboModule {
 ${methodSignatures}
 }
 
@@ -25,7 +56,22 @@ export default TurboModuleRegistry.getEnforcing<Spec>(
 `;
 }
 
-export function generateIndexTs(methods: MethodSignature[]): string {
+function buildTypeImportLine(
+  referencedTypeDeclarations: TypeDeclaration[]
+): string {
+  if (referencedTypeDeclarations.length === 0) {
+    return '';
+  }
+
+  const names = referencedTypeDeclarations.map((entry) => entry.name).join(', ');
+  return `import type { ${names} } from './NativeBrownfieldNavigation';\n`;
+}
+
+export function generateIndexTs(
+  methods: MethodSignature[],
+  referencedTypeDeclarations: TypeDeclaration[] = []
+): string {
+  const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
   const functionImplementations = methods
     .map((method) => {
       const params = method.params
@@ -47,6 +93,7 @@ export function generateIndexTs(methods: MethodSignature[]): string {
     .join(',\n');
 
   return `import NativeBrownfieldNavigation from './NativeBrownfieldNavigation';
+${typeImportLine}
 
 const BrownfieldNavigation = {
 ${functionImplementations},
@@ -104,7 +151,11 @@ export function transpileWithConsumerBabel(
   return transformed.code;
 }
 
-export function generateIndexDts(methods: MethodSignature[]): string {
+export function generateIndexDts(
+  methods: MethodSignature[],
+  referencedTypeDeclarations: TypeDeclaration[] = []
+): string {
+  const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
   const methodSignatures = methods
     .map((method) => {
       const params = method.params
@@ -114,7 +165,7 @@ export function generateIndexDts(methods: MethodSignature[]): string {
     })
     .join('\n');
 
-  return `declare const BrownfieldNavigation: {
+  return `${typeImportLine}declare const BrownfieldNavigation: {
 ${methodSignatures}
 };
 

package/src/navigation/parser.ts

@@ -1,9 +1,48 @@
 import fs from 'node:fs';
 import { Project } from 'ts-morph';
 
-import type { MethodParam, MethodSignature } from './types.js';
+import type {
+  ModelDefinition,
+  ModelFieldDefinition,
+  MethodParam,
+  MethodSignature,
+  ParsedNavigationSpec,
+  TypeDeclaration,
+} from './types.js';
+import { Node } from 'ts-morph';
 
-export function parseNavigationSpec(specPath: string): MethodSignature[] {
+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 collectReferencedTypesFromText(typeText: string): string[] {
+  const matches = typeText.match(/\b[A-Za-z_]\w*\b/g);
+  if (!matches) {
+    return [];
+  }
+
+  return matches.filter((match) => !SKIP_TYPE_TOKENS.has(match));
+}
+
+export function parseNavigationSpec(specPath: string): ParsedNavigationSpec {
   if (!fs.existsSync(specPath)) {
     throw new Error(`Spec file not found: ${specPath}`);
   }
@@ -20,7 +59,7 @@ export function parseNavigationSpec(specPath: string): MethodSignature[] {
     );
   }
 
-  return specInterface.getMethods().map((method): MethodSignature => {
+  const methods = specInterface.getMethods().map((method): MethodSignature => {
     const name = method.getName();
     const params: MethodParam[] = method.getParameters().map((param) => {
       const typeNode = param.getTypeNode();
@@ -40,4 +79,99 @@ export function parseNavigationSpec(specPath: string): MethodSignature[] {
       isAsync: returnType.startsWith('Promise<'),
     };
   });
+
+  const declarationNodes = [
+    ...sourceFile.getTypeAliases(),
+    ...sourceFile.getInterfaces(),
+  ].filter((node) => {
+    const nodeName = node.getName();
+    return nodeName !== 'BrownfieldNavigationSpec' && nodeName !== 'Spec';
+  });
+
+  const declarationByName = new Map<string, string>(
+    declarationNodes.map((node) => {
+      const declarationText = node.getText();
+      const normalizedDeclaration = node.isExported()
+        ? declarationText
+        : `export ${declarationText}`;
+      return [node.getName(), normalizedDeclaration];
+    })
+  );
+  const referencedTypeNames = new Set<string>();
+  for (const method of methods) {
+    for (const typeText of [
+      method.returnType,
+      ...method.params.map((param) => param.type),
+    ]) {
+      for (const typeName of collectReferencedTypesFromText(typeText)) {
+        referencedTypeNames.add(typeName);
+      }
+    }
+  }
+
+  const referencedTypeDeclarations: TypeDeclaration[] = [];
+  const modelDefinitions: ModelDefinition[] = [];
+  const addedTypeNames = new Set<string>();
+  const queue = [...referencedTypeNames];
+
+  while (queue.length > 0) {
+    const typeName = queue.shift();
+    if (!typeName || addedTypeNames.has(typeName)) {
+      continue;
+    }
+
+    const declaration = declarationByName.get(typeName);
+    if (!declaration) {
+      continue;
+    }
+
+    addedTypeNames.add(typeName);
+    referencedTypeDeclarations.push({ name: typeName, declaration });
+    const declarationNode = declarationNodes.find((node) => node.getName() === typeName);
+    if (declarationNode) {
+      const fields = extractModelFields(declarationNode);
+      if (fields.length > 0) {
+        modelDefinitions.push({ name: typeName, fields });
+      }
+    }
+
+    for (const nestedTypeName of collectReferencedTypesFromText(declaration)) {
+      if (
+        !addedTypeNames.has(nestedTypeName) &&
+        declarationByName.has(nestedTypeName)
+      ) {
+        queue.push(nestedTypeName);
+      }
+    }
+  }
+
+  return {
+    methods,
+    referencedTypeDeclarations,
+    modelDefinitions,
+  };
+}
+
+function extractModelFields(node: Node): ModelFieldDefinition[] {
+  if (Node.isInterfaceDeclaration(node)) {
+    return node.getProperties().map((property) => ({
+      name: property.getName(),
+      type: property.getTypeNode()?.getText() ?? 'unknown',
+      optional: property.hasQuestionToken(),
+    }));
+  }
+
+  if (Node.isTypeAliasDeclaration(node)) {
+    const typeNode = node.getTypeNode();
+    if (!typeNode || !Node.isTypeLiteral(typeNode)) {
+      return [];
+    }
+    return typeNode.getProperties().map((property) => ({
+      name: property.getName(),
+      type: property.getTypeNode()?.getText() ?? 'unknown',
+      optional: property.hasQuestionToken(),
+    }));
+  }
+
+  return [];
 }

package/src/navigation/runner.ts

@@ -218,7 +218,8 @@ export async function runNavigationCodegen({
   intro(`Running Brownfield Navigation codegen`);
 
   logger.info(`Parsing spec file: ${resolvedSpecPath}`);
-  const methods = parseNavigationSpec(resolvedSpecPath);
+  const { methods, referencedTypeDeclarations, modelDefinitions } =
+    parseNavigationSpec(resolvedSpecPath);
   if (methods.length === 0) {
     throw new Error('No methods found in spec file');
   }
@@ -229,22 +230,33 @@ export async function runNavigationCodegen({
 
   const packageRoot = getNavigationPackagePath(projectRoot);
   const androidJavaPackageName = DEFAULT_ANDROID_JAVA_PACKAGE;
-  const indexTs = generateIndexTs(methods);
+  const indexTs = generateIndexTs(methods, referencedTypeDeclarations);
   const models = await generateNavigationModels({
     specPath: resolvedSpecPath,
     methods,
     kotlinPackageName: androidJavaPackageName,
+    modelDefinitions,
   });
 
   const artifacts: GeneratedNavigationArtifacts = {
-    turboModuleSpec: generateTurboModuleSpec(methods),
+    turboModuleSpec: generateTurboModuleSpec(methods, referencedTypeDeclarations, {
+      modelTypeNames: models.modelTypeNames,
+    }),
     indexTs,
     indexJs: transpileWithConsumerBabel(indexTs, projectRoot, packageRoot),
-    indexDts: generateIndexDts(methods),
-    swiftDelegate: generateSwiftDelegate(methods),
-    objcImplementation: generateObjCImplementation(methods),
-    kotlinDelegate: generateKotlinDelegate(methods, androidJavaPackageName),
-    kotlinModule: generateKotlinModule(methods, androidJavaPackageName),
+    indexDts: generateIndexDts(methods, referencedTypeDeclarations),
+    swiftDelegate: generateSwiftDelegate(methods, {
+      modelTypeNames: models.modelTypeNames,
+    }),
+    objcImplementation: generateObjCImplementation(methods, {
+      modelTypeNames: models.modelTypeNames,
+    }),
+    kotlinDelegate: generateKotlinDelegate(methods, androidJavaPackageName, {
+      modelTypeNames: models.modelTypeNames,
+    }),
+    kotlinModule: generateKotlinModule(methods, androidJavaPackageName, {
+      modelTypeNames: models.modelTypeNames,
+    }),
   };
 
   if (models.modelTypeNames.length > 0) {

package/src/navigation/types.ts

@@ -11,6 +11,28 @@ export interface MethodSignature {
   isAsync: boolean;
 }
 
+export interface TypeDeclaration {
+  name: string;
+  declaration: string;
+}
+
+export interface ModelFieldDefinition {
+  name: string;
+  type: string;
+  optional: boolean;
+}
+
+export interface ModelDefinition {
+  name: string;
+  fields: ModelFieldDefinition[];
+}
+
+export interface ParsedNavigationSpec {
+  methods: MethodSignature[];
+  referencedTypeDeclarations: TypeDeclaration[];
+  modelDefinitions: ModelDefinition[];
+}
+
 export interface GeneratedNavigationArtifacts {
   turboModuleSpec: string;
   indexTs: string;