@pixpilot/scaffoldfy-configs 0.31.0 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pixpilot/scaffoldfy-configs
 
+## 0.33.0
+
+### Minor Changes
+
+- update app templates and enhance setup script
+
+## 0.32.0
+
+### Minor Changes
+
+- support JSONC template files
+
 ## 0.31.0
 
 ### Minor Changes

package/README.md

@@ -104,6 +104,16 @@ Usage:
 npx @pixpilot/scaffoldfy@latest --config https://unpkg.com/@pixpilot/scaffoldfy-configs@latest/update-root-package-json/scaffoldfy.json
 ```
 
+### workspace-generator
+
+Generate workspace with apps and packages
+
+Usage:
+
+```sh
+npx @pixpilot/scaffoldfy@latest --config https://unpkg.com/@pixpilot/scaffoldfy-configs@latest/workspace-generator/scaffoldfy.jsonc
+```
+
 ### workspace-initializer
 
 Initial setup for a pnpm + Turbo monorepo template, including project info, license, and initial package generation.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pixpilot/scaffoldfy-configs",
   "type": "module",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "author": "PixPilot <m.doaie@hotmail.com>",
   "license": "MIT",
   "repository": {
@@ -20,14 +20,17 @@
   "files": [
     "*"
   ],
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
+  },
   "devDependencies": {
     "@types/node": "^22.18.11",
     "eslint": "^9.38.0",
     "@internal/eslint-config": "0.3.0",
+    "@internal/tsdown-config": "0.1.0",
     "@internal/prettier-config": "0.0.1",
     "@internal/vitest-config": "0.1.0",
-    "@internal/tsdown-config": "0.1.0",
-    "@pixpilot/scaffoldfy": "0.51.0"
+    "@pixpilot/scaffoldfy": "0.52.0"
   },
   "prettier": "@internal/prettier-config",
   "publishConfig": {

package/scripts/generate-readme.mjs

@@ -1,6 +1,7 @@
 import { readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { parse, printParseErrorCode } from 'jsonc-parser';
 
 const packageDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const readmePath = path.join(packageDirectory, 'README.md');
@@ -16,7 +17,10 @@ async function findConfigPaths(directory) {
       if (entry.isDirectory() && !ignoredDirectories.has(entry.name)) {
         return findConfigPaths(path.join(directory, entry.name));
       }
-      if (entry.isFile() && entry.name === 'scaffoldfy.json') {
+      if (
+        entry.isFile() &&
+        (entry.name === 'scaffoldfy.json' || entry.name === 'scaffoldfy.jsonc')
+      ) {
         return [path.join(directory, entry.name)];
       }
       return [];
@@ -31,10 +35,21 @@ async function readTemplate(configPath) {
     .relative(packageDirectory, path.dirname(configPath))
     .split(path.sep)
     .join('/');
-  const relativeConfigPath = relativeDirectory
-    ? `${relativeDirectory}/scaffoldfy.json`
-    : 'scaffoldfy.json';
-  const config = JSON.parse(await readFile(configPath, 'utf8'));
+  const relativeConfigPath = path
+    .relative(packageDirectory, configPath)
+    .split(path.sep)
+    .join('/');
+  const errors = [];
+  const config = parse(await readFile(configPath, 'utf8'), errors, {
+    allowTrailingComma: true,
+  });
+
+  if (errors.length > 0) {
+    const details = errors
+      .map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`)
+      .join(', ');
+    throw new Error(`${relativeConfigPath} is not valid JSON or JSONC: ${details}`);
+  }
 
   if (typeof config.description !== 'string' || !config.description.trim()) {
     throw new Error(`${relativeConfigPath} has no description`);

package/test/workspace-generator.test.ts

@@ -0,0 +1,152 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { afterEach, describe, expect, it } from 'vitest';
+
+const SCRIPT_PATH = path.join(
+  __dirname,
+  '..',
+  'workspace-generator',
+  'scripts',
+  'setup-workspace.cjs',
+);
+const temporaryDirectories: string[] = [];
+
+afterEach(() => {
+  for (const directory of temporaryDirectories.splice(0)) {
+    fs.rmSync(directory, { force: true, recursive: true });
+  }
+});
+
+function createFakeGit(testDirectory: string): string {
+  const binDirectory = path.join(testDirectory, 'bin');
+  const fakeGitPath = path.join(binDirectory, 'fake-git.cjs');
+  const gitCommandPath = path.join(
+    binDirectory,
+    process.platform === 'win32' ? 'git.exe' : 'git',
+  );
+
+  fs.mkdirSync(binDirectory, { recursive: true });
+  fs.writeFileSync(
+    fakeGitPath,
+    [
+      "'use strict';",
+      "const fs = require('node:fs');",
+      "const Module = require('node:module');",
+      "const path = require('node:path');",
+      'function applyGitOperation(command, args) {',
+      "  if (command === 'clone') {",
+      '  const destination = args.at(-1);',
+      "  if (destination === '.') {",
+      "    fs.writeFileSync(path.join(process.cwd(), 'base-template.txt'), 'base');",
+      '  } else {',
+      '    fs.mkdirSync(destination, { recursive: true });',
+      '  }',
+      "  } else if (command === 'sparse-checkout') {",
+      '  const sourceDirectory = args.at(-1);',
+      '  const templateDirectory = path.join(process.cwd(), sourceDirectory);',
+      '  fs.mkdirSync(templateDirectory, { recursive: true });',
+      "  fs.writeFileSync(path.join(templateDirectory, 'template.txt'), sourceDirectory);",
+      '}',
+      '}',
+      "if (process.env.SCAFFOLDFY_FAKE_GIT_MODE === 'preload') {",
+      '  const resolveFilename = Module._resolveFilename;',
+      '  Module._resolveFilename = function resolveFakeGit(request, ...args) {',
+      '    const command = path.basename(request);',
+      "    if (command === 'clone' || command === 'sparse-checkout') {",
+      '      applyGitOperation(command, process.argv.slice(2));',
+      "      return path.join(__dirname, 'noop.cjs');",
+      '    }',
+      '    return resolveFilename.call(this, request, ...args);',
+      '  };',
+      '} else {',
+      '  const [command, ...args] = process.argv.slice(2);',
+      '  applyGitOperation(command, args);',
+      '}',
+    ].join('\n'),
+  );
+
+  if (process.platform === 'win32') {
+    fs.writeFileSync(path.join(binDirectory, 'noop.cjs'), "'use strict';\n");
+    fs.copyFileSync(process.execPath, gitCommandPath);
+  } else {
+    fs.writeFileSync(
+      gitCommandPath,
+      `#!${process.execPath}\nrequire('./fake-git.cjs');\n`,
+    );
+    fs.chmodSync(gitCommandPath, 0o755);
+  }
+
+  return binDirectory;
+}
+
+function runSetup(workspaceApps: string): string {
+  const testDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'scaffoldfy-workspace-'));
+  const workspaceDirectory = path.join(testDirectory, 'workspace');
+  temporaryDirectories.push(testDirectory);
+  fs.mkdirSync(workspaceDirectory);
+  const gitBinDirectory = createFakeGit(testDirectory);
+  const fakeGitPath = path.join(gitBinDirectory, 'fake-git.cjs');
+
+  execFileSync(process.execPath, [SCRIPT_PATH], {
+    cwd: workspaceDirectory,
+    stdio: 'pipe',
+    env: {
+      ...process.env,
+      PATH: `${gitBinDirectory}${path.delimiter}${process.env.PATH ?? ''}`,
+      ...(process.platform === 'win32' && {
+        NODE_OPTIONS: `--require=${fakeGitPath} ${process.env.NODE_OPTIONS ?? ''}`,
+        Path: `${gitBinDirectory}${path.delimiter}${process.env.Path ?? ''}`,
+        SCAFFOLDFY_FAKE_GIT_MODE: 'preload',
+      }),
+      WORKSPACE_APPS: workspaceApps,
+    },
+  });
+
+  return workspaceDirectory;
+}
+
+describe('workspace-generator setup script', () => {
+  it('should clone the base template when only Library is selected', () => {
+    const workspaceDirectory = runSetup('library');
+
+    expect(
+      fs.readFileSync(path.join(workspaceDirectory, 'base-template.txt'), 'utf8'),
+    ).toBe('base');
+    expect(fs.existsSync(path.join(workspaceDirectory, 'apps'))).toBe(false);
+  });
+
+  it('should add every selected app to the base workspace', () => {
+    const workspaceDirectory = runSetup(
+      'library,nextjs-cloudflare,chrome-extension,expo',
+    );
+
+    expect(
+      fs.readFileSync(path.join(workspaceDirectory, 'base-template.txt'), 'utf8'),
+    ).toBe('base');
+    expect(
+      fs.readFileSync(
+        path.join(workspaceDirectory, 'apps', 'web', 'template.txt'),
+        'utf8',
+      ),
+    ).toBe('apps/web');
+    expect(
+      fs.readFileSync(
+        path.join(workspaceDirectory, 'apps', 'chrome-extension', 'template.txt'),
+        'utf8',
+      ),
+    ).toBe('apps/chrome-extension');
+    expect(
+      fs.readFileSync(
+        path.join(workspaceDirectory, 'apps', 'expo', 'template.txt'),
+        'utf8',
+      ),
+    ).toBe('apps/expo');
+  });
+
+  it('should fail when no workspace app is selected', () => {
+    expect(() => runSetup('')).toThrow('Select at least one workspace app.');
+  });
+});

