@9apes/cli 0.1.0

package/src/vite-plugin.ts

@@ -0,0 +1,160 @@
+import path from 'path';
+import pLimit from 'p-limit';
+import { injectDebugIdIntoFile, injectDebugIdIntoMapFile } from './inject.js';
+import {
+  generateDebugId,
+  getDebugIdSnippet,
+  getGitCommitHash,
+  scanForJavaScriptFiles,
+  validateDirectoryPath,
+} from './sourcemap.js';
+import { uploadFile, type UploadError } from './upload.js';
+
+export interface NineapesSourcemapsOptions {
+  projectId: string;
+  apiKey: string;
+  baseUrl?: string;
+  releaseVersion?: string;
+}
+
+const DEFAULT_BASE_URL = 'https://dev.nineapes.com/api/v1';
+
+interface BuildConfigLike {
+  outDir: string;
+}
+
+interface ResolvedConfigLike {
+  root: string;
+  build: BuildConfigLike;
+}
+
+interface VitePluginLike {
+  name: string;
+  apply?: 'build';
+  configResolved?: (config: ResolvedConfigLike) => void;
+  closeBundle?: () => Promise<void>;
+}
+
+export function withNineapesSourcemaps(options: NineapesSourcemapsOptions): VitePluginLike {
+  let resolvedConfig: ResolvedConfigLike | null = null;
+
+  return {
+    name: 'nineapes-sourcemaps',
+    apply: 'build',
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async closeBundle() {
+      if (!resolvedConfig) {
+        throw new Error('Vite config is not resolved');
+      }
+
+      const outDir = path.resolve(resolvedConfig.root, resolvedConfig.build.outDir);
+      const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+
+      console.log(`[nineapes-sourcemaps] Processing output directory: ${outDir}`);
+
+      const resolvedPath = await validateDirectoryPath(outDir);
+      const [filePairs, commitHash] = await Promise.all([
+        scanForJavaScriptFiles(resolvedPath),
+        getGitCommitHash(resolvedPath),
+      ]);
+
+      if (filePairs.length === 0) {
+        console.log('[nineapes-sourcemaps] No JavaScript files found, skipping sourcemap upload');
+        return;
+      }
+
+      const totalUploadCount = filePairs.reduce((count, pair) => {
+        return count + 1 + (pair.mapFile ? 1 : 0);
+      }, 0);
+
+      const injectLimiter = pLimit(15);
+      const uploadLimiter = pLimit(10);
+
+      let injectCompleted = 0;
+      let injectFailed = 0;
+      let uploadCompleted = 0;
+      let uploadFailed = 0;
+      const uploadPromises: Promise<UploadError[]>[] = [];
+
+      const injectionResults = await Promise.allSettled(
+        filePairs.map((filePair) =>
+          injectLimiter(async () => {
+            const debugId = generateDebugId();
+
+            await Promise.all([
+              injectDebugIdIntoFile(filePair.jsFile, getDebugIdSnippet(debugId), debugId),
+              injectDebugIdIntoMapFile(filePair.mapFile, debugId),
+            ]);
+
+            injectCompleted++;
+
+            const uploadPromise = uploadLimiter(async () =>
+              uploadFile(
+                filePair,
+                debugId,
+                { apiKey: options.apiKey },
+                options.projectId,
+                baseUrl,
+                options.releaseVersion,
+                commitHash,
+                (success) => {
+                  if (success) {
+                    uploadCompleted++;
+                  } else {
+                    uploadFailed++;
+                  }
+                }
+              )
+            );
+
+            uploadPromises.push(uploadPromise);
+          })
+        )
+      );
+
+      const injectionErrors: string[] = [];
+      for (const result of injectionResults) {
+        if (result.status === 'rejected') {
+          injectFailed++;
+          const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+          injectionErrors.push(message);
+        }
+      }
+
+      if (injectionErrors.length > 0) {
+        throw new Error(
+          `[nineapes-sourcemaps] Injection failed for ${injectFailed} file(s): ${injectionErrors.join('\n')}`
+        );
+      }
+
+      const uploadResults = await Promise.allSettled(uploadPromises);
+      const uploadErrors: UploadError[] = [];
+      for (const result of uploadResults) {
+        if (result.status === 'fulfilled') {
+          uploadErrors.push(...result.value);
+        } else {
+          uploadErrors.push({
+            fileName: 'unknown',
+            errorMessage: result.reason instanceof Error ? result.reason.message : String(result.reason),
+          });
+        }
+      }
+
+      if (uploadErrors.length > 0) {
+        const formattedErrors = uploadErrors
+          .map((error) => {
+            const code = error.statusCode ? ` status=${error.statusCode}` : '';
+            return `- ${error.fileName}${code}: ${error.errorMessage}`;
+          })
+          .join('\n');
+        throw new Error(`[nineapes-sourcemaps] Upload failed:\n${formattedErrors}`);
+      }
+
+      console.log(
+        `[nineapes-sourcemaps] Done. Injected ${injectCompleted} file pair(s), uploaded ${uploadCompleted}/${totalUploadCount} file(s)`
+      );
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "nodenext",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": false,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "moduleResolution": "nodenext",
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}