create-stylus 1.1.0

package/src/tasks/copy-template-files.ts

@@ -0,0 +1,252 @@
+import { execa } from "execa";
+import { Options, TemplateDescriptor } from "../types";
+import { baseDir } from "../utils/consts";
+import { findFilesRecursiveSync } from "../utils/find-files-recursively";
+import { mergePackageJson } from "../utils/merge-package-json";
+import fs from "fs";
+import url from 'url';
+import ncp from "ncp";
+import path from "path";
+import { promisify } from "util";
+import link from "../utils/link";
+import { copyExtensionFile } from "./copy-extension-file";
+
+const copy = promisify(ncp);
+let copyOrLink = copy;
+
+const isTemplateRegex = /([^\/\\]*?)\.template\./;
+const isPackageJsonRegex = /package\.json/;
+const isYarnLockRegex = /yarn\.lock/;
+const isNextGeneratedRegex = /packages\/nextjs\/generated/;
+const isArgsRegex = /([^\/\\]*?)\.args\./;
+const isGitKeepRegex = /\.gitkeep/;
+
+// Additional files/directories to exclude from template copying
+const excludePatterns = [
+  /\.github\//,               // GitHub specific files todo: add workflows/main.yml later
+  /CHANGELOG\.md/,            // Changelog file
+  /__test.*__/,               // All test directories (__test__, __tests__, etc.)
+];
+
+const copyBaseFiles = async (
+    { dev: isDev }: Options,
+    basePath: string,
+    targetDir: string
+  ) => {
+  await copyOrLink(basePath, targetDir, {
+    clobber: false,
+    filter: (fileName) => {  // NOTE: filter IN
+      const isTemplate = isTemplateRegex.test(fileName);
+      const isPackageJson = isPackageJsonRegex.test(fileName);
+      const isYarnLock = isYarnLockRegex.test(fileName);
+      const isNextGenerated = isNextGeneratedRegex.test(fileName);
+      const isGitKeep = isGitKeepRegex.test(fileName);
+
+      // Check if file matches any exclude pattern
+      const isExcluded = excludePatterns.some(pattern => pattern.test(fileName));
+
+      const skipAlways = isPackageJson || isGitKeep || isExcluded;
+      const skipDevOnly = isYarnLock || isNextGenerated;
+      const shouldSkip = skipAlways || (isDev && skipDevOnly);
+
+      return !shouldSkip;
+    },
+  });
+
+  ["stylus", "nextjs"].forEach(packageName => {
+    const envExamplePath = path.join(basePath, "packages", packageName, ".env.example");
+    const envPath = path.join(targetDir, "packages", packageName, ".env");
+    if (fs.existsSync(envExamplePath)) {
+      copy(envExamplePath, envPath);
+    }
+  });
+
+  const basePackageJsonPaths = findFilesRecursiveSync(basePath, (path: string) => isPackageJsonRegex.test(path));
+
+  basePackageJsonPaths.forEach((packageJsonPath: string) => {
+    const partialPath = packageJsonPath.split(basePath)[1];
+    mergePackageJson(
+      path.join(targetDir, partialPath),
+      path.join(basePath, partialPath),
+      isDev
+    );
+  });
+
+  if (isDev) {
+    const baseYarnLockPaths = findFilesRecursiveSync(basePath, (path: string) => isYarnLockRegex.test(path));
+    baseYarnLockPaths.forEach((yarnLockPath: string) => {
+      const partialPath = yarnLockPath.split(basePath)[1];
+      copy(
+        path.join(basePath, partialPath),
+        path.join(targetDir, partialPath)
+      );
+    });
+
+    const nextGeneratedPaths = findFilesRecursiveSync(basePath, (path: string) => isNextGeneratedRegex.test(path));
+    nextGeneratedPaths.forEach((nextGeneratedPath: string) => {
+      const partialPath = nextGeneratedPath.split(basePath)[1];
+      copy(
+        path.join(basePath, partialPath),
+        path.join(targetDir, partialPath)
+      );
+    });
+  }
+};
+
+
+
+const processTemplatedFiles = async (
+  { dev: isDev, extension }: Options,
+  basePath: string,
+  targetDir: string
+) => {
+  const baseTemplatedFileDescriptors: TemplateDescriptor[] =
+    findFilesRecursiveSync(basePath, (path: string) => isTemplateRegex.test(path)).map(
+      (baseTemplatePath: string) => ({
+        path: baseTemplatePath,
+        fileUrl: url.pathToFileURL(baseTemplatePath).href,
+        relativePath: baseTemplatePath.split(basePath)[1],
+        source: "base",
+      })
+    );
+
+  await Promise.all(
+    baseTemplatedFileDescriptors.map(async (templateFileDescriptor) => {
+      const templateTargetName =
+        templateFileDescriptor.path.match(isTemplateRegex)?.[1]!;
+
+      const argsPath = templateFileDescriptor.relativePath.replace(
+        isTemplateRegex,
+        `${templateTargetName}.args.`
+      );
+
+      // Load the template
+      const template = (await import(templateFileDescriptor.fileUrl)).default;
+
+      if (!template) {
+        throw new Error(
+          `Template ${templateTargetName} from ${templateFileDescriptor.source} doesn't have a default export`
+        );
+      }
+      if (typeof template !== "function") {
+        throw new Error(
+          `Template ${templateTargetName} from ${templateFileDescriptor.source} is not exporting a function by default`
+        );
+      }
+
+      // Collect args from multiple sources
+      const argsFileUrls = [];
+
+      // Check for args in target directory (from extensions)
+      if (extension) {
+        const extensionArgsPath = path.join(targetDir, argsPath);
+        if (fs.existsSync(extensionArgsPath)) {
+          argsFileUrls.push(url.pathToFileURL(extensionArgsPath).href);
+        }
+      }
+
+      // Load and combine all args
+      const argsModules = await Promise.all(
+        argsFileUrls.map(async (argsFileUrl) => {
+          try {
+            return await import(argsFileUrl) as Record<string, any>;
+          } catch (error) {
+            console.warn(`Failed to load args from: ${argsFileUrl}`);
+            return {};
+          }
+        })
+      );
+
+      // Combine all args into a single object
+      const combinedArgs = argsModules.reduce((acc, module) => {
+        return { ...acc, ...module };
+      }, {});
+
+      // Execute template with combined args
+      const output = template(combinedArgs);
+
+      const targetPath = path.join(
+        targetDir,
+        templateFileDescriptor.relativePath.split(templateTargetName)[0],
+        templateTargetName
+      );
+      fs.writeFileSync(targetPath, output);
+
+      if (isDev) {
+        const devOutput = `--- TEMPLATE FILE
+templates/${templateFileDescriptor.source}${templateFileDescriptor.relativePath}
+
+
+--- ARGS FILES
+${argsFileUrls.length > 0 
+  ? argsFileUrls.map(url => `\t- ${url.split("packages")[1] || url}`).join("\n")
+  : "(no args files writing to the template)"}
+
+
+--- RESULTING ARGS
+${Object.keys(combinedArgs).length > 0
+  ? Object.entries(combinedArgs)
+      .map(([key, value]) => `\t- ${key}:\t${JSON.stringify(value)}`)
+      .join("\n")
+  : "(no args sent for the template)"}
+`;
+        fs.writeFileSync(`${targetPath}.dev`, devOutput);
+      }
+    })
+  );
+};
+
+export async function copyTemplateFiles(
+  options: Options,
+  templateDir: string,
+  targetDir: string
+) {
+  copyOrLink = options.dev ? link : copy;
+  const basePath = path.join(templateDir, baseDir);
+
+  // 1. Copy base template to target directory
+  await copyBaseFiles(options, basePath, targetDir);
+
+  // 2. Copy extension files if extension is provided
+  if (options.extension) {
+    await copyExtensionFile(options.extension, targetDir);
+  }
+
+  // 3. Process templated files with extension args
+  await processTemplatedFiles(options, basePath, targetDir);
+
+  // 4. Clean up template and args files
+  await cleanupTemplateFiles(targetDir);
+
+  // 5. Initialize git repo to avoid husky error
+  await execa("git", ["init"], { cwd: targetDir });
+  await execa("git", ["checkout", "-b", "main"], { cwd: targetDir });
+}
+
+async function cleanupTemplateFiles(targetDir: string) {
+  const basePath = targetDir;
+  
+  // Find all template and args files
+  const templateFiles = findFilesRecursiveSync(basePath, (path: string) => isTemplateRegex.test(path));
+  const argsFiles = findFilesRecursiveSync(basePath, (path: string) => isArgsRegex.test(path));
+  
+  // Delete template files
+  templateFiles.forEach((templatePath) => {
+    try {
+      fs.unlinkSync(templatePath);
+    } catch (error) {
+      console.warn(`Failed to delete template file: ${templatePath}`);
+    }
+  });
+  
+  // Delete args files
+  argsFiles.forEach((argsPath) => {
+    try {
+      fs.unlinkSync(argsPath);
+    } catch (error) {
+      console.warn(`Failed to delete args file: ${argsPath}`);
+    }
+  });
+}
+
+

