@callstack/brownfield-cli 1.0.0

package/src/brownie/index.ts

@@ -0,0 +1,11 @@
+import { styleText } from 'node:util';
+
+import * as Commands from './commands/index.js';
+
+export type * from './types.js';
+export * from './store-discovery.js';
+
+export const groupName = `${styleText(['bold', 'blueBright'], '@callstack/brownie')}${styleText('whiteBright', ' - Shared state management CLI for React Native Brownfield')}`;
+
+export { Commands };
+export default Commands;

package/src/brownie/store-discovery.ts

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Project } from 'ts-morph';
+
+export interface DiscoveredStore {
+  name: string;
+  schemaPath: string;
+}
+
+/**
+ * Recursively finds all *.brownie.ts files in a directory.
+ */
+function findBrownieFiles(dir: string, files: string[] = []): string[] {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+        continue;
+      }
+      findBrownieFiles(fullPath, files);
+    } else if (entry.name.endsWith('.brownie.ts')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Parses a brownie file and extracts store names from BrownieStores interface.
+ */
+function parseStoresFromFile(
+  project: Project,
+  filePath: string
+): DiscoveredStore[] {
+  const sourceFile = project.addSourceFileAtPath(filePath);
+  const stores: DiscoveredStore[] = [];
+
+  const modules = sourceFile.getModules();
+  for (const mod of modules) {
+    const moduleName = mod.getName();
+    if (
+      moduleName !== "'@callstack/brownie'" &&
+      moduleName !== '"@callstack/brownie"'
+    ) {
+      continue;
+    }
+
+    const iface = mod.getInterface('BrownieStores');
+    if (!iface) {
+      continue;
+    }
+
+    for (const prop of iface.getProperties()) {
+      stores.push({
+        name: prop.getName(),
+        schemaPath: filePath,
+      });
+    }
+  }
+
+  return stores;
+}
+
+/**
+ * Discovers all brownie stores by parsing BrownieStores interface
+ * from declare module '@callstack/brownie' blocks.
+ */
+export function discoverStores(
+  rootDir: string = process.cwd()
+): DiscoveredStore[] {
+  const brownieFiles = findBrownieFiles(rootDir);
+
+  if (brownieFiles.length === 0) {
+    throw new Error(
+      'No brownie store files found. Create a file ending with .brownie.ts ' +
+        '(e.g., MyStore.brownie.ts)'
+    );
+  }
+
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const allStores: DiscoveredStore[] = [];
+
+  for (const filePath of brownieFiles) {
+    const stores = parseStoresFromFile(project, filePath);
+    allStores.push(...stores);
+  }
+
+  if (allStores.length === 0) {
+    throw new Error(
+      'No stores found in brownie files. Make sure to declare module ' +
+        "'@callstack/brownie' with BrownieStores interface."
+    );
+  }
+
+  const names = allStores.map((s) => s.name);
+  const duplicates = names.filter((n, i) => names.indexOf(n) !== i);
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Duplicate store names found: ${[...new Set(duplicates)].join(', ')}`
+    );
+  }
+
+  return allStores;
+}

package/src/brownie/types.ts

@@ -0,0 +1 @@
+export type Platform = 'swift' | 'kotlin';

package/src/index.ts

@@ -0,0 +1,84 @@
+import { styleText } from 'node:util';
+
+import { logger } from '@rock-js/tools';
+
+import { Command } from 'commander';
+
+import { ExampleUsage } from './shared/index.js';
+import brownfieldCommands, {
+  groupName as brownfieldCommandsGroupName,
+} from './brownfield/index.js';
+import brownieCommands, {
+  groupName as brownieCommandsGroupName,
+} from './brownie/index.js';
+
+const program = new Command();
+
+program
+  .name(styleText('magenta', 'brownie'))
+  .usage(styleText('yellow', '[options] [command]'))
+  .description(
+    styleText('magentaBright', 'React Native Brownfield CLI - ') +
+      styleText(['magenta', 'bold', 'underline'], 'Brownie')
+  )
+  .version(process.env.npm_package_version ?? '0.0.0');
+
+program
+  .optionsGroup('Global options:')
+  .option('--verbose', 'enable verbose logging')
+  .hook('preAction', () => {
+    const opts = program.opts();
+    if (opts.verbose) {
+      logger.setVerbose(opts.verbose ?? false);
+    }
+  });
+
+program.configureHelp({
+  styleTitle: (str) => styleText('bold', str),
+  styleCommandText: (str) => styleText('cyan', str),
+  styleArgumentText: (str) => styleText('yellow', str),
+  styleSubcommandText: (str) => styleText('blue', str),
+});
+
+function registrationHelper(
+  commandsRegistration: Record<string, unknown | Command | ExampleUsage>,
+  groupName: string
+) {
+  program.commandsGroup(groupName);
+
+  const exampleUsageItems: ExampleUsage[] = [];
+  Object.values(commandsRegistration).forEach((commandOrExampleUsage) => {
+    if (commandOrExampleUsage instanceof Command) {
+      // command
+      program.addCommand(commandOrExampleUsage);
+    } else if (commandOrExampleUsage instanceof ExampleUsage) {
+      // piece of example usage for the command group
+      exampleUsageItems.push(commandOrExampleUsage);
+    }
+  });
+
+  if (exampleUsageItems.length) {
+    const longestUsageItemCommandLength = exampleUsageItems.reduce(
+      (max, item) => Math.max(max, item.command.length),
+      0
+    );
+
+    program.addHelpText(
+      'after',
+      `\nExamples:\n${exampleUsageItems.map((item) => `\t ${styleText('dim', item.command.padEnd(longestUsageItemCommandLength))}\t${item.description}`).join('\n')}\n`
+    );
+  }
+}
+
+registrationHelper(brownfieldCommands, brownfieldCommandsGroupName);
+registrationHelper(brownieCommands, brownieCommandsGroupName);
+
+program.commandsGroup('Utility commands').helpCommand('help [command]');
+
+export function runCLI(argv: string[]): void {
+  program.parse(argv);
+
+  if (!argv.slice(2).length) {
+    program.outputHelp();
+  }
+}

package/src/main.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runCLI } from './index.js';
+
+runCLI(process.argv);

package/src/shared/classes/ExampleUsage.ts

@@ -0,0 +1,6 @@
+export class ExampleUsage {
+  constructor(
+    public readonly command: string,
+    public readonly description: string
+  ) {}
+}

package/src/shared/classes/index.ts

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

package/src/shared/index.ts

@@ -0,0 +1,2 @@
+export * from './utils/index.js';
+export * from './classes/index.js';

package/src/shared/utils/cli.ts

@@ -0,0 +1,47 @@
+import { logger, RockError, type RockCLIOptions } from '@rock-js/tools';
+
+import type { Command } from 'commander';
+
+export function curryOptions(programCommand: Command, options: RockCLIOptions) {
+  options.forEach((option) => {
+    if (option.parse) {
+      programCommand = programCommand.option(
+        option.name,
+        option.description,
+        option.parse,
+        option.default
+      );
+    } else {
+      programCommand = programCommand.option(
+        option.name,
+        option.description,
+        option.default
+      );
+    }
+  });
+
+  return programCommand;
+}
+
+export function actionRunner<T, R>(fn: (...args: T[]) => Promise<R>) {
+  return async function wrappedCLIAction(...args: T[]) {
+    try {
+      await fn(...args);
+    } catch (error) {
+      if (error instanceof RockError) {
+        if (logger.isVerbose()) {
+          logger.error(error);
+        } else {
+          logger.error(error.message);
+          if (error.cause) {
+            logger.error(`Cause: ${error.cause}`);
+          }
+        }
+      } else {
+        logger.error(`Unexpected error while running command:`, error);
+      }
+
+      process.exit(1);
+    }
+  };
+}

package/src/shared/utils/index.ts

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