@objectstack/driver-memory 4.0.3 → 4.0.5

package/src/memory-matcher.ts

@@ -1,177 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-
-/**
- * Simple In-Memory Query Matcher
- * 
- * Implements a subset of the ObjectStack Filter Protocol (MongoDB-compatible)
- * for evaluating conditions against in-memory JavaScript objects.
- */
-
-type RecordType = Record<string, any>;
-
-/**
- * matches - Check if a record matches a filter criteria
- * @param record The data record to check
- * @param filter The filter condition (where clause)
- */
-export function match(record: RecordType, filter: any): boolean {
-    if (!filter || Object.keys(filter).length === 0) return true;
-    
-    // 1. Handle Top-Level Logical Operators ($and, $or, $not)
-    // These usually appear at the root or nested.
-    
-    // $and: [ { ... }, { ... } ]
-    if (Array.isArray(filter.$and)) {
-        if (!filter.$and.every((f: any) => match(record, f))) {
-            return false;
-        }
-    }
-    
-    // $or: [ { ... }, { ... } ]
-    if (Array.isArray(filter.$or)) {
-        if (!filter.$or.some((f: any) => match(record, f))) {
-            return false;
-        }
-    }
-    
-    // $not: { ... }
-    if (filter.$not) {
-        if (match(record, filter.$not)) {
-            return false;
-        }
-    }
-    
-    // 2. Iterate over field constraints
-    for (const key of Object.keys(filter)) {
-        // Skip logical operators we already handled (or future ones)
-        if (key.startsWith('$')) continue;
-        
-        const condition = filter[key];
-        const value = getValueByPath(record, key);
-        
-        if (!checkCondition(value, condition)) {
-            return false;
-        }
-    }
-    
-    return true;
-}
-
-/**
- * Access nested properties via dot-notation (e.g. "user.name")
- */
-export function getValueByPath(obj: any, path: string): any {
-    if (!path.includes('.')) return obj[path];
-    return path.split('.').reduce((o, i) => (o ? o[i] : undefined), obj);
-}
-
-/**
- * Evaluate a specific condition against a value
- */
-function checkCondition(value: any, condition: any): boolean {
-    // Case A: Implicit Equality (e.g. status: 'active')
-    // If condition is a primitive or Date/Array (exact match), treat as equality.
-    if (
-        typeof condition !== 'object' || 
-        condition === null || 
-        condition instanceof Date ||
-        Array.isArray(condition)
-    ) {
-        // Loose equality to handle undefined/null mismatch or string/number coercion if desired.
-        // But stick to == for JS loose equality which is often convenient in weakly typed queries.
-        return value == condition;
-    }
-    
-    // Case B: Operator Object (e.g. { $gt: 10, $lt: 20 })
-    const keys = Object.keys(condition);
-    const isOperatorObject = keys.some(k => k.startsWith('$'));
-    
-    if (!isOperatorObject) {
-         // It's just a nested object comparison or implicit equality against an object
-         // Simplistic check:
-         return JSON.stringify(value) === JSON.stringify(condition);
-    }
-
-    // Iterate operators
-    for (const op of keys) {
-        const target = condition[op];
-        
-        // Handle undefined values
-        if (value === undefined && op !== '$exists' && op !== '$ne' && op !== '$null') {
-            return false; 
-        }
-
-        switch (op) {
-            case '$eq': 
-                if (value != target) return false; 
-                break;
-            case '$ne': 
-                if (value == target) return false; 
-                break;
-            
-            // Numeric / Date
-            case '$gt': 
-                if (!(value > target)) return false; 
-                break;
-            case '$gte': 
-                if (!(value >= target)) return false; 
-                break;
-            case '$lt': 
-                if (!(value < target)) return false; 
-                break;
-            case '$lte': 
-                if (!(value <= target)) return false; 
-                break;
-            case '$between':
-                // target should be [min, max]
-                if (Array.isArray(target) && (value < target[0] || value > target[1])) return false;
-                break;
-
-            // Sets
-            case '$in': 
-                if (!Array.isArray(target) || !target.includes(value)) return false; 
-                break;
-            case '$nin': 
-                if (Array.isArray(target) && target.includes(value)) return false; 
-                break;
-            
-            // Existence
-            case '$exists':
-                const exists = value !== undefined && value !== null;
-                if (exists !== !!target) return false;
-                break;
-
-            // Strings
-            case '$contains': 
-                if (typeof value !== 'string' || !value.includes(target)) return false; 
-                break;
-            case '$notContains':
-                if (typeof value !== 'string' || value.includes(target)) return false;
-                break;
-            case '$startsWith': 
-                if (typeof value !== 'string' || !value.startsWith(target)) return false; 
-                break;
-            case '$endsWith': 
-                if (typeof value !== 'string' || !value.endsWith(target)) return false; 
-                break;
-            case '$null':
-                // $null: true → value must be null/undefined; $null: false → value must not be null/undefined
-                if (target === true && value != null) return false;
-                if (target === false && value == null) return false;
-                break;
-            case '$regex':
-                try {
-                    const re = new RegExp(target, condition.$options || '');
-                    if (!re.test(String(value))) return false;
-                } catch (e) { return false; }
-                break;
-
-            default: 
-                // Unknown operator, ignore or fail. Ignoring safe for optional features.
-                break;
-        }
-    }
-    
-    return true;
-}

