@objectstack/driver-memory 1.0.2 → 1.0.5

package/dist/memory-driver.js

@@ -1,404 +0,0 @@
-import { createLogger } from '@objectstack/core';
-import { match, getValueByPath } from './memory-matcher.js';
-/**
- * Example: In-Memory Driver
- *
- * A minimal reference implementation of the ObjectStack Driver Protocol.
- * This driver stores data in a simple JavaScript object (Heap).
- */
-export class InMemoryDriver {
-    constructor(config) {
-        this.name = 'in-memory-driver';
-        this.version = '0.0.1';
-        this.supports = {
-            // Transaction & Connection Management
-            transactions: false,
-            // Query Operations
-            queryFilters: true, // Implemented via memory-matcher
-            queryAggregations: true, // Implemented
-            querySorting: true, // Implemented via JS sort
-            queryPagination: true, // Implemented
-            queryWindowFunctions: false, // TODO: Not implemented
-            querySubqueries: false, // TODO: Not implemented
-            joins: false, // TODO: Not implemented
-            // Advanced Features
-            fullTextSearch: false, // TODO: Not implemented
-            vectorSearch: false, // TODO: Not implemented
-            geoSpatial: false, // TODO: Not implemented
-            jsonFields: true, // Native JS object support
-            arrayFields: true, // Native JS array support
-        };
-        /**
-         * The "Database": A map of TableName -> Array of Records
-         */
-        this.db = {};
-        this.config = config || {};
-        this.logger = config?.logger || createLogger({ level: 'info', format: 'pretty' });
-        this.logger.debug('InMemory driver instance created', { config: this.config });
-    }
-    // Duck-typed RuntimePlugin hook
-    install(ctx) {
-        this.logger.debug('Installing InMemory driver via plugin hook');
-        if (ctx.engine && ctx.engine.ql && typeof ctx.engine.ql.registerDriver === 'function') {
-            ctx.engine.ql.registerDriver(this);
-            this.logger.info('InMemory driver registered with ObjectQL engine');
-        }
-        else {
-            this.logger.warn('Could not register driver - ObjectQL engine not found in context');
-        }
-    }
-    // ===================================
-    // Lifecycle
-    // ===================================
-    async connect() {
-        this.logger.info('InMemory Database Connected (Virtual)');
-    }
-    async disconnect() {
-        const tableCount = Object.keys(this.db).length;
-        const recordCount = Object.values(this.db).reduce((sum, table) => sum + table.length, 0);
-        this.db = {};
-        this.logger.info('InMemory Database Disconnected & Cleared', {
-            tableCount,
-            recordCount
-        });
-    }
-    async checkHealth() {
-        this.logger.debug('Health check performed', {
-            tableCount: Object.keys(this.db).length,
-            status: 'healthy'
-        });
-        return true;
-    }
-    // ===================================
-    // Execution
-    // ===================================
-    async execute(command, params) {
-        this.logger.warn('Raw execution not supported in InMemory driver', { command });
-        return null;
-    }
-    // ===================================
-    // CRUD
-    // ===================================
-    async find(object, query, options) {
-        this.logger.debug('Find operation', { object, query });
-        const table = this.getTable(object);
-        let results = table;
-        // 1. Filter
-        if (query.where) {
-            results = results.filter(record => match(record, query.where));
-        }
-        // 1.5 Aggregation & Grouping
-        if (query.groupBy || (query.aggregations && query.aggregations.length > 0)) {
-            results = this.performAggregation(results, query);
-        }
-        // 2. Sort
-        if (query.orderBy) {
-            // Normalize sort to array
-            const sortFields = Array.isArray(query.orderBy) ? query.orderBy : [query.orderBy];
-            results.sort((a, b) => {
-                for (const { field, order } of sortFields) {
-                    const valA = getValueByPath(a, field);
-                    const valB = getValueByPath(b, field);
-                    if (valA === valB)
-                        continue;
-                    const comparison = valA > valB ? 1 : -1;
-                    return order === 'desc' ? -comparison : comparison;
-                }
-                return 0;
-            });
-        }
-        // 3. Pagination (Offset)
-        if (query.offset) {
-            results = results.slice(query.offset);
-        }
-        // 4. Pagination (Limit)
-        if (query.limit) {
-            results = results.slice(0, query.limit);
-        }
-        this.logger.debug('Find completed', { object, resultCount: results.length });
-        return results;
-    }
-    async *findStream(object, query, options) {
-        this.logger.debug('FindStream operation', { object });
-        const results = await this.find(object, query, options);
-        for (const record of results) {
-            yield record;
-        }
-    }
-    async findOne(object, query, options) {
-        this.logger.debug('FindOne operation', { object, query });
-        const results = await this.find(object, { ...query, limit: 1 }, options);
-        const result = results[0] || null;
-        this.logger.debug('FindOne completed', { object, found: !!result });
-        return result;
-    }
-    async create(object, data, options) {
-        this.logger.debug('Create operation', { object, hasData: !!data });
-        const table = this.getTable(object);
-        // COMPATIBILITY: Driver must return 'id' as string
-        const newRecord = {
-            id: data.id || this.generateId(),
-            ...data,
-            created_at: data.created_at || new Date(),
-            updated_at: data.updated_at || new Date(),
-        };
-        table.push(newRecord);
-        this.logger.debug('Record created', { object, id: newRecord.id, tableSize: table.length });
-        return newRecord;
-    }
-    async update(object, id, data, options) {
-        this.logger.debug('Update operation', { object, id });
-        const table = this.getTable(object);
-        const index = table.findIndex(r => r.id == id);
-        if (index === -1) {
-            this.logger.warn('Record not found for update', { object, id });
-            throw new Error(`Record with ID ${id} not found in ${object}`);
-        }
-        const updatedRecord = {
-            ...table[index],
-            ...data,
-            updated_at: new Date()
-        };
-        table[index] = updatedRecord;
-        this.logger.debug('Record updated', { object, id });
-        return updatedRecord;
-    }
-    async upsert(object, data, conflictKeys, options) {
-        this.logger.debug('Upsert operation', { object, conflictKeys });
-        const table = this.getTable(object);
-        let existingRecord = null;
-        if (data.id) {
-            existingRecord = table.find(r => r.id === data.id);
-        }
-        else if (conflictKeys && conflictKeys.length > 0) {
-            existingRecord = table.find(r => conflictKeys.every(key => r[key] === data[key]));
-        }
-        if (existingRecord) {
-            this.logger.debug('Record exists, updating', { object, id: existingRecord.id });
-            return this.update(object, existingRecord.id, data, options);
-        }
-        else {
-            this.logger.debug('Record does not exist, creating', { object });
-            return this.create(object, data, options);
-        }
-    }
-    async delete(object, id, options) {
-        this.logger.debug('Delete operation', { object, id });
-        const table = this.getTable(object);
-        const index = table.findIndex(r => r.id == id);
-        if (index === -1) {
-            this.logger.warn('Record not found for deletion', { object, id });
-            return false;
-        }
-        table.splice(index, 1);
-        this.logger.debug('Record deleted', { object, id, tableSize: table.length });
-        return true;
-    }
-    async count(object, query, options) {
-        let results = this.getTable(object);
-        if (query?.where) {
-            results = results.filter(record => match(record, query.where));
-        }
-        const count = results.length;
-        this.logger.debug('Count operation', { object, count });
-        return count;
-    }
-    // ===================================
-    // Bulk Operations
-    // ===================================
-    async bulkCreate(object, dataArray, options) {
-        this.logger.debug('BulkCreate operation', { object, count: dataArray.length });
-        const results = await Promise.all(dataArray.map(data => this.create(object, data, options)));
-        this.logger.debug('BulkCreate completed', { object, count: results.length });
-        return results;
-    }
-    async updateMany(object, query, data, options) {
-        this.logger.debug('UpdateMany operation', { object, query });
-        const table = this.getTable(object);
-        let targetRecords = table;
-        if (query && query.where) {
-            targetRecords = targetRecords.filter(r => match(r, query.where));
-        }
-        const count = targetRecords.length;
-        // Update each record
-        for (const record of targetRecords) {
-            // Find index in original table
-            const index = table.findIndex(r => r.id === record.id);
-            if (index !== -1) {
-                const updated = {
-                    ...table[index],
-                    ...data,
-                    updated_at: new Date()
-                };
-                table[index] = updated;
-            }
-        }
-        this.logger.debug('UpdateMany completed', { object, count });
-        return { count };
-    }
-    async deleteMany(object, query, options) {
-        this.logger.debug('DeleteMany operation', { object, query });
-        const table = this.getTable(object);
-        const initialLength = table.length;
-        // Filter IN PLACE or create new array?
-        // Creating new array is safer for now.
-        const remaining = table.filter(r => {
-            if (!query || !query.where)
-                return false; // Delete all? No, standard safety implies explicit empty filter for delete all.
-            // Wait, normally deleteMany({}) deletes all.
-            // Let's assume if query passed, use it.
-            const matches = match(r, query.where);
-            return !matches; // Keep if it DOES NOT match
-        });
-        this.db[object] = remaining;
-        const count = initialLength - remaining.length;
-        this.logger.debug('DeleteMany completed', { object, count });
-        return { count };
-    }
-    // Compatibility aliases
-    async bulkUpdate(object, updates, options) {
-        this.logger.debug('BulkUpdate operation', { object, count: updates.length });
-        const results = await Promise.all(updates.map(u => this.update(object, u.id, u.data, options)));
-        this.logger.debug('BulkUpdate completed', { object, count: results.length });
-        return results;
-    }
-    async bulkDelete(object, ids, options) {
-        this.logger.debug('BulkDelete operation', { object, count: ids.length });
-        await Promise.all(ids.map(id => this.delete(object, id, options)));
-        this.logger.debug('BulkDelete completed', { object, count: ids.length });
-    }
-    // ===================================
-    // Schema & Transactions
-    // ===================================
-    async syncSchema(object, schema, options) {
-        if (!this.db[object]) {
-            this.db[object] = [];
-            this.logger.info('Created in-memory table', { object });
-        }
-    }
-    async dropTable(object, options) {
-        if (this.db[object]) {
-            const recordCount = this.db[object].length;
-            delete this.db[object];
-            this.logger.info('Dropped in-memory table', { object, recordCount });
-        }
-    }
-    async beginTransaction() {
-        throw new Error('Transactions not supported in InMemoryDriver');
-    }
-    async commit() { }
-    async rollback() { }
-    // ===================================
-    // Aggregation Logic
-    // ===================================
-    performAggregation(records, query) {
-        const { groupBy, aggregations } = query;
-        const groups = new Map();
-        // 1. Group records
-        if (groupBy && groupBy.length > 0) {
-            for (const record of records) {
-                // Create a composite key from group values
-                const keyParts = groupBy.map(field => {
-                    const val = getValueByPath(record, field);
-                    return val === undefined || val === null ? 'null' : String(val);
-                });
-                const key = JSON.stringify(keyParts);
-                if (!groups.has(key)) {
-                    groups.set(key, []);
-                }
-                groups.get(key).push(record);
-            }
-        }
-        else {
-            // No grouping -> Single group containing all records
-            // If aggregation is requested without group by, it runs on whole set (even if empty)
-            if (aggregations && aggregations.length > 0) {
-                groups.set('all', records);
-            }
-            else {
-                // Should not be here if performAggregation called correctly
-                groups.set('all', records);
-            }
-        }
-        // 2. Compute aggregates for each group
-        const resultRows = [];
-        for (const [key, groupRecords] of groups.entries()) {
-            const row = {};
-            // A. Add Group fields to row (if groupBy exists)
-            if (groupBy && groupBy.length > 0) {
-                if (groupRecords.length > 0) {
-                    const firstRecord = groupRecords[0];
-                    for (const field of groupBy) {
-                        this.setValueByPath(row, field, getValueByPath(firstRecord, field));
-                    }
-                }
-            }
-            // B. Compute Aggregations
-            if (aggregations) {
-                for (const agg of aggregations) {
-                    const value = this.computeAggregate(groupRecords, agg);
-                    row[agg.alias] = value;
-                }
-            }
-            resultRows.push(row);
-        }
-        return resultRows;
-    }
-    computeAggregate(records, agg) {
-        const { function: func, field } = agg;
-        const values = field ? records.map(r => getValueByPath(r, field)) : [];
-        switch (func) {
-            case 'count':
-                if (!field || field === '*')
-                    return records.length;
-                return values.filter(v => v !== null && v !== undefined).length;
-            case 'sum':
-            case 'avg': {
-                const nums = values.filter(v => typeof v === 'number');
-                const sum = nums.reduce((a, b) => a + b, 0);
-                if (func === 'sum')
-                    return sum;
-                return nums.length > 0 ? sum / nums.length : null;
-            }
-            case 'min': {
-                // Handle comparable values
-                const valid = values.filter(v => v !== null && v !== undefined);
-                if (valid.length === 0)
-                    return null;
-                // Works for numbers and strings
-                return valid.reduce((min, v) => (v < min ? v : min), valid[0]);
-            }
-            case 'max': {
-                const valid = values.filter(v => v !== null && v !== undefined);
-                if (valid.length === 0)
-                    return null;
-                return valid.reduce((max, v) => (v > max ? v : max), valid[0]);
-            }
-            default:
-                return null;
-        }
-    }
-    setValueByPath(obj, path, value) {
-        const parts = path.split('.');
-        let current = obj;
-        for (let i = 0; i < parts.length - 1; i++) {
-            const part = parts[i];
-            if (!current[part])
-                current[part] = {};
-            current = current[part];
-        }
-        current[parts[parts.length - 1]] = value;
-    }
-    // ===================================
-    // Helpers
-    // ===================================
-    getTable(name) {
-        if (!this.db[name]) {
-            this.db[name] = [];
-        }
-        return this.db[name];
-    }
-    generateId() {
-        return Math.random().toString(36).substring(2, 15);
-    }
-}

