chore: improve error handling

Author: skovy

src/cli.ts

@@ -3,7 +3,7 @@
 import { cac } from 'cac';
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { processTransform } from './process-transform';
+import { perform } from './perform';
 
 const PACKAGE_PATH = join(__dirname, '../package.json');
 const PACKAGE_JSON = JSON.parse(readFileSync(PACKAGE_PATH, 'utf8'));
@@ -28,7 +28,7 @@ const run = async () => {
     .action(async (files: string, flags) => {
       const { transform } = flags;
 
-      await processTransform({ files, transform });
+      await perform({ files, transform });
     });
 
   cli.help();

src/files.ts

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import glob from 'glob';
+
+export interface TransformFileInfo {
+  /**
+   * The file path for the current file being transformed.
+   */
+  path: string;
+
+  /**
+   * The file contents for the current file being transformed.
+   */
+  source: string;
+}
+
+export const getFileInfo = (file: string): TransformFileInfo => {
+  try {
+    const source = fs.readFileSync(file, 'utf8').toString();
+    return { path: file, source };
+  } catch (err) {
+    console.error(`An error occurred trying to read "${file}": ${err}`);
+    process.exit(1);
+  }
+};
+
+export const writeFile = (file: string, contents: string): void => {
+  try {
+    fs.writeFileSync(file, contents);
+  } catch (err) {
+    console.error(`An error occurred trying to write "${file}": ${err}`);
+  }
+};
+
+export const getAllFilesToTransform = (files: string) => glob.sync(files);

src/load-transform.ts

@@ -0,0 +1,45 @@
+import { api } from './api';
+import { getAllFilesToTransform, getFileInfo, writeFile } from './files';
+import { loadTransform } from './transform';
+
+interface ProcessTransformOptions {
+  /**
+   * The file path to process and run through the transform.
+   */
+  files: string;
+
+  /**
+   * The transform path to run each file through.
+   */
+  transform: string;
+}
+
+/**
+ * Perform a transformation across a set of files.
+ */
+export const perform = async (options: ProcessTransformOptions) => {
+  const transform = await loadTransform(options.transform);
+  const files = getAllFilesToTransform(options.files);
+
+  files.map(file => {
+    const fileInfo = getFileInfo(file);
+
+    try {
+      const result = transform(fileInfo, api);
+
+      if (result !== null) {
+        writeFile(file, result);
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(
+          `The following error occurred transforming "${file}":\n  ${err.message}`
+        );
+      } else {
+        console.error(
+          `An unexpected error occurred transforming "${file}": ${err}`
+        );
+      }
+    }
+  });
+};

src/perform.ts

@@ -1,21 +1,51 @@
+import { bundleRequire } from 'bundle-require';
 import { TransformAPI } from './api';
+import { TransformFileInfo } from './files';
 
-export interface TransformFileInfo {
-  /**
-   * The file path for the current file being transformed.
-   */
-  path: string;
+const MINIMUM_TRANSFORM_EXAMPLE = `
+  import { Transform } from "css-codemod";
 
-  /**
-   * The file contents for the current file being transformed.
-   */
-  source: string;
-}
+  export const transform: Transform = (fileInfo, api) => {};
+`;
 
 export type Transform = (
   /**
    * Metadata for the current file being transformed.
    */
   fileInfo: TransformFileInfo,
+
+  /**
+   * Helpers injected by css-codemod.
+   */
   api: TransformAPI
 ) => null | string;
+
+/**
+ * Validate the general structure of the transform to catch simple errors.
+ */
+const validateTransform = (transform: unknown): Transform => {
+  if (typeof transform === 'function') {
+    return transform as Transform;
+  } else {
+    console.error(
+      `Transform file must export a valid transform. For example:\n${MINIMUM_TRANSFORM_EXAMPLE}`
+    );
+    process.exit(1);
+  }
+};
+
+/**
+ * Load and validate the transform file given the filepath.
+ */
+export const loadTransform = async (filepath: string): Promise<Transform> => {
+  try {
+    const { mod } = await bundleRequire({ filepath });
+    const transform = validateTransform(mod.transform || mod.default);
+    return transform;
+  } catch (err) {
+    console.error(
+      `An error occurred loading the transform file. Verify "${filepath}" exists.`
+    );
+    process.exit(1);
+  }
+};