developing extension(part 1)

package.json

@@ -11,6 +11,8 @@
   "bin": "bin/create-dapp-se2.js",
   "scripts": {
     "build": "rollup -c rollup.config.js",
+    "build:dev": "yarn build && rollup -c src/dev/rollup.config.js",
+    "create-extension": "node dist/create-extension/create-extension.js",
     "dev": "rollup -c rollup.config.js --watch",
     "cli": "node bin/create-dapp-se2.js",
     "lint": "eslint .",

src/dev/create-extension.ts

@@ -0,0 +1,170 @@
+import arg from "arg";
+import path from "path";
+import fs from "fs";
+import { promisify } from "util";
+import { execa } from "execa";
+import ncp from "ncp";
+import { fileURLToPath } from "url";
+import { BASE_DIR, SOLIDITY_FRAMEWORKS, SOLIDITY_FRAMEWORKS_DIR } from "../utils/consts";
+import chalk from "chalk";
+
+const EXTERNAL_EXTENSIONS_DIR = "externalExtensions";
+const TARGET_EXTENSION_DIR = "extension";
+const TEMPLATE_FILE_SUFFIX = ".template.mjs";
+const DEPLOYED_CONTRACTS_FILE = "deployedContracts.ts";
+const YARN_LOCK_FILE = "yarn.lock";
+const PACKAGE_JSON_FILE = "package.json";
+const NEXTJS_DIR = "nextjs";
+
+const prettyLog = {
+  info: (message: string, indent = 0) => console.log(chalk.cyan(`${"  ".repeat(indent)}${message}`)),
+  success: (message: string, indent = 0) => console.log(chalk.green(`${"  ".repeat(indent)}✔︎ ${message}`)),
+  warning: (message: string, indent = 0) => console.log(chalk.yellow(`${"  ".repeat(indent)}⚠ ${message}`)),
+  error: (message: string, indent = 0) => console.log(chalk.red(`${"  ".repeat(indent)}✖ ${message}`)),
+};
+
+const ncpPromise = promisify(ncp);
+
+const currentFileUrl = import.meta.url;
+const templateDirectory = path.resolve(decodeURI(fileURLToPath(currentFileUrl)), "../../../templates");
+
+const getProjectPath = (rawArgs: string[]) => {
+  const args = arg({}, { argv: rawArgs.slice(2) });
+  const projectPath = args._[0];
+  if (!projectPath) {
+    throw new Error("Project path is required");
+  }
+  return { projectPath };
+};
+
+const getChangedFilesFromFirstCommit = async (projectPath: string): Promise<string[]> => {
+  const { stdout: firstCommit } = await execa("git", ["rev-list", "--max-parents=0", "HEAD"], {
+    cwd: projectPath,
+  });
+  const { stdout } = await execa("git", ["diff", "--name-only", `${firstCommit.trim()}..HEAD`], {
+    cwd: projectPath,
+  });
+  return stdout.split("\n").filter(Boolean);
+};
+
+const createDirectories = async (filePath: string, projectName: string) => {
+  const dirPath = path.join(EXTERNAL_EXTENSIONS_DIR, projectName, TARGET_EXTENSION_DIR, path.dirname(filePath));
+  await fs.promises.mkdir(dirPath, { recursive: true });
+};
+
+const findTemplateFiles = async (dir: string, templates: Set<string>) => {
+  const files = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const file of files) {
+    const fullPath = path.join(dir, file.name);
+    if (file.isDirectory()) {
+      await findTemplateFiles(fullPath, templates);
+    } else if (file.name.endsWith(TEMPLATE_FILE_SUFFIX)) {
+      let relativePath = path.relative(templateDirectory, fullPath).replace(new RegExp(`${TEMPLATE_FILE_SUFFIX}$`), "");
+      const pathSegments = relativePath.split(path.sep);
+
+      // Normalize the relative path by stripping the initial parts
+      if (pathSegments[0] === BASE_DIR) {
+        relativePath = pathSegments.slice(1).join(path.sep);
+      } else if (pathSegments[0] === SOLIDITY_FRAMEWORKS_DIR) {
+        const framework = pathSegments[1];
+        if (Object.values(SOLIDITY_FRAMEWORKS).includes(framework as any)) {
+          relativePath = pathSegments.slice(2).join(path.sep);
+        }
+      }
+
+      templates.add(relativePath);
+    }
+  }
+};
+
+const copyFiles = async (files: string[], projectName: string, projectPath: string, templates: Set<string>) => {
+  for (const file of files) {
+    const pathSegmentsOfFile = file.split(path.sep);
+    const sourcePath = path.resolve(projectPath, file);
+    const destPath = path.join(EXTERNAL_EXTENSIONS_DIR, projectName, TARGET_EXTENSION_DIR, file);
+    const sourceFileName = path.basename(sourcePath);
+
+    if (templates.has(file)) {
+      prettyLog.warning(`Skipping file: ${file}`, 2);
+      prettyLog.info(`Please instead create/update: ${destPath}.args.mjs`, 3);
+      console.log("\n");
+      continue;
+    }
+
+    if (sourceFileName === DEPLOYED_CONTRACTS_FILE) {
+      prettyLog.warning(`Skipping file: ${file}`, 2);
+      prettyLog.info(`${sourceFileName} can be generated using \`yarn deploy\``, 3);
+      console.log("\n");
+      continue;
+    }
+
+    if (sourceFileName === YARN_LOCK_FILE) {
+      prettyLog.warning(`Skipping file: ${file}`, 2);
+      prettyLog.info(`${file} will be generated when doing \`yarn install\``, 3);
+      console.log("\n");
+      continue;
+    }
+
+    const isRootPackageJson = pathSegmentsOfFile.length === 1 && pathSegmentsOfFile[0] === PACKAGE_JSON_FILE;
+    const isNextJsPackageJson =
+      pathSegmentsOfFile.includes(NEXTJS_DIR) && pathSegmentsOfFile.includes(PACKAGE_JSON_FILE);
+    const isSolidityFrameworkPackageJson =
+      (pathSegmentsOfFile.includes(SOLIDITY_FRAMEWORKS.HARDHAT) ||
+        pathSegmentsOfFile.includes(SOLIDITY_FRAMEWORKS.FOUNDRY)) &&
+      pathSegmentsOfFile.includes(PACKAGE_JSON_FILE);
+
+    if (isRootPackageJson || isNextJsPackageJson || isSolidityFrameworkPackageJson) {
+      prettyLog.warning(`Skipping file: ${file}`, 2);
+      prettyLog.info(`Please manually just add new scripts or dependencies in: ${destPath}`, 3);
+      console.log("\n");
+      continue;
+    }
+
+    const coreFilesPath = [
+      path.join(templateDirectory, BASE_DIR, file),
+      path.join(templateDirectory, SOLIDITY_FRAMEWORKS_DIR, SOLIDITY_FRAMEWORKS.HARDHAT, file),
+      path.join(templateDirectory, SOLIDITY_FRAMEWORKS_DIR, SOLIDITY_FRAMEWORKS.FOUNDRY, file),
+    ];
+    if (coreFilesPath.some(fs.existsSync)) {
+      prettyLog.error(`Ignored file: ${file}`, 2);
+      prettyLog.info("Only new files can be added", 3);
+      console.log("\n");
+      continue;
+    }
+
+    await createDirectories(file, projectName);
+    await ncpPromise(sourcePath, destPath);
+    prettyLog.success(`Copied: ${file}`, 2);
+    console.log("\n");
+  }
+};
+
+const main = async (rawArgs: string[]) => {
+  try {
+    const { projectPath } = getProjectPath(rawArgs);
+    const projectName = path.basename(projectPath);
+    const templates = new Set<string>();
+    await findTemplateFiles(templateDirectory, templates);
+
+    console.log("\n");
+    prettyLog.info(`Extension name: ${projectName}\n`);
+
+    prettyLog.info("Getting list of changed files...", 1);
+    const changedFiles = await getChangedFilesFromFirstCommit(projectPath);
+
+    if (changedFiles.length === 0) {
+      prettyLog.warning("No changed files to copy.", 1);
+      console.log("\n");
+    } else {
+      prettyLog.info(`Found ${changedFiles.length} changed files, processing them...`, 1);
+      console.log("\n");
+      await copyFiles(changedFiles, projectName, projectPath, templates);
+    }
+
+    prettyLog.info(`Files processed successfully, updated ${EXTERNAL_EXTENSIONS_DIR}/${projectName} directory.`);
+  } catch (err: any) {
+    prettyLog.error(`Error: ${err.message}`);
+  }
+};
+
+main(process.argv).catch(() => process.exit(1));