package/dist/memory-driver.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=memory-driver.test.d.ts.map

package/dist/memory-driver.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory-driver.test.d.ts","sourceRoot":"","sources":["../src/memory-driver.test.ts"],"names":[],"mappings":""}

package/dist/memory-driver.test.js

@@ -1,93 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { InMemoryDriver } from './memory-driver.js';
-describe('InMemoryDriver', () => {
-    let driver;
-    const testTable = 'test_table';
-    beforeEach(async () => {
-        driver = new InMemoryDriver();
-        await driver.connect();
-        // No explicit clear DB method exposed, but new instance is clean.
-    });
-    describe('Lifecycle', () => {
-        it('should connect successfully', async () => {
-            expect(driver.checkHealth()).resolves.toBe(true);
-        });
-        it('should clear data on disconnect', async () => {
-            await driver.create(testTable, { id: '1', name: 'test' });
-            await driver.disconnect();
-            const results = await driver.find(testTable, { fields: ['id'], object: testTable });
-            expect(results).toHaveLength(0);
-        });
-    });
-    describe('Plugin Installation', () => {
-        it('should register driver with engine', () => {
-            const registerDriverFn = vi.fn();
-            const mockEngine = {
-                ql: {
-                    registerDriver: registerDriverFn
-                }
-            };
-            driver.install({ engine: mockEngine });
-            expect(registerDriverFn).toHaveBeenCalledWith(driver);
-        });
-        it('should handle missing engine gracefully', () => {
-            const mockCtx = {}; // No engine
-            // Should not throw
-            driver.install(mockCtx);
-        });
-    });
-    describe('CRUD Operations', () => {
-        it('should create and find records', async () => {
-            const data = { id: '1', name: 'Alice', age: 30 };
-            const created = await driver.create(testTable, data);
-            expect(created.id).toBe('1');
-            const results = await driver.find(testTable, {
-                fields: ['id', 'name', 'age'],
-                object: testTable
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].id).toBe('1');
-            expect(results[0].name).toBe('Alice');
-        });
-        it('should support updating records by ID', async () => {
-            await driver.create(testTable, { id: '1', name: 'Bob', active: true });
-            const updateResult = await driver.update(testTable, '1', { active: false });
-            expect(updateResult.active).toBe(false);
-            const results = await driver.find(testTable, { fields: ['active'], object: testTable });
-            expect(results[0].active).toBe(false);
-        });
-        it('should support deleting records by ID', async () => {
-            await driver.create(testTable, { id: '1', name: 'Charlie' });
-            await driver.create(testTable, { id: '2', name: 'David' });
-            const deleteResult = await driver.delete(testTable, '1');
-            expect(deleteResult).toBe(true);
-            const results = await driver.find(testTable, { fields: ['name'], object: testTable });
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('David');
-        });
-    });
-    describe('Query Capability', () => {
-        it('should filter results', async () => {
-            await driver.create(testTable, { id: '1', role: 'admin' });
-            await driver.create(testTable, { id: '2', role: 'user' });
-            await driver.create(testTable, { id: '3', role: 'user' });
-            const results = await driver.find(testTable, {
-                fields: ['id'],
-                object: testTable,
-                where: { role: 'user' }
-            });
-            expect(results).toHaveLength(2);
-        });
-        it('should limit results', async () => {
-            await driver.create(testTable, { id: '1' });
-            await driver.create(testTable, { id: '2' });
-            await driver.create(testTable, { id: '3' });
-            const results = await driver.find(testTable, {
-                fields: ['id'],
-                object: testTable,
-                limit: 2
-            });
-            expect(results).toHaveLength(2);
-        });
-    });
-});

