@pixpilot/scaffoldfy-configs 0.32.0 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pixpilot/scaffoldfy-configs
 
+## 0.34.0
+
+### Minor Changes
+
+- update ESLint configuration for test files
+
+## 0.33.0
+
+### Minor Changes
+
+- update app templates and enhance setup script
+
 ## 0.32.0
 
 ### Minor Changes

package/eslint.config.mjs

@@ -3,4 +3,13 @@ import baseConfig from '@internal/eslint-config/base';
 // Uncomment to use the internal ESLint config if available
 // /** @type {import('@internal/eslint-config').Config} */
 /** @type {import('typescript-eslint').Config} */
-export default await baseConfig();
+export default [
+  ...(await baseConfig()),
+  {
+    files: ['test/**/*.test.ts'],
+    rules: {
+      'dot-notation': 'off',
+      'ts/dot-notation': 'off',
+    },
+  },
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pixpilot/scaffoldfy-configs",
   "type": "module",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "author": "PixPilot <m.doaie@hotmail.com>",
   "license": "MIT",
   "repository": {
@@ -26,11 +26,11 @@
   "devDependencies": {
     "@types/node": "^22.18.11",
     "eslint": "^9.38.0",
-    "@internal/eslint-config": "0.3.0",
+    "@internal/prettier-config": "0.0.1",
     "@internal/tsdown-config": "0.1.0",
     "@internal/vitest-config": "0.1.0",
     "@pixpilot/scaffoldfy": "0.52.0",
-    "@internal/prettier-config": "0.0.1"
+    "@internal/eslint-config": "0.3.0"
   },
   "prettier": "@internal/prettier-config",
   "publishConfig": {

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/test/workspace-package-generator.test.ts

@@ -124,13 +124,13 @@ describe('workspace-package-generator – add-dependencies script', () => {
     const initial = { name: 'test-pkg', dependencies: {} };
     const result = runAddDeps(initial, 'lodash axios');
 
-    expect(result.dependencies).toMatchObject({ lodash: '*', axios: '*' });
+    expect(result['dependencies']).toMatchObject({ lodash: '*', axios: '*' });
   });
 
   it('should sort dependencies alphabetically', () => {
     const initial = { name: 'test-pkg', dependencies: {} };
     const result = runAddDeps(initial, 'zod axios chalk');
-    const keys = Object.keys(result.dependencies as Record<string, string>);
+    const keys = Object.keys(result['dependencies'] as Record<string, string>);
 
     expect(keys).toEqual([...keys].sort());
   });
@@ -142,7 +142,7 @@ describe('workspace-package-generator – add-dependencies script', () => {
       devDependencies: { zod: '^3.0.0', axios: '^1.0.0', chalk: '^5.0.0' },
     };
     const result = runAddDeps(initial, 'vitest');
-    const keys = Object.keys(result.devDependencies as Record<string, string>);
+    const keys = Object.keys(result['devDependencies'] as Record<string, string>);
 
     expect(keys).toEqual([...keys].sort());
   });

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",
@@ -28,6 +28,17 @@
       ]
     }
     // {
+    //   "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:",
@@ -36,24 +47,19 @@
     //     "value": "workspaceApps.includes('nextjs')"
     //   }
     // },
-    // {
-    //   "id": "expoVisualTest",
-    //   "type": "input",
-    //   "message": "Expo visual-test value:",
-    //   "enabled": {
-    //     "type": "condition",
-    //     "value": "workspaceApps.includes('expo')"
-    //   }
-    // }
   ],
   "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();