@lark-apaas/fullstack-cli 1.1.60 → 1.1.61-alpha.20260818172555

package/templates/scripts/lint.js

@@ -76,49 +76,13 @@ function isStylelintTarget(filePath) {
   return filePath.endsWith('.css');
 }
 
-const STYLELINT_CONFIG_FILES = [
-  '.stylelintrc',
-  '.stylelintrc.js',
-  '.stylelintrc.cjs',
-  '.stylelintrc.json',
-  'stylelint.config.js',
-];
-
-/**
- * 老模板（fullstack-nestjs-template 1.x 时代）的应用跑不了 stylelint，跑了就挂、把 pre-commit
- * 卡死。两种形态都实测过：
- *
- * - 缺 scripts.stylelint → `npm error Missing script: "stylelint"`
- * - 缺 .stylelintrc.*    → `ConfigurationError: No configuration provided`
- *
- * 注意光判断 stylelint 装没装拦不住：@lark-apaas/fullstack-presets 的 dependencies 里有
- * stylelint，只要 dep 了 presets 二进制就在。缺任一件就跳过这一步。
- */
-function canRunStylelint() {
-  let pkg;
-  try {
-    pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
-  } catch {
-    return false;
-  }
-
-  if (!pkg.scripts || !pkg.scripts.stylelint) return false;
-
-  return STYLELINT_CONFIG_FILES.some(file => fs.existsSync(path.join(cwd, file)));
-}
-
 async function runDefaultLint() {
   const taskSpecs = [
     [getBinName('npm'), ['run', 'eslint']],
     [getBinName('npm'), ['run', 'type:check']],
+    [getBinName('npm'), ['run', 'stylelint']],
   ];
 
-  if (canRunStylelint()) {
-    taskSpecs.push([getBinName('npm'), ['run', 'stylelint']]);
-  } else {
-    console.warn('[lint] Skip stylelint: missing scripts.stylelint or stylelint config');
-  }
-
   process.exit(await runTasksSerially(taskSpecs));
 }
 
@@ -156,9 +120,7 @@ async function runSelectiveLint(inputFiles) {
     taskSpecs.push([getBinName('npx'), ['eslint', '--quiet', ...eslintFiles]]);
   }
 
-  if (stylelintFiles.length > 0 && !canRunStylelint()) {
-    console.warn('[lint] Skip stylelint: missing scripts.stylelint or stylelint config');
-  } else if (stylelintFiles.length > 0) {
+  if (stylelintFiles.length > 0) {
     taskSpecs.push([getBinName('npx'), ['stylelint', '--quiet', ...stylelintFiles]]);
   }
 

package/templates/scripts/patch-vite-dependency-graph-hash.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const runtimeRoot = path.resolve(
+  process.argv[2] ||
+    process.env.MIAODA_PLATFORM_RUNTIME_ROOT ||
+    '/opt/miaoda/preview-runtime'
+);
+const vitePackageFile = path.join(
+  runtimeRoot,
+  'node_modules',
+  'vite',
+  'package.json'
+);
+const targetFile = path.join(
+  runtimeRoot,
+  'node_modules',
+  'vite',
+  'dist',
+  'node',
+  'chunks',
+  'node.js'
+);
+const markerFile = path.join(
+  runtimeRoot,
+  '.miaoda-vite-dependency-hash-patch.json'
+);
+const expectedVersion = '8.1.5';
+const patchId = 'vite-8.1.5-cache-runtime-identity-v4';
+const expectedTargetSha256 =
+  '3968fab97a9d0882f0e2e754bd0d5b417f0a84596e293179a9a6e585919f041c';
+const originalLockfileHash = `function getLockfileHash(environment) {
+\tconst lockfilePath = lookupFile(environment.config.root, lockfilePaths);`;
+const patchedLockfileHash = `function getLockfileHash(environment) {
+\tconst miaodaClientDependencyGraphHash = process.env.MIAODA_VITE_DEPENDENCY_GRAPH_HASH;
+\tif (miaodaClientDependencyGraphHash !== void 0) {
+\t\tif (!/^[a-f0-9]{64}$/.test(miaodaClientDependencyGraphHash)) throw new Error("MIAODA_VITE_DEPENDENCY_GRAPH_HASH_INVALID");
+\t\treturn miaodaClientDependencyGraphHash;
+\t}
+\tconst lockfilePath = lookupFile(environment.config.root, lockfilePaths);`;
+const originalConfigBundleRoot = `async function bundleConfigFile(fileName, isESM) {
+\tlet importMetaResolverRegistered = false;
+\tconst root = path.dirname(fileName);
+\tconst dirnameVarName = "__vite_injected_original_dirname";`;
+const patchedConfigBundleRoot = `async function bundleConfigFile(fileName, isESM) {
+\tlet importMetaResolverRegistered = false;
+\tconst root = path.dirname(fileName);
+\tlet miaodaConfigPackageAliases = Object.create(null);
+\tconst miaodaConfigPackageAliasesRaw = process.env.MIAODA_VITE_CONFIG_PACKAGE_ALIASES;
+\tconst miaodaConfigRuntimeRoot = process.env.MIAODA_PLATFORM_RUNTIME_ROOT;
+\tif (process.env.MIAODA_CACHE_BOOTSTRAP_ENABLED === "true" && miaodaConfigPackageAliasesRaw !== void 0) {
+\t\ttry {
+\t\t\tconst parsed = JSON.parse(miaodaConfigPackageAliasesRaw);
+\t\t\tconst realRuntimeRoot = fs.realpathSync(miaodaConfigRuntimeRoot);
+\t\t\tif (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new Error("aliases");
+\t\t\tfor (const [packageName, entry] of Object.entries(parsed)) {
+\t\t\t\tif (!/^(?:@[a-z0-9][a-z0-9._~-]*\\/)?[a-z0-9][a-z0-9._~-]*$/i.test(packageName) || typeof entry !== "string" || !path.isAbsolute(entry)) throw new Error("entry");
+\t\t\t\tconst realEntry = fs.realpathSync(entry);
+\t\t\t\tconst relative = path.relative(realRuntimeRoot, realEntry);
+\t\t\t\tif (relative === ".." || relative.startsWith(\`..\${path.sep}\`) || path.isAbsolute(relative)) throw new Error("path");
+\t\t\t\tmiaodaConfigPackageAliases[packageName] = realEntry;
+\t\t\t}
+\t\t} catch {
+\t\t\tthrow new Error("MIAODA_VITE_CONFIG_PACKAGE_ALIASES_INVALID");
+\t\t}
+\t}
+\tconst dirnameVarName = "__vite_injected_original_dirname";`;
+const originalConfigPackageResolve = `idFsPath = nodeResolveWithVite(id, importer, {`;
+const patchedConfigPackageResolve = `idFsPath = Object.hasOwn(miaodaConfigPackageAliases, id) ? miaodaConfigPackageAliases[id] : nodeResolveWithVite(id, importer, {`;
+
+for (const file of [vitePackageFile, targetFile]) {
+  if (!fs.existsSync(file)) {
+    throw new Error(`MIAODA_VITE_PATCH_INPUT_MISSING: ${file}`);
+  }
+}
+const vitePackage = JSON.parse(fs.readFileSync(vitePackageFile, 'utf8'));
+if (vitePackage.version !== expectedVersion) {
+  throw new Error(
+    `MIAODA_VITE_PATCH_VERSION_MISMATCH: expected=${expectedVersion} actual=${vitePackage.version}`
+  );
+}
+
+let source = fs.readFileSync(targetFile, 'utf8');
+const alreadyPatched =
+  source.includes(patchedLockfileHash) &&
+  source.includes(patchedConfigBundleRoot) &&
+  source.includes(patchedConfigPackageResolve);
+if (alreadyPatched) {
+  if (
+    source.includes(originalLockfileHash) ||
+    source.includes(originalConfigBundleRoot) ||
+    source.includes(originalConfigPackageResolve)
+  ) {
+    throw new Error('MIAODA_VITE_PATCH_STATE_INVALID');
+  }
+} else {
+  const targetSha256 = crypto.createHash('sha256').update(source).digest('hex');
+  if (targetSha256 !== expectedTargetSha256) {
+    throw new Error(
+      `MIAODA_VITE_PATCH_TARGET_SHA_MISMATCH: expected=${expectedTargetSha256} actual=${targetSha256}`
+    );
+  }
+  const sentinels = [
+    originalLockfileHash,
+    originalConfigBundleRoot,
+    originalConfigPackageResolve,
+  ];
+  if (sentinels.some(sentinel => source.split(sentinel).length - 1 !== 1)) {
+    throw new Error(
+      'MIAODA_VITE_PATCH_SENTINEL_MISMATCH: expected exactly one of each sentinel'
+    );
+  }
+  source = source
+    .replace(originalLockfileHash, patchedLockfileHash)
+    .replace(originalConfigBundleRoot, patchedConfigBundleRoot)
+    .replace(originalConfigPackageResolve, patchedConfigPackageResolve);
+  fs.writeFileSync(targetFile, source);
+}
+
+const targetSha256 = crypto
+  .createHash('sha256')
+  .update(fs.readFileSync(targetFile))
+  .digest('hex');
+fs.writeFileSync(
+  markerFile,
+  `${JSON.stringify(
+    {
+      schemaVersion: 1,
+      patchId,
+      viteVersion: expectedVersion,
+      target: 'node_modules/vite/dist/node/chunks/node.js',
+      targetSha256,
+    },
+    null,
+    2
+  )}\n`
+);
+process.stdout.write(`${patchId}\n`);

package/templates/scripts/server-cache-module-resolver.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const Module = require('node:module');
+const { createRequire, isBuiltin } = Module;
+
+const configuredCacheNodeModules = path.resolve(
+  process.env.MIAODA_SERVER_CACHE_NODE_MODULES || ''
+);
+if (
+  !process.env.MIAODA_SERVER_CACHE_NODE_MODULES ||
+  !fs.existsSync(configuredCacheNodeModules) ||
+  !fs.statSync(configuredCacheNodeModules).isDirectory()
+) {
+  throw new Error('MIAODA_SERVER_CACHE_NODE_MODULES_INVALID');
+}
+const cacheNodeModules = fs.realpathSync(configuredCacheNodeModules);
+
+const cacheRequire = createRequire(
+  path.join(path.dirname(cacheNodeModules), 'cache-runtime-entry.cjs')
+);
+const originalResolveFilename = Module._resolveFilename;
+
+function isBarePackageRequest(request) {
+  return (
+    typeof request === 'string' &&
+    request.length > 0 &&
+    !isBuiltin(request) &&
+    !request.startsWith('.') &&
+    !path.isAbsolute(request) &&
+    !request.startsWith('#')
+  );
+}
+
+function isInsideCache(filename) {
+  if (typeof filename !== 'string' || !filename) return false;
+  const relative = path.relative(cacheNodeModules, filename);
+  return (
+    relative === '' ||
+    (!relative.startsWith('..') && !path.isAbsolute(relative))
+  );
+}
+
+Module._resolveFilename = function miaodaCacheFirstResolve(
+  request,
+  parent,
+  isMain,
+  options
+) {
+  // Packages already executing from the cache must keep Node's native lookup
+  // order so their nested dependency versions win over the cache root. Only a
+  // bare import originating in workspace source needs the cache entrypoint.
+  if (isBarePackageRequest(request) && !isInsideCache(parent?.filename)) {
+    try {
+      return cacheRequire.resolve(request);
+    } catch {
+      // Workspace aliases such as @server/* are intentionally delegated to
+      // tsconfig-paths and Node's original resolver.
+    }
+  }
+  return originalResolveFilename.call(this, request, parent, isMain, options);
+};