reqon-dsl 0.3.0 → 0.4.0

package/dist/scheduler/cron-parser.js

@@ -2,7 +2,7 @@
  * Parse a cron expression and calculate the next run time
  *
  * Cron format: "minute hour day-of-month month day-of-week"
- * Supports: numbers, ranges (1-5), steps (*​/5), lists (1,3,5), and wildcards (*)
+ * Supports: numbers, ranges (1-5), steps (* /5), lists (1,3,5), and wildcards (*)
  */
 export function parseCronExpression(expression) {
     const parts = expression.trim().split(/\s+/);
@@ -14,11 +14,29 @@ export function parseCronExpression(expression) {
         hour: parseField(parts[1], 0, 23),
         dayOfMonth: parseField(parts[2], 1, 31),
         month: parseField(parts[3], 1, 12),
-        dayOfWeek: parseField(parts[4], 0, 6), // 0 = Sunday
+        dayOfWeek: parseField(parts[4], 0, 6, true), // 0 = Sunday; 7 also = Sunday
+        // POSIX day matching keys off whether each field is a literal wildcard.
+        dayOfMonthRestricted: parts[2] !== '*',
+        dayOfWeekRestricted: parts[4] !== '*',
     };
 }
-function parseField(field, min, max) {
+/**
+ * Parse one cron field into the explicit set of integers it matches.
+ *
+ * Validation is strict and fails fast (rather than silently yielding an empty
+ * set or, worse, hanging): steps must be integers >= 1, bounds must be numeric,
+ * and ranges must not run backwards. When `allowSundaySeven` is set (day-of-week
+ * only) a literal 7 is accepted and normalised to 0 (Sunday).
+ */
+function parseField(field, min, max, allowSundaySeven = false) {
     const values = new Set();
+    const toInt = (token, label) => {
+        const n = parseInt(token, 10);
+        if (!Number.isInteger(n) || !/^[+-]?\d+$/.test(token.trim())) {
+            throw new Error(`Invalid cron ${label} '${token}' in '${field}': expected an integer`);
+        }
+        return n;
+    };
     for (const part of field.split(',')) {
         if (part === '*') {
             // All values
@@ -30,88 +48,244 @@ function parseField(field, min, max) {
             // Step values (e.g., */5 or 1-10/2)
             const [range, stepStr] = part.split('/');
             const step = parseInt(stepStr, 10);
+            if (!Number.isInteger(step) || step < 1) {
+                throw new Error(`Invalid cron step '${stepStr}' in '${part}': step must be an integer >= 1`);
+            }
             let start = min;
             let end = max;
             if (range !== '*') {
                 if (range.includes('-')) {
-                    const [rangeStart, rangeEnd] = range.split('-').map((n) => parseInt(n, 10));
-                    start = rangeStart;
-                    end = rangeEnd;
+                    const [rangeStart, rangeEnd] = range.split('-');
+                    start = toInt(rangeStart, 'range start');
+                    end = toInt(rangeEnd, 'range end');
                 }
                 else {
-                    start = parseInt(range, 10);
+                    start = toInt(range, 'range start');
                 }
             }
+            if (end < start) {
+                throw new Error(`Invalid cron range '${range}' in '${part}': ${start} is after ${end}`);
+            }
             for (let i = start; i <= end; i += step) {
                 values.add(i);
             }
         }
         else if (part.includes('-')) {
             // Range (e.g., 1-5)
-            const [start, end] = part.split('-').map((n) => parseInt(n, 10));
+            const [startStr, endStr] = part.split('-');
+            const start = toInt(startStr, 'range start');
+            const end = toInt(endStr, 'range end');
+            if (end < start) {
+                throw new Error(`Invalid cron range '${part}': ${start} is after ${end}`);
+            }
             for (let i = start; i <= end; i++) {
                 values.add(i);
             }
         }
         else {
             // Single value
-            values.add(parseInt(part, 10));
+            values.add(toInt(part, 'value'));
         }
     }
-    // Validate all values are in range
+    // Day-of-week 7 is an alias for Sunday (0) in standard cron.
+    const normalized = new Set();
     for (const value of values) {
-        if (value < min || value > max) {
+        normalized.add(allowSundaySeven && value === 7 ? 0 : value);
+    }
+    // Validate all values are in range (NaN is rejected by `toInt` above, but
+    // guard explicitly so an out-of-range NaN can never slip through).
+    for (const value of normalized) {
+        if (Number.isNaN(value) || value < min || value > max) {
             throw new Error(`Cron field value ${value} out of range [${min}, ${max}]`);
         }
     }
-    return Array.from(values).sort((a, b) => a - b);
+    return Array.from(normalized).sort((a, b) => a - b);
+}
+/** Number of days in a given (1-based) month, accounting for leap years. */
+function daysInMonth(year, month) {
+    return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+/** The day-of-week (0 = Sunday) for a calendar date — timezone-independent. */
+function weekdayOf(year, month, day) {
+    return new Date(Date.UTC(year, month - 1, day)).getUTCDay();
+}
+/** Read the wall-clock fields of an instant in `timeZone`. */
+function partsInZone(instant, timeZone) {
+    const dtf = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        hourCycle: 'h23',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+    const map = {};
+    for (const part of dtf.formatToParts(new Date(instant))) {
+        if (part.type !== 'literal')
+            map[part.type] = parseInt(part.value, 10);
+    }
+    return {
+        year: map.year,
+        month: map.month,
+        day: map.day,
+        hour: map.hour === 24 ? 0 : map.hour,
+        minute: map.minute,
+    };
+}
+/** Offset (ms) such that wall-clock-in-zone = instant + offset, at `instant`. */
+function zoneOffsetMs(instant, timeZone) {
+    const dtf = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        hourCycle: 'h23',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+    const m = {};
+    for (const part of dtf.formatToParts(new Date(instant))) {
+        if (part.type !== 'literal')
+            m[part.type] = parseInt(part.value, 10);
+    }
+    const hour = m.hour === 24 ? 0 : m.hour;
+    return Date.UTC(m.year, m.month - 1, m.day, hour, m.minute, m.second) - instant;
 }
 /**
- * Calculate the next run time for a cron schedule
+ * Convert a wall-clock time in `timeZone` to the corresponding UTC instant.
+ * Around DST transitions the wall time may be ambiguous or nonexistent; this
+ * resolves to a deterministic nearby instant.
  */
-export function getNextCronRun(schedule, after = new Date()) {
-    const next = new Date(after);
-    next.setSeconds(0, 0);
-    next.setMinutes(next.getMinutes() + 1); // Start from next minute
-    // Try up to 4 years to find a match
+function wallToInstant(wc, timeZone) {
+    const asUTC = Date.UTC(wc.year, wc.month - 1, wc.day, wc.hour, wc.minute);
+    const offset = zoneOffsetMs(asUTC, timeZone);
+    let instant = asUTC - offset;
+    const offset2 = zoneOffsetMs(instant, timeZone);
+    if (offset2 !== offset)
+        instant = asUTC - offset2;
+    return instant;
+}
+/** Advance a wall-clock by one minute, rolling over fields as needed. */
+function addMinute(wc) {
+    let { year, month, day, hour, minute } = wc;
+    minute += 1;
+    if (minute > 59) {
+        minute = 0;
+        hour += 1;
+        if (hour > 23) {
+            hour = 0;
+            day += 1;
+            if (day > daysInMonth(year, month)) {
+                day = 1;
+                month += 1;
+                if (month > 12) {
+                    month = 1;
+                    year += 1;
+                }
+            }
+        }
+    }
+    return { year, month, day, hour, minute };
+}
+/**
+ * Calculate the next run time for a cron schedule, evaluated against
+ * wall-clock time in `timeZone` (default UTC, so DST never shifts the result).
+ * Day-of-month and day-of-week follow POSIX: when both are restricted the
+ * match is their union (OR), not their intersection.
+ */
+export function getNextCronRun(schedule, after = new Date(), timeZone = 'UTC') {
+    // Fail fast on combinations that can never match (e.g. Feb 31) instead of
+    // grinding through a full multi-year minute-by-minute scan before throwing.
+    assertReachableDayMonth(schedule);
+    // Start from the first whole minute strictly after `after`.
+    const wc = addMinute(partsInZone(after.getTime(), timeZone));
     const maxIterations = 4 * 366 * 24 * 60;
     for (let i = 0; i < maxIterations; i++) {
-        // Check month
-        if (!schedule.month.includes(next.getMonth() + 1)) {
-            // Move to first day of next matching month
-            next.setMonth(next.getMonth() + 1);
-            next.setDate(1);
-            next.setHours(0, 0, 0, 0);
+        if (!schedule.month.includes(wc.month)) {
+            wc.month += 1;
+            if (wc.month > 12) {
+                wc.month = 1;
+                wc.year += 1;
+            }
+            wc.day = 1;
+            wc.hour = 0;
+            wc.minute = 0;
             continue;
         }
-        // Check day of month
-        if (!schedule.dayOfMonth.includes(next.getDate())) {
-            next.setDate(next.getDate() + 1);
-            next.setHours(0, 0, 0, 0);
+        if (wc.day > daysInMonth(wc.year, wc.month)) {
+            wc.month += 1;
+            if (wc.month > 12) {
+                wc.month = 1;
+                wc.year += 1;
+            }
+            wc.day = 1;
+            wc.hour = 0;
+            wc.minute = 0;
             continue;
         }
-        // Check day of week
-        if (!schedule.dayOfWeek.includes(next.getDay())) {
-            next.setDate(next.getDate() + 1);
-            next.setHours(0, 0, 0, 0);
+        if (!matchesDay(schedule, wc)) {
+            wc.day += 1;
+            wc.hour = 0;
+            wc.minute = 0;
             continue;
         }
-        // Check hour
-        if (!schedule.hour.includes(next.getHours())) {
-            next.setHours(next.getHours() + 1);
-            next.setMinutes(0, 0, 0);
+        if (!schedule.hour.includes(wc.hour)) {
+            wc.hour += 1;
+            wc.minute = 0;
+            if (wc.hour > 23) {
+                wc.hour = 0;
+                wc.day += 1;
+            }
             continue;
         }
-        // Check minute
-        if (!schedule.minute.includes(next.getMinutes())) {
-            next.setMinutes(next.getMinutes() + 1);
+        if (!schedule.minute.includes(wc.minute)) {
+            wc.minute += 1;
+            if (wc.minute > 59) {
+                wc.minute = 0;
+                wc.hour += 1;
+                if (wc.hour > 23) {
+                    wc.hour = 0;
+                    wc.day += 1;
+                }
+            }
             continue;
         }
-        // Found a match!
-        return next;
+        return new Date(wallToInstant(wc, timeZone));
     }
     throw new Error('Could not find next cron run time within 4 years');
 }
+/** Maximum days any given (1-based) month can have, allowing for leap Februarys. */
+const MAX_DAYS_IN_MONTH = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+/**
+ * Throw if a restricted day-of-month can never occur in any allowed month.
+ * Only applies when day-of-week is a wildcard: with a restricted weekday the
+ * POSIX OR means a matching day still occurs every month, so it is reachable.
+ */
+function assertReachableDayMonth(schedule) {
+    if (!schedule.dayOfMonthRestricted || schedule.dayOfWeekRestricted)
+        return;
+    const reachable = schedule.month.some((m) => schedule.dayOfMonth.some((d) => d <= MAX_DAYS_IN_MONTH[m]));
+    if (!reachable) {
+        throw new Error(`Cron schedule can never match: day-of-month [${schedule.dayOfMonth.join(',')}] never occurs in month(s) [${schedule.month.join(',')}]`);
+    }
+}
+/** POSIX day matching: union of day-of-month and day-of-week when both set. */
+function matchesDay(schedule, wc) {
+    const domMatch = schedule.dayOfMonth.includes(wc.day);
+    const dowMatch = schedule.dayOfWeek.includes(weekdayOf(wc.year, wc.month, wc.day));
+    const domR = schedule.dayOfMonthRestricted;
+    const dowR = schedule.dayOfWeekRestricted;
+    if (domR && dowR)
+        return domMatch || dowMatch;
+    if (domR)
+        return domMatch;
+    if (dowR)
+        return dowMatch;
+    return true;
+}
 /**
  * Convert interval schedule to milliseconds
  */
@@ -142,7 +316,7 @@ export function getNextRunTime(schedule, after = new Date()) {
                 throw new Error('Cron schedule missing cron expression');
             }
             const cronSchedule = parseCronExpression(schedule.cronExpression);
-            return getNextCronRun(cronSchedule, after);
+            return getNextCronRun(cronSchedule, after, schedule.timezone ?? 'UTC');
         }
         case 'once': {
             if (!schedule.runAt) {
@@ -178,19 +352,24 @@ export function shouldRunNow(schedule, lastRun, checkIntervalMs = 1000) {
             if (!schedule.cronExpression)
                 return false;
             const cronSchedule = parseCronExpression(schedule.cronExpression);
-            const nextRun = getNextCronRun(cronSchedule, lastRun ?? new Date(0));
-            // Check if we're within the check interval of the next run time
-            const diff = Math.abs(now.getTime() - nextRun.getTime());
-            return diff <= checkIntervalMs;
+            // Drift-free: the job is due once its next scheduled time after the last
+            // run has arrived. A late or slow poll never silently skips a tick — the
+            // overshot run still satisfies `nextRun <= now`, instead of needing `now`
+            // to land within a 1s window of the scheduled time.
+            const baseline = lastRun ?? new Date(now.getTime() - checkIntervalMs);
+            const nextRun = getNextCronRun(cronSchedule, baseline, schedule.timezone ?? 'UTC');
+            return nextRun.getTime() <= now.getTime();
         }
         case 'once': {
             if (!schedule.runAt)
                 return false;
             if (lastRun)
                 return false; // Already ran
+            // Fire as soon as the scheduled instant has arrived. A missed tick must
+            // not strand the job: once runAt is in the past (and it has never run),
+            // the next check still catches it, rather than only a ±checkInterval window.
             const runAt = new Date(schedule.runAt);
-            const diff = Math.abs(now.getTime() - runAt.getTime());
-            return diff <= checkIntervalMs;
+            return now.getTime() >= runAt.getTime();
         }
         default:
             return false;

package/dist/scheduler/scheduler.js

@@ -1,7 +1,9 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { writeFileAtomic } from '../utils/file.js';
 import { MissionExecutor } from '../interpreter/executor.js';
 import { getNextRunTime, shouldRunNow } from './cron-parser.js';
+import { setLongTimeout } from '../utils/long-timeout.js';
 /**
  * Scheduler for running missions on a schedule
  */
@@ -35,9 +37,18 @@ export class Scheduler {
             throw new Error(`Mission '${mission.name}' has no schedule defined`);
         }
         this.missions.set(mission.name, { mission, filePath });
-        // Create or update job state
+        // Create or update job state. A schedule that can never produce a next run
+        // (e.g. an impossible cron like Feb 31) must not abort registration — the
+        // job is registered with an undefined nextRun and the check loop isolates
+        // it so it can't starve sibling jobs.
         const existingJob = this.state.jobs[mission.name];
-        const nextRun = getNextRunTime(mission.schedule);
+        let nextRun = null;
+        try {
+            nextRun = getNextRunTime(mission.schedule);
+        }
+        catch (error) {
+            this.log(`Mission '${mission.name}' has an unschedulable cron: ${error.message}`);
+        }
         this.state.jobs[mission.name] = {
             id: mission.name,
             missionName: mission.name,
@@ -97,7 +108,7 @@ export class Scheduler {
         }
         // Clear all pending retry timers to prevent memory leaks
         for (const timer of this.retryTimers) {
-            clearTimeout(timer);
+            timer.clear();
         }
         this.retryTimers.clear();
         // Save state
@@ -109,19 +120,25 @@ export class Scheduler {
      */
     async checkAndRun() {
         const now = new Date();
+        // Each job is isolated: a throw while evaluating one schedule (e.g. an
+        // impossible cron) must not break the loop and starve siblings. Due jobs
+        // are dispatched without awaiting so a slow mission can't head-of-line
+        // block the rest of the tick.
         for (const [name, job] of Object.entries(this.state.jobs)) {
-            if (!job.enabled)
-                continue;
-            const scheduledMission = this.missions.get(name);
-            if (!scheduledMission)
-                continue;
-            const schedule = scheduledMission.mission.schedule;
-            if (!schedule)
-                continue; // Mission must have schedule
-            // Check if job should run
-            if (shouldRunNow(schedule, job.lastRun, this.config.checkInterval)) {
+            try {
+                if (!job.enabled)
+                    continue;
+                const scheduledMission = this.missions.get(name);
+                if (!scheduledMission)
+                    continue;
+                const schedule = scheduledMission.mission.schedule;
+                if (!schedule)
+                    continue; // Mission must have schedule
+                // Check if job should run
+                if (!shouldRunNow(schedule, job.lastRun, this.config.checkInterval))
+                    continue;
                 // Check if already running
-                if (job.isRunning && (schedule.skipIfRunning !== false)) {
+                if (job.isRunning && schedule.skipIfRunning !== false) {
                     this.emitEvent({
                         type: 'skipped',
                         jobId: job.id,
@@ -131,8 +148,14 @@ export class Scheduler {
                     });
                     continue;
                 }
-                // Run the job
-                await this.runJob(job, scheduledMission);
+                // Dispatch without awaiting: the loop keeps checking other jobs while
+                // this mission runs. Failures are handled inside runJob.
+                void this.runJob(job, scheduledMission).catch((error) => {
+                    this.log(`Job '${name}' run error: ${error.message}`);
+                });
+            }
+            catch (error) {
+                this.log(`Error checking job '${name}': ${error.message}`);
             }
         }
     }
@@ -206,8 +229,16 @@ export class Scheduler {
         }
         finally {
             job.isRunning = false;
-            // Calculate next run time
-            job.nextRun = getNextRunTime(scheduledMission.mission.schedule, new Date()) ?? undefined;
+            // Calculate next run time; never let an unschedulable cron throw out of
+            // the finally block and mask the run's real outcome.
+            try {
+                job.nextRun =
+                    getNextRunTime(scheduledMission.mission.schedule, new Date()) ?? undefined;
+            }
+            catch (error) {
+                job.nextRun = undefined;
+                this.log(`Could not compute next run for '${job.missionName}': ${error.message}`);
+            }
             await this.saveState();
         }
     }
@@ -221,8 +252,9 @@ export class Scheduler {
         if (job.consecutiveFailures <= retryConfig.maxRetries) {
             this.log(`Job '${job.missionName}' failed, retrying in ${retryConfig.delaySeconds}s ` +
                 `(attempt ${job.consecutiveFailures}/${retryConfig.maxRetries})`);
-            // Schedule retry and track the timer to prevent memory leaks
-            const timer = setTimeout(() => {
+            // Schedule retry and track the timer to prevent memory leaks. Use a
+            // long-delay-safe timer so a large retry delay can't overflow setTimeout.
+            const timer = setLongTimeout(() => {
                 this.retryTimers.delete(timer);
                 const scheduledMission = this.missions.get(job.missionName);
                 if (scheduledMission && this.running) {
@@ -318,7 +350,9 @@ export class Scheduler {
         try {
             await mkdir(this.config.stateDir, { recursive: true });
             const statePath = join(this.config.stateDir, 'state.json');
-            await writeFile(statePath, JSON.stringify(this.state, null, 2));
+            // Atomic write (temp file + fsync + rename) so a crash mid-write can't
+            // truncate or corrupt state.json.
+            await writeFileAtomic(statePath, JSON.stringify(this.state, null, 2));
         }
         catch (error) {
             this.log(`Failed to save scheduler state: ${error.message}`);

package/dist/stores/factory.d.ts

@@ -16,6 +16,12 @@ export interface CreateStoreOptions {
     postgrest?: Omit<PostgRESTOptions, 'table'>;
     /** Logger instance */
     logger?: Logger;
+    /**
+     * Explicitly allow sql/nosql to fall back to a local file store. Without
+     * this, an unimplemented sql/nosql store hard-errors rather than silently
+     * writing JSON to disk (a data-loss trap).
+     */
+    allowFileFallback?: boolean;
 }
 /**
  * Create a store adapter based on type

package/dist/stores/factory.js

@@ -40,6 +40,11 @@ export function createStore(options) {
                 });
             }
             // TODO: Implement raw SQL adapter (pg, mysql2, etc.)
+            if (!options.allowFileFallback) {
+                throw new Error(`SQL store is not implemented. Configure a PostgREST/Supabase backend, or ` +
+                    `opt into the local file fallback (enable development mode / allowFileFallback) ` +
+                    `for store '${options.name}'.`);
+            }
             logger.warn(`SQL store not yet implemented, falling back to file store for '${options.name}'`);
             return new FileStore(options.name, {
                 ...options.fileOptions,
@@ -47,6 +52,11 @@ export function createStore(options) {
             });
         case 'nosql':
             // TODO: Implement NoSQL adapter
+            if (!options.allowFileFallback) {
+                throw new Error(`NoSQL store is not implemented. Configure a real backend, or opt into the ` +
+                    `local file fallback (enable development mode / allowFileFallback) for ` +
+                    `store '${options.name}'.`);
+            }
             logger.warn(`NoSQL store not yet implemented, falling back to file store for '${options.name}'`);
             return new FileStore(options.name, {
                 ...options.fileOptions,
@@ -60,7 +70,7 @@ export function createStore(options) {
  * Map DSL store type to adapter type
  * In development mode, sql/nosql fall back to file stores
  */
-export function resolveStoreType(dslType, developmentMode = true) {
+export function resolveStoreType(dslType, developmentMode = false) {
     // These types are used directly
     if (dslType === 'memory' || dslType === 'file' || dslType === 'postgrest') {
         return dslType;

package/dist/stores/file.js

@@ -1,8 +1,10 @@
 import { writeFile } from 'node:fs/promises';
-import { writeFileSync, existsSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { applyStoreFilter } from './types.js';
-import { ensureDirectory, readJsonFile, serialize, } from '../utils/file.js';
+import { ensureDirectory, readJsonFile, serialize, writeFileAtomic, writeFileAtomicSync, } from '../utils/file.js';
+import { safeJoin } from '../utils/path.js';
+import { deepMerge } from '../utils/deep-merge.js';
 const DEFAULT_OPTIONS = {
     baseDir: '.reqon-data',
     persist: 'immediate',
@@ -44,7 +46,7 @@ export class FileStore {
      */
     constructor(name, options = {}) {
         this.options = { ...DEFAULT_OPTIONS, ...options };
-        this.filePath = join(this.options.baseDir, `${name}.json`);
+        this.filePath = safeJoin(this.options.baseDir, `${name}.json`);
         // Lazy initialization - init() is called on first operation
     }
     /**
@@ -111,14 +113,14 @@ export class FileStore {
     async writeToDisk() {
         const obj = Object.fromEntries(this.data);
         const content = serialize(obj, this.options.pretty);
-        await writeFile(this.filePath, content, 'utf-8');
+        await writeFileAtomic(this.filePath, content);
         this.dirty = false;
     }
     /** Synchronous write for flush/close operations */
     writeToDiskSync() {
         const obj = Object.fromEntries(this.data);
         const content = serialize(obj, this.options.pretty);
-        writeFileSync(this.filePath, content, 'utf-8');
+        writeFileAtomicSync(this.filePath, content);
         this.dirty = false;
     }
     async get(key) {
@@ -144,12 +146,7 @@ export class FileStore {
         // Upsert all records in memory first (no disk I/O per record)
         for (const { key, value } of records) {
             const existing = this.data.get(key);
-            if (existing) {
-                this.data.set(key, { ...existing, ...value });
-            }
-            else {
-                this.data.set(key, { ...value });
-            }
+            this.data.set(key, existing ? deepMerge(existing, value) : { ...value });
         }
         // Single persist operation for all records
         await this.persist();
@@ -157,12 +154,7 @@ export class FileStore {
     async update(key, value) {
         await this.ensureInitialized();
         const existing = this.data.get(key);
-        if (existing) {
-            this.data.set(key, { ...existing, ...value });
-        }
-        else {
-            this.data.set(key, value);
-        }
+        this.data.set(key, existing ? deepMerge(existing, value) : { ...value });
         await this.persist();
     }
     async delete(key) {

package/dist/stores/memory.js

@@ -1,4 +1,5 @@
 import { applyStoreFilter } from './types.js';
+import { deepMerge } from '../utils/deep-merge.js';
 export class MemoryStore {
     data = new Map();
     name;
@@ -19,22 +20,12 @@ export class MemoryStore {
     async bulkUpsert(records) {
         for (const { key, value } of records) {
             const existing = this.data.get(key);
-            if (existing) {
-                this.data.set(key, { ...existing, ...value });
-            }
-            else {
-                this.data.set(key, { ...value });
-            }
+            this.data.set(key, existing ? deepMerge(existing, value) : { ...value });
         }
     }
     async update(key, value) {
         const existing = this.data.get(key);
-        if (existing) {
-            this.data.set(key, { ...existing, ...value });
-        }
-        else {
-            this.data.set(key, value);
-        }
+        this.data.set(key, existing ? deepMerge(existing, value) : { ...value });
     }
     async delete(key) {
         this.data.delete(key);