apostrophe 4.30.0 → 4.31.0-alpha.1

package/test/templates-jsx.js

@@ -0,0 +1,537 @@
+const t = require('../test-lib/test.js');
+const assert = require('assert/strict');
+
+describe('Templates: JSX', function() {
+
+  let apos;
+
+  this.timeout(t.timeout);
+
+  after(async function() {
+    return t.destroy(apos);
+  });
+
+  before(async function() {
+    apos = await t.create({
+      root: module,
+      modules: {
+        'express-test': {},
+        'template-jsx-test': {
+          options: {
+            ignoreNoCodeWarning: true
+          }
+        },
+        'template-jsx-subclass-test': {
+          options: {
+            ignoreNoCodeWarning: true
+          }
+        },
+        'template-jsx-options-test': {},
+        'jsx-component-test': {},
+        'jsx-bridge-test': {
+          options: {
+            ignoreNoCodeWarning: true
+          }
+        },
+        'jsx-mixed-test': {},
+        'jsx-area-test': {},
+        'jsx-async-widget': {},
+        'jsx-ctx-widget': {}
+      }
+    });
+  });
+
+  // ---- Equivalents of the existing Nunjucks template tests ----
+
+  it('should render a JSX template relative to a module', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'test', { age: 50 });
+    assert.equal(result.trim(), '<h1>50</h1>');
+  });
+
+  it('should respect templateData at module level for JSX templates', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'test');
+    assert.equal(result.trim(), '<h1>30</h1>');
+  });
+
+  it('should respect JSX template overrides in subclasses', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-subclass-test'].render(req, 'override-test');
+    assert.equal(result.trim(), '<h1>I am overridden</h1>');
+  });
+
+  it('should inherit JSX templates in the absence of overrides', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-subclass-test'].render(req, 'inherit-test');
+    assert.equal(result.trim(), '<h1>I am inherited</h1>');
+  });
+
+  it('should expose module options and helpers to JSX via the helpers second argument', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-options-test'].render(req, 'options-test');
+    assert.match(result, /nifty/);
+    assert.match(result, /\b4\b/);
+  });
+
+  // ---- Auto-escape and dangerouslySetInnerHTML ----
+
+  it('should auto-escape strings in element bodies', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'escape-body', {
+      html: '<script>alert("xss")</script>'
+    });
+    assert.match(result, /&lt;script&gt;alert\("xss"\)&lt;\/script&gt;/);
+    assert.doesNotMatch(result, /<script>/i);
+  });
+
+  it('should auto-escape attribute values, including quotes', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'escape-attr', {
+      url: 'javascript:alert("hi")',
+      title: 'evil "quotes" & <tags>'
+    });
+    assert.match(result, /href="javascript:alert\(&quot;hi&quot;\)"/);
+    assert.match(result, /title="evil &quot;quotes&quot; &amp; &lt;tags&gt;"/);
+  });
+
+  it('should emit raw HTML via dangerouslySetInnerHTML without escaping', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'dangerously-set', {
+      html: '<strong>raw</strong> & <em>html</em>'
+    });
+    assert.match(result, /<strong>raw<\/strong> & <em>html<\/em>/);
+  });
+
+  it('should rewrite className to class and htmlFor to for', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'class-and-for');
+    assert.match(result, /class="form-label"/);
+    assert.match(result, /for="username"/);
+    assert.doesNotMatch(result, /className=/);
+    assert.doesNotMatch(result, /htmlFor=/);
+  });
+
+  it('should rewrite camelCase SVG presentation attrs to kebab-case', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'svg-attrs');
+    // Kebab-case conversions
+    assert.match(result, /stroke-width="2"/);
+    assert.match(result, /stroke-linecap="round"/);
+    assert.match(result, /stroke-linejoin="round"/);
+    assert.match(result, /stroke-dasharray="4 2"/);
+    assert.match(result, /stroke-opacity="0.5"/);
+    assert.match(result, /fill-rule="evenodd"/);
+    assert.match(result, /clip-rule="evenodd"/);
+    assert.match(result, /pointer-events="none"/);
+    assert.match(result, /text-anchor="middle"/);
+    // Native camelCase preserved
+    assert.match(result, /viewBox="0 0 24 24"/);
+    assert.match(result, /preserveAspectRatio="xMidYMid meet"/);
+    // No camelCase forms leaked through
+    assert.doesNotMatch(result, /strokeWidth=/);
+    assert.doesNotMatch(result, /fillRule=/);
+  });
+
+  it('should self-close void elements', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'void-elements');
+    assert.match(result, /<hr \/>/);
+    assert.match(result, /<input type="text" name="email" \/>/);
+    assert.match(result, /<br \/>/);
+  });
+
+  it('should handle boolean attributes and skip null/undefined/false attribute values', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'boolean-attrs');
+    assert.match(result, /<input/);
+    assert.match(result, / checked/);
+    assert.doesNotMatch(result, /checked="true"/);
+    assert.doesNotMatch(result, /disabled/);
+    assert.doesNotMatch(result, /data-extra/);
+    assert.doesNotMatch(result, /data-undefined/);
+  });
+
+  it('should render arrays of nodes (e.g. lists from .map())', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['template-jsx-test'].render(req, 'list', {
+      items: [ 'a', 'b', 'c' ]
+    });
+    assert.match(result, /<ul>/);
+    assert.match(result, /<li>a<\/li>/);
+    assert.match(result, /<li>b<\/li>/);
+    assert.match(result, /<li>c<\/li>/);
+  });
+
+  // ---- Async <Component> ----
+
+  it('should await async components inline within JSX', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-component-test'].render(req, 'uses-component', {
+      name: 'World'
+    });
+    assert.match(result, /<section>/);
+    assert.match(result, /<h1>Welcome<\/h1>/);
+    assert.match(
+      result,
+      /<span class="greet">Hello World \(after delay\)<\/span>/
+    );
+  });
+
+  // ---- <Area> ----
+
+  it('should render a doc area inline via the Area helper', async function() {
+    const req = apos.task.getAnonReq();
+    const piece = {
+      _id: 'jsx-area-piece-1',
+      metaType: 'doc',
+      type: 'jsx-area-test',
+      title: 'Area Host',
+      slug: 'area-host',
+      main: {
+        _id: 'jsx-area-1',
+        metaType: 'area',
+        items: [
+          {
+            _id: 'jsx-area-widget-1',
+            metaType: 'widget',
+            type: '@apostrophecms/rich-text',
+            content: '<p>area body</p>'
+          }
+        ]
+      }
+    };
+    const result = await apos.modules['jsx-area-test'].render(req, 'with-area', { piece });
+    assert.match(result, /<main>/);
+    assert.match(result, /class="apos-area"/);
+    assert.match(result, /<div data-rich-text>/);
+    assert.match(result, /<p>area body<\/p>/);
+  });
+
+  it('Area helper should reject calls with a missing or invalid name', async function() {
+    const req = apos.task.getAnonReq();
+    const piece = {
+      _id: 'jsx-area-piece-2',
+      metaType: 'doc',
+      type: 'jsx-area-test',
+      title: 'Bad Area',
+      slug: 'bad-area',
+      // No `nope` field exists in the schema
+      nope: {
+        _id: 'jsx-area-nope-1',
+        metaType: 'area',
+        items: []
+      }
+    };
+    let caught;
+    try {
+      await apos.modules['jsx-area-test'].render(req, 'bad-area', { piece });
+    } catch (e) {
+      caught = e;
+    }
+    assert(caught, 'expected the render to throw');
+    assert.match(caught.message, /no field named nope/);
+  });
+
+  // ---- <Widget> ----
+
+  it('should render a single widget via the Widget helper', async function() {
+    const req = apos.task.getAnonReq();
+    const widget = {
+      _id: 'jsx-widget-direct-1',
+      metaType: 'widget',
+      type: '@apostrophecms/rich-text',
+      content: '<p>just a widget</p>'
+    };
+    const result = await apos.modules['jsx-area-test'].render(req, 'with-widget', { widget });
+    assert.match(result, /<section class="wrapper">/);
+    assert.match(result, /<div data-rich-text>/);
+    assert.match(result, /<p>just a widget<\/p>/);
+    // Widget should NOT add the surrounding apos-area wrapper.
+    assert.doesNotMatch(result, /class="apos-area"/);
+  });
+
+  it('Widget helper should silently skip a null widget', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-area-test'].render(req, 'with-widget', { widget: null });
+    assert.match(result, /<section class="wrapper"><\/section>/);
+  });
+
+  // ---- `with={...}` context options on Area and Widget ----
+
+  it('Area should pass `with={...}` context options through to the widget', async function() {
+    const req = apos.task.getAnonReq();
+    const piece = {
+      _id: 'jsx-ctx-area-piece-1',
+      metaType: 'doc',
+      type: 'jsx-area-test',
+      title: 'Ctx Host',
+      slug: 'ctx-host',
+      main: {
+        _id: 'jsx-ctx-area-1',
+        metaType: 'area',
+        items: [
+          {
+            _id: 'jsx-ctx-widget-1',
+            metaType: 'widget',
+            type: 'jsx-ctx'
+          }
+        ]
+      }
+    };
+    const result = await apos.modules['jsx-area-test'].render(req, 'with-area-ctx', { piece });
+    assert.match(result, /data-tag="from-area-with"/);
+    assert.match(result, /<span class="ctx-widget"[^>]*>from-area-with<\/span>/);
+  });
+
+  it('Widget should pass `with={...}` context options through to the widget', async function() {
+    const req = apos.task.getAnonReq();
+    const widget = {
+      _id: 'jsx-ctx-widget-direct-1',
+      metaType: 'widget',
+      type: 'jsx-ctx'
+    };
+    const result = await apos.modules['jsx-area-test'].render(req, 'with-widget-ctx', { widget });
+    assert.match(result, /data-tag="from-widget-with"/);
+    assert.match(result, /<span class="ctx-widget"[^>]*>from-widget-with<\/span>/);
+  });
+
+  // Exercises the full render-time async pipeline: a page JSX template calls
+  // <Area>, the area renders each widget via its widget.jsx, and the widget.jsx
+  // itself invokes <Component> which runs an async component that delays before
+  // returning. If any await is missing along that path — page → Area → widget.jsx
+  // → Component — the deferred output ("(after delay)") will not appear in the
+  // rendered HTML.
+  it('a JSX widget.jsx that calls an async <Component> should resolve through the full render pipeline', async function() {
+    const req = apos.task.getAnonReq();
+    const piece = {
+      _id: 'jsx-async-host',
+      metaType: 'doc',
+      type: 'jsx-area-test',
+      title: 'Async Host',
+      slug: 'async-host',
+      main: {
+        _id: 'jsx-async-area',
+        metaType: 'area',
+        items: [
+          {
+            _id: 'jsx-async-widget-instance',
+            metaType: 'widget',
+            type: 'jsx-async',
+            who: 'World'
+          }
+        ]
+      }
+    };
+    const result = await apos.modules['jsx-area-test'].render(req, 'with-area', { piece });
+    assert.match(result, /<div class="async-widget">/);
+    assert.match(
+      result,
+      /<span class="greet">Hello World \(after delay\)<\/span>/
+    );
+  });
+
+  // ---- JSX → Nunjucks bridge via Extend ----
+
+  it('should let JSX extend a Nunjucks layout, mapping props to {% block %} overrides', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'njk-extends', {
+      message: 'hello & <world>',
+      pageSlug: '/test'
+    });
+    assert.match(result, /<title>A JSX page<\/title>/);
+    assert.match(result, /<body data-page="\/test">/);
+    assert.match(result, /<main>/);
+    assert.match(result, /<h1>I am from JSX<\/h1>/);
+    // Auto-escape applies to ordinary string children inside JSX, even when
+    // the surrounding output ends up in a Nunjucks block override.
+    assert.match(result, /<p>hello &amp; &lt;world&gt;<\/p>/);
+    assert.doesNotMatch(result, /default body/);
+    assert.doesNotMatch(result, /default title/);
+  });
+
+  // ---- JSX → JSX layout via Template + children ----
+
+  it('should let JSX extend a JSX layout, passing children through', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'jsx-extends', {
+      message: 'inside the jsx layout'
+    });
+    assert.match(result, /<title>JSX-in-JSX<\/title>/);
+    assert.match(result, /<header>shared header<\/header>/);
+    assert.match(result, /<main>/);
+    assert.match(result, /<p>inside the jsx layout<\/p>/);
+    assert.match(result, /<footer>shared footer<\/footer>/);
+  });
+
+  // ---- <Extend> against a .jsx target behaves like <Template> ----
+
+  it('Extend against a .jsx target should behave like Template (props + children)', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'jsx-extends-via-extend', {
+      message: 'inside via extend'
+    });
+    assert.match(result, /<title>Extend-against-JSX<\/title>/);
+    assert.match(result, /<header>shared header<\/header>/);
+    assert.match(result, /<p>inside via extend<\/p>/);
+    assert.match(result, /<footer>shared footer<\/footer>/);
+  });
+
+  // ---- <Template> against a .html target: include semantics ----
+
+  it('Template against a .html target should pass props as data and NOT override blocks', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'include-html');
+    // Block content is the default — Template did NOT override it.
+    assert.match(result, /<p class="block-output">default-block<\/p>/);
+    // The JSX prop arrived as data.content in Nunjucks.
+    assert.match(result, /<p class="data-output">prop-content<\/p>/);
+  });
+
+  // ---- Template short-form `name=` (no `templateName`) ----
+
+  it('Template `name=` short form should resolve and pass other props as data', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'short-form');
+    assert.match(result, /<p>short:from-short<\/p>/);
+  });
+
+  // ---- Cross-module `module:file` ----
+
+  it('Template should resolve `module:file` cross-module references', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'cross-module');
+    assert.match(result, /<p class="partial">partial:from-cross-module<\/p>/);
+  });
+
+  // ---- templateName/name disambiguation rule ----
+
+  it('Template with both `templateName` and `name` should forward `name` as a prop and not `templateName`', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'disambig-with-template-name');
+    // `name` is forwarded as data.name when `templateName` is also present.
+    assert.match(result, /data-name="forwarded-value"/);
+    // `templateName` itself is never forwarded as a data prop.
+    assert.match(result, /data-template-name="undefined"/);
+  });
+
+  it('Template with only `name=` should use it as the selector and not forward it as data', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-bridge-test'].render(req, 'disambig-name-only');
+    // `name` was the selector (resolved disambig-target.jsx), not a prop.
+    assert.match(result, /data-name="undefined"/);
+    // The target rendered, proving `name` selected it.
+    assert.match(result, /data-template-name="undefined"/);
+  });
+
+  // ---- import / require inside .jsx ----
+
+  it('should support `import` inside .jsx files', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-mixed-test'].render(req, 'uses-import', {
+      value: 'imported'
+    });
+    assert.match(result, /<span>\[imported\]<\/span>/);
+  });
+
+  it('should support `require` inside .jsx files', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-mixed-test'].render(req, 'uses-require', {
+      value: 'required'
+    });
+    assert.match(result, /<span>\[required\]<\/span>/);
+  });
+
+  // ---- Async JSX with promise-returning helpers in arrays ----
+
+  it('should await promises returned from inside arrays', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-mixed-test'].render(req, 'async-list', {
+      items: [ 'one', 'two', 'three' ]
+    });
+    assert.match(result, /<ul><li>one<\/li><li>two<\/li><li>three<\/li><\/ul>/);
+  });
+
+  // ---- Nunjucks SafeString interop ----
+
+  it('should not double-escape Nunjucks SafeString values returned by helpers', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-mixed-test'].render(req, 'safe-helper');
+    // Helper escapes its input itself, returns SafeString. JSX must not
+    // re-escape the resulting <b> tag, but the inner text was escaped by
+    // the helper.
+    assert.match(result, /<div><b>hello &amp; &lt;world&gt;<\/b><\/div>/);
+  });
+
+  // ---- Full self.apos exposure ----
+
+  it('should expose full self.apos as `apos` and templateApos as `helpers` (distinct objects)', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-mixed-test'].render(req, 'apos-full', { req });
+    // apos.util.generateId() lives on self.apos.util, not on templateApos.
+    assert.match(result, /data-id-length="\d+"/);
+    // apos.doc.find(req, ...) returns a real cursor we can await.
+    assert.match(result, /data-global-count="\d+"/);
+    // apos and helpers must be different objects, not aliases.
+    assert.match(result, /data-distinct="true"/);
+    // apos.doc is the doc-module instance, with module methods like .find().
+    assert.match(result, /data-apos-doc-is-module="true"/);
+    // It is a different object than the helper bag for @apostrophecms/doc.
+    assert.match(result, /data-helpers-doc-is-helper-bag="true"/);
+    // The `modules` collections on the two objects are distinct.
+    assert.match(result, /data-modules-distinct="true"/);
+  });
+
+  // ---- Localization helper ----
+
+  it('should expose __t as the localization helper', async function() {
+    const req = apos.task.getAnonReq();
+    const result = await apos.modules['jsx-mixed-test'].render(req, 'localized');
+    assert.match(result, /<p>404 - Page not found<\/p>/);
+  });
+
+  // ---- Resolution: prefer .jsx when it exists alongside .html ----
+
+  it('resolveTemplate should prefer .jsx over .html in the same directory', function() {
+    const module = apos.modules['template-jsx-test'];
+    const resolved = apos.template.resolveTemplate(module, 'test');
+    assert.equal(resolved.kind, 'jsx');
+    assert.equal(resolved.ext, 'jsx');
+  });
+
+  it('resolveTemplate should still find .html templates when no .jsx exists', function() {
+    // template-test only has .html, not .jsx
+    const module = apos.modules['@apostrophecms/template'];
+    const resolved = apos.template.resolveTemplate(module, 'outerLayout');
+    assert.equal(resolved.kind, 'nunjucks');
+    assert.equal(resolved.ext, 'html');
+  });
+
+  // ---- Error handling ----
+
+  it('should annotate runtime errors thrown by JSX templates with the file path', async function() {
+    const req = apos.task.getAnonReq();
+    let caught;
+    try {
+      await apos.modules['jsx-mixed-test'].render(req, 'throws');
+    } catch (e) {
+      caught = e;
+    }
+    assert(caught, 'expected the render to throw');
+    assert.match(caught.message, /\[JSX template .*throws\.jsx\]/);
+    assert.equal(caught.aposJsxFile.endsWith('throws.jsx'), true);
+  });
+
+  it('should report JSX compile errors with the file path and a clear code', async function() {
+    const req = apos.task.getAnonReq();
+    let caught;
+    try {
+      await apos.modules['jsx-mixed-test'].render(req, 'syntax-error');
+    } catch (e) {
+      caught = e;
+    }
+    assert(caught, 'expected the render to throw');
+    assert.match(caught.message, /syntax-error\.jsx/);
+  });
+
+});