package/src/persistence/file-adapter.ts

@@ -1,103 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-/**
- * FileSystemPersistenceAdapter
- *
- * Persists the in-memory database to a JSON file on disk.
- * Supports atomic writes (write to temp file then rename) and auto-save with dirty tracking.
- *
- * Node.js only — will throw if used in non-Node.js environments.
- */
-export class FileSystemPersistenceAdapter {
-  private readonly filePath: string;
-  private readonly autoSaveInterval: number;
-  private dirty = false;
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private currentDb: Record<string, any[]> | null = null;
-
-  constructor(options?: { path?: string; autoSaveInterval?: number }) {
-    this.filePath = options?.path || path.join('.objectstack', 'data', 'memory-driver.json');
-    this.autoSaveInterval = options?.autoSaveInterval ?? 2000;
-  }
-
-  /**
-   * Load persisted data from disk.
-   * Returns null if no file exists.
-   */
-  async load(): Promise<Record<string, any[]> | null> {
-    try {
-      if (!fs.existsSync(this.filePath)) {
-        return null;
-      }
-      const raw = fs.readFileSync(this.filePath, 'utf-8');
-      const data = JSON.parse(raw);
-      return data as Record<string, any[]>;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Save data to disk using atomic write (temp file + rename).
-   */
-  async save(db: Record<string, any[]>): Promise<void> {
-    this.currentDb = db;
-    this.dirty = true;
-  }
-
-  /**
-   * Flush pending writes to disk immediately.
-   */
-  async flush(): Promise<void> {
-    if (!this.dirty || !this.currentDb) return;
-    await this.writeToDisk(this.currentDb);
-    this.dirty = false;
-  }
-
-  /**
-   * Start the auto-save timer.
-   */
-  startAutoSave(): void {
-    if (this.timer) return;
-    this.timer = setInterval(async () => {
-      if (this.dirty && this.currentDb) {
-        await this.writeToDisk(this.currentDb);
-        this.dirty = false;
-      }
-    }, this.autoSaveInterval);
-
-    // Allow process to exit even if timer is running
-    if (this.timer) {
-      this.timer.unref();
-    }
-  }
-
-  /**
-   * Stop the auto-save timer and flush pending writes.
-   */
-  async stopAutoSave(): Promise<void> {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    await this.flush();
-  }
-
-  /**
-   * Atomic write: write to temp file, then rename.
-   */
-  private async writeToDisk(db: Record<string, any[]>): Promise<void> {
-    const dir = path.dirname(this.filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    const tmpPath = this.filePath + '.tmp';
-    const json = JSON.stringify(db, null, 2);
-    fs.writeFileSync(tmpPath, json, 'utf-8');
-    fs.renameSync(tmpPath, this.filePath);
-  }
-}

package/src/persistence/index.ts

@@ -1,4 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-export { FileSystemPersistenceAdapter } from './file-adapter.js';
-export { LocalStoragePersistenceAdapter } from './local-storage-adapter.js';

package/src/persistence/local-storage-adapter.ts

@@ -1,60 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-/**
- * LocalStoragePersistenceAdapter
- *
- * Persists the in-memory database to browser localStorage.
- * Synchronous storage with a ~5MB size limit warning.
- *
- * Browser only — will throw if used in non-browser environments.
- */
-export class LocalStoragePersistenceAdapter {
-  private readonly storageKey: string;
-  private static readonly SIZE_WARNING_BYTES = 4.5 * 1024 * 1024; // 4.5MB warning threshold
-
-  constructor(options?: { key?: string }) {
-    this.storageKey = options?.key || 'objectstack:memory-db';
-  }
-
-  /**
-   * Load persisted data from localStorage.
-   * Returns null if no data exists.
-   */
-  async load(): Promise<Record<string, any[]> | null> {
-    try {
-      const raw = localStorage.getItem(this.storageKey);
-      if (!raw) return null;
-      return JSON.parse(raw) as Record<string, any[]>;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Save data to localStorage.
-   * Warns if data size approaches the ~5MB localStorage limit.
-   */
-  async save(db: Record<string, any[]>): Promise<void> {
-    const json = JSON.stringify(db);
-
-    if (json.length > LocalStoragePersistenceAdapter.SIZE_WARNING_BYTES) {
-      console.warn(
-        `[ObjectStack] localStorage persistence data size (${(json.length / 1024 / 1024).toFixed(2)}MB) ` +
-        `is approaching the ~5MB limit. Consider using a different persistence strategy.`
-      );
-    }
-
-    try {
-      localStorage.setItem(this.storageKey, json);
-    } catch (e: any) {
-      console.error('[ObjectStack] Failed to persist data to localStorage:', e?.message || e);
-    }
-  }
-
-  /**
-   * Flush is a no-op for localStorage (writes are synchronous).
-   */
-  async flush(): Promise<void> {
-    // localStorage writes are synchronous, no flushing needed
-  }
-}

package/src/persistence/persistence.test.ts

@@ -1,298 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { InMemoryDriver } from '../memory-driver.js';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-const TEST_DATA_DIR = path.join('/tmp', 'objectstack-test-persistence');
-const TEST_FILE_PATH = path.join(TEST_DATA_DIR, 'test-db.json');
-
-describe('InMemoryDriver Persistence', () => {
-  beforeEach(() => {
-    // Clean up test directory
-    if (fs.existsSync(TEST_DATA_DIR)) {
-      fs.rmSync(TEST_DATA_DIR, { recursive: true });
-    }
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(TEST_DATA_DIR)) {
-      fs.rmSync(TEST_DATA_DIR, { recursive: true });
-    }
-  });
-
-  describe('File Persistence', () => {
-    it('should persist and restore data via file adapter', async () => {
-      // Create and populate driver with file persistence
-      const driver1 = new InMemoryDriver({
-        persistence: { type: 'file', path: TEST_FILE_PATH, autoSaveInterval: 100 },
-      });
-      await driver1.connect();
-      await driver1.create('users', { id: '1', name: 'Alice' });
-      await driver1.create('users', { id: '2', name: 'Bob' });
-
-      // Flush and disconnect
-      await driver1.flush();
-      await driver1.disconnect();
-
-      // Verify file was created
-      expect(fs.existsSync(TEST_FILE_PATH)).toBe(true);
-
-      // Create a new driver and verify data is restored
-      const driver2 = new InMemoryDriver({
-        persistence: { type: 'file', path: TEST_FILE_PATH, autoSaveInterval: 100 },
-      });
-      await driver2.connect();
-
-      const users = await driver2.find('users', { object: 'users' });
-      expect(users).toHaveLength(2);
-      expect(users[0].name).toBe('Alice');
-      expect(users[1].name).toBe('Bob');
-
-      await driver2.disconnect();
-    });
-
-    it('should support shorthand "file" persistence string', async () => {
-      // Use shorthand — just verifies no error is thrown with 'file'
-      const driver = new InMemoryDriver({ persistence: 'file' });
-      await driver.connect();
-      await driver.create('items', { id: '1', name: 'Widget' });
-      await driver.disconnect();
-    });
-
-    it('should persist updates and deletes', async () => {
-      const driver1 = new InMemoryDriver({
-        persistence: { type: 'file', path: TEST_FILE_PATH, autoSaveInterval: 100 },
-      });
-      await driver1.connect();
-
-      // Create, update, and delete
-      await driver1.create('tasks', { id: '1', title: 'Task A', done: false });
-      await driver1.create('tasks', { id: '2', title: 'Task B', done: false });
-      await driver1.update('tasks', '1', { done: true });
-      await driver1.delete('tasks', '2');
-
-      await driver1.flush();
-      await driver1.disconnect();
-
-      // Restore
-      const driver2 = new InMemoryDriver({
-        persistence: { type: 'file', path: TEST_FILE_PATH, autoSaveInterval: 100 },
-      });
-      await driver2.connect();
-
-      const tasks = await driver2.find('tasks', { object: 'tasks' });
-      expect(tasks).toHaveLength(1);
-      expect(tasks[0].id).toBe('1');
-      expect(tasks[0].done).toBe(true);
-
-      await driver2.disconnect();
-    });
-
-    it('should handle missing persistence file gracefully', async () => {
-      const driver = new InMemoryDriver({
-        persistence: { type: 'file', path: '/tmp/nonexistent/path/db.json' },
-      });
-      await driver.connect();
-
-      const users = await driver.find('users', { object: 'users' });
-      expect(users).toHaveLength(0);
-
-      await driver.disconnect();
-    });
-  });
-
-  describe('Custom Adapter Persistence', () => {
-    it('should use a custom adapter for persistence', async () => {
-      const stored: Record<string, any[]> = {};
-      const customAdapter = {
-        load: async () => Object.keys(stored).length > 0 ? { ...stored } : null,
-        save: async (db: Record<string, any[]>) => {
-          for (const [k, v] of Object.entries(db)) {
-            stored[k] = [...v];
-          }
-        },
-        flush: async () => {},
-      };
-
-      const driver1 = new InMemoryDriver({
-        persistence: { adapter: customAdapter },
-      });
-      await driver1.connect();
-      await driver1.create('projects', { id: '1', name: 'Alpha' });
-      await driver1.disconnect();
-
-      // Verify data was saved via custom adapter
-      expect(stored.projects).toBeDefined();
-      expect(stored.projects).toHaveLength(1);
-
-      // Restore from custom adapter
-      const driver2 = new InMemoryDriver({
-        persistence: { adapter: customAdapter },
-      });
-      await driver2.connect();
-      const projects = await driver2.find('projects', { object: 'projects' });
-      expect(projects).toHaveLength(1);
-      expect(projects[0].name).toBe('Alpha');
-
-      await driver2.disconnect();
-    });
-  });
-
-  describe('Pure Memory (No Persistence)', () => {
-    it('should work without persistence when explicitly disabled', async () => {
-      const driver = new InMemoryDriver({ persistence: false });
-      await driver.connect();
-
-      await driver.create('items', { id: '1', name: 'Widget' });
-      const items = await driver.find('items', { object: 'items' });
-      expect(items).toHaveLength(1);
-
-      await driver.disconnect();
-
-      // After disconnect, data is gone
-      const itemsAfter = await driver.find('items', { object: 'items' });
-      expect(itemsAfter).toHaveLength(0);
-    });
-  });
-
-  describe('Auto Persistence', () => {
-    it('should auto-detect Node.js environment and use file persistence with shorthand', async () => {
-      // In Node.js, 'auto' should select file persistence
-      const driver = new InMemoryDriver({ persistence: 'auto' });
-      await driver.connect();
-      await driver.create('items', { id: '1', name: 'Widget' });
-      await driver.disconnect();
-    });
-
-    it('should auto-detect Node.js environment and use file persistence with object config', async () => {
-      const filePath = path.join(TEST_DATA_DIR, 'auto-test-db.json');
-      const driver1 = new InMemoryDriver({
-        persistence: { type: 'auto', path: filePath, autoSaveInterval: 100 },
-      });
-      await driver1.connect();
-      await driver1.create('users', { id: '1', name: 'Alice' });
-      await driver1.flush();
-      await driver1.disconnect();
-
-      // Verify file was created (Node.js env selects file adapter)
-      expect(fs.existsSync(filePath)).toBe(true);
-
-      // Restore from file
-      const driver2 = new InMemoryDriver({
-        persistence: { type: 'auto', path: filePath, autoSaveInterval: 100 },
-      });
-      await driver2.connect();
-      const users = await driver2.find('users', { object: 'users' });
-      expect(users).toHaveLength(1);
-      expect(users[0].name).toBe('Alice');
-      await driver2.disconnect();
-    });
-  });
-
-  describe('Bulk Operations with Persistence', () => {
-    it('should persist bulk creates', async () => {
-      const driver1 = new InMemoryDriver({
-        persistence: { type: 'file', path: TEST_FILE_PATH, autoSaveInterval: 100 },
-      });
-      await driver1.connect();
-      await driver1.bulkCreate('items', [
-        { id: '1', name: 'A' },
-        { id: '2', name: 'B' },
-        { id: '3', name: 'C' },
-      ]);
-      await driver1.flush();
-      await driver1.disconnect();
-
-      const driver2 = new InMemoryDriver({
-        persistence: { type: 'file', path: TEST_FILE_PATH, autoSaveInterval: 100 },
-      });
-      await driver2.connect();
-      const items = await driver2.find('items', { object: 'items' });
-      expect(items).toHaveLength(3);
-      await driver2.disconnect();
-    });
-  });
-
-  describe('Serverless Environment Detection', () => {
-    const serverlessEnvVars = [
-      'VERCEL',
-      'VERCEL_ENV',
-      'AWS_LAMBDA_FUNCTION_NAME',
-      'NETLIFY',
-      'FUNCTIONS_WORKER_RUNTIME',
-      'K_SERVICE',
-      'FUNCTION_TARGET',
-      'DENO_DEPLOYMENT_ID',
-    ];
-
-    afterEach(() => {
-      // Clean up all serverless env vars after each test
-      for (const key of serverlessEnvVars) {
-        delete process.env[key];
-      }
-    });
-
-    it('should disable file persistence in auto mode when VERCEL env is set', async () => {
-      process.env.VERCEL = '1';
-      const filePath = path.join(TEST_DATA_DIR, 'serverless-test.json');
-      const driver = new InMemoryDriver({
-        persistence: { type: 'auto', path: filePath },
-      });
-      await driver.connect();
-      await driver.create('items', { id: '1', name: 'Widget' });
-      await driver.flush();
-      await driver.disconnect();
-
-      // File should NOT have been created because auto mode skips file persistence in serverless
-      expect(fs.existsSync(filePath)).toBe(false);
-    });
-
-    it('should disable file persistence in auto shorthand mode when AWS_LAMBDA_FUNCTION_NAME is set', async () => {
-      process.env.AWS_LAMBDA_FUNCTION_NAME = 'my-function';
-      const driver = new InMemoryDriver({ persistence: 'auto' });
-      await driver.connect();
-      await driver.create('items', { id: '1', name: 'Widget' });
-
-      // Should work as pure in-memory without errors
-      const items = await driver.find('items', { object: 'items' });
-      expect(items).toHaveLength(1);
-
-      await driver.disconnect();
-    });
-
-    it('should still allow explicit file persistence in serverless if user requests it', async () => {
-      process.env.VERCEL = '1';
-      const filePath = path.join(TEST_DATA_DIR, 'explicit-file-serverless.json');
-      const driver = new InMemoryDriver({
-        persistence: { type: 'file', path: filePath, autoSaveInterval: 100 },
-      });
-      await driver.connect();
-      await driver.create('items', { id: '1', name: 'Widget' });
-      await driver.flush();
-      await driver.disconnect();
-
-      // Explicit 'file' type should still create the file even in serverless
-      expect(fs.existsSync(filePath)).toBe(true);
-    });
-
-    it('should still allow custom adapter in serverless', async () => {
-      process.env.NETLIFY = 'true';
-      const stored: Record<string, any[]> = {};
-      const customAdapter = {
-        load: async () => Object.keys(stored).length > 0 ? { ...stored } : null,
-        save: async (db: Record<string, any[]>) => {
-          for (const [k, v] of Object.entries(db)) { stored[k] = [...v]; }
-        },
-        flush: async () => {},
-      };
-
-      const driver = new InMemoryDriver({ persistence: { adapter: customAdapter } });
-      await driver.connect();
-      await driver.create('items', { id: '1', name: 'Widget' });
-      await driver.disconnect();
-
-      expect(stored.items).toBeDefined();
-      expect(stored.items).toHaveLength(1);
-    });
-  });
-});

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "moduleResolution": "bundler",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "forceConsistentCasingInFileNames": true,
-    "types": [
-      "node"
-    ],
-    "rootDir": "./src"
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}