src/dev/rollup.config.js

@@ -0,0 +1,12 @@
+import typescript from "@rollup/plugin-typescript";
+import autoExternal from "rollup-plugin-auto-external";
+
+export default {
+  input: "src/dev/create-extension.ts",
+  output: {
+    dir: "dist/create-extension",
+    format: "es",
+    sourcemap: true,
+  },
+  plugins: [autoExternal(), typescript({ exclude: ["templates/**", "externalExtensions/**"] })],
+};

src/tasks/copy-template-files.ts

@@ -9,10 +9,9 @@ import path from "path";
 import { promisify } from "util";
 import link from "../utils/link";
 import { getArgumentFromExternalExtensionOption } from "../utils/external-extensions";
+import { BASE_DIR, SOLIDITY_FRAMEWORKS_DIR } from "../utils/consts";
 
-const BASE_DIR = "base";
 const EXTERNAL_EXTENSION_TMP_DIR = "tmp-external-extension";
-const SOLIDITY_FRAMEWORKS_DIR = "solidity-frameworks";
 
 const copy = promisify(ncp);
 let copyOrLink = copy;

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

@@ -13,7 +13,9 @@ export async function createFirstGitCommit(targetDir: string, options: Options)
     if (options.solidityFramework === SOLIDITY_FRAMEWORKS.FOUNDRY) {
       const foundryWorkSpacePath = path.resolve(targetDir, "packages", SOLIDITY_FRAMEWORKS.FOUNDRY);
       // forge install foundry libraries
-      await execa("forge", ["install", ...foundryLibraries], { cwd: foundryWorkSpacePath });
+      await execa("forge", ["install", ...foundryLibraries, "--no-commit"], { cwd: foundryWorkSpacePath });
+      await execa("git", ["add", "-A"], { cwd: targetDir });
+      await execa("git", ["commit", "--amend", "--no-edit"], { cwd: targetDir });
     }
   } catch (e: any) {
     // cast error as ExecaError to get stderr

src/utils/consts.ts

@@ -1,3 +1,6 @@
+export const BASE_DIR = "base";
+export const SOLIDITY_FRAMEWORKS_DIR = "solidity-frameworks";
+
 export const SOLIDITY_FRAMEWORKS = {
   HARDHAT: "hardhat",
   FOUNDRY: "foundry",