monsqlize 2.0.5 → 3.0.0

package/dist/types/slow-query-log.d.mts

@@ -0,0 +1,126 @@
+import type { LoggerLike } from './base.mjs';
+
+export interface SlowQueryLogEntry {
+    database: string;
+    collection: string;
+    operation: string;
+    durationMs: number;
+    query?: unknown;
+    timestamp?: Date;
+    queryHash?: string;
+    metadata?: Record<string, unknown>;
+}
+
+export interface SlowQueryLogRecord {
+    queryHash: string;
+    database: string;
+    collection: string;
+    operation: string;
+    count: number;
+    totalTimeMs: number;
+    avgTimeMs: number;
+    maxTimeMs: number;
+    minTimeMs: number;
+    firstSeen: Date;
+    lastSeen: Date;
+    sampleQuery?: unknown;
+    metadata?: Record<string, unknown>;
+}
+
+export interface SlowQueryLogFilter {
+    database?: string;
+    collection?: string;
+    operation?: string;
+    queryHash?: string;
+}
+
+export interface SlowQueryLogQueryOptions {
+    sort?: Record<string, 1 | -1>;
+    limit?: number;
+    skip?: number;
+}
+
+export interface SlowQueryLogStorageConfig {
+    type?: 'memory' | 'mongodb';
+    useBusinessConnection?: boolean;
+    uri?: string | null;
+    database?: string;
+    collection?: string;
+    ttl?: number;
+    options?: Record<string, unknown>;
+}
+
+export interface SlowQueryLogConfig {
+    enabled: boolean;
+    storage: SlowQueryLogStorageConfig;
+    batch: {
+        enabled: boolean;
+        size: number;
+        interval: number;
+        maxBufferSize: number;
+    };
+    filter: {
+        excludeDatabases: string[];
+        excludeCollections: string[];
+        excludeOperations: string[];
+        minExecutionTimeMs: number;
+    };
+    advanced: {
+        errorHandling: 'log' | 'throw' | 'silent';
+        autoCreateIndexes: boolean;
+    };
+}
+
+export type SlowQueryLogConfigInput = boolean | Partial<SlowQueryLogConfig>;
+
+export interface SlowQueryLogStorage {
+    initialize(): Promise<void>;
+    save(log: SlowQueryLogEntry): Promise<void>;
+    saveBatch(logs: SlowQueryLogEntry[]): Promise<void>;
+    query(filter?: SlowQueryLogFilter, options?: SlowQueryLogQueryOptions): Promise<SlowQueryLogRecord[]>;
+    close(): Promise<void>;
+}
+
+export declare const DEFAULT_SLOW_QUERY_LOG_CONFIG: SlowQueryLogConfig;
+export declare function generateQueryHash(input: unknown): string;
+
+export declare class BatchQueue {
+    constructor(storage: Pick<SlowQueryLogStorage, 'saveBatch'>, options?: Partial<SlowQueryLogConfig['batch']>, logger?: LoggerLike | null);
+    add(log: SlowQueryLogEntry): Promise<void>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare class SlowQueryLogMemoryStorage implements SlowQueryLogStorage {
+    initialize(): Promise<void>;
+    save(log: SlowQueryLogEntry): Promise<void>;
+    saveBatch(logs: SlowQueryLogEntry[]): Promise<void>;
+    query(filter?: SlowQueryLogFilter, options?: SlowQueryLogQueryOptions): Promise<SlowQueryLogRecord[]>;
+    close(): Promise<void>;
+}
+
+export declare class MongoDBSlowQueryLogStorage implements SlowQueryLogStorage {
+    constructor(config?: SlowQueryLogStorageConfig, businessClient?: unknown, logger?: LoggerLike | null);
+    initialize(): Promise<void>;
+    save(log: SlowQueryLogEntry): Promise<void>;
+    saveBatch(logs: SlowQueryLogEntry[]): Promise<void>;
+    query(filter?: SlowQueryLogFilter, options?: SlowQueryLogQueryOptions): Promise<SlowQueryLogRecord[]>;
+    close(): Promise<void>;
+}
+
+export declare class SlowQueryLogConfigManager {
+    static mergeConfig(userConfig?: SlowQueryLogConfigInput, businessType?: string): SlowQueryLogConfig;
+    static validate(config: SlowQueryLogConfig, businessType?: string): boolean;
+}
+
+export declare class SlowQueryLogManager {
+    readonly config: SlowQueryLogConfig;
+    readonly storage: SlowQueryLogStorage;
+    readonly queue: BatchQueue | null;
+    constructor(userConfig?: SlowQueryLogConfigInput, businessClient?: unknown, businessType?: string, logger?: LoggerLike | null);
+    initialize(): Promise<void>;
+    save(log: SlowQueryLogEntry): Promise<void>;
+    query(filter?: SlowQueryLogFilter, options?: SlowQueryLogQueryOptions): Promise<SlowQueryLogRecord[]>;
+    close(): Promise<void>;
+}
+

package/dist/types/sync.d.mts

@@ -0,0 +1,149 @@
+import type { ChangeStreamDocument, Document, MongoClientOptions } from 'mongodb';
+
+import type { LoggerLike } from './base.mjs';
+
+export type SyncChangeEvent<TDocument extends Document = Document> = ChangeStreamDocument<TDocument> & {
+    _id?: unknown;
+    operationType: 'insert' | 'update' | 'replace' | 'delete';
+    ns: {
+        db: string;
+        coll: string;
+    };
+    documentKey?: Record<string, unknown>;
+    fullDocument?: TDocument;
+};
+
+export interface SyncTargetHealthCheckConfig {
+    /** Whether to enable health checks; defaults to true. */
+    enabled?: boolean;
+    /** Health check interval in milliseconds; defaults to 30000. */
+    interval?: number;
+    /** Timeout for a single health check in milliseconds; defaults to 5000. */
+    timeout?: number;
+    /** Number of retries after failure; defaults to 3. */
+    retries?: number;
+}
+
+export interface SyncTargetConfig {
+    name: string;
+    uri?: string;
+    pool?: string;
+    databaseName?: string;
+    /** Collections handled by this target; omit or pass ['*'] to handle all collections. */
+    collections?: string[];
+    options?: MongoClientOptions;
+    apply?: (event: SyncChangeEvent, document: Record<string, unknown> | undefined, context?: SyncTargetApplyContext) => Promise<void>;
+    /** Target node health check configuration. @since v1.0.8 */
+    healthCheck?: SyncTargetHealthCheckConfig;
+}
+
+export interface SyncTargetApplyContext {
+    targetName: string;
+    idempotencyKey?: string;
+}
+
+export interface SyncIdempotencyStoreLike {
+    get(key: string): Promise<unknown> | unknown;
+    set(key: string, value: unknown, ttl?: number): Promise<unknown> | unknown;
+    del?(key: string): Promise<unknown> | unknown;
+}
+
+export type SyncIdempotencyMarkMode = 'success' | 'start';
+
+export interface SyncIdempotencyConfig {
+    /** Enable runtime per-target idempotency checks. Defaults to false. */
+    enabled?: boolean;
+    /** Optional durable store; when omitted, an in-memory store is used. */
+    store?: SyncIdempotencyStoreLike;
+    /** Cache/store key prefix. Defaults to monsqlize:sync:idempotency. */
+    keyPrefix?: string;
+    /** Marker TTL in milliseconds. Store implementations may ignore it. */
+    ttl?: number;
+    /** Mark after target success by default; start mode requires target-owned recovery for post-mark failures. */
+    markMode?: SyncIdempotencyMarkMode;
+    /** Custom event key builder. Return null/undefined to disable idempotency for that event. */
+    keyBuilder?: (event: SyncChangeEvent, targetName: string) => string | null | undefined;
+}
+
+export interface ResumeTokenRedisLike {
+    get(key: string): Promise<string | null> | string | null;
+    set(key: string, value: string): Promise<unknown> | unknown;
+    del?(key: string): Promise<unknown> | unknown;
+}
+
+export interface ResumeTokenConfig {
+    storage?: 'file' | 'redis';
+    path?: string;
+    redis?: ResumeTokenRedisLike;
+    key?: string;
+    /** Throw when a stored resume token cannot be loaded or parsed. Defaults to strictSave. */
+    strictLoad?: boolean;
+    /** Throw when resume-token persistence fails. Defaults to true for reliable CDC. */
+    strictSave?: boolean;
+    /** Number of retry attempts after a failed token save. Defaults to 0. */
+    saveRetries?: number;
+    /** Delay between token-save retries in milliseconds. Defaults to 100. */
+    saveRetryDelayMs?: number;
+}
+
+export interface SyncConfig {
+    enabled: boolean;
+    targets: SyncTargetConfig[];
+    /** Source collections watched by the manager; omit or pass ['*'] to watch all collections. */
+    collections?: string[];
+    resumeToken?: ResumeTokenConfig;
+    filter?: (event: SyncChangeEvent) => boolean;
+    /** Optional per-target idempotency gate for replay protection. */
+    idempotency?: SyncIdempotencyConfig;
+    /**
+     * Transform a change-stream document before forwarding to sync targets.
+     * v1 form took a single argument (`doc => ...`); v2 added a second `event` argument.
+     * Signature is permissive (`any`) to accept both forms — v1 was never typed.
+     */
+    transform?: (document: any, event?: SyncChangeEvent) => any;
+}
+
+export interface SyncStats {
+    isRunning: boolean;
+    eventCount: number;
+    syncedCount: number;
+    errorCount: number;
+    startTime: Date | null;
+    lastEventTime: Date | null;
+    lastError: Error | null;
+    tokenSaveErrorCount: number;
+    lastTokenSaveError: Error | null;
+    duplicateEventCount: number;
+    duplicateTargetCount: number;
+    targets: Array<{
+        name: string;
+        syncCount: number;
+        errorCount: number;
+        duplicateCount: number;
+        lastSyncTime: Date | null;
+        lastError: Error | null;
+        successRate: string;
+    }>;
+}
+
+export declare function validateSyncConfig(config: SyncConfig): void;
+
+export declare class ResumeTokenStore {
+    constructor(options?: ResumeTokenConfig & { logger?: LoggerLike | null; });
+    load(): Promise<unknown | null>;
+    save(token: unknown): Promise<void>;
+    clear(): Promise<void>;
+}
+
+export declare class ChangeStreamSyncManager {
+    constructor(options: {
+        db: unknown;
+        poolManager?: unknown;
+        config: SyncConfig;
+        logger?: LoggerLike | null;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStats(): SyncStats;
+}
+

package/dist/types/sync.d.ts

@@ -29,13 +29,42 @@ export interface SyncTargetConfig {
     uri?: string;
     pool?: string;
     databaseName?: string;
+    /** Collections handled by this target; omit or pass ['*'] to handle all collections. */
     collections?: string[];
     options?: MongoClientOptions;
-    apply?: (event: SyncChangeEvent, document: Record<string, unknown> | undefined) => Promise<void>;
+    apply?: (event: SyncChangeEvent, document: Record<string, unknown> | undefined, context?: SyncTargetApplyContext) => Promise<void>;
     /** Target node health check configuration. @since v1.0.8 */
     healthCheck?: SyncTargetHealthCheckConfig;
 }
 
+export interface SyncTargetApplyContext {
+    targetName: string;
+    idempotencyKey?: string;
+}
+
+export interface SyncIdempotencyStoreLike {
+    get(key: string): Promise<unknown> | unknown;
+    set(key: string, value: unknown, ttl?: number): Promise<unknown> | unknown;
+    del?(key: string): Promise<unknown> | unknown;
+}
+
+export type SyncIdempotencyMarkMode = 'success' | 'start';
+
+export interface SyncIdempotencyConfig {
+    /** Enable runtime per-target idempotency checks. Defaults to false. */
+    enabled?: boolean;
+    /** Optional durable store; when omitted, an in-memory store is used. */
+    store?: SyncIdempotencyStoreLike;
+    /** Cache/store key prefix. Defaults to monsqlize:sync:idempotency. */
+    keyPrefix?: string;
+    /** Marker TTL in milliseconds. Store implementations may ignore it. */
+    ttl?: number;
+    /** Mark after target success by default; start mode requires target-owned recovery for post-mark failures. */
+    markMode?: SyncIdempotencyMarkMode;
+    /** Custom event key builder. Return null/undefined to disable idempotency for that event. */
+    keyBuilder?: (event: SyncChangeEvent, targetName: string) => string | null | undefined;
+}
+
 export interface ResumeTokenRedisLike {
     get(key: string): Promise<string | null> | string | null;
     set(key: string, value: string): Promise<unknown> | unknown;
@@ -47,14 +76,25 @@ export interface ResumeTokenConfig {
     path?: string;
     redis?: ResumeTokenRedisLike;
     key?: string;
+    /** Throw when a stored resume token cannot be loaded or parsed. Defaults to strictSave. */
+    strictLoad?: boolean;
+    /** Throw when resume-token persistence fails. Defaults to true for reliable CDC. */
+    strictSave?: boolean;
+    /** Number of retry attempts after a failed token save. Defaults to 0. */
+    saveRetries?: number;
+    /** Delay between token-save retries in milliseconds. Defaults to 100. */
+    saveRetryDelayMs?: number;
 }
 
 export interface SyncConfig {
     enabled: boolean;
     targets: SyncTargetConfig[];
+    /** Source collections watched by the manager; omit or pass ['*'] to watch all collections. */
     collections?: string[];
     resumeToken?: ResumeTokenConfig;
     filter?: (event: SyncChangeEvent) => boolean;
+    /** Optional per-target idempotency gate for replay protection. */
+    idempotency?: SyncIdempotencyConfig;
     /**
      * Transform a change-stream document before forwarding to sync targets.
      * v1 form took a single argument (`doc => ...`); v2 added a second `event` argument.
@@ -70,10 +110,16 @@ export interface SyncStats {
     errorCount: number;
     startTime: Date | null;
     lastEventTime: Date | null;
+    lastError: Error | null;
+    tokenSaveErrorCount: number;
+    lastTokenSaveError: Error | null;
+    duplicateEventCount: number;
+    duplicateTargetCount: number;
     targets: Array<{
         name: string;
         syncCount: number;
         errorCount: number;
+        duplicateCount: number;
         lastSyncTime: Date | null;
         lastError: Error | null;
         successRate: string;

package/dist/types/transaction.d.mts

@@ -0,0 +1,152 @@
+import type { CacheLike } from './runtime.mjs';
+import type { LoggerLike } from './base.mjs';
+
+export type CacheInvalidationIntent =
+    | { type: 'pattern'; value: string }
+    | { type: 'key'; value: string };
+
+/** Minimal MongoDB session contract used by the transaction layer. */
+export interface MongoSession {
+    id: unknown;
+    inTransaction(): boolean;
+    startTransaction(options?: Record<string, unknown>): void;
+    commitTransaction(): Promise<void>;
+    abortTransaction(): Promise<void>;
+    endSession(): Promise<void>;
+    /** v1 compat — v1 callers read `session.transaction?.state`; populated by the underlying driver. */
+    transaction?: { state?: string;[key: string]: unknown };
+}
+
+/** Options forwarded to the MongoDB driver when starting a transaction session. */
+export interface TransactionOptions {
+    readConcern?: {
+        level: 'local' | 'majority' | 'snapshot' | 'linearizable' | 'available';
+    };
+    readPreference?: 'primary' | 'primaryPreferred' | 'secondary' | 'secondaryPreferred' | 'nearest';
+    causalConsistency?: boolean;
+    /** Maximum transaction duration in milliseconds before an automatic abort. */
+    maxDuration?: number;
+    /** @alias maxDuration — v1 compat field */
+    timeout?: number;
+    enableRetry?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+    retryBackoff?: number;
+    enableCacheLock?: boolean;
+    lockCleanupInterval?: number;
+    writeConcern?: Record<string, unknown>;
+}
+
+/** Snapshot of a transaction's current state. */
+export interface TransactionInfo {
+    id: string;
+    status: 'pending' | 'started' | 'committed' | 'aborted';
+    duration: number;
+    sessionId: string;
+}
+
+/** Aggregate statistics for all transactions managed by a `TransactionManager`. */
+export interface TransactionStats {
+    totalTransactions: number;
+    successfulTransactions: number;
+    failedTransactions: number;
+    readOnlyTransactions: number;
+    writeTransactions: number;
+    activeTransactions: number;
+    averageDuration: number;
+    p95Duration: number;
+    p99Duration: number;
+    successRate: string;
+    readOnlyRatio: string;
+    sampleCount: number;
+}
+
+/**
+ * In-memory lock tracker used to serialise cache invalidation across transaction boundaries.
+ * Attached to `TransactionManager`; locks are auto-released when a transaction commits or aborts.
+ */
+export declare class CacheLockManager {
+    constructor(options?: { logger?: LoggerLike | null; maxDuration?: number; cleanupInterval?: number; });
+    /** Register a lock for `key` owned by `owner`. */
+    addLock(key: string, owner: { id?: unknown; } | string): void;
+    /** Return `true` if `key` is currently locked. */
+    isLocked(key: string): boolean;
+    /** Release all locks held by `owner`. */
+    releaseLocks(owner: { id?: unknown; } | string): void;
+    /** Return lock usage statistics. */
+    getStats(): { totalLocks: number; activeLocks: number; maxDuration: number; };
+    /** Release all locks immediately. */
+    clear(): void;
+    /** Stop the background cleanup timer. */
+    stop(): void;
+}
+
+/** Represents a single MongoDB transaction session with optional cache-lock integration. */
+export declare class Transaction {
+    readonly id: string;
+    readonly session: MongoSession;
+    readonly state: 'pending' | 'active' | 'committed' | 'aborted';
+    constructor(session: MongoSession, options?: {
+        cache?: CacheLike | null;
+        logger?: LoggerLike | null;
+        lockManager?: CacheLockManager | null;
+        timeout?: number;
+        transactionOptions?: Record<string, unknown>;
+    });
+    /** Begin the transaction (starts the MongoDB session transaction). */
+    start(): Promise<void>;
+    /** Commit the transaction; replays recorded cache invalidations on success. */
+    commit(): Promise<void>;
+    /** Abort the transaction and discard pending cache invalidations. */
+    abort(): Promise<void>;
+    /** Alias for `commit()` — v1 compat shorthand. */
+    end(): Promise<void>;
+    /** Record a cache-invalidation pattern to be replayed on commit. */
+    recordInvalidation(pattern: string): Promise<void>;
+    /** Record an exact cache key or pattern invalidation intent to be replayed on commit. */
+    recordCacheInvalidation(intent: CacheInvalidationIntent): Promise<void>;
+    /** @internal Record that a MongoDB write helper ran in this transaction. */
+    recordWriteOperation(): void;
+    /** Return the elapsed duration in milliseconds since the transaction started. */
+    getDuration(): number;
+    /** Return a snapshot of the transaction's current state and metadata. */
+    getInfo(): TransactionInfo;
+    /** Return v1-compatible per-transaction statistics. */
+    getStats(): {
+        id: string;
+        state: 'pending' | 'active' | 'committed' | 'aborted';
+        duration: number;
+        hasWriteOperation: boolean;
+        operationCount: number;
+        lockedKeysCount: number;
+    };
+}
+
+/** Manages the lifecycle of MongoDB transactions, including retry and session pooling. */
+export declare class TransactionManager {
+    constructor(options: {
+        client: unknown;
+        cache?: CacheLike | null;
+        logger?: LoggerLike | null;
+        lockManager?: CacheLockManager | null;
+        maxDuration?: number;
+        enableRetry?: boolean;
+        maxRetries?: number;
+        retryDelay?: number;
+        retryBackoff?: number;
+        defaultReadConcern?: TransactionOptions['readConcern'];
+        defaultWriteConcern?: TransactionOptions['writeConcern'];
+        defaultReadPreference?: TransactionOptions['readPreference'];
+        maxStatsSamples?: number;
+    });
+    /** Open a new transaction session. */
+    startSession(options?: TransactionOptions): Promise<Transaction>;
+    /** Execute `callback` inside a transaction; commits on success, aborts on failure. */
+    withTransaction<T>(callback: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    /** Return all currently active (uncommitted) transactions. */
+    getActiveTransactions(): Transaction[];
+    /** Abort all active transactions immediately. */
+    abortAll(): Promise<void>;
+    /** Return aggregate transaction statistics. */
+    getStats(): TransactionStats;
+}

package/dist/types/transaction.d.ts

@@ -1,6 +1,10 @@
 import type { CacheLike } from './runtime';
 import type { LoggerLike } from './base';
 
+export type CacheInvalidationIntent =
+    | { type: 'pattern'; value: string }
+    | { type: 'key'; value: string };
+
 /** Minimal MongoDB session contract used by the transaction layer. */
 export interface MongoSession {
     id: unknown;
@@ -99,6 +103,10 @@ export declare class Transaction {
     end(): Promise<void>;
     /** Record a cache-invalidation pattern to be replayed on commit. */
     recordInvalidation(pattern: string): Promise<void>;
+    /** Record an exact cache key or pattern invalidation intent to be replayed on commit. */
+    recordCacheInvalidation(intent: CacheInvalidationIntent): Promise<void>;
+    /** @internal Record that a MongoDB write helper ran in this transaction. */
+    recordWriteOperation(): void;
     /** Return the elapsed duration in milliseconds since the transaction started. */
     getDuration(): number;
     /** Return a snapshot of the transaction's current state and metadata. */

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "monsqlize",
-  "version": "2.0.5",
-  "description": "TypeScript-native MongoDB ODM with multi-level caching (cache-hub), distributed locks, Saga orchestration, unified expression system (122 operators), connection pool management, ChangeStream sync, slow-query logging, and full v1 API compatibility",
+  "version": "3.0.0",
+  "description": "TypeScript production data runtime layer for MongoDB today, with cache, transactions, pools, models, sync, and observability",
   "type": "commonjs",
   "main": "./dist/cjs/index.cjs",
   "module": "./dist/esm/index.mjs",
   "types": "./dist/types/index.d.ts",
+  "bin": {
+    "monsqlize": "dist/cjs/cli/data-task.cjs"
+  },
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
+      "types": {
+        "import": "./dist/types/index.d.mts",
+        "require": "./dist/types/index.d.ts"
+      },
       "require": "./dist/cjs/index.cjs",
       "import": "./dist/esm/index.mjs"
     },
@@ -18,6 +24,10 @@
     "dist/**/*.cjs",
     "dist/**/*.mjs",
     "dist/**/*.d.ts",
+    "dist/**/*.d.mts",
+    "changelogs/v3.0.0.md",
+    "changelogs/v2.0.7.md",
+    "changelogs/v2.0.6.md",
     "changelogs/v2.0.5.md",
     "changelogs/v2.0.4.md",
     "changelogs/v2.0.3.md",
@@ -25,20 +35,25 @@
     "changelogs/v2.0.1.md",
     "changelogs/v2.0.0.md",
     "README.md",
+    "MIGRATION.md",
+    "SECURITY.md",
     "LICENSE",
     "CHANGELOG.md"
   ],
   "keywords": [
     "mongodb",
     "database",
-    "orm",
+    "data-runtime",
+    "database-runtime",
     "cache",
     "transaction",
     "distributed",
+    "cache-invalidation",
     "pagination",
     "performance",
     "mongodb-driver",
     "nosql",
+    "typescript",
     "query-builder",
     "api"
   ],
@@ -60,7 +75,7 @@
     "mongodbMemoryServer": {
       "downloadDir": ".cache/mongodb-memory-server/binaries",
       "preferGlobalPath": "false",
-      "version": "7.0.14"
+      "version": "7.0.37"
     }
   },
   "engines": {
@@ -80,24 +95,27 @@
     "test:real-env:private": "node scripts/validation/run-private-real-env-checks.cjs",
     "test:examples": "npm run build && tsc -p tsconfig.examples.json && node scripts/run-examples.cjs",
     "test:performance": "npm run build && npm run build:tests && node .generated/test-dist/test/performance/baselines/function-cache.benchmark.js",
-    "test:unit": "npm run build && npm run build:tests && node --test .generated/test-dist/test/unit/expression/expression.test.js .generated/test-dist/test/unit/expression/operators.test.js .generated/test-dist/test/unit/errors/errors.test.js .generated/test-dist/test/unit/management/management.test.js .generated/test-dist/test/unit/writes/batch.test.js .generated/test-dist/test/unit/cache/cache.test.js .generated/test-dist/test/unit/cache/cache-refactor-guard.test.js .generated/test-dist/test/unit/coverage/core-helpers.test.js .generated/test-dist/test/unit/function-cache/function-cache.test.js .generated/test-dist/test/unit/model/model-registry.test.js .generated/test-dist/test/unit/lock/lock.test.js .generated/test-dist/test/unit/transaction/transaction.test.js .generated/test-dist/test/unit/pool/pool.test.js .generated/test-dist/test/unit/runtime/runtime-compat.test.js .generated/test-dist/test/unit/sync/sync.test.js .generated/test-dist/test/unit/slow-query-log/slow-query-log.test.js .generated/test-dist/test/unit/slow-query-log/slow-query-log-behavior.test.js .generated/test-dist/test/unit/saga/saga.test.js .generated/test-dist/test/unit/count-queue/count-queue.test.js .generated/test-dist/test/unit/model/model-softdelete-versioning.test.js .generated/test-dist/test/unit/function-cache/function-cache-behavior.test.js .generated/test-dist/test/unit/saga/saga-behavior.test.js .generated/test-dist/test/unit/lock/lock-distributed.test.js .generated/test-dist/test/unit/coverage/capability-wiring.test.js .generated/test-dist/test/unit/pool/pool-stats.test.js .generated/test-dist/test/unit/coverage/pure-functions.test.js",
+    "test:unit": "npm run build && npm run build:tests && node test/run-tests.cjs unit",
     "test:integration": "npm run build && npm run build:tests && node --test --test-concurrency=1 .generated/test-dist/test/integration/cache/cache.test.js .generated/test-dist/test/integration/cache/cache-behavior.test.js .generated/test-dist/test/integration/mongodb/connect.test.js .generated/test-dist/test/integration/mongodb/queries.test.js .generated/test-dist/test/integration/mongodb/management.test.js .generated/test-dist/test/integration/mongodb/writes-batch.test.js .generated/test-dist/test/integration/mongodb/find.test.js .generated/test-dist/test/integration/mongodb/find-one.test.js .generated/test-dist/test/integration/mongodb/find-page.test.js .generated/test-dist/test/integration/mongodb/aggregate.test.js .generated/test-dist/test/integration/mongodb/chaining.test.js .generated/test-dist/test/integration/mongodb/insert.test.js .generated/test-dist/test/integration/mongodb/update.test.js .generated/test-dist/test/integration/mongodb/delete.test.js .generated/test-dist/test/integration/mongodb/update-pipeline.test.js .generated/test-dist/test/integration/model/model-features.test.js .generated/test-dist/test/integration/transaction/transaction.test.js .generated/test-dist/test/integration/pool/pool.test.js .generated/test-dist/test/integration/pool/pool-behavior.test.js .generated/test-dist/test/integration/watch/watch-native.test.js .generated/test-dist/test/integration/runtime/runtime-core-regression.test.js .generated/test-dist/test/integration/sync/sync.test.js .generated/test-dist/test/integration/slow-query-log/slow-query-log.test.js .generated/test-dist/test/integration/model/model-crud-extended.test.js .generated/test-dist/test/integration/mongodb/management-complete.test.js .generated/test-dist/test/integration/runtime/runtime-methods-extended.test.js .generated/test-dist/test/integration/mongodb/find-page-advanced.test.js",
+    "test:data-tasks:integration": "npm run build && npm run build:tests && node test/run-tests.cjs data-tasks-integration",
+    "test:data-task-cli": "npm run build && npm run build:tests && node test/run-tests.cjs data-task-cli",
+    "test:pack-install": "npm run build && node scripts/pack-install-smoke.cjs",
     "test:refactor-guard": "npm run build && npm run build:tests && node --test --test-concurrency=1 .generated/test-dist/test/compatibility/exports/exports.test.js .generated/test-dist/test/integration/model/model-features.test.js .generated/test-dist/test/integration/runtime/runtime-core-regression.test.js .generated/test-dist/test/integration/sync/sync.test.js",
     "test:refactor-guard:cache": "npm run build && npm run build:tests && node --test .generated/test-dist/test/unit/cache/cache-refactor-guard.test.js",
-    "test:coverage": "npm run build && npm run build:tests && c8 --reporter=text --reporter=lcov --reporter=json-summary --include \".generated/test-dist/dist/cjs/**/*.cjs\" --check-coverage --lines 90 --statements 90 --functions 90 --branches 90 node test/run-tests.cjs",
+    "test:coverage": "node scripts/run-coverage.cjs",
     "test:audit": "npm audit --omit=dev --registry=https://registry.npmjs.org/",
     "test": "npm run build && npm run build:tests && node test/run-tests.cjs",
-    "type-check": "npm run build && tsc -p tsconfig.json --noEmit && tsd --files test/types/root-import.test-d.ts --files test/types/cache-usage.test-d.ts --files test/types/model-usage.test-d.ts --files test/types/pool-usage.test-d.ts --files test/types/sync-usage.test-d.ts --files test/types/slow-query-log-usage.test-d.ts --files test/types/saga-usage.test-d.ts",
+    "type-check": "npm run build && tsc -p tsconfig.json --noEmit && tsd --files test/types/root-import.test-d.ts --files test/types/cache-usage.test-d.ts --files test/types/model-usage.test-d.ts --files test/types/pool-usage.test-d.ts --files test/types/sync-usage.test-d.ts --files test/types/slow-query-log-usage.test-d.ts --files test/types/saga-usage.test-d.ts --files test/types/data-tasks-usage.test-d.ts",
     "check:test-language": "node scripts/check-test-language.cjs",
     "check:docs-examples": "node scripts/validation/check-doc-example-matrix.cjs",
+    "check:release-candidate": "node scripts/check-release-candidate.cjs",
     "verify:fast": "npm run lint && npm run check:docs-examples && npm run type-check && npm run check:sizes:strict && npm run test:runtime && npm run test:compatibility && npm run test:refactor-guard && npm run test:refactor-guard:cache",
     "verify:full": "npm run lint && npm run check:docs-examples && npm run type-check && npm run check:sizes:strict && npm run test:examples && npm run test:server-matrix",
     "verify:release": "npm run verify:full && npm run test:real-env:private",
     "verify": "npm run verify:full",
     "release:preflight": "node scripts/release-preflight.cjs",
     "prepublishOnly": "npm run release:preflight",
-    "release:publish": "npm run release:preflight && npm publish --ignore-scripts",
-    "postpublish": "echo 'Publish succeeded. Create GitHub Release: https://github.com/vextjs/monSQLize/releases/new?tag=v'$npm_package_version"
+    "release:publish": "npm run release:preflight && npm publish --ignore-scripts"
   },
   "devDependencies": {
     "@eslint/js": "9.39.4",
@@ -105,9 +123,9 @@
     "@types/semver": "7.7.1",
     "c8": "11.0.0",
     "chai": "6.2.2",
-    "esbuild": "0.25.12",
+    "esbuild": "0.28.1",
     "eslint": "9.39.4",
-    "mongodb-memory-server": "11.1.0",
+    "mongodb-memory-server": "10.4.3",
     "sinon": "22.0.0",
     "tsd": "0.33.0",
     "typescript": "5.9.3"
@@ -115,9 +133,9 @@
   "dependencies": {
     "async-lock": "1.4.1",
     "cache-hub": "2.2.4",
-    "ioredis": "5.8.2",
+    "ioredis": "5.11.1",
     "mongodb": "6.21.0",
-    "schema-dsl": "2.0.10",
+    "schema-dsl": "2.1.6",
     "ssh2": "1.17.0"
   }
 }