package/src/tasks/create-first-git-commit.ts

@@ -0,0 +1,35 @@
+import { execa } from "execa";
+
+// Checkout the latest release tag in a git submodule
+async function checkoutLatestTag(submodulePath: string): Promise<void> {
+  try {
+    const { stdout } = await execa("git", ["tag", "-l", "--sort=-v:refname"], {
+      cwd: submodulePath,
+    });
+    const tagLines = stdout.split("\n");
+    if (tagLines.length > 0) {
+      const latestTag = tagLines[0];
+      await execa("git", ["-C", `${submodulePath}`, "checkout", latestTag]);
+    } else {
+      throw new Error(`No tags found in submodule at ${submodulePath}`);
+    }
+  } catch (error) {
+    console.error("Error checking out latest tag:", error);
+    throw error;
+  }
+}
+
+export async function createFirstGitCommit(targetDir: string) {
+  try {
+    await execa("git", ["add", "-A"], { cwd: targetDir });
+    await execa(
+      "git",
+      ["commit", "-m", "Initial commit with 🏗️ Scaffold-Stylus", "--no-verify"],
+      { cwd: targetDir },
+    );
+  } catch (e: any) {
+    throw new Error("Failed to initialize git repository", {
+      cause: e?.stderr ?? e,
+    });
+  }
+}

