feat: Create script for generating .ts json fixtures

Author: trillium

packages/test-case-component/src/processFixtures/loadAndProcessFixtures.ts

@@ -0,0 +1,55 @@
+import { loadTestCaseFixture } from "../loadTestCaseFixture";
+import { loadYamlFiles } from "./loadYamlFiles";
+
+export interface LoadAndProcessFixturesOptions {
+    fixturesDir: string;
+    allowList?: string[];
+    deps: {
+        fs: any;
+        path: any;
+        yaml: any;
+    };
+}
+
+/**
+ * Loads YAML test case files from a directory, processes them into fixtures, and returns an array of processed test case data.
+ * Optionally filters which files to load using an allow list.
+ *
+ * @param {Object} options - Options for loading and processing fixtures.
+ * @param {string} options.fixturesDir - Directory containing YAML fixture files.
+ * @param {string[]=} options.allowList - Optional list of filenames to include.
+ * @returns {Promise<any[]>} Array of processed test case data, each with a `raw` property containing the original YAML object.
+ */
+export async function loadAndProcessFixtures({
+    fixturesDir,
+    allowList,
+    deps,
+}: LoadAndProcessFixturesOptions) {
+    const fixtures = await loadYamlFiles({
+        dir: fixturesDir,
+        deps,
+        allowList,
+    });
+    const data_errors: any[] = [];
+
+    const data = (
+        await Promise.all(
+            fixtures.map(async (val: any) => {
+                try {
+                    const fixture = await loadTestCaseFixture(val);
+                    return { ...fixture, raw: val };
+                } catch (err) {
+                    console.error(err);
+                    data_errors.push(val);
+                    return null;
+                }
+            })
+        )
+    ).filter((test: any) => test != null);
+
+    if (data_errors.length > 0) {
+        console.error("data errors:", data_errors);
+    }
+
+    return data;
+}

packages/test-case-component/src/processFixtures/loadYamlFiles.ts

@@ -0,0 +1,42 @@
+export type LoadYamlFilesArgs = {
+    dir: string;
+    deps: {
+        fs: any;
+        path: any;
+        yaml: any;
+    };
+    allowList?: string[];
+};
+
+/**
+ * Loads YAML files from a directory, optionally filtering by an allow list.
+ * @param args Object containing dir, deps, and optional allowList
+ * @returns Array of parsed YAML objects, each with a filename property
+ */
+export async function loadYamlFiles(args: LoadYamlFilesArgs) {
+    const { dir, deps, allowList } = args;
+    const { fs, path, yaml } = deps;
+    // Use dir as-is, since it is already absolute
+    const directoryPath = dir;
+    const files = fs.readdirSync(directoryPath);
+    const data: any[] = [];
+
+    files.forEach((file: string) => {
+        if (
+            path.extname(file) === ".yml" &&
+            (!allowList || allowList.includes(file))
+        ) {
+            try {
+                const filePath = path.join(directoryPath, file);
+                const fileContents = fs.readFileSync(filePath, "utf8");
+                const yamlData: any = yaml.load(fileContents);
+                yamlData.filename = file;
+                data.push(yamlData);
+            } catch {
+                console.error("File load failure", file);
+            }
+        }
+    });
+
+    return data;
+}

packages/test-case-component/src/scripts/yml-to-json.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env ts-node
+
+// scripts/yml-to-json.ts
+// Usage: pnpm ts-node scripts/yml-to-json.ts <input-folder> <output-folder> [--destructive]
+
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { loadAndProcessFixtures } from "../processFixtures/loadAndProcessFixtures";
+
+console.log("[yml-to-json] Begin");
+
+if (process.argv.length < 4) {
+    console.error(
+        "Usage: pnpm ts-node scripts/yml-to-json.ts <input-folder> <output-folder> [--destructive]",
+    );
+    process.exit(1);
+}
+
+const inputDir = path.resolve(process.argv[2]);
+const outputDir = path.resolve(process.argv[3]);
+const outputSubdir = process.argv[4];
+let outputLanguagesDir: string | undefined = undefined;
+if (outputSubdir) {
+    outputLanguagesDir = path.join(outputDir, outputSubdir);
+    if (!fs.existsSync(outputLanguagesDir)) {
+        fs.mkdirSync(outputLanguagesDir, { recursive: true });
+    }
+}
+
+if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+}
+const isDestructive = process.argv.includes("--destructive");
+
+if (fs.existsSync(outputDir) && isDestructive) {
+    fs.readdirSync(outputDir).forEach((file) => {
+        const filePath = path.join(outputDir, file);
+        if (fs.statSync(filePath).isFile()) {
+            fs.unlinkSync(filePath);
+        }
+    });
+}
+
+/**
+ * Groups processed fixtures by language
+ */
+function groupFixturesByLanguage(processedFixtures: Array<{ language: string; processed: any }>): Record<string, any[]> {
+    const languageMap: Record<string, any[]> = {};
+    for (const item of processedFixtures) {
+        if (!item) { continue; }
+        if (!languageMap[item.language]) { languageMap[item.language] = []; }
+        languageMap[item.language].push(item.processed);
+    }
+    return languageMap;
+}
+
+/**
+ * Writes grouped fixtures to JSON files
+ */
+function writeLanguageJsonFiles(languageMap: Record<string, any[]>, outputDir: string, debug: boolean): Record<string, number> {
+    const results: Record<string, number> = {};
+    Object.entries(languageMap).forEach(([language, fixtures]) => {
+        const targetDir = outputLanguagesDir || outputDir;
+        const outputPath = path.join(targetDir, `${language}.ts`);
+        if (debug) { console.log(`[yml-to-json] Writing ${fixtures.length} fixtures to ${outputPath}`); }
+        fs.writeFileSync(outputPath, `export default ${JSON.stringify(fixtures, null, 2)};\n`);
+        results[language] = fixtures.length;
+        if (debug) { console.log(`Wrote ${fixtures.length} fixtures to ${outputPath}`); }
+    });
+    return results;
+}
+
+const deps = { fs, path, yaml };
+
+async function main() {
+    console.log("🦋 [main] being:");
+    const debug = false;
+    const fixtures = await loadAndProcessFixtures({
+        fixturesDir: inputDir,
+        allowList: undefined,
+        deps
+    });
+    if (debug) { console.log("🦋 processedFixtures:", JSON.stringify(fixtures, null, 2)); }
+    const languageMap = groupFixturesByLanguage(
+        fixtures.map((fixture: any) => ({
+            language: fixture.language || "plaintext",
+            processed: fixture,
+        }))
+    );
+    writeLanguageJsonFiles(languageMap, outputDir, debug);
+    console.log("🦋 languageMap:");
+    Object.entries(languageMap).forEach(([key, arr]) => {
+        console.log(`${key}: ${arr.length}`);
+    });
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});