package/dist/memory-matcher.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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 declare function match(record: RecordType, filter: any): boolean;
-/**
- * Access nested properties via dot-notation (e.g. "user.name")
- */
-export declare function getValueByPath(obj: any, path: string): any;
-export {};
-//# sourceMappingURL=memory-matcher.d.ts.map

package/dist/memory-matcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory-matcher.d.ts","sourceRoot":"","sources":["../src/memory-matcher.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAyC9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CAG1D"}

package/dist/memory-matcher.js

@@ -1,160 +0,0 @@
-/**
- * Simple In-Memory Query Matcher
- *
- * Implements a subset of the ObjectStack Filter Protocol (MongoDB-compatible)
- * for evaluating conditions against in-memory JavaScript objects.
- */
-/**
- * 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, filter) {
-    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) => match(record, f))) {
-            return false;
-        }
-    }
-    // $or: [ { ... }, { ... } ]
-    if (Array.isArray(filter.$or)) {
-        if (!filter.$or.some((f) => 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, path) {
-    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, condition) {
-    // 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') {
-            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 '$startsWith':
-                if (typeof value !== 'string' || !value.startsWith(target))
-                    return false;
-                break;
-            case '$endsWith':
-                if (typeof value !== 'string' || !value.endsWith(target))
-                    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;
-}