package/workspace-generator/scaffoldfy.jsonc

@@ -14,8 +14,8 @@
           "value": "library"
         },
         {
-          "name": "Next.js",
-          "value": "nextjs"
+          "name": "Next.js Cloudflare",
+          "value": "nextjs-cloudflare"
         },
         {
           "name": "Chrome Extension",
@@ -26,34 +26,40 @@
           "value": "expo"
         }
       ]
-    },
-    {
-      "id": "nextjsVisualTest",
-      "type": "input",
-      "message": "Next.js visual-test value:",
-      "enabled": {
-        "type": "condition",
-        "value": "workspaceApps.includes('nextjs')"
-      }
-    },
-    {
-      "id": "expoVisualTest",
-      "type": "input",
-      "message": "Expo visual-test value:",
-      "enabled": {
-        "type": "condition",
-        "value": "workspaceApps.includes('expo')"
-      }
     }
+    // {
+    //   "id": "workspaceTools",
+    //   "type": "checkbox",
+    //   "message": "Select the packages to include:",
+    //   "choices": [
+    //     {
+    //       "name": "storybook",
+    //       "value": "storybook"
+    //     }
+    //   ]
+    // }
+    // {
+    //   "id": "nextjsVisualTest",
+    //   "type": "input",
+    //   "message": "Next.js visual-test value:",
+    //   "enabled": {
+    //     "type": "condition",
+    //     "value": "workspaceApps.includes('nextjs')"
+    //   }
+    // },
   ],
   "tasks": [
     {
-      "id": "clone-monorepo-template",
-      "name": "Clone Monorepo Template",
-      "description": "Clone the monorepo template",
-      "type": "exec",
+      "id": "setup-workspace",
+      "name": "Set up workspace apps",
+      "description": "Clone the monorepo template and add each selected app",
+      "type": "exec-file",
       "config": {
-        "command": "git clone https://github.com/pixpilot/pnpm-turbo-monorepo-template.git"
+        "file": "./scripts/setup-workspace.cjs",
+        "runtime": "node",
+        "parameters": {
+          "WORKSPACE_APPS": "{{workspaceApps}}"
+        }
       }
     }
   ]