package/test-lib/util.js

@@ -1,5 +1,27 @@
 const { createId } = require('@paralleldrive/cuid2');
-const mongodbConnect = require('../lib/mongodb-connect');
+
+const testDbProtocol = process.env.APOS_TEST_DB_PROTOCOL || 'mongodb';
+
+// Build a test database URI for postgres based on the shortName.
+// Returns undefined for mongodb, letting the default logic handle it.
+function getTestDbUri(shortName) {
+  if (testDbProtocol === 'postgres') {
+    // PostgreSQL database names cannot contain hyphens
+    const dbName = shortName.replace(/-/g, '_');
+    return `postgres://localhost:5432/${dbName}`;
+  }
+  if (testDbProtocol === 'multipostgres') {
+    // Multi-schema mode: shared real database, per-test schema
+    const schemaName = shortName.replace(/-/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+    return `multipostgres://localhost:5432/apos_test-${schemaName}`;
+  }
+  if (testDbProtocol === 'sqlite') {
+    const os = require('os');
+    const path = require('path');
+    const dbName = shortName.replace(/-/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+    return `sqlite://${path.join(os.tmpdir(), `apos_test_${dbName}.db`)}`;
+  }
+}
 
 // Properly clean up an apostrophe instance and drop its
 // database collections to create a sane environment for the next test.
@@ -10,23 +32,23 @@ const mongodbConnect = require('../lib/mongodb-connect');
 // If `apos` is null, no work is done.
 
 async function destroy(apos) {
-  if (!apos) {
+  if (!apos || apos._destroyed) {
     return;
   }
+  apos._destroyed = true;
+  const dbModule = apos.modules['@apostrophecms/db'];
+  const { uri } = dbModule;
+  const dbName = apos.db && (apos.db.databaseName || apos.db._name);
   await apos.destroy();
-  const { uri } = apos.modules['@apostrophecms/db'];
-  const dbName = apos.db && apos.db.databaseName;
-  // TODO at some point accommodate nonsense like testing remote databases
-  // that won't let us use dropDatabase, no shell available etc., but the
-  // important principle here is that we should not have to have an apos
-  // object to clean up the database, otherwise we have to get hold of one
-  // when initialization failed and that's really not apostrophe's concern
-  if (dbName && uri) {
-    const client = await mongodbConnect(`${uri}${dbName}`);
-    const db = client.db(dbName);
-    await db.dropDatabase();
-    await client.close();
+  if (!uri || !dbName) {
+    return;
   }
+  // Make a fresh connection (the original was closed by destroy)
+  // and use it to drop the test database
+  const client = await dbModule.connectToAdapter(uri);
+  const db = client.db(dbName);
+  await db.dropDatabase();
+  await client.close();
 };
 
 async function create(options = {}) {
@@ -55,6 +77,18 @@ async function create(options = {}) {
     express.options.session.secret = express.options.session.secret || 'test';
     config.modules['@apostrophecms/express'] = express;
   }
+  // When APOS_TEST_DB_PROTOCOL=postgres, automatically configure the db
+  // module to use a postgres URI unless already explicitly configured
+  const testUri = getTestDbUri(config.shortName);
+  if (testUri) {
+    config.modules = config.modules || {};
+    const dbModule = config.modules['@apostrophecms/db'] || {};
+    dbModule.options = dbModule.options || {};
+    if (!dbModule.options.uri && !dbModule.options.client) {
+      dbModule.options.uri = testUri;
+    }
+    config.modules['@apostrophecms/db'] = dbModule;
+  }
   return require('../index.js')(config);
 }
 
@@ -151,5 +185,7 @@ module.exports = {
   loginAs,
   logout,
   getUserJar,
+  getTestDbUri,
+  testDbProtocol,
   timeout: (process.env.TEST_TIMEOUT && parseInt(process.env.TEST_TIMEOUT)) || 20000
 };

package/.claude/settings.local.json

@@ -1,15 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(timeout 180 npx mocha:*)",
-      "Bash(timeout 600 npx mocha:*)",
-      "Bash(npm ls:*)",
-      "Bash(timeout 540 npx mocha:*)",
-      "Bash(echo:*)",
-      "Bash(timeout 10 node:*)",
-      "Bash(timeout 300 npx mocha:*)",
-      "Bash(timeout 60 npx mocha:*)",
-      "Bash(timeout 120 npx mocha:*)"
-    ]
-  }
-}