@callstack/brownfield-cli 1.0.0

package/src/brownfield/commands/packageIos.ts

@@ -0,0 +1,114 @@
+import path from 'node:path';
+
+import {
+  getBuildOptions,
+  mergeFrameworks,
+  type BuildFlags as AppleBuildFlags,
+} from '@rock-js/platform-apple-helpers';
+import { packageIosAction } from '@rock-js/plugin-brownfield-ios';
+import {
+  colorLink,
+  getReactNativeVersion,
+  logger,
+  relativeToCwd,
+} from '@rock-js/tools';
+
+import { Command } from 'commander';
+
+import { isBrownieInstalled } from '../../brownie/config.js';
+import { runCodegen } from '../../brownie/commands/codegen.js';
+import { getProjectInfo } from '../utils/index.js';
+import {
+  actionRunner,
+  curryOptions,
+  ExampleUsage,
+} from '../../shared/index.js';
+
+export const packageIosCommand = curryOptions(
+  new Command('package:ios').description('Build iOS XCFramework'),
+  getBuildOptions({ platformName: 'ios' }).map((option) =>
+    option.name.startsWith('--build-folder')
+      ? {
+          ...option,
+          description:
+            option.description +
+            " By default, the '<iOS project folder>/build' path will be used.",
+        }
+      : option
+  )
+).action(
+  actionRunner(async (options: AppleBuildFlags) => {
+    const { projectRoot, platformConfig, userConfig } = getProjectInfo('ios');
+
+    if (!userConfig.project.ios) {
+      throw new Error('iOS project not found.');
+    }
+
+    if (!userConfig.project.ios.xcodeProject) {
+      throw new Error('iOS Xcode project not found in the configuration.');
+    }
+
+    const brownieCacheDir = path.join(
+      userConfig.project.ios.sourceDir,
+      '.brownfield'
+    );
+
+    options.buildFolder ??= path.join(brownieCacheDir, 'build');
+    const packageDir = path.join(brownieCacheDir, 'package');
+    const configuration = options.configuration ?? 'Debug';
+
+    const hasBrownie = isBrownieInstalled(projectRoot);
+    if (hasBrownie) {
+      await runCodegen({ platform: 'swift' });
+    }
+
+    await packageIosAction(
+      options,
+      {
+        projectRoot,
+        reactNativePath: userConfig.reactNativePath,
+        // below: the userConfig.reactNativeVersion may be a non-semver-format string,
+        // e.g. '0.82' (note the missing patch component),
+        // therefore we resolve it manually from RN's package.json using Rock's utils
+        reactNativeVersion: getReactNativeVersion(projectRoot),
+        usePrebuiltRNCore: false, // for brownfield, it is required to build RN from source
+        packageDir, // the output directory for artifacts
+        skipCache: true, // cache is dependent on existence of Rock config file
+      },
+      platformConfig
+    );
+
+    if (hasBrownie) {
+      const productsPath = path.join(options.buildFolder, 'Build', 'Products');
+      const brownieOutputPath = path.join(packageDir, 'Brownie.xcframework');
+
+      await mergeFrameworks({
+        sourceDir: userConfig.project.ios.sourceDir,
+        frameworkPaths: [
+          path.join(
+            productsPath,
+            `${configuration}-iphoneos`,
+            'Brownie',
+            'Brownie.framework'
+          ),
+          path.join(
+            productsPath,
+            `${configuration}-iphonesimulator`,
+            'Brownie',
+            'Brownie.framework'
+          ),
+        ],
+        outputPath: brownieOutputPath,
+      });
+
+      logger.success(
+        `Brownie.xcframework created at ${colorLink(relativeToCwd(brownieOutputPath))}`
+      );
+    }
+  })
+);
+
+export const packageIosExample = new ExampleUsage(
+  'package:ios --scheme BrownfieldLib --configuration Release',
+  "Build iOS XCFramework for 'BrownfieldLib' scheme in Release configuration"
+);

package/src/brownfield/commands/publishAndroid.ts

@@ -0,0 +1,36 @@
+import { publishLocalAarAction } from '@rock-js/plugin-brownfield-android';
+import {
+  publishLocalAarOptions,
+  type PublishLocalAarFlags,
+} from '@rock-js/platform-android';
+
+import { Command } from 'commander';
+
+import { getProjectInfo } from '../utils/index.js';
+import {
+  actionRunner,
+  curryOptions,
+  ExampleUsage,
+} from '../../shared/index.js';
+
+export const publishAndroidCommand = curryOptions(
+  new Command('publish:android').description(
+    'Publish Android package to Maven local'
+  ),
+  publishLocalAarOptions
+).action(
+  actionRunner(async (options: PublishLocalAarFlags) => {
+    const { projectRoot, platformConfig } = getProjectInfo('android');
+
+    await publishLocalAarAction({
+      projectRoot,
+      pluginConfig: platformConfig,
+      moduleName: options.moduleName,
+    });
+  })
+);
+
+export const publishAndroidExample = new ExampleUsage(
+  'publish:android --module-name :BrownfieldLib',
+  "Publish all built variants for 'BrownfieldLib' module to Maven local"
+);

package/src/brownfield/index.ts

@@ -0,0 +1,24 @@
+import { styleText } from 'node:util';
+import {
+  packageAndroidCommand,
+  packageAndroidExample,
+} from './commands/packageAndroid.js';
+import {
+  publishAndroidCommand,
+  publishAndroidExample,
+} from './commands/publishAndroid.js';
+import { packageIosCommand, packageIosExample } from './commands/packageIos.js';
+
+export * from './utils/index.js';
+
+export const groupName = `${styleText(['bold', 'blueBright'], '@callstack/react-native-brownfield')}${styleText('whiteBright', ' - utilities for React Native Brownfield projects')}`;
+
+export const Commands = {
+  packageAndroidCommand,
+  packageAndroidExample,
+  publishAndroidCommand,
+  publishAndroidExample,
+  packageIosCommand,
+  packageIosExample,
+};
+export default Commands;

package/src/brownfield/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './paths.js';
+export * from './rn-cli.js';

package/src/brownfield/utils/paths.ts

@@ -0,0 +1,40 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+import type {
+  AndroidProjectConfig,
+  IOSProjectConfig,
+} from '@react-native-community/cli-types';
+import cloneDeep from 'lodash.clonedeep';
+
+export function makeRelativeProjectConfigPaths<
+  UserConfig extends AndroidProjectConfig | IOSProjectConfig | undefined,
+>(projectRoot: string, userConfig: UserConfig): UserConfig {
+  const relativeConfig = cloneDeep(userConfig);
+
+  if (userConfig?.sourceDir) {
+    relativeConfig!.sourceDir = path.relative(
+      projectRoot,
+      userConfig.sourceDir
+    );
+  }
+
+  return relativeConfig;
+}
+
+/**
+ * Helper function to find RN project root by recursively looking for a package.json in the parent directories
+ * @returns The path to the project root directory
+ */
+export function findProjectRoot(): string {
+  let currentDir = process.cwd();
+
+  while (currentDir !== '/') {
+    if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  throw new Error('Could not find project root (no package.json found)');
+}

package/src/brownfield/utils/rn-cli.ts

@@ -0,0 +1,58 @@
+import type { PackageAarFlags } from '@rock-js/platform-android';
+import type {
+  AndroidProjectConfig,
+  Config as UserConfig,
+  ProjectConfig,
+} from '@react-native-community/cli-types';
+import cliConfigImport from '@react-native-community/cli-config';
+
+const cliConfig: typeof cliConfigImport =
+  typeof cliConfigImport === 'function'
+    ? cliConfigImport
+    : // @ts-expect-error: interop default
+      cliConfigImport.default;
+
+import { findProjectRoot, makeRelativeProjectConfigPaths } from './paths.js';
+
+/**
+ * Gets the project info for the given platform from the current working directory
+ * @param platform the platform for which to get project info
+ * @returns project root and android project config
+ */
+export function getProjectInfo<Platform extends 'ios' | 'android'>(
+  platform: Platform
+): {
+  projectRoot: string;
+  userConfig: UserConfig;
+  platformConfig: ProjectConfig[Platform];
+} {
+  const projectRoot = findProjectRoot();
+
+  const userConfig = cliConfig({
+    projectRoot,
+    selectedPlatform: platform,
+  });
+
+  // below: relative sourceDir path is required by RN CLI's API
+  const platformConfig = makeRelativeProjectConfigPaths(
+    projectRoot,
+    userConfig.project[platform]
+  );
+
+  if (!platformConfig) {
+    throw new Error(`${platform} project not found.`);
+  }
+
+  return { projectRoot, userConfig, platformConfig };
+}
+
+export const getAarConfig = (
+  args: PackageAarFlags,
+  androidConfig: AndroidProjectConfig
+) => {
+  const config = {
+    sourceDir: androidConfig.sourceDir,
+    moduleName: args.moduleName ?? '',
+  };
+  return config;
+};

package/src/brownie/commands/codegen.ts

@@ -0,0 +1,139 @@
+import path from 'node:path';
+import { styleText } from 'node:util';
+
+import { Command, Option } from 'commander';
+
+import { intro, logger, outro } from '@rock-js/tools';
+import { QuickTypeError } from 'quicktype-core';
+import { actionRunner } from '../../shared/index.js';
+import {
+  loadConfig,
+  getSwiftOutputPath,
+  type BrownieConfig,
+} from '../config.js';
+import { generateSwift } from '../generators/swift.js';
+import { generateKotlin } from '../generators/kotlin.js';
+import { discoverStores, type DiscoveredStore } from '../store-discovery.js';
+import type { Platform } from '../types.js';
+
+function getOutputPath(dir: string, name: string, ext: string): string {
+  return path.join(dir, `${name}.${ext}`);
+}
+
+function formatQuickTypeError(error: QuickTypeError): string {
+  let message = error.errorMessage;
+  for (const [key, value] of Object.entries(error.properties)) {
+    message = message.replaceAll('${' + key + '}', value);
+  }
+
+  return message;
+}
+
+async function generateForStore(
+  store: DiscoveredStore,
+  config: BrownieConfig,
+  platforms: Platform[],
+  showLabel: boolean
+): Promise<void> {
+  const { name, schemaPath } = store;
+  const storeLabel = showLabel ? ` [${name}]` : '';
+
+  logger.info(`Generating types for store ${name}`);
+
+  for (const p of platforms) {
+    let outputPath: string;
+
+    if (p === 'swift') {
+      const swiftOutputDir = getSwiftOutputPath();
+      outputPath = getOutputPath(swiftOutputDir, name, 'swift');
+    } else {
+      const kotlinOutputDir = config.kotlin;
+      if (!kotlinOutputDir) {
+        continue;
+      }
+      outputPath = getOutputPath(kotlinOutputDir, name, 'kt');
+    }
+
+    try {
+      if (p === 'swift') {
+        await generateSwift({
+          name,
+          schemaPath,
+          typeName: name,
+          outputPath,
+        });
+      } else {
+        await generateKotlin({
+          name,
+          schemaPath,
+          typeName: name,
+          outputPath,
+          packageName: config.kotlinPackageName,
+        });
+      }
+      logger.success(
+        `Generated ${outputPath}${styleText('italic', storeLabel)}`
+      );
+    } catch (error) {
+      logger.error(
+        `Error generating ${p}${storeLabel}: ${error instanceof QuickTypeError ? formatQuickTypeError(error) : error instanceof Error ? error.message : error}`
+      );
+      process.exit(1);
+    }
+  }
+}
+
+export type RunCodegenOptions = { platform?: Platform };
+
+/**
+ * Runs the codegen command with the given arguments.
+ */
+export async function runCodegen({ platform }: RunCodegenOptions) {
+  intro(
+    `Running Brownie codegen for ${platform ? `platform ${platform}` : 'all platforms'}`
+  );
+
+  const config = loadConfig();
+
+  if (platform && !['swift', 'kotlin'].includes(platform)) {
+    logger.error(`Invalid platform: ${platform}. Must be 'swift' or 'kotlin'`);
+    process.exit(1);
+  }
+
+  const stores = discoverStores();
+  const isMultipleStores = stores.length > 1;
+  const schemaList = stores.map((s) => path.basename(s.schemaPath)).join(', ');
+
+  logger.info(
+    styleText('cyan', `Generating store types from ${schemaList}...`)
+  );
+
+  for (const store of stores) {
+    let platforms: Platform[];
+
+    if (platform) {
+      platforms = [platform];
+    } else {
+      // Only generate Swift by default (Kotlin not yet released)
+      platforms = ['swift'];
+    }
+
+    await generateForStore(store, config, platforms, isMultipleStores);
+  }
+
+  outro('Done!');
+}
+
+export const codegenCommand = new Command('codegen')
+  .description('Generate native store types from TypeScript schema')
+  .addOption(
+    new Option(
+      '-p, --platform <platform>',
+      'Generate for specific platform (swift)'
+    ).choices(['swift'])
+  )
+  .action(
+    actionRunner(async (options: RunCodegenOptions) => {
+      await runCodegen(options);
+    })
+  );

package/src/brownie/commands/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js';

package/src/brownie/config.ts

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+export interface BrownieConfig {
+  kotlin?: string;
+  kotlinPackageName?: string;
+}
+
+interface PackageJson {
+  brownie?: BrownieConfig;
+}
+
+/**
+ * Checks if @callstack/brownie package is installed.
+ */
+export function isBrownieInstalled(
+  projectRoot: string = process.cwd()
+): boolean {
+  const require = createRequire(path.join(projectRoot, 'package.json'));
+  try {
+    require.resolve('@callstack/brownie/package.json');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolves the path to the @callstack/brownie package.
+ */
+export function getBrowniePackagePath(
+  projectRoot: string = process.cwd()
+): string {
+  const require = createRequire(path.join(projectRoot, 'package.json'));
+  try {
+    const browniePackageJson =
+      require.resolve('@callstack/brownie/package.json');
+    return path.dirname(browniePackageJson);
+  } catch {
+    throw new Error(
+      "@callstack/brownie is not installed. Run 'npm install @callstack/brownie' or 'yarn add @callstack/brownie'"
+    );
+  }
+}
+
+/**
+ * Returns the output path for generated Swift files.
+ */
+export function getSwiftOutputPath(
+  projectRoot: string = process.cwd()
+): string {
+  const browniePath = getBrowniePackagePath(projectRoot);
+  return path.join(browniePath, 'ios', 'Generated');
+}
+
+/**
+ * Loads brownie config from package.json in the current working directory.
+ */
+export function loadConfig(): BrownieConfig {
+  const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('package.json not found');
+  }
+
+  const packageJson: PackageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, 'utf-8')
+  );
+  return packageJson.brownie ?? {};
+}

package/src/brownie/generators/kotlin.ts

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  quicktype,
+  InputData,
+  JSONSchemaInput,
+  FetchingJSONSchemaStore,
+} from 'quicktype-core';
+import { schemaForTypeScriptSources } from 'quicktype-typescript-input';
+
+export interface KotlinGeneratorOptions {
+  name: string;
+  schemaPath: string;
+  typeName: string;
+  outputPath: string;
+  packageName?: string;
+}
+
+/**
+ * Extracts Kotlin package name from output path.
+ * e.g. "./kotlin/app/src/main/java/com/example/generated/BrownfieldStore.kt" -> "com.example.generated"
+ */
+function extractPackageName(outputPath: string): string {
+  const javaIndex = outputPath.indexOf('/java/');
+  if (javaIndex === -1) {
+    return 'generated';
+  }
+
+  const packagePath = outputPath.slice(javaIndex + 6);
+  const parts = packagePath.split('/');
+  parts.pop();
+  return parts.join('.');
+}
+
+/**
+ * Generates Kotlin data class from TypeScript schema.
+ */
+export async function generateKotlin(
+  options: KotlinGeneratorOptions
+): Promise<void> {
+  const {
+    name,
+    schemaPath,
+    typeName,
+    outputPath,
+    packageName: configPackageName,
+  } = options;
+
+  const absoluteSchemaPath = path.resolve(process.cwd(), schemaPath);
+
+  if (!fs.existsSync(absoluteSchemaPath)) {
+    throw new Error(`Schema file not found: ${absoluteSchemaPath}`);
+  }
+
+  const schemaData = schemaForTypeScriptSources([absoluteSchemaPath]);
+  if (!schemaData.schema) {
+    throw new Error('Failed to generate schema from TypeScript');
+  }
+
+  const parsedSchema = JSON.parse(schemaData.schema);
+  const definitions = parsedSchema.definitions as
+    | Record<string, unknown>
+    | undefined;
+
+  if (!definitions?.[typeName]) {
+    throw new Error(
+      `Type "${typeName}" not found in schema. Available types: ${Object.keys(definitions || {}).join(', ')}`
+    );
+  }
+
+  parsedSchema.$ref = `#/definitions/${typeName}`;
+  const modifiedSchema = JSON.stringify(parsedSchema);
+
+  const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+  await schemaInput.addSource({
+    name: typeName,
+    schema: modifiedSchema,
+  });
+
+  const inputData = new InputData();
+  inputData.addInput(schemaInput);
+
+  const absoluteOutputPath = path.resolve(process.cwd(), outputPath);
+  const packageName =
+    configPackageName ?? extractPackageName(absoluteOutputPath);
+
+  const { lines } = await quicktype({
+    inputData,
+    lang: 'kotlin',
+    rendererOptions: {
+      framework: 'just-types',
+      package: packageName,
+    },
+  });
+
+  let kotlinOutput = lines.join('\n');
+
+  const companionObject = ` {
+    companion object {
+        const val STORE_NAME = "${name}"
+    }
+}`;
+  const classPattern = new RegExp(`(data class ${typeName}\\s*\\([^)]*\\))`);
+  kotlinOutput = kotlinOutput.replace(classPattern, `$1${companionObject}`);
+
+  const outputDir = path.dirname(absoluteOutputPath);
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(absoluteOutputPath, kotlinOutput);
+}

package/src/brownie/generators/swift.ts

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  quicktype,
+  InputData,
+  JSONSchemaInput,
+  FetchingJSONSchemaStore,
+} from 'quicktype-core';
+import { schemaForTypeScriptSources } from 'quicktype-typescript-input';
+
+export interface SwiftGeneratorOptions {
+  name: string;
+  schemaPath: string;
+  typeName: string;
+  outputPath: string;
+}
+
+/**
+ * Generates Swift Codable struct from TypeScript schema.
+ */
+export async function generateSwift(
+  options: SwiftGeneratorOptions
+): Promise<void> {
+  const { name, schemaPath, typeName, outputPath } = options;
+
+  const absoluteSchemaPath = path.resolve(process.cwd(), schemaPath);
+
+  if (!fs.existsSync(absoluteSchemaPath)) {
+    throw new Error(`Schema file not found: ${absoluteSchemaPath}`);
+  }
+
+  const schemaData = schemaForTypeScriptSources([absoluteSchemaPath]);
+  if (!schemaData.schema) {
+    throw new Error('Failed to generate schema from TypeScript');
+  }
+
+  const parsedSchema = JSON.parse(schemaData.schema);
+  const definitions = parsedSchema.definitions as
+    | Record<string, unknown>
+    | undefined;
+
+  if (!definitions?.[typeName]) {
+    throw new Error(
+      `Type "${typeName}" not found in schema. Available types: ${Object.keys(definitions || {}).join(', ')}`
+    );
+  }
+
+  parsedSchema.$ref = `#/definitions/${typeName}`;
+  const modifiedSchema = JSON.stringify(parsedSchema);
+
+  const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+  await schemaInput.addSource({
+    name: typeName,
+    schema: modifiedSchema,
+  });
+
+  const inputData = new InputData();
+  inputData.addInput(schemaInput);
+
+  const { lines } = await quicktype({
+    inputData,
+    lang: 'swift',
+    rendererOptions: {
+      'access-level': 'public',
+      'mutable-properties': 'true',
+      initializers: 'false',
+      'swift-5-support': 'true',
+      protocol: 'equatable',
+    },
+  });
+
+  const storeNameExtension = `
+extension ${typeName}: BrownieStoreProtocol {
+  public static let storeName = "${name}"
+}
+`;
+
+  const swiftOutput = lines.join('\n') + storeNameExtension;
+  const absoluteOutputPath = path.resolve(process.cwd(), outputPath);
+  const outputDir = path.dirname(absoluteOutputPath);
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(absoluteOutputPath, swiftOutput);
+}