package/workspace-generator/scripts/setup-workspace.cjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const process = require('node:process');
+
+const BASE_TEMPLATE_REPOSITORY =
+  'https://github.com/pixpilot/pnpm-turbo-monorepo-template.git';
+
+const APP_TEMPLATES = {
+  'nextjs-cloudflare': {
+    repository: 'https://github.com/ccpu/nextjs-cloudflare-monorepo-template.git',
+    sourceDirectory: 'apps/web',
+    destinationDirectory: 'apps/web',
+  },
+  'chrome-extension': {
+    repository: 'https://github.com/ccpu/chrome-extension-monorepo-template.git',
+    sourceDirectory: 'apps/chrome-extension',
+    destinationDirectory: 'apps/chrome-extension',
+  },
+  expo: {
+    repository: 'https://github.com/ccpu/full-stack-starter.git',
+    sourceDirectory: 'apps/expo',
+    destinationDirectory: 'apps/expo',
+  },
+};
+
+function runGit(args, cwd) {
+  execFileSync('git', args, { cwd, stdio: 'inherit' });
+}
+
+function getSelectedApps() {
+  return new Set(
+    (process.env.WORKSPACE_APPS ?? '')
+      .split(',')
+      .map((app) => app.trim())
+      .filter(Boolean),
+  );
+}
+
+function ensureEmptyDirectory(directory) {
+  if (fs.readdirSync(directory).length > 0) {
+    throw new Error(`Workspace directory must be empty: ${directory}`);
+  }
+}
+
+function copyDirectoryContents(sourceDirectory, destinationDirectory) {
+  for (const entry of fs.readdirSync(sourceDirectory, { withFileTypes: true })) {
+    fs.cpSync(
+      path.join(sourceDirectory, entry.name),
+      path.join(destinationDirectory, entry.name),
+      { recursive: entry.isDirectory(), errorOnExist: true, force: false },
+    );
+  }
+}
+
+function addAppTemplate(template, workspaceDirectory) {
+  const destinationDirectory = path.join(
+    workspaceDirectory,
+    template.destinationDirectory,
+  );
+  fs.mkdirSync(destinationDirectory, { recursive: true });
+
+  if (fs.readdirSync(destinationDirectory).length > 0) {
+    throw new Error(`App destination already exists: ${destinationDirectory}`);
+  }
+
+  const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'scaffoldfy-app-'));
+  const repositoryDirectory = path.join(temporaryDirectory, 'repository');
+
+  try {
+    runGit(
+      [
+        'clone',
+        '--depth',
+        '1',
+        '--filter=blob:none',
+        '--sparse',
+        template.repository,
+        repositoryDirectory,
+      ],
+      workspaceDirectory,
+    );
+    runGit(['sparse-checkout', 'set', template.sourceDirectory], repositoryDirectory);
+
+    const sourceDirectory = path.join(repositoryDirectory, template.sourceDirectory);
+    if (!fs.existsSync(sourceDirectory)) {
+      throw new Error(
+        `Template directory "${template.sourceDirectory}" was not found in ${template.repository}`,
+      );
+    }
+
+    copyDirectoryContents(sourceDirectory, destinationDirectory);
+  } finally {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  }
+}
+
+function main() {
+  const workspaceDirectory = process.cwd();
+  const selectedApps = getSelectedApps();
+
+  if (selectedApps.size === 0) {
+    throw new Error('Select at least one workspace app.');
+  }
+
+  ensureEmptyDirectory(workspaceDirectory);
+  runGit(['clone', '--depth', '1', BASE_TEMPLATE_REPOSITORY, '.'], workspaceDirectory);
+
+  for (const app of selectedApps) {
+    const template = APP_TEMPLATES[app];
+    if (template) {
+      addAppTemplate(template, workspaceDirectory);
+    }
+  }
+}
+
+main();