fix: avoid schema-dsl extension double registration

Author: rockyshi1993

changelogs/unreleased.md

@@ -16,6 +16,8 @@
 
 - Fixed aggregate direct `.toArray()` to honor cache/meta execution paths, extended `find()` ObjectId auto-conversion to comparison operators, forwarded CountQueue abort signals into MongoDB count options, and added a warning when sync idempotency falls back to in-memory storage.
 - Upgraded `schema-dsl` to `2.1.1` and moved Model schema compilation/validation onto a MonSQLize runtime-scoped `schema-dsl/runtime` engine. `schemaDsl` now supports runtime options, extension registration, external runtime injection, and validation disablement.
+- Fixed `schemaDsl: { runtime, extensions }` lifecycle handling so injected runtimes register extensions once during `connect()` instead of registering the same factory during construction and reconnect setup.
+- Raised the default `mongodb-memory-server` launch timeout to 30 seconds for test, validation, examples, and `useMemoryServer` paths while keeping `MONSQLIZE_MEMORY_MONGO_LAUNCH_TIMEOUT_MS` as the override.
 - Added a short-lived read-cache dirty barrier around writes and transaction commits. Cached reads now bypass and avoid refilling query cache while a namespace is being invalidated, reducing stale-cache windows when a process exits between a database write and post-write invalidation.
 - Added optional Change Stream sync idempotency gates (`sync.idempotency`) with per-target keys and duplicate stats, so supervised restarts can skip targets already marked as applied before saving the shared resume token.
 - Added `writePathPolicy` with default `allow-both` behavior and optional `model-only` namespace enforcement across collection, db, legacy, raw, management, batch, and aggregate `$out` / `$merge` write paths.

scripts/validation/memory-server-policy.cjs

