Postgres

.github/workflows/monorepo.yml

@@ -7,6 +7,7 @@ env:
   NODE_VERSIONS_JSON: "[20,22,24]"
   MONGODB_VERSIONS_JSON: '["7","8"]'
   REDIS_VERSION: "7"
+  POSTGRES_VERSION: "16"
 
 on:
   push:
@@ -124,7 +125,7 @@ jobs:
         run: |
           month='${{ steps.cache-month.outputs.value }}'
           mongo_suffix=$(jq -r '.[]' <<< '${{ env.MONGODB_VERSIONS_JSON }}' | paste -sd'-' -)
-          echo "key=docker-images-${month}-mongo${mongo_suffix}-redis${{ env.REDIS_VERSION }}" >> "$GITHUB_OUTPUT"
+          echo "key=docker-images-${month}-mongo${mongo_suffix}-redis${{ env.REDIS_VERSION }}-pg${{ env.POSTGRES_VERSION }}" >> "$GITHUB_OUTPUT"
 
       - name: Restore docker image cache
         id: docker-cache
@@ -143,6 +144,8 @@ jobs:
           done
           docker pull "redis:${{ env.REDIS_VERSION }}"
           docker save "redis:${{ env.REDIS_VERSION }}" -o ".github/docker-cache/redis-${{ env.REDIS_VERSION }}.tar"
+          docker pull "postgres:${{ env.POSTGRES_VERSION }}"
+          docker save "postgres:${{ env.POSTGRES_VERSION }}" -o ".github/docker-cache/postgres-${{ env.POSTGRES_VERSION }}.tar"
 
   warm-sharp-cache:
     name: Warm sharp/libvips cache (Node ${{ matrix.nodeVersion }})
@@ -216,7 +219,7 @@ jobs:
           du -sh ~/.npm/_libvips || true
 
   package-tests:
-    name: ${{ format('{0} ({1}, {2})', matrix.package, matrix.nodeVersion, matrix.needsMongo && matrix.mongodbVersion || 'n/a') }}
+    name: ${{ format('{0} ({1}, {2}{3})', matrix.group, matrix.nodeVersion, matrix.adapter || 'n/a', matrix.needsMongo && format(' mongo {0}', matrix.mongodbVersion) || '') }}
     needs:
       - setup
       - shared-runtime
@@ -279,7 +282,7 @@ jobs:
       - name: Restore docker image cache
         id: docker-cache-restore
         uses: actions/cache/restore@v4
-        if: matrix.needsMongo || matrix.needsRedis
+        if: matrix.needsMongo || matrix.needsRedis || matrix.needsPostgres
         with:
           path: .github/docker-cache
           key: ${{ needs.shared-runtime.outputs.docker-cache-key }}
@@ -300,6 +303,14 @@ jobs:
         if: steps.docker-cache-restore.outputs.cache-hit != 'true' && matrix.needsRedis
         run: docker pull redis:${{ env.REDIS_VERSION }}
 
+      - name: Load cached Postgres image
+        if: steps.docker-cache-restore.outputs.cache-hit == 'true' && matrix.needsPostgres
+        run: docker load -i ".github/docker-cache/postgres-${{ env.POSTGRES_VERSION }}.tar"
+
+      - name: Pull Postgres image (cache miss)
+        if: steps.docker-cache-restore.outputs.cache-hit != 'true' && matrix.needsPostgres
+        run: docker pull postgres:${{ env.POSTGRES_VERSION }}
+
       - name: Start MongoDB
         if: matrix.needsMongo
         run: |
@@ -358,15 +369,64 @@ jobs:
           docker logs redis
           exit 1
 
