@lark-apaas/fullstack-cli 1.1.59-alpha.3 → 1.1.59

package/templates/scripts/preview-startup-timing.cjs

@@ -1,377 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const net = require('net');
-const path = require('path');
-
-const PREFIX = '[MiaodaPreviewPhase] ';
-const RUN_ID_PATTERN = /^prv_[A-Za-z0-9_-]{1,128}$/;
-
-function resolveAppId(env) {
-  const basePath = env.CLIENT_BASE_PATH || '';
-  const match = /^\/(?:app|af\/p)\/([^/]+)/.exec(basePath);
-  return match ? match[1] : env.MIAODA_APP_ID || '';
-}
-
-function createPreviewPhaseReporter(options = {}) {
-  const env = options.env || process.env;
-  const write = options.write || (line => process.stdout.write(`${line}\n`));
-  const now = options.now || Date.now;
-
-  function emit(phase, status, detail = {}) {
-    const runId = env.MIAODA_PREVIEW_RUN_ID || '';
-    if (!RUN_ID_PATTERN.test(runId)) return false;
-    const atMs = detail.at_ms == null ? now() : detail.at_ms;
-    const event = {
-      ...detail,
-      schema_version: 1,
-      run_id: runId,
-      app_id: resolveAppId(env),
-      sandbox_id: env.SANDBOX_ID || '',
-      phase,
-      status,
-      at_ms: atMs,
-    };
-    write(`${PREFIX}${JSON.stringify(event)}`);
-    return true;
-  }
-
-  return { emit };
-}
-
-function createTscServerCommand(reason, missingModules = []) {
-  return {
-    command: 'npm',
-    args: ['run', 'dev:server', '--', '--builder', 'tsc'],
-    compiler: 'tsc',
-    type_check: true,
-    type_check_mode: 'compiler_integrated',
-    type_check_command: null,
-    reason,
-    missing_modules: missingModules,
-  };
-}
-
-function normalizeTcpPort(value, fallback, name = 'TCP port') {
-  const candidate = value == null || value === '' ? fallback : value;
-  const serialized = String(candidate);
-  if (!/^\d+$/.test(serialized)) {
-    throw new Error(`${name} must be a valid TCP port`);
-  }
-  const port = Number(serialized);
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new Error(`${name} must be a valid TCP port`);
-  }
-  return port;
-}
-
-function buildListeningPortLookupArgs(port) {
-  const validatedPort = normalizeTcpPort(port, 0);
-  return [`-tiTCP:${validatedPort}`, '-sTCP:LISTEN'];
-}
-
-function hasRuntimeCompilerPluginConsumer(projectRoot, sourceRoot) {
-  const root = path.resolve(projectRoot, sourceRoot || 'src');
-  const stack = [root];
-  let scannedFiles = 0;
-  let scannedBytes = 0;
-  const maxFiles = 2000;
-  const maxBytes = 16 * 1024 * 1024;
-  const consumerPatterns = [
-    /\bSwaggerModule\s*\.\s*(?:createDocument|loadPluginMetadata)\b/,
-    /\bcreateDocument\s*\(/,
-    /\bloadPluginMetadata\s*\(/,
-    /\bDevTools(?:V2)?Module\s*\.\s*mount\b/,
-  ];
-
-  if (!fs.existsSync(root)) return true;
-
-  try {
-    while (stack.length > 0) {
-      const current = stack.pop();
-      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-          if (!['node_modules', 'dist', '.git'].includes(entry.name)) {
-            stack.push(path.join(current, entry.name));
-          }
-          continue;
-        }
-        if (!entry.isFile() || !/\.(?:[cm]?js|tsx?)$/.test(entry.name)) {
-          continue;
-        }
-        scannedFiles += 1;
-        const filePath = path.join(current, entry.name);
-        const stat = fs.statSync(filePath);
-        scannedBytes += stat.size;
-        if (scannedFiles > maxFiles || scannedBytes > maxBytes) return true;
-        const source = fs.readFileSync(filePath, 'utf8');
-        if (consumerPatterns.some(pattern => pattern.test(source))) return true;
-      }
-    }
-  } catch {
-    // If we cannot prove the compiler plugin is unobservable at runtime, keep TSC.
-    return true;
-  }
-  return false;
-}
-
-function resolvePreviewServerCommand(options = {}) {
-  const projectRoot = options.project_root || path.resolve(__dirname, '..');
-  let packageJson = options.package_json;
-  if (!packageJson) {
-    try {
-      packageJson = JSON.parse(
-        fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8')
-      );
-    } catch {
-      packageJson = {};
-    }
-  }
-
-  let nestCliConfig = options.nest_cli_config;
-  if (!nestCliConfig) {
-    try {
-      nestCliConfig = JSON.parse(
-        fs.readFileSync(path.join(projectRoot, 'nest-cli.json'), 'utf8')
-      );
-    } catch {
-      nestCliConfig = {};
-    }
-  }
-
-  const serverScript = packageJson?.scripts?.['dev:server'] || '';
-  const normalizedServerScript = serverScript
-    .trim()
-    .replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=[^\s]+\s+)*/, '')
-    .replace(/\s+/g, ' ');
-  const isNestWatchScript = normalizedServerScript === 'nest start --watch';
-  if (!isNestWatchScript) {
-    return {
-      command: 'npm',
-      args: ['run', 'dev:server'],
-      compiler: 'configured',
-      type_check: false,
-      type_check_mode: 'configured',
-      type_check_command: null,
-      reason: 'custom_server_script',
-      missing_modules: [],
-    };
-  }
-
-  const configuredBuilder = nestCliConfig?.compilerOptions?.builder;
-  if (configuredBuilder && configuredBuilder !== 'tsc') {
-    return {
-      command: 'npm',
-      args: ['run', 'dev:server'],
-      compiler: 'configured',
-      type_check: false,
-      type_check_mode: 'configured',
-      type_check_command: null,
-      reason: 'custom_nest_builder',
-      missing_modules: [],
-    };
-  }
-
-  const serverTypecheckScript =
-    packageJson?.scripts?.['type:check:server'] || '';
-  const normalizedTypecheckScript = serverTypecheckScript
-    .trim()
-    .replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=[^\s]+\s+)*/, '')
-    .replace(/\s+/g, ' ');
-  const isNonEmittingTscScript =
-    /^(?:npx )?tsc --noEmit --project [A-Za-z0-9_./-]+$/.test(
-      normalizedTypecheckScript
-    );
-  if (!isNonEmittingTscScript) {
-    return createTscServerCommand('server_typecheck_script_unavailable');
-  }
-
-  const previewCapability = nestCliConfig?.['x-miaoda-preview'];
-  if (
-    previewCapability?.compiler !== 'swc' ||
-    previewCapability?.typeCheck !== 'deferred'
-  ) {
-    return createTscServerCommand('preview_swc_capability_not_declared');
-  }
-
-  const compilerPlugins = Array.isArray(nestCliConfig?.compilerOptions?.plugins)
-    ? nestCliConfig.compilerOptions.plugins
-    : [];
-  const compilerPluginNames = compilerPlugins.map(plugin =>
-    typeof plugin === 'string' ? plugin : plugin?.name || ''
-  );
-  if (
-    compilerPluginNames.some(pluginName => pluginName !== '@nestjs/swagger')
-  ) {
-    return createTscServerCommand('unsupported_nest_compiler_plugins');
-  }
-  if (compilerPluginNames.includes('@nestjs/swagger')) {
-    const runtimeConsumer =
-      typeof options.has_runtime_compiler_plugin_consumer === 'boolean'
-        ? options.has_runtime_compiler_plugin_consumer
-        : hasRuntimeCompilerPluginConsumer(
-            projectRoot,
-            nestCliConfig?.sourceRoot || 'src'
-          );
-    if (runtimeConsumer) {
-      return createTscServerCommand(
-        'runtime_compiler_plugin_consumer_detected'
-      );
-    }
-  }
-
-  const resolveModule =
-    options.resolve_module ||
-    (moduleName => {
-      const resolved = require.resolve(moduleName, { paths: [projectRoot] });
-      if (moduleName === '@swc/core') {
-        const swc = require(resolved);
-        if (typeof swc.transformSync !== 'function') {
-          throw new Error('@swc/core native binding is unavailable');
-        }
-      }
-      return resolved;
-    });
-  const requiredModules = ['@swc/cli', '@swc/core'];
-  const missingModules = requiredModules.filter(moduleName => {
-    try {
-      resolveModule(moduleName);
-      return false;
-    } catch {
-      return true;
-    }
-  });
-
-  if (missingModules.length > 0) {
-    return createTscServerCommand('swc_dependencies_missing', missingModules);
-  }
-
-  return {
-    command: 'npm',
-    args: ['run', 'dev:server', '--', '--builder', 'swc'],
-    compiler: 'swc',
-    type_check: true,
-    type_check_mode: 'deferred_tsc_watch',
-    type_check_command: {
-      command: 'npm',
-      args: [
-        'run',
-        'type:check:server',
-        '--',
-        '--watch',
-        '--preserveWatchOutput',
-        '--locale',
-        'en',
-      ],
-    },
-    reason: 'swc_dependencies_ready',
-    missing_modules: [],
-  };
-}
-
-function parseTscWatchSummary(line) {
-  const match = /Found\s+(\d+)\s+errors?\.\s+Watching for file changes\./i.exec(
-    line
-  );
-  if (!match) return null;
-  const errorCount = Number(match[1]);
-  return { error_count: errorCount, passed: errorCount === 0 };
-}
-
-function connectTcpOnce({ host, port, timeout_ms }) {
-  return new Promise(resolve => {
-    const socket = net.createConnection({ host, port });
-    let settled = false;
-    const finish = ready => {
-      if (settled) return;
-      settled = true;
-      socket.destroy();
-      resolve(ready);
-    };
-    socket.setTimeout(timeout_ms, () => finish(false));
-    socket.once('connect', () => finish(true));
-    socket.once('error', () => finish(false));
-  });
-}
-
-async function waitForTcpReady(options) {
-  const hosts = options.host ? [options.host] : ['127.0.0.1', '::1'];
-  const port = Number(options.port);
-  const timeoutMs = options.timeout_ms == null ? 120000 : options.timeout_ms;
-  const intervalMs = options.interval_ms == null ? 50 : options.interval_ms;
-  const now = options.now || Date.now;
-  const sleep =
-    options.sleep || (ms => new Promise(resolve => setTimeout(resolve, ms)));
-  const connect = options.connect || connectTcpOnce;
-  const shouldContinue = options.should_continue || (() => true);
-  const startedAtMs =
-    options.started_at_ms == null ? now() : options.started_at_ms;
-  let attempts = 0;
-
-  while (now() - startedAtMs < timeoutMs) {
-    if (!shouldContinue()) {
-      const atMs = now();
-      return {
-        ready: false,
-        cancelled: true,
-        attempts,
-        at_ms: atMs,
-        duration_ms: atMs - startedAtMs,
-        precision_ms: intervalMs,
-      };
-    }
-    attempts += 1;
-    const ready = (
-      await Promise.all(
-        hosts.map(host =>
-          connect({
-            host,
-            port,
-            timeout_ms: Math.max(1, Math.min(intervalMs, timeoutMs)),
-          })
-        )
-      )
-    ).some(Boolean);
-    const atMs = now();
-    if (!shouldContinue()) {
-      return {
-        ready: false,
-        cancelled: true,
-        attempts,
-        at_ms: atMs,
-        duration_ms: atMs - startedAtMs,
-        precision_ms: intervalMs,
-      };
-    }
-    if (ready) {
-      return {
-        ready: true,
-        attempts,
-        at_ms: atMs,
-        duration_ms: atMs - startedAtMs,
-        precision_ms: intervalMs,
-      };
-    }
-    const elapsed = now() - startedAtMs;
-    if (elapsed >= timeoutMs) break;
-    await sleep(Math.min(intervalMs, timeoutMs - elapsed));
-  }
-
-  const atMs = now();
-  return {
-    ready: false,
-    attempts,
-    at_ms: atMs,
-    duration_ms: atMs - startedAtMs,
-    precision_ms: intervalMs,
-  };
-}
-
-module.exports = {
-  buildListeningPortLookupArgs,
-  createPreviewPhaseReporter,
-  normalizeTcpPort,
-  parseTscWatchSummary,
-  resolvePreviewServerCommand,
-  waitForTcpReady,
-};