@@ -4,6 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const DEFAULT_MEMORY_SERVER_VERSION = '7.0.14';
+const DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS = 30_000;
 const MANAGED_DB_PATH_PREFIXES = ['single-', 'replset-', 'examples-single-', 'examples-replset-', 'probe-single-', 'probe-replset-'];
 
 function isGeneratedPath(dir) {
@@ -159,7 +160,7 @@ async function seedMemoryServerBinaryCache(version) {
 function resolveMemoryServerLaunchTimeoutMs() {
     const raw = process.env.MONSQLIZE_MEMORY_MONGO_LAUNCH_TIMEOUT_MS;
     if (!raw) {
-        return undefined;
+        return DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS;
     }
 
     const value = Number.parseInt(raw, 10);
@@ -225,6 +226,7 @@ async function stopMemoryServerWithCleanup(instance, dbPath) {
 
 module.exports = {
     DEFAULT_MEMORY_SERVER_VERSION,
+    DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS,
     configureMemoryServerEnv,
     createMemoryServerDbPath,
     memoryServerCleanupOptions,

src/adapters/mongodb/common/connect.ts

@@ -17,6 +17,7 @@ import type { MongoConnectConfig, MongoConnectionState } from '../../../../types
 export type { MongoConnectConfig, MongoConnectionState } from '../../../../types/mongodb';
 
 const DEFAULT_MEMORY_SERVER_VERSION = '7.0.14';
+const DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS = 30_000;
 const MANAGED_DB_PATH_PREFIXES = ['single-', 'replset-', 'examples-single-', 'examples-replset-', 'probe-single-', 'probe-replset-'];
 
 // Singleton memory server (v1 compatible: reuses an already-started instance)
@@ -153,7 +154,7 @@ async function cleanupManagedDbPath(dbPath: string | null): Promise<boolean> {
 function resolveLaunchTimeout(): number | undefined {
     const raw = process.env.MONSQLIZE_MEMORY_MONGO_LAUNCH_TIMEOUT_MS;
     if (!raw) {
-        return undefined;
+        return DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS;
     }
 
     const value = Number.parseInt(raw, 10);

src/entry/runtime-core.ts

@@ -148,7 +148,7 @@ import {
 import { resolveScopedCollection } from './runtime-scoped-collection';
 import { normalizeRuntimeCacheWithLifecycle } from './runtime-cache-normalizer';
 import { prepareSshTunnelConnectConfig } from './runtime-ssh';
-import { createRuntimeSchemaDslEngine, disposeRuntimeSchemaDslEngine, replaceRuntimeSchemaDslEngine, type SchemaDslEngine } from './runtime-schema-dsl';
+import { createInitialRuntimeSchemaDslEngine, disposeRuntimeSchemaDslEngine, replaceRuntimeSchemaDslEngine, type SchemaDslEngine } from './runtime-schema-dsl';
 
 // All public symbols are re-exported from the barrel file to keep the public API unchanged
 export * from './runtime-exports';
@@ -221,7 +221,7 @@ export class MonSQLizeRuntime {
         this._cache = normalizedCache.cache;
         this._cacheClose = normalizedCache.close;
         this._logger = Logger.create(options.logger ?? null);
-        this._schemaDslEngine = createRuntimeSchemaDslEngine(options);
+        this._schemaDslEngine = createInitialRuntimeSchemaDslEngine();
         if (shouldWarnUnsignedCursorSecret(options)) this._logger.warn?.('[MonSQLizeRuntime] cursorSecret is not configured; findPage cursor tokens are unsigned.');
         if (shouldWarnTransactionDistributedLock(options)) this._logger.warn?.('[MonSQLizeRuntime] transaction.distributedLock is a compatibility configuration and is not wired into the transaction cache lock in the v2 runtime. Transaction cache locks remain process-local; use explicit business locking with idempotency/fencing or disable cache when cross-instance strict consistency is required.');
         this._cacheLockManager = new CacheLockManager({

src/entry/runtime-schema-dsl.ts

@@ -4,6 +4,10 @@ import type { MonSQLizeOptions } from '../../types/monsqlize';
 
 export type { SchemaDslEngine } from '../capabilities/model/schema-dsl';
 
+export function createInitialRuntimeSchemaDslEngine(): SchemaDslEngine {
+    return createSchemaDslEngine(false);
+}
+
 export function createRuntimeSchemaDslEngine(options: MonSQLizeOptions): SchemaDslEngine {
     return createSchemaDslEngine(options.schemaDsl);
 }

test/bootstrap/memory-server-policy.ts

@@ -2,6 +2,7 @@ import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdir
 import path from 'node:path';
 
 export const DEFAULT_MEMORY_SERVER_VERSION = '7.0.14';
+export const DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS = 30_000;
 const MANAGED_DB_PATH_PREFIXES = ['single-', 'replset-', 'examples-single-', 'examples-replset-', 'probe-single-', 'probe-replset-'];
 
 type MemoryServerPolicy = {
@@ -171,7 +172,7 @@ export async function seedMemoryServerBinaryCache(version?: string): Promise<voi
 export function resolveMemoryServerLaunchTimeoutMs(): number | undefined {
     const raw = process.env.MONSQLIZE_MEMORY_MONGO_LAUNCH_TIMEOUT_MS;
     if (!raw) {
-        return undefined;
+        return DEFAULT_MEMORY_SERVER_LAUNCH_TIMEOUT_MS;
     }
 
     const value = Number.parseInt(raw, 10);

test/integration/model/model-schema-validation-errors.test.ts

@@ -259,6 +259,42 @@ describe('model — schema-dsl runtime configuration', () => {
         assert.doesNotThrow(() => schemaRuntime.s({ tenantId: 'tenantId!' }));
         schemaRuntime.dispose();
     });
+
+    it('registers schemaDsl.extensions once when using an injected runtime', async () => {
+        const schemaRuntime = createRuntime();
+        const runtime = new MonSQLize({
+            type: 'mongodb',
+            databaseName: 'test_schema_runtime_injected_extensions',
+            config: { uri },
+            schemaDsl: {
+                runtime: schemaRuntime,
+                extensions: [{
+                    type: 'customType',
+                    literal: 'tenant-id',
+                    factoryName: 'tenantId',
+                    schema: { type: 'string', pattern: '^tenant_[a-z0-9]+$' },
+                }],
+            },
+        });
+        await runtime.connect();
+        const modelName = 'schema_runtime_injected_extensions_' + Date.now();
+        try {
+            Model.define(modelName, {
+                schema: (dsl: any) => dsl({
+                    tenantId: dsl.tenantId().require(),
+                }),
+            });
+            const model = runtime.model(modelName);
+            assert.equal(model.validate({ tenantId: 'tenant_demo' }).valid, true);
+            assert.equal(model.validate({ tenantId: 'bad' }).valid, false);
+        } finally {
+            await runtime.close();
+            Model.undefine(modelName);
+        }
+
+        assert.doesNotThrow(() => schemaRuntime.s({ tenantId: 'tenant-id!' }));
+        schemaRuntime.dispose();
+    });
 });
 
 describe('model — schema-dsl type delegation via redefine()', () => {