apostrophe 4.29.0 → 4.30.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 4.30.0-alpha.1
+
+### Adds
+
+- Postgres and SQLite alpha release
+
 ## 4.29.0 (2026-04-15)
 
 ### Adds

package/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);
+  });
+};

package/claude-tools/minimal-hang-test.js

@@ -0,0 +1,28 @@
+// Minimal test to isolate what causes the hang.
+// Must reference the test/ directory as root for proper module resolution.
+const t = require('../test-lib/test.js');
+const path = require('path');
+
+// Fake a module object rooted in test/ like the real tests do
+const fakeModule = {
+  id: path.join(__dirname, '../test/fake'),
+  filename: path.join(__dirname, '../test/fake.js'),
+  paths: [path.join(__dirname, '../test/node_modules')]
+};
+
+describe('Minimal hang test', function() {
+  this.timeout(60000);
+  let apos;
+
+  after(async function() {
+    await t.destroy(apos);
+    console.log('after: destroy complete');
+  });
+
+  it('should create and use apos without hanging', async function() {
+    apos = await t.create({
+      root: fakeModule
+    });
+    console.log('apos created successfully');
+  });
+});

package/claude-tools/mongo-close-test.js

@@ -0,0 +1,11 @@
+// Test whether a MongoDB connection keeps the process alive after close()
+const mongoConnect = require('../../../packages/db-connect/lib/mongodb-connect');
+
+(async () => {
+  const uri = 'mongodb://localhost:27017/test_handle_leak';
+  console.log('Connecting...');
+  const client = await mongoConnect(uri);
+  console.log('Connected. Closing...');
+  await client.close();
+  console.log('Closed. Process should exit now if no leaked handles.');
+})();

package/claude-tools/stdin-ref-test.js

@@ -0,0 +1,14 @@
+// Check if process.stdin keeps the process alive
+// If this script hangs, stdin is ref'd. If it exits, stdin is unref'd.
+
+console.log(`stdin isTTY: ${process.stdin.isTTY}`);
+console.log(`stdin readableFlowing: ${process.stdin.readableFlowing}`);
+console.log(`stdin isPaused: ${process.stdin.isPaused()}`);
+
+// Check ref status
+if (typeof process.stdin.unref === 'function') {
+  console.log('stdin has unref method');
+}
+
+console.log('Waiting to see if process exits on its own...');
+// Don't do anything - just see if the process exits

package/eslint.config.js

@@ -7,7 +7,8 @@ module.exports = defineConfig([
     '**/blueimp/**/*.js',
     'test/public',
     'test/apos-build',
-    'coverage'
+    'coverage',
+    'claude-tools'
   ]),
   apostrophe
 ]);

package/modules/@apostrophecms/db/index.js

@@ -4,11 +4,12 @@
 //
 // ### `uri`
 //
-// The MongoDB connection URI. See the [MongoDB URI documentation](https://docs.mongodb.com/manual/reference/connection-string/).
+// The databse connection URI. See the [MongoDB URI documentation](https://docs.mongodb.com/manual/reference/connection-string/)
+// and the postgres documentation.
 //
 // ### `connect`
 //
-// If present, this object is passed on as options to MongoDB's "connect"
+// If present, this object is passed on as options to the database adapters "connect"
 // method, along with the uri. See the [MongoDB connect settings documentation](http://mongodb.github.io/node-mongodb-native/2.2/reference/connecting/connection-settings/).
 //
 // By default, Apostrophe sets options to retry lost connections forever,
@@ -20,9 +21,16 @@
 //
 // ### `client`
 //
-// An existing MongoDB connection (MongoClient) object. If present, it is used
+// An existing MongoDB-compatible client object. If present, it is used
 // and `uri`, `host`, `connect`, etc. are ignored.
 //
+// ### `adapters`
+//
+// An array of adapters, each of which must provide `name`, `connect(uri, options)`,
+// and `protocols` properties. `name` may be used to override a core adapter,
+// such as `postgres` or `mongodb`. `connect` must resolve to a client object
+// supporting a sufficient subset of the mongodb API.
+//
 // ### `versionCheck`
 //
 // If `true`, check to make sure the database does not belong to an
@@ -49,15 +57,15 @@
 // in your project. However you may find it easier to just use the
 // `client` option.
 