+      - name: Start PostgreSQL
+        if: matrix.needsPostgres
+        run: |
+          docker rm -f postgres >/dev/null 2>&1 || true
+          docker run -d \
+            --name postgres \
+            --publish 5432:5432 \
+            -e POSTGRES_HOST_AUTH_METHOD=trust \
+            --health-cmd "pg_isready -U postgres" \
+            --health-interval 5s \
+            --health-timeout 5s \
+            --health-retries 12 \
+            postgres:${{ env.POSTGRES_VERSION }}
+          echo "Waiting for PostgreSQL to report healthy..."
+          for attempt in $(seq 1 60); do
+            status=$(docker inspect --format='{{.State.Health.Status}}' postgres 2>/dev/null || echo "starting")
+            if [ "$status" = "healthy" ]; then
+              exit 0
+            fi
+            if [ "$status" = "unhealthy" ]; then
+              echo "PostgreSQL reported unhealthy" >&2
+              docker logs postgres
+              exit 1
+            fi
+            sleep 2
+          done
+          echo "PostgreSQL failed to become healthy in time" >&2
+          docker logs postgres
+          exit 1
+
       - name: Install workspace dependencies
         run: pnpm install --frozen-lockfile
 
       - name: Run package tests
-        run: pnpm run --filter "${{ matrix.package }}" --if-present test
+        run: |
+          failed=0
+          for pkg in $(echo '${{ matrix.packages }}' | jq -r '.[]'); do
+            echo "::group::Testing $pkg"
+            if ! pnpm run --filter "$pkg" --if-present test; then
+              echo "::error::Tests failed for $pkg"
+              failed=1
+            fi
+            echo "::endgroup::"
+          done
+          exit $failed
         env:
           CI: true
           # Yes we want import-export to test with automatic-translation
           TEST_WITH_PRO: "1"
+          # Adapter selection: mongodb (default), postgres, or sqlite.
+          # ADAPTER is used by db-connect tests, APOS_TEST_DB_PROTOCOL by apostrophe tests.
+          ADAPTER: ${{ matrix.adapter }}
+          APOS_TEST_DB_PROTOCOL: ${{ matrix.adapter }}
+          PGUSER: postgres
+
+      - name: Stop PostgreSQL
+        if: always() && matrix.needsPostgres
+        run: docker rm -f postgres || true
 
       - name: Stop Redis
         if: always() && matrix.needsRedis

.github/workflows/scripts/detect-impacted-packages.mjs

@@ -73,7 +73,8 @@ async function main() {
       package: name,
       directory: packages.get(name).relativeDir,
       requiresMongo: packages.get(name).requiresMongo !== false,
-      requiresRedis: packages.get(name).requiresRedis === true
+      requiresRedis: packages.get(name).requiresRedis === true,
+      mongodbOnly: packages.get(name).mongodbOnly === true
     }))
   };
 
@@ -130,14 +131,16 @@ async function loadPackages() {
       const testConfig = manifest.apostropheTestConfig || {};
       const requiresMongo = testConfig.requiresMongo !== false;
       const requiresRedis = testConfig.requiresRedis === true;
+      const mongodbOnly = testConfig.mongodbOnly === true;
 
       map.set(manifest.name, {
         name: manifest.name,
         relativeDir: path.posix.join('packages', entry.name),
         dependencies,
         hasTestScript,
         requiresMongo,
-        requiresRedis
+        requiresRedis,
+        mongodbOnly
       });
     }));
 

.github/workflows/scripts/expand-runtime-matrix.mjs

@@ -1,6 +1,21 @@
 #!/usr/bin/env node
-// Expands the impacted package matrix with runtime permutations supplied 
+// Expands the impacted package matrix with runtime permutations supplied
 // via env vars.
+//
+// Packages are grouped into jobs to stay within GitHub's 256-entry matrix limit:
+//   - "apostrophe" runs solo (the main package, benefits from its own status).
+//   - All other database packages are grouped into an "ecosystem" job.
+//   - mongodbOnly packages are grouped into "ecosystem-mongodb".
+//   - Non-database packages are grouped into "standalone".
+//
+// For groups that need a database, three adapter variants are emitted:
+//   1. mongodb  – all Node versions × all MongoDB versions
+//   2. postgres – latest LTS Node only, no MongoDB
+//   3. sqlite   – latest LTS Node only, no MongoDB
+//
+// The latest LTS Node version is the highest even-numbered entry in
+// NODE_VERSIONS_JSON.
+
 import { readFile } from 'fs/promises';
 
 const args = process.argv.slice(2);
@@ -36,25 +51,120 @@ function parseJsonArray(name, raw) {
 const nodeVersions = parseJsonArray('NODE_VERSIONS_JSON', process.env.NODE_VERSIONS_JSON);
 const mongodbVersions = parseJsonArray('MONGODB_VERSIONS_JSON', process.env.MONGODB_VERSIONS_JSON);
 
+// Latest LTS = highest even-numbered Node version
+const latestLts = [...nodeVersions]
+  .filter((v) => Number(v) % 2 === 0)
+  .sort((a, b) => Number(b) - Number(a))[0];
+
 const impact = JSON.parse(await readFile(impactPath, 'utf8'));
 const packages = impact?.matrix?.include || [];
-const include = [];
+
+// The main apostrophe package always gets its own jobs for clear CI status.
+const SOLO_PACKAGES = new Set(['apostrophe']);
+
+// Sort packages into groups
+const solo = [];
+const ecosystem = [];
+const ecosystemMongodbOnly = [];
+const standalone = [];
 
 for (const pkg of packages) {
-  const needsMongo = pkg.requiresMongo !== false;
-  const needsRedis = pkg.requiresRedis === true;
-  const mongoTargets = needsMongo ? mongodbVersions : [''];
+  const needsDb = pkg.requiresMongo !== false;
+  if (SOLO_PACKAGES.has(pkg.package)) {
+    solo.push(pkg);
+  } else if (needsDb && pkg.mongodbOnly) {
+    ecosystemMongodbOnly.push(pkg);
+  } else if (needsDb) {
+    ecosystem.push(pkg);
+  } else {
+    standalone.push(pkg);
+  }
+}
+
+const include = [];
+
+// Emit runtime combinations for a group of packages.
+function emitGroup(group, pkgs) {
+  if (!pkgs.length) {
+    return;
+  }
+  const packageNames = JSON.stringify(pkgs.map((p) => p.package));
+  const needsRedis = pkgs.some((p) => p.requiresRedis === true);
+  const mongodbOnly = pkgs.every((p) => p.mongodbOnly);
+
+  // mongodb: all Node versions × all MongoDB versions
   for (const nodeVersion of nodeVersions) {
-    for (const mongodbVersion of mongoTargets) {
+    for (const mongodbVersion of mongodbVersions) {
       include.push({
-        ...pkg,
+        group,
+        packages: packageNames,
         nodeVersion,
         mongodbVersion,
-        needsMongo,
+        adapter: 'mongodb',
+        needsMongo: true,
+        needsPostgres: false,
         needsRedis
       });
     }
   }
+  // postgres and sqlite: latest LTS only, skip for mongodb-only groups
+  if (!mongodbOnly) {
+    include.push({
+      group,
+      packages: packageNames,
+      nodeVersion: latestLts,
+      mongodbVersion: '',
+      adapter: 'postgres',
+      needsMongo: false,
+      needsPostgres: true,
+      needsRedis
+    });
+    include.push({
+      group,
+      packages: packageNames,
+      nodeVersion: latestLts,
+      mongodbVersion: '',
+      adapter: 'sqlite',
+      needsMongo: false,
+      needsPostgres: false,
+      needsRedis
+    });
+  }
+}
+
+// Emit non-database group (no adapter variants, just Node versions)
+function emitStandalone(group, pkgs) {
+  if (!pkgs.length) {
+    return;
+  }
+  const packageNames = JSON.stringify(pkgs.map((p) => p.package));
+  for (const nodeVersion of nodeVersions) {
+    include.push({
+      group,
+      packages: packageNames,
+      nodeVersion,
+      mongodbVersion: '',
+      adapter: '',
+      needsMongo: false,
+      needsPostgres: false,
+      needsRedis: false
+    });
+  }
+}
+
+// Solo packages each get their own group
+for (const pkg of solo) {
+  emitGroup(pkg.package, [pkg]);
+}
+
+if (ecosystem.length) {
+  emitGroup('ecosystem', ecosystem);
+}
+if (ecosystemMongodbOnly.length) {
+  emitGroup('ecosystem-mongodb', ecosystemMongodbOnly);
+}
+if (standalone.length) {
+  emitStandalone('standalone', standalone);
 }
 
 process.stdout.write(JSON.stringify({ include }));

package.json

@@ -5,7 +5,8 @@
     "dev": "pnpm --parallel --recursive run dev",
     "build": "pnpm --recursive run build",
     "lint": "pnpm --recursive run lint",
-    "test": "pnpm --recursive run test",
+    "test": "APOS_TEST_DB_PROTOCOL=postgres npm run test:main && APOS_TEST_DB_PROTOCOL=mongodb npm run test:main && APOS_TEST_DB_PROTOCOL=sqlite npm run test:main && APOS_TEST_DB_PROTOCOL=multipostgres npm run test:main",
+    "test:main": "echo \"APOS_TEST_DB_PROTOCOL IS: $APOS_TEST_DB_PROTOCOL\" && pnpm --recursive run test",
     "eslint": "pnpm --recursive run eslint",
     "mocha": "pnpm --recursive run mocha",
     "clean": "pnpm -r exec rm -rf node_modules && rm -rf node_modules && rm pnpm-lock.yaml"
@@ -18,6 +19,7 @@
   },
   "pnpm": {
     "onlyBuiltDependencies": [
+      "better-sqlite3",
       "sharp",
       "vue-demi",
       "@parcel/watcher",

packages/apostrophe/.gitignore

@@ -42,3 +42,6 @@ test/public/uploads
 
 # vim swp files
 .*.sw*
+
+# claude-tools log files
+claude-tools/**/*.log

packages/apostrophe/claude-tools/detect-handles.js

@@ -0,0 +1,46 @@
+// Require this before running mocha to detect what activates process.stdin
+// Usage: npx mocha -t 10000 --require ./claude-tools/detect-handles.js test/assets.js
+
+console.log(`stdin paused at startup: ${process.stdin.isPaused()}`);
+console.log(`stdin readableFlowing at startup: ${process.stdin.readableFlowing}`);
+
+// Monkey-patch stdin.resume to capture the call stack
+const origResume = process.stdin.resume.bind(process.stdin);
+process.stdin.resume = function(...args) {
+  console.log('\n=== process.stdin.resume() called ===');
+  console.log(new Error().stack);
+  return origResume(...args);
+};
+
+// Monkey-patch stdin.on to detect 'data' listener additions
+const origOn = process.stdin.on.bind(process.stdin);
+process.stdin.on = function(event, ...args) {
+  if (event === 'data' || event === 'readable') {
+    console.log(`\n=== process.stdin.on('${event}') called ===`);
+    console.log(new Error().stack);
+  }
+  return origOn(event, ...args);
+};
+
+// Periodically check stdin state changes
+let lastState = process.stdin.readableFlowing;
+const checker = setInterval(() => {
+  if (process.stdin.readableFlowing !== lastState) {
+    console.log(`\n=== stdin readableFlowing changed: ${lastState} -> ${process.stdin.readableFlowing} ===`);
+    console.log(new Error().stack);
+    lastState = process.stdin.readableFlowing;
+  }
+}, 100);
+checker.unref();
+
+const origRun = require('mocha/lib/runner').prototype.run;
+require('mocha/lib/runner').prototype.run = function(fn) {
+  return origRun.call(this, function(failures) {
+    console.log(`\nstdin paused at end: ${process.stdin.isPaused()}`);
+    console.log(`stdin readableFlowing at end: ${process.stdin.readableFlowing}`);
+    setTimeout(() => {
+      process.exit(failures ? 3 : 0);
+    }, 2000);
+    if (fn) fn(failures);
+  });
+};