package/src/tasks/create-project-directory.ts

@@ -0,0 +1,34 @@
+import { execa } from "execa";
+import fs from "fs";
+
+export async function createProjectDirectory(projectName: string) {
+  // Check if directory already exists
+  if (fs.existsSync(projectName)) {
+    // If directory exists, check if it's empty
+    if (fs.readdirSync(projectName).length > 0) {
+      throw new Error(
+        `Directory ${projectName} already exists and is not empty. Cannot continue.`,
+      );
+    }
+    // If directory exists and is empty, we can proceed (or do nothing here, as it's already created and empty)
+    // For clarity, we can return true or simply let the function continue if no further action is needed.
+    // In this case, since the directory exists and is empty, the goal is achieved.
+    return true;
+  }
+
+  try {
+    const result = await execa("mkdir", [projectName]);
+
+    if (result.failed) {
+      throw new Error("There was a problem running the mkdir command");
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to create directory: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+
+  return true;
+}

package/src/tasks/index.ts

@@ -0,0 +1,5 @@
+export * from "./copy-template-files";
+export * from "./create-project-directory";
+export * from "./install-packages";
+export * from "./create-first-git-commit";
+export * from "./prettier-format";

package/src/tasks/install-packages.ts

@@ -0,0 +1,15 @@
+import { projectInstall } from "pkg-install";
+import {execa} from "execa";
+import type {Options} from "../types";
+import path from "path";
+
+export async function installPackages(targetDir: string, options: Options) {
+  // Condition to check if 'devnet' is included and only update submodules
+  // if (options.extensions?.includes("starknet-native")) {
+  // }
+
+  return projectInstall({
+    cwd: targetDir,
+    prefer: "yarn",
+  });
+}

package/src/tasks/prettier-format.ts

@@ -0,0 +1,17 @@
+import { execa } from "execa";
+import path from "path";
+
+export async function prettierFormat(targetDir: string) {
+  try {
+    const nextjsPath = path.join(targetDir, "packages/nextjs");
+    const result = await execa("yarn", ["format"], { cwd: nextjsPath });
+
+    if (result.failed) {
+      throw new Error("There was a problem running the format command");
+    }
+  } catch (error) {
+    throw new Error("Failed to format Next.js project", { cause: error });
+  }
+
+  return true;
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+export type Args = string[];
+
+export type RawOptions = {
+  directory: string | null;
+  install: boolean | null;
+  dev: boolean;
+  extension: string | null;
+};
+
+type NonNullableRawOptions = {
+  [Prop in keyof RawOptions]: NonNullable<RawOptions[Prop]>;
+};
+
+export type Options = NonNullableRawOptions;
+
+export const isDefined = <T>(item: T | undefined | null): item is T =>
+  item !== undefined && item !== null;
+
+export type TemplateDescriptor = {
+  path: string;
+  fileUrl: string;
+  relativePath: string;
+  source: string;
+};
+
+export type Extension = {
+  extensionFlagValue: string;
+  description: string;
+  repository: string;
+  branch: string;
+};

package/src/utils/consts.ts

@@ -0,0 +1 @@
+export const baseDir = "base";

package/src/utils/find-files-recursively.ts

@@ -0,0 +1,19 @@
+import fs from "fs";
+import path from "path";
+
+export const findFilesRecursiveSync = (
+  baseDir: string,
+  criteriaFn: (path: string) => boolean = () => true
+): string[] => {
+  const subPaths = fs.readdirSync(baseDir);
+  const files = subPaths.map((relativePath) => {
+    const fullPath = path.resolve(baseDir, relativePath);
+    return fs.lstatSync(fullPath).isDirectory()
+      ? [...findFilesRecursiveSync(fullPath, criteriaFn)]
+      : criteriaFn(fullPath)
+      ? [fullPath]
+      : [];
+  });
+
+  return files.flat();
+};

package/src/utils/link.ts

@@ -0,0 +1,44 @@
+import type { Options } from "ncp";
+import { existsSync, lstatSync, readdirSync } from "fs";
+import { promises } from "fs";
+import path from "path";
+
+const { mkdir, link } = promises;
+/**
+ * The goal is that this function has the same API as ncp, so they can be used
+ * interchangeably.
+ * 
+ * - clobber not implemented
+ */
+const linkRecursive = async (source: string, destination: string, options?: Options): Promise<void> => {
+  const passesFilter = options?.filter === undefined
+    ? true // no filter
+    : typeof options.filter === 'function'
+      ? options.filter(source) // filter is function
+      : options.filter.test(source) // filter is regex
+
+  if (!passesFilter) {
+    return
+  }
+
+  if(lstatSync(source).isDirectory()) {
+    const subPaths = readdirSync(source);
+    await Promise.all(
+      subPaths.map(async subPath => {
+        const sourceSubpath = path.join(source, subPath);
+        const isSubPathAFolder = lstatSync(sourceSubpath).isDirectory()
+        const destSubPath = path.join(destination, subPath)
+        const existsDestSubPath = existsSync(destSubPath)
+        if (isSubPathAFolder && !existsDestSubPath) {
+          await mkdir(destSubPath)
+        }
+        await linkRecursive(sourceSubpath, destSubPath, options)
+      })
+    )
+    return
+  }
+
+  return link(source, destination)
+}
+
+export default linkRecursive

package/src/utils/load-extensions.ts

@@ -0,0 +1,10 @@
+import type { Extension } from "../types";
+import extensions from "../extensions.json";
+
+export function loadExtensions(): Extension[] {
+  return extensions as Extension[];
+}
+
+export function findExtensionByFlag(flagValue: string): Extension | undefined {
+  return extensions.find((ext: Extension) => ext.extensionFlagValue === flagValue);
+} 

package/src/utils/merge-package-json.ts

@@ -0,0 +1,33 @@
+// @ts-expect-error We don't have types for this probably add .d.ts file
+import mergeJsonStr from "merge-packages";
+import fs from "fs";
+
+export function mergePackageJson(
+  targetPackageJsonPath: string,
+  secondPackageJsonPath: string,
+  isDev: boolean
+) {
+  const existsTarget = fs.existsSync(targetPackageJsonPath);
+  const existsSecond = fs.existsSync(secondPackageJsonPath);
+  if (!existsTarget && !existsSecond) {
+    return;
+  }
+
+  const targetPackageJson = existsTarget ? fs.readFileSync(targetPackageJsonPath, "utf8") : '{}';
+  const secondPackageJson = existsSecond ? fs.readFileSync(secondPackageJsonPath, "utf8") : '{}';
+
+  const mergedPkgStr = mergeJsonStr.default(
+    targetPackageJson,
+    secondPackageJson
+  );
+  
+  // Parse and reformat the merged JSON to ensure proper formatting
+  const mergedPkgObj = JSON.parse(mergedPkgStr);
+  const formattedPkgStr = JSON.stringify(mergedPkgObj, null, 2) + '\n';
+  
+  fs.writeFileSync(targetPackageJsonPath, formattedPkgStr, "utf8");
+  if (isDev) {
+    const devStr = `TODO: write relevant information for the contributor`
+    fs.writeFileSync(`${targetPackageJsonPath}.dev`, devStr, "utf8");
+  }
+}

package/src/utils/parse-arguments-into-options.ts

@@ -0,0 +1,38 @@
+import type { Args, RawOptions } from "../types";
+import arg from "arg";
+
+// TODO update smartContractFramework code with general extensions
+export function parseArgumentsIntoOptions(rawArgs: Args): RawOptions {
+  const args = arg(
+    {
+      "--skip-install": Boolean,
+      "-s": "--skip-install",
+
+      "--dev": Boolean,
+
+      "--dir": String,
+      "-d": "--dir",
+
+      "--extension": String,
+      "-e": "--extension",
+    },
+    {
+      argv: rawArgs.slice(2).map((a) => a.toLowerCase()),
+    },
+  );
+
+  const skipInstall = args["--skip-install"] ?? null;
+
+  const dev = args["--dev"] ?? false; // info: use false avoid asking user
+
+  const directory = args["--dir"] ?? null;
+
+  const extension = args["--extension"] ?? null;
+
+  return {
+    directory,
+    install: skipInstall ? false : null,
+    dev,
+    extension,
+  };
+}

package/src/utils/prompt-for-missing-options.ts

@@ -0,0 +1,53 @@
+import { Options, RawOptions } from "../types";
+import inquirer from "inquirer";
+import { loadExtensions } from "./load-extensions";
+
+// default values for unspecified args
+const defaultOptions: RawOptions = {
+  directory: "./my-dapp-example",
+  install: true,
+  dev: false,
+  extension: null,
+};
+
+export async function promptForMissingOptions(
+  options: RawOptions,
+): Promise<Options> {
+  const cliAnswers = Object.fromEntries(
+    Object.entries(options).filter(([key, value]) => value !== null),
+  );
+
+  const extensions = loadExtensions();
+  const extensionChoices = extensions.map(ext => ({
+    name: `${ext.extensionFlagValue} - ${ext.description}`,
+    value: ext.extensionFlagValue,
+  }));
+
+  const questions = [
+    {
+      type: "input",
+      name: "directory",
+      message:
+        "Where do you want to install the new files? Choose ./ (root folder) or provide a new folder name.",
+      default: defaultOptions.directory,
+      validate: (value: string) => value.length > 0,
+    },
+    {
+      type: "confirm",
+      name: "install",
+      message: "Install dependencies?",
+      default: defaultOptions.install,
+    },
+  ];
+
+  const answers = await inquirer.prompt(questions, cliAnswers);
+
+  const mergedOptions: Options = {
+    directory: options.directory ?? answers.directory,
+    install: options.install ?? answers.install,
+    dev: options.dev ?? defaultOptions.dev,
+    extension: options.extension ?? answers.extension,
+  };
+
+  return mergedOptions;
+}

package/src/utils/render-intro-message.ts

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+
+export const TITLE_TEXT = `
+ ${chalk.bold.blue("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+")}
+ ${chalk.bold.blue("| Create Scaffold-Stylus app  |")}
+ ${chalk.bold.blue("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+")}
+`;
+
+export function renderIntroMessage() {
+  console.log(TITLE_TEXT);
+}

package/src/utils/render-outro-message.ts

@@ -0,0 +1,34 @@
+import type { Options } from "../types";
+import chalk from "chalk";
+
+export async function renderOutroMessage(options: Options) {
+  let message = `
+  \n
+  ${chalk.bold.green("Congratulations!")} Your project has been scaffolded! 🎉
+
+  ${chalk.bold("Next steps:")}
+  
+  ${chalk.dim("cd")} ${options.directory}
+  `;
+
+  message += `
+    \t${chalk.bold("Start the local development node")}
+    \t${chalk.dim("yarn")} chain
+    `;
+
+  message += `
+    \t${chalk.bold("In a new terminal window, deploy your contracts")}
+    \t${chalk.dim("yarn")} deploy
+   `;
+
+  message += `
+  \t${chalk.bold("In a new terminal window, start the frontend")}
+  \t${chalk.dim("yarn")} start
+  `;
+
+  message += `
+  ${chalk.bold.green("Thanks for using Scaffold-Stylus 🙏, Happy Building!")}
+  `;
+
+  console.log(message);
+}