-const mongodbConnect = require('../../../lib/mongodb-connect');
-const escapeHost = require('../../../lib/escape-host');
+const dbConnect = require('@apostrophecms/db-connect');
+const escapeHost = require('../../../lib/escape-host.js');
 
 module.exports = {
   options: {
     versionCheck: true
   },
   async init(self) {
-    await self.connectToMongo();
+    await self.connectToDb();
     await self.versionCheck();
   },
   handlers(self) {
@@ -81,14 +89,12 @@ module.exports = {
   },
   methods(self) {
     return {
-      // Open the database connection. Always uses MongoClient with its
-      // sensible defaults. Builds a URI if necessary, so we can call it
-      // in a consistent way.
-      //
-      // One default we override: if the connection is lost, we keep
-      // attempting to reconnect forever. This is the most sensible behavior
-      // for a persistent process that requires MongoDB in order to operate.
-      async connectToMongo() {
+      // Connect to the database and sets self.apos.dbClient
+      // and self.apos.db. Builds a mongodb URI by default,
+      // accepting host, port, user, password and name options
+      // if present. More typically a URI is specified via
+      // APOS_DB_URI, or via APOS_MONGODB_URI for bc.
+      async connectToDb() {
         if (self.options.client) {
           // Reuse a single client connection http://mongodb.github.io/node-mongodb-native/2.2/api/Db.html#db
           self.apos.dbClient = self.options.client;
@@ -96,32 +102,67 @@ module.exports = {
           self.connectionReused = true;
           return;
         }
-        let uri = 'mongodb://';
-        if (process.env.APOS_MONGODB_URI) {
-          uri = process.env.APOS_MONGODB_URI;
+        let uri;
+        const viaEnv = process.env.APOS_DB_URI || process.env.APOS_MONGODB_URI;
+        if (viaEnv) {
+          uri = viaEnv;
         } else if (self.options.uri) {
           uri = self.options.uri;
         } else {
-          if (self.options.user) {
-            uri += self.options.user + ':' + self.options.password + '@';
-          }
-          if (!self.options.host) {
-            self.options.host = 'localhost';
-          }
-          if (!self.options.port) {
-            self.options.port = 27017;
+          const validAdapters = [ 'mongodb', 'sqlite', 'postgres', 'multipostgres' ];
+          const adapter = process.env.APOS_DEFAULT_DB_ADAPTER || self.options.defaultAdapter || 'mongodb';
+          if (!validAdapters.includes(adapter)) {
+            throw new Error(`Invalid defaultAdapter: "${adapter}". Must be one of: ${validAdapters.join(', ')}`);
           }
           if (!self.options.name) {
             self.options.name = self.apos.shortName;
           }
-          uri += escapeHost(self.options.host) + ':' + self.options.port + '/' + self.options.name;
+          if (adapter === 'sqlite') {
+            const path = require('path');
+            uri = `sqlite://${path.resolve(self.apos.rootDir, 'data', self.options.name + '.sqlite')}`;
+          } else {
+            const credentials = self.options.user
+              ? encodeURIComponent(self.options.user) + ':' + encodeURIComponent(self.options.password) + '@'
+              : '';
+            if (adapter === 'mongodb') {
+              if (!self.options.host) {
+                self.options.host = 'localhost';
+              }
+              if (!self.options.port) {
+                self.options.port = 27017;
+              }
+              uri = 'mongodb://' + credentials + escapeHost(self.options.host) + ':' + self.options.port + '/' + self.options.name;
+            } else {
+              // postgres or multipostgres
+              if (!self.options.host) {
+                self.options.host = 'localhost';
+              }
+              if (!self.options.port) {
+                self.options.port = 5432;
+              }
+              uri = adapter + '://' + credentials + escapeHost(self.options.host) + ':' + self.options.port + '/' + self.options.name;
+            }
+          }
         }
 
-        self.apos.dbClient = await mongodbConnect(uri, self.options.connect);
+        self.apos.dbClient = await dbConnect(uri, {
+          ...self.options.connect,
+          adapters: self.options.adapters
+        });
         self.uri = uri;
         // Automatically uses the db name in the connection string
         self.apos.db = self.apos.dbClient.db();
       },
+      // Connect to a database using the appropriate adapter based on the URI protocol.
+      // Returns a client object compatible with the MongoDB driver interface.
+      // This method has no side effects — it does not set apos.db or apos.dbClient.
+      // It can be used to make temporary connections, e.g. for dropping a test database.
+      async connectToAdapter(uri, options) {
+        return dbConnect(uri, {
+          ...options,
+          adapters: self.options.adapters
+        });
+      },
       async versionCheck() {
         if (!self.options.versionCheck) {
           return;

package/modules/@apostrophecms/http/index.js

@@ -2,7 +2,7 @@ const _ = require('lodash');
 const qs = require('qs');
 const fetch = require('node-fetch');
 const tough = require('tough-cookie');
-const escapeHost = require('../../../lib/escape-host');
+const escapeHost = require('../../../lib/escape-host.js');
 const util = require('util');
 
 module.exports = {

package/modules/@apostrophecms/job/index.js

@@ -244,7 +244,9 @@ module.exports = {
               },
               setTotal (n) {
                 total = n;
-                return self.setTotal(job, n);
+                const result = self.setTotal(job, n);
+                promises.push(result);
+                return result;
               },
               setResults (_results) {
                 results = _results;
@@ -412,12 +414,12 @@ module.exports = {
       //
       // No promise is returned as this method just updates
       // the job tracking information in the background.
-      setTotal(job, total) {
-        self.db.updateOne({ _id: job._id }, { $set: { total } }, function (err) {
-          if (err) {
-            self.apos.util.error(err);
-          }
-        });
+      async setTotal(job, total) {
+        try {
+          await self.db.updateOne({ _id: job._id }, { $set: { total } });
+        } catch (err) {
+          self.apos.util.error(err);
+        }
       },
       // Mark the given job as ended. If `success`
       // is true the job is reported as an overall

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apostrophe",
-  "version": "4.29.0",
+  "version": "4.30.0-alpha.1",
   "description": "The Apostrophe Content Management System.",
   "main": "index.js",
   "repository": {
@@ -117,33 +117,33 @@
     "webpack": "^5.106.1",
     "webpack-merge": "^5.7.3",
     "xregexp": "^2.0.0",
-    "@apostrophecms/emulate-mongo-3-driver": "^1.0.6",
-    "express-cache-on-demand": "^1.0.4",
+    "@apostrophecms/db-connect": "^1.0.0-alpha.1",
     "broadband": "^1.1.0",
-    "boring": "^1.1.1",
-    "oembetter": "^1.1.4",
     "postcss-viewport-to-container-toggle": "^2.3.0",
+    "sanitize-html": "^2.17.3",
+    "oembetter": "^1.1.4",
     "uploadfs": "^1.26.1",
-    "sanitize-html": "^2.17.3"
+    "express-cache-on-demand": "^1.0.4",
+    "boring": "^1.1.1"
   },
   "devDependencies": {
+    "chai": "^4.3.10",
     "eslint": "^9.39.1",
     "form-data": "^4.0.4",
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
     "stylelint": "^16.5.0",
-    "stylelint-config-apostrophe": "^4.4.0",
-    "eslint-config-apostrophe": "^6.0.2"
+    "eslint-config-apostrophe": "^6.0.2",
+    "stylelint-config-apostrophe": "^4.4.0"
   },
   "browserslist": [
     "ie >= 10"
   ],
   "scripts": {
     "pretest": "npm run lint",
-    "test": "npm run test:base && npm run test:missing && npm run test:assets && npm run test:esm",
-    "test:base": "nyc mocha -t 10000 --ignore=test/assets.js",
+    "test": "npm run test:base && npm run test:missing && npm run test:esm",
+    "test:base": "nyc mocha -t 10000",
     "test:missing": "nyc mocha -t 10000 test/add-missing-schema-fields-project/test.js",
-    "test:assets": "nyc mocha -t 10000 test/assets.js",
     "test:esm": "mocha -t 1000 test/esm-project/esm.js",
     "eslint": "eslint .",
     "eslint-fix": "npm run eslint -- --fix",

package/test/add-missing-schema-fields-project/test.js

@@ -11,10 +11,18 @@ describe('Apostrophe - add-missing-schema-fields task', function() {
 
   let apos;
 
+  // When APOS_TEST_DB_PROTOCOL is set, child processes that run `node app.js`
+  // need the matching APOS_DB_URI so they use the same database as t.create()
+  const projectCwd = path.resolve(process.cwd(), 'test/add-missing-schema-fields-project/');
+  const testDbUri = t.getTestDbUri('add-missing-schema-fields-project');
+  const execEnv = testDbUri
+    ? { env: { ...process.env, APOS_DB_URI: testDbUri } }
+    : {};
+
   before(async function() {
     await util.promisify(exec)(
       'npm install',
-      { cwd: path.resolve(process.cwd(), 'test/add-missing-schema-fields-project/') }
+      { cwd: projectCwd }
     );
   });
 
@@ -25,7 +33,7 @@ describe('Apostrophe - add-missing-schema-fields task', function() {
   it('should not run migrations when running the task', async function() {
     await util.promisify(exec)(
       'node app.js @apostrophecms/migration:add-missing-schema-fields',
-      { cwd: path.resolve(process.cwd(), 'test/add-missing-schema-fields-project/') }
+      { cwd: projectCwd, ...execEnv }
     );
 
     apos = await t.create({
@@ -64,7 +72,7 @@ describe('Apostrophe - add-missing-schema-fields task', function() {
   it('should run migrations when running @apostrophecms/migration:migrate task', async function() {
     await util.promisify(exec)(
       'node app.js @apostrophecms/migration:migrate',
-      { cwd: path.resolve(process.cwd(), 'test/add-missing-schema-fields-project/') }
+      { cwd: projectCwd, ...execEnv }
     );
 
     apos = await t.create({