pgserve 1.1.3-rc.4 → 1.1.3-rc.7

package/.github/workflows/build-all-platforms.yml

@@ -43,26 +43,16 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # Linux/macOS: cross-compile on ubuntu (faster)
-          - target: bun-linux-x64
-            platform: linux-x64
+          # Linux x64
+          - platform: linux-x64
             output: pgserve-linux-x64
             os: ubuntu-latest
-          - target: bun-linux-arm64
-            platform: linux-arm64
-            output: pgserve-linux-arm64
-            os: ubuntu-latest
-          - target: bun-darwin-x64
-            platform: darwin-x64
-            output: pgserve-darwin-x64
-            os: ubuntu-latest
-          - target: bun-darwin-arm64
-            platform: darwin-arm64
+          # macOS ARM64 (Apple Silicon)
+          - platform: darwin-arm64
             output: pgserve-darwin-arm64
-            os: ubuntu-latest
-          # Windows: native build required for --windows-icon
-          - target: bun-windows-x64
-            platform: windows-x64
+            os: macos-latest
+          # Windows x64 - must build on Windows for --windows-icon
+          - platform: windows-x64
             output: pgserve-windows-x64.exe
             os: windows-latest
 
@@ -89,12 +79,12 @@ jobs:
           ls -lh dist/
         shell: bash
 
-      # Linux/macOS: cross-compile
+      # Linux/macOS: native build
       - name: Build for ${{ matrix.platform }}
         if: matrix.platform != 'windows-x64'
         run: |
           mkdir -p dist
-          bun build --compile --target=${{ matrix.target }} bin/pglite-server.js --outfile dist/${{ matrix.output }}
+          bun build --compile bin/pglite-server.js --outfile dist/${{ matrix.output }}
           ls -lh dist/
 
       - name: Upload artifact
@@ -147,7 +137,8 @@ jobs:
           ls -la dist/
 
           MISSING=""
-          for platform in linux-x64 linux-arm64 darwin-x64 darwin-arm64; do
+          # Supported platforms: linux-x64, darwin-arm64, windows-x64
+          for platform in linux-x64 darwin-arm64; do
             if [ ! -f "dist/pgserve-$platform" ]; then
               MISSING="$MISSING pgserve-$platform"
             fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgserve",
-  "version": "1.1.3-rc.4",
+  "version": "1.1.3-rc.7",
   "description": "Embedded PostgreSQL server with true concurrent connections - zero config, auto-provision databases",
   "main": "src/index.js",
   "type": "module",

package/src/postgres.js

@@ -13,11 +13,162 @@
  * - No locale dependency (works on any system)
  */
 
+/* global fetch, Bun */
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
 
+/**
+ * Get platform key for binary lookup (e.g., 'windows-x64', 'linux-x64', 'darwin-arm64')
+ * @returns {string} Platform key
+ */
+function getPlatformKey() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  if (platform === 'win32') return 'windows-x64';
+  if (platform === 'linux' && arch === 'x64') return 'linux-x64';
+  if (platform === 'darwin' && arch === 'arm64') return 'darwin-arm64';
+  if (platform === 'darwin' && arch === 'x64') return 'darwin-x64';
+  if (platform === 'linux' && arch === 'arm64') return 'linux-arm64';
+
+  throw new Error(`Unsupported platform: ${platform}-${arch}`);
+}
+
+/**
+ * Get the directory where extracted binaries are cached
+ * @returns {string} Cache directory path
+ */
+function getBinaryCacheDir() {
+  const platformKey = getPlatformKey();
+  return path.join(os.homedir(), '.pgserve', 'bin', platformKey);
+}
+
+/**
+ * Download and extract PostgreSQL binaries on first run.
+ * Downloads from npm registry (@embedded-postgres packages).
+ *
+ * @returns {Promise<string>} Path to extracted directory
+ */
+async function downloadPostgresBinaries() {
+  const platform = os.platform();
+  const cacheDir = getBinaryCacheDir();
+  const cacheBinDir = path.join(cacheDir, 'bin');
+  const initdbName = platform === 'win32' ? 'initdb.exe' : 'initdb';
+  const postgresName = platform === 'win32' ? 'postgres.exe' : 'postgres';
+
+  // Check if already downloaded
+  if (fs.existsSync(path.join(cacheBinDir, initdbName)) &&
+      fs.existsSync(path.join(cacheBinDir, postgresName))) {
+    return cacheDir;
+  }
+
+  const platformKey = getPlatformKey();
+  const pkgName = `@embedded-postgres/${platformKey}`;
+  const pkgVersion = '17.7.0-beta.15';
+
+  console.log(`[pgserve] PostgreSQL binaries not found.`);
+  console.log(`[pgserve] Downloading ${pkgName}@${pkgVersion}...`);
+
+  // Get tarball URL from npm registry
+  const registryUrl = `https://registry.npmjs.org/${pkgName}`;
+  const registryRes = await fetch(registryUrl);
+  if (!registryRes.ok) {
+    throw new Error(`Failed to fetch package info: ${registryRes.status}`);
+  }
+  const pkgInfo = await registryRes.json();
+  const tarballUrl = pkgInfo.versions[pkgVersion]?.dist?.tarball;
+
+  if (!tarballUrl) {
+    throw new Error(`Version ${pkgVersion} not found for ${pkgName}`);
+  }
+
+  // Download tarball
+  console.log(`[pgserve] Downloading from npm registry...`);
+  const tarballRes = await fetch(tarballUrl);
+  if (!tarballRes.ok) {
+    throw new Error(`Failed to download tarball: ${tarballRes.status}`);
+  }
+
+  const tarballBuffer = await tarballRes.arrayBuffer();
+  const tarballSize = (tarballBuffer.byteLength / 1024 / 1024).toFixed(1);
+  console.log(`[pgserve] Downloaded ${tarballSize} MB`);
+
+  // Create temp file for tarball
+  const tempDir = path.join(os.tmpdir(), `pgserve-download-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const tarballPath = path.join(tempDir, 'package.tgz');
+  fs.writeFileSync(tarballPath, Buffer.from(tarballBuffer));
+
+  // Extract tarball using tar (available on all platforms via bun/node)
+  console.log(`[pgserve] Extracting binaries...`);
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  // Use Bun.spawn for extraction
+  const extractProc = Bun.spawn(['tar', '-xzf', tarballPath, '-C', tempDir], {
+    stdout: 'pipe',
+    stderr: 'pipe'
+  });
+  await extractProc.exited;
+
+  // Copy native/* to cache dir
+  const nativeDir = path.join(tempDir, 'package', 'native');
+  if (!fs.existsSync(nativeDir)) {
+    throw new Error('Extracted package does not contain native/ directory');
+  }
+
+  // Copy files recursively
+  await copyDirRecursive(nativeDir, cacheDir);
+
+  // Make executables executable (Unix only)
+  if (platform !== 'win32') {
+    const binDir = path.join(cacheDir, 'bin');
+    if (fs.existsSync(binDir)) {
+      const files = fs.readdirSync(binDir);
+      for (const file of files) {
+        const filePath = path.join(binDir, file);
+        try {
+          fs.chmodSync(filePath, 0o755);
+        } catch {
+          // Ignore
+        }
+      }
+    }
+  }
+
+  // Cleanup temp
+  try {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+
+  console.log(`[pgserve] PostgreSQL binaries installed to ${cacheDir}`);
+  return cacheDir;
+}
+
+/**
+ * Recursively copy a directory
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ */
+async function copyDirRecursive(src, dest) {
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      await copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 /**
  * Ensure library symlinks exist in the lib directory.
  * The @embedded-postgres package ships versioned libraries but binaries look for soname versions.
@@ -94,10 +245,45 @@ function ensureLibrarySymlinks(libDir, platform) {
 }
 
 // Resolve binary paths from embedded-postgres platform packages
-function getBinaryPaths() {
+// Now async to support bundled binary extraction
+async function getBinaryPaths() {
   const platform = os.platform();
   const arch = os.arch();
+  const exeSuffix = platform === 'win32' ? '.exe' : '';
+
+  // Priority 1: Check extracted cache directory (standalone exe mode)
+  // This is where bundled binaries are extracted on first run
+  const cacheDir = getBinaryCacheDir();
+  const cacheBinDir = path.join(cacheDir, 'bin');
+  const cachedInitdb = path.join(cacheBinDir, 'initdb' + exeSuffix);
+  const cachedPostgres = path.join(cacheBinDir, 'postgres' + exeSuffix);
+
+  if (fs.existsSync(cachedInitdb) && fs.existsSync(cachedPostgres)) {
+    const libDir = path.join(cacheDir, 'lib');
+    if ((platform === 'linux' || platform === 'darwin') && fs.existsSync(libDir)) {
+      ensureLibrarySymlinks(libDir, platform);
+    }
+    return { initdb: cachedInitdb, postgres: cachedPostgres, binDir: cacheBinDir, libDir };
+  }
+
+  // Priority 2: Download binaries if not found (standalone exe mode)
+  // This downloads from npm registry on first run
+  const downloadedDir = await downloadPostgresBinaries();
+  if (downloadedDir) {
+    const downloadedBinDir = path.join(downloadedDir, 'bin');
+    const downloadedInitdb = path.join(downloadedBinDir, 'initdb' + exeSuffix);
+    const downloadedPostgres = path.join(downloadedBinDir, 'postgres' + exeSuffix);
+
+    if (fs.existsSync(downloadedInitdb) && fs.existsSync(downloadedPostgres)) {
+      const libDir = path.join(downloadedDir, 'lib');
+      if ((platform === 'linux' || platform === 'darwin') && fs.existsSync(libDir)) {
+        ensureLibrarySymlinks(libDir, platform);
+      }
+      return { initdb: downloadedInitdb, postgres: downloadedPostgres, binDir: downloadedBinDir, libDir };
+    }
+  }
 
+  // Priority 3: Find the package in node_modules (npm install case)
   let pkgName;
   if (platform === 'linux' && arch === 'x64') {
     pkgName = '@embedded-postgres/linux-x64';
@@ -111,7 +297,6 @@ function getBinaryPaths() {
     throw new Error(`Unsupported platform: ${platform}-${arch}`);
   }
 
-  // Find the package in node_modules (check multiple locations for npx/pnpm/npm compatibility)
   const possiblePaths = [
     path.join(process.cwd(), 'node_modules', pkgName, 'native', 'bin'),
     path.join(import.meta.dirname, '..', 'node_modules', pkgName, 'native', 'bin'),
@@ -120,8 +305,8 @@ function getBinaryPaths() {
   ];
 
   for (const binDir of possiblePaths) {
-    const initdb = path.join(binDir, platform === 'win32' ? 'initdb.exe' : 'initdb');
-    const postgres = path.join(binDir, platform === 'win32' ? 'postgres.exe' : 'postgres');
+    const initdb = path.join(binDir, 'initdb' + exeSuffix);
+    const postgres = path.join(binDir, 'postgres' + exeSuffix);
     if (fs.existsSync(initdb) && fs.existsSync(postgres)) {
       // Resolve the actual binary paths (handles symlinks from package managers)
       const realInitdb = fs.realpathSync(initdb);
@@ -237,8 +422,8 @@ export class PostgresManager {
    * Start the embedded PostgreSQL instance
    */
   async start() {
-    // Get binary paths
-    this.binaries = getBinaryPaths();
+    // Get binary paths (may extract bundled binaries on first run)
+    this.binaries = await getBinaryPaths();
 
     // Make binaries executable
     await fs.promises.chmod(this.binaries.initdb, '755');