stack/scripts/generate-sdks.ts

import fs from "fs";
import path from "path";
import { COMMENT_BLOCK, COMMENT_LINE, PLATFORMS, copyFromSrcToDest, processMacros, withGeneratorLock, writeFileSyncIfChanged } from "./utils";

/**
 * Main function to generate from a template:
 * 1. Ensures the destination exists.
 * 2. Copies from src to dest (applying a composite editFn).
 * 3. Removes any items in dest that aren’t in src.
 * 4. Cleans up empty folders.
 *
 * The composite editFn encapsulates the hard rules:
 * - Global ignores (e.g. node_modules, dist, etc.)
 * - Skipping source package.json.
 * - Renaming package-template.json -> package.json.
 * - Inserting header comments into .tsx, .ts, or .js files.
 * - Adding a comment field in package.json files.
 *
 * Custom editFns provided in options can further modify content.
 */
function generateFromTemplate(options: {
  src: string;
  dest: string;
  editFn?: (relativePath: string, content: string) => string;
  filterFn?: (relativePath: string) => boolean;
  destFn?: (relativePath: string) => string;
}) {
  const { src, dest, editFn, filterFn, destFn } = options;

  // Composite edit function that applies the hard rules first,
  // then defers to any custom edit function.
  function compositeEditFn(
    relativePath: string,
    content: string
  ): string {
    let newContent: string = editFn ? editFn(relativePath, content) : content;

    // For .tsx, .ts, or .js files, add header comments.
    if (/\.(tsx|ts|js)$/.test(relativePath)) {
      const hasShebang =
        newContent.startsWith("#") ||
        newContent.startsWith('"') ||
        newContent.startsWith("'");
      let shebangLine = "";
      let contentWithoutShebang = newContent;
      if (hasShebang) {
        const lines = newContent.split("\n");
        shebangLine = lines[0] + "\n\n";
        contentWithoutShebang = lines.slice(1).join("\n");
      }
      newContent = shebangLine + COMMENT_BLOCK + contentWithoutShebang;
    }

    // If the resulting file is package.json, add a comment field to the JSON.
    if (path.basename(relativePath) === "package.json") {
      const jsonObj = JSON.parse(newContent);
      newContent = JSON.stringify({ "//": COMMENT_LINE, ...jsonObj }, null, 2);
    }

    return newContent;
  }

  function compositeDestFn(relativePath: string) {
    if (relativePath === "package-template.json") {
      return "package.json";
    }

    if (destFn) {
      return destFn(relativePath);
    }
    return relativePath;
  }

  function compositeFilterFn(relativePath: string) {
    const ignores = ["node_modules", "dist", ".turbo", ".gitignore", "package.json"];
    for (const ignore of ignores) {
      if (relativePath.startsWith(ignore)) {
        return false;
      }
    }

    if (filterFn) {
      return filterFn(relativePath);
    }
    return true;
  }

  // Ensure the destination directory exists.
  if (!fs.existsSync(dest)) {
    fs.mkdirSync(dest, { recursive: true });
  }
  
  copyFromSrcToDest({
    srcDir: src,
    destDir: dest,
    editFn: compositeEditFn,
    filterFn: compositeFilterFn,
    destFn: compositeDestFn,
    destRemoveSkipFn: (relativePath) => {
      return relativePath.startsWith("node_modules") || relativePath.startsWith("dist") || relativePath.startsWith(".turbo");
    },
  });
}

function processPackageJson(path: string, content: string) {
  let jsonObj: any;
  try {
    jsonObj = JSON.parse(content);
  } catch (error) {
    throw new Error(`Failed to parse package.json at ${path}`, { cause: error });
  }
  return JSON.stringify({ "//": `${COMMENT_LINE} (FOR package.json FILES, PLEASE EDIT package-template.json)`, ...jsonObj }, null, 2);
}

function baseEditFn(options: {
  relativePath: string, 
  content: string,
  platforms: string[]
}) {
  if (options.relativePath.startsWith("src/generated")) {
    return options.content;
  }
  const result = processMacros(options.content, options.platforms);
  if (options.relativePath === 'package-template.json') {
    return processPackageJson(options.relativePath, result);
  }
  return result;
}


withGeneratorLock(async () => {
  const baseDir = path.resolve(__dirname, "..", "packages");
  const srcDir = path.resolve(baseDir, "template");

  // Copy package-template.json to package.json in the template,
  // applying macros and adding a comment field.
  const packageTemplateContent = fs.readFileSync(
    path.join(srcDir, "package-template.json"),
    "utf-8"
  );
  const processedPackageJson = processMacros(packageTemplateContent, PLATFORMS["template"]);
  writeFileSyncIfChanged(
    path.join(srcDir, "package.json"),
    processPackageJson(path.join(srcDir, "package-template.json"), processedPackageJson)
  );

  generateFromTemplate({
    src: srcDir,
    dest: path.resolve(baseDir, "js"),
    editFn: (relativePath, content) => {
      return baseEditFn({ relativePath, content, platforms: PLATFORMS["js"] });
    },
    filterFn: (relativePath) => {
      const ignores = [
        "postcss.config.js",
        "tailwind.config.js",
        "quetzal.config.json",
        "components.json",
        ".env",
        ".env.local",
        "scripts/",
        "quetzal-translations/",
        "src/components/",
        "src/components-page/",
        "src/generated/",
        "src/providers/",
        "src/global.css",
        "src/global.d.ts",
      ];

      if (ignores.some((ignorePath) => relativePath.startsWith(ignorePath)) || relativePath.endsWith(".tsx")) {
        return false;
      } else {
        return true;
      }
    },
  });

  generateFromTemplate({
    src: srcDir,
    dest: path.resolve(baseDir, "stack"),
    editFn: (relativePath, content) => {
      return baseEditFn({ relativePath, content, platforms: PLATFORMS["next"] });
    },
  });

  generateFromTemplate({
    src: srcDir,
    dest: path.resolve(baseDir, "react"),
    editFn: (relativePath, content) => {
      return baseEditFn({ relativePath, content, platforms: PLATFORMS["react"] });
    },
  });
}).catch((error) => {
  console.error(error);
  process.exit(1);
});