handler.ts

import {
  DeployConfig,
  DeployError,
  deploy,
  getConfig,
  validateConfig,
} from '@openfn/deploy';
import type { Logger } from '../util/logger';
import { DeployOptions } from './command';
import * as beta from '../projects/deploy';
import path from 'node:path';
import { fileExists } from '../util/file-exists';
import { yamlToJson } from '@openfn/project';
import fs from 'node:fs/promises';

export type DeployFn = typeof deploy;

const actualDeploy: DeployFn = deploy;

// Flexible `deployFn` interface for testing.
async function deployHandler<F extends (...args: any) => any>(
  options: DeployOptions,
  logger: Logger,
  deployFn: F
): Promise<ReturnType<typeof deployFn>>;

async function deployHandler(
  options: DeployOptions,
  logger: Logger,
  deployFn = actualDeploy
) {
  if (options.beta) {
    return beta.handler(options as any, logger);
  }

  try {
    const config = mergeOverrides(await getConfig(options.configPath), options);

    const v2ConfigPath = path.join(
      options.workspace || process.cwd(),
      'openfn.yaml'
    );
    if (!process.env.PREFER_LEGACY_SYNC && (await fileExists(v2ConfigPath))) {
      // default endpoint to one from openfn.yaml
      const v2config = yamlToJson(await fs.readFile(v2ConfigPath, 'utf-8'));
      if (!config.endpoint && v2config?.project?.endpoint) {
        config.endpoint = v2config.project.endpoint;
      }

      logger.always(
        'Detected openfn.yaml file - switching to v2 deploy (openfn project deploy). Set PREFER_LEGACY_SYNC to disable this.'
      );
      return beta.handler(
        {
          ...options,
          force: true,
          endpoint: config.endpoint,
          apiKey: config.apiKey ?? undefined,
        },
        logger
      );
    }

    if (options.confirm === false) {
      config.requireConfirmation = options.confirm;
    }

    if (process.env['OPENFN_API_KEY']) {
      logger.info('Using OPENFN_API_KEY environment variable');
      config.apiKey = process.env['OPENFN_API_KEY'];
    }

    if (process.env['OPENFN_ENDPOINT']) {
      logger.info('Using OPENFN_ENDPOINT environment variable');
      config.endpoint = process.env['OPENFN_ENDPOINT'];
    }

    logger.debug('Deploying with config', config);
    logger.info(`Deploying`);

    validateConfig(config);

    const isOk = await deployFn(config, logger);

    process.exitCode = isOk ? 0 : 1;
    return isOk;
  } catch (error: any) {
    if (error instanceof DeployError) {
      logger.error(error.message);
      process.exitCode = 10;
      return false;
    }

    throw error;
  }
}

// Priority
// Config
// Env vars
// Options
function mergeOverrides(
  config: DeployConfig,
  options: DeployOptions
): DeployConfig {
  const workspace = options.workspace || process.cwd();
  const resolveRelative = (p: string) =>
    path.isAbsolute(p) ? p : path.join(workspace, p);
  const specPath = pickFirst(options.projectPath, config.specPath);
  const statePath = pickFirst(options.statePath, config.statePath);
  return {
    ...config,
    apiKey: pickFirst(process.env['OPENFN_API_KEY'], config.apiKey),
    endpoint: pickFirst(process.env['OPENFN_ENDPOINT'], config.endpoint),
    statePath: resolveRelative(statePath),
    specPath: resolveRelative(specPath),
    configPath: resolveRelative(options.configPath),
    requireConfirmation: pickFirst(options.confirm, config.requireConfirmation),
  };
}

function pickFirst<T>(...args: (T | null | undefined)[]): T {
  return args.find((arg) => arg !== undefined && arg !== null) as T;
}

export default deployHandler;