@push.rocks/smartdb 1.0.1

package/dist_ts/ts_smartdb/server/handlers/InsertHandler.js

@@ -0,0 +1,79 @@
+import * as plugins from '../../plugins.js';
+/**
+ * InsertHandler - Handles insert commands
+ */
+export class InsertHandler {
+    async handle(context) {
+        const { storage, database, command, documentSequences } = context;
+        const collection = command.insert;
+        if (typeof collection !== 'string') {
+            return {
+                ok: 0,
+                errmsg: 'insert command requires a collection name',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Get documents from command or document sequences
+        let documents = command.documents || [];
+        // Check for OP_MSG document sequences (for bulk inserts)
+        if (documentSequences && documentSequences.has('documents')) {
+            documents = documentSequences.get('documents');
+        }
+        if (!Array.isArray(documents) || documents.length === 0) {
+            return {
+                ok: 0,
+                errmsg: 'insert command requires documents array',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        const ordered = command.ordered !== false;
+        const writeErrors = [];
+        let insertedCount = 0;
+        // Ensure collection exists
+        await storage.createCollection(database, collection);
+        const indexEngine = context.getIndexEngine(collection);
+        // Insert documents
+        for (let i = 0; i < documents.length; i++) {
+            const doc = documents[i];
+            try {
+                // Ensure _id exists
+                if (!doc._id) {
+                    doc._id = new plugins.bson.ObjectId();
+                }
+                // Check index constraints before insert (doc now has _id)
+                await indexEngine.onInsert(doc);
+                await storage.insertOne(database, collection, doc);
+                insertedCount++;
+            }
+            catch (error) {
+                const writeError = {
+                    index: i,
+                    code: error.code || 11000,
+                    errmsg: error.message || 'Insert failed',
+                };
+                // Check for duplicate key error
+                if (error.message?.includes('Duplicate key')) {
+                    writeError.code = 11000;
+                    writeError.keyPattern = { _id: 1 };
+                    writeError.keyValue = { _id: doc._id };
+                }
+                writeErrors.push(writeError);
+                if (ordered) {
+                    // Stop on first error for ordered inserts
+                    break;
+                }
+            }
+        }
+        const response = {
+            ok: 1,
+            n: insertedCount,
+        };
+        if (writeErrors.length > 0) {
+            response.writeErrors = writeErrors;
+        }
+        return response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_smartdb/server/handlers/UpdateHandler.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from '../../plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+/**
+ * UpdateHandler - Handles update, findAndModify commands
+ */
+export declare class UpdateHandler implements ICommandHandler {
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+    /**
+     * Handle update command
+     */
+    private handleUpdate;
+    /**
+     * Handle findAndModify command
+     */
+    private handleFindAndModify;
+    /**
+     * Apply filter equality conditions to a new document (for upsert)
+     */
+    private applyFilterToDoc;
+    /**
+     * Set a nested value using dot notation
+     */
+    private setNestedValue;
+}

package/dist_ts/ts_smartdb/server/handlers/UpdateHandler.js

@@ -0,0 +1,296 @@
+import * as plugins from '../../plugins.js';
+import { QueryEngine } from '../../engine/QueryEngine.js';
+import { UpdateEngine } from '../../engine/UpdateEngine.js';
+/**
+ * UpdateHandler - Handles update, findAndModify commands
+ */
+export class UpdateHandler {
+    async handle(context) {
+        const { command } = context;
+        // Check findAndModify first since it also has an 'update' field
+        if (command.findAndModify) {
+            return this.handleFindAndModify(context);
+        }
+        else if (command.update && typeof command.update === 'string') {
+            // 'update' command has collection name as the value
+            return this.handleUpdate(context);
+        }
+        return {
+            ok: 0,
+            errmsg: 'Unknown update-related command',
+            code: 59,
+            codeName: 'CommandNotFound',
+        };
+    }
+    /**
+     * Handle update command
+     */
+    async handleUpdate(context) {
+        const { storage, database, command, documentSequences } = context;
+        const collection = command.update;
+        if (typeof collection !== 'string') {
+            return {
+                ok: 0,
+                errmsg: 'update command requires a collection name',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Get updates from command or document sequences
+        let updates = command.updates || [];
+        // Check for OP_MSG document sequences
+        if (documentSequences && documentSequences.has('updates')) {
+            updates = documentSequences.get('updates');
+        }
+        if (!Array.isArray(updates) || updates.length === 0) {
+            return {
+                ok: 0,
+                errmsg: 'update command requires updates array',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        const ordered = command.ordered !== false;
+        const writeErrors = [];
+        let totalMatched = 0;
+        let totalModified = 0;
+        let totalUpserted = 0;
+        const upserted = [];
+        // Ensure collection exists
+        await storage.createCollection(database, collection);
+        const indexEngine = context.getIndexEngine(collection);
+        for (let i = 0; i < updates.length; i++) {
+            const updateSpec = updates[i];
+            const filter = updateSpec.q || updateSpec.filter || {};
+            const update = updateSpec.u || updateSpec.update || {};
+            const multi = updateSpec.multi || false;
+            const upsert = updateSpec.upsert || false;
+            const arrayFilters = updateSpec.arrayFilters;
+            try {
+                // Try to use index-accelerated query
+                const candidateIds = await indexEngine.findCandidateIds(filter);
+                let documents;
+                if (candidateIds !== null) {
+                    documents = await storage.findByIds(database, collection, candidateIds);
+                }
+                else {
+                    documents = await storage.findAll(database, collection);
+                }
+                // Apply filter
+                let matchingDocs = QueryEngine.filter(documents, filter);
+                if (matchingDocs.length === 0 && upsert) {
+                    // Upsert: create new document
+                    const newDoc = { _id: new plugins.bson.ObjectId() };
+                    // Apply filter fields to the new document
+                    this.applyFilterToDoc(newDoc, filter);
+                    // Apply update
+                    const updatedDoc = UpdateEngine.applyUpdate(newDoc, update, arrayFilters);
+                    // Handle $setOnInsert
+                    if (update.$setOnInsert) {
+                        Object.assign(updatedDoc, update.$setOnInsert);
+                    }
+                    // Update index for the new document
+                    await indexEngine.onInsert(updatedDoc);
+                    await storage.insertOne(database, collection, updatedDoc);
+                    totalUpserted++;
+                    upserted.push({ index: i, _id: updatedDoc._id });
+                }
+                else {
+                    // Update existing documents
+                    const docsToUpdate = multi ? matchingDocs : matchingDocs.slice(0, 1);
+                    totalMatched += docsToUpdate.length;
+                    for (const doc of docsToUpdate) {
+                        const updatedDoc = UpdateEngine.applyUpdate(doc, update, arrayFilters);
+                        // Check if document actually changed
+                        const changed = JSON.stringify(doc) !== JSON.stringify(updatedDoc);
+                        if (changed) {
+                            // Update index
+                            await indexEngine.onUpdate(doc, updatedDoc);
+                            await storage.updateById(database, collection, doc._id, updatedDoc);
+                            totalModified++;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                writeErrors.push({
+                    index: i,
+                    code: error.code || 1,
+                    errmsg: error.message || 'Update failed',
+                });
+                if (ordered) {
+                    break;
+                }
+            }
+        }
+        const response = {
+            ok: 1,
+            n: totalMatched + totalUpserted,
+            nModified: totalModified,
+        };
+        if (upserted.length > 0) {
+            response.upserted = upserted;
+        }
+        if (writeErrors.length > 0) {
+            response.writeErrors = writeErrors;
+        }
+        return response;
+    }
+    /**
+     * Handle findAndModify command
+     */
+    async handleFindAndModify(context) {
+        const { storage, database, command } = context;
+        const collection = command.findAndModify;
+        const query = command.query || {};
+        const update = command.update;
+        const remove = command.remove || false;
+        const returnNew = command.new || false;
+        const upsert = command.upsert || false;
+        const sort = command.sort;
+        const fields = command.fields;
+        const arrayFilters = command.arrayFilters;
+        // Validate - either update or remove, not both
+        if (update && remove) {
+            return {
+                ok: 0,
+                errmsg: 'cannot specify both update and remove',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        if (!update && !remove) {
+            return {
+                ok: 0,
+                errmsg: 'either update or remove is required',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Ensure collection exists
+        await storage.createCollection(database, collection);
+        // Try to use index-accelerated query
+        const indexEngine = context.getIndexEngine(collection);
+        const candidateIds = await indexEngine.findCandidateIds(query);
+        let documents;
+        if (candidateIds !== null) {
+            documents = await storage.findByIds(database, collection, candidateIds);
+        }
+        else {
+            documents = await storage.findAll(database, collection);
+        }
+        let matchingDocs = QueryEngine.filter(documents, query);
+        // Apply sort if specified
+        if (sort) {
+            matchingDocs = QueryEngine.sort(matchingDocs, sort);
+        }
+        const doc = matchingDocs[0];
+        if (remove) {
+            // Delete operation
+            if (!doc) {
+                return { ok: 1, value: null };
+            }
+            // Update index for delete
+            await indexEngine.onDelete(doc);
+            await storage.deleteById(database, collection, doc._id);
+            let result = doc;
+            if (fields) {
+                result = QueryEngine.project([doc], fields)[0];
+            }
+            return {
+                ok: 1,
+                value: result,
+                lastErrorObject: {
+                    n: 1,
+                },
+            };
+        }
+        else {
+            // Update operation
+            if (!doc && !upsert) {
+                return { ok: 1, value: null };
+            }
+            let resultDoc;
+            let originalDoc = null;
+            let isUpsert = false;
+            if (doc) {
+                // Update existing
+                originalDoc = { ...doc };
+                resultDoc = UpdateEngine.applyUpdate(doc, update, arrayFilters);
+                // Update index
+                await indexEngine.onUpdate(doc, resultDoc);
+                await storage.updateById(database, collection, doc._id, resultDoc);
+            }
+            else {
+                // Upsert
+                isUpsert = true;
+                const newDoc = { _id: new plugins.bson.ObjectId() };
+                this.applyFilterToDoc(newDoc, query);
+                resultDoc = UpdateEngine.applyUpdate(newDoc, update, arrayFilters);
+                if (update.$setOnInsert) {
+                    Object.assign(resultDoc, update.$setOnInsert);
+                }
+                // Update index for insert
+                await indexEngine.onInsert(resultDoc);
+                await storage.insertOne(database, collection, resultDoc);
+            }
+            // Apply projection
+            let returnValue = returnNew ? resultDoc : (originalDoc || null);
+            if (returnValue && fields) {
+                returnValue = QueryEngine.project([returnValue], fields)[0];
+            }
+            const response = {
+                ok: 1,
+                value: returnValue,
+                lastErrorObject: {
+                    n: 1,
+                    updatedExisting: !isUpsert && doc !== undefined,
+                },
+            };
+            if (isUpsert) {
+                response.lastErrorObject.upserted = resultDoc._id;
+            }
+            return response;
+        }
+    }
+    /**
+     * Apply filter equality conditions to a new document (for upsert)
+     */
+    applyFilterToDoc(doc, filter) {
+        for (const [key, value] of Object.entries(filter)) {
+            // Skip operators
+            if (key.startsWith('$'))
+                continue;
+            // Handle nested paths
+            if (typeof value === 'object' && value !== null) {
+                // Check if it's an operator
+                const valueKeys = Object.keys(value);
+                if (valueKeys.some(k => k.startsWith('$'))) {
+                    // Extract equality value from $eq if present
+                    if ('$eq' in value) {
+                        this.setNestedValue(doc, key, value.$eq);
+                    }
+                    continue;
+                }
+            }
+            // Direct value assignment
+            this.setNestedValue(doc, key, value);
+        }
+    }
+    /**
+     * Set a nested value using dot notation
+     */
+    setNestedValue(obj, path, value) {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current)) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UpdateHandler.js","sourceRoot":"","sources":["../../../../ts/ts_smartdb/server/handlers/UpdateHandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_smartdb/server/handlers/index.d.ts

@@ -0,0 +1,8 @@
+export { HelloHandler } from './HelloHandler.js';
+export { InsertHandler } from './InsertHandler.js';
+export { FindHandler } from './FindHandler.js';
+export { UpdateHandler } from './UpdateHandler.js';
+export { DeleteHandler } from './DeleteHandler.js';
+export { AggregateHandler } from './AggregateHandler.js';
+export { IndexHandler } from './IndexHandler.js';
+export { AdminHandler } from './AdminHandler.js';

package/dist_ts/ts_smartdb/server/handlers/index.js

@@ -0,0 +1,10 @@
+// Export all command handlers
+export { HelloHandler } from './HelloHandler.js';
+export { InsertHandler } from './InsertHandler.js';
+export { FindHandler } from './FindHandler.js';
+export { UpdateHandler } from './UpdateHandler.js';
+export { DeleteHandler } from './DeleteHandler.js';
+export { AggregateHandler } from './AggregateHandler.js';
+export { IndexHandler } from './IndexHandler.js';
+export { AdminHandler } from './AdminHandler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy90c19zbWFydGRiL3NlcnZlci9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4QkFBOEI7QUFFOUIsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDIn0=

package/dist_ts/ts_smartdb/server/index.d.ts

@@ -0,0 +1,6 @@
+export { SmartdbServer } from './SmartdbServer.js';
+export type { ISmartdbServerOptions } from './SmartdbServer.js';
+export { WireProtocol } from './WireProtocol.js';
+export { CommandRouter } from './CommandRouter.js';
+export type { ICommandHandler, IHandlerContext, ICursorState } from './CommandRouter.js';
+export * from './handlers/index.js';

package/dist_ts/ts_smartdb/server/index.js

@@ -0,0 +1,7 @@
+// Server module exports
+export { SmartdbServer } from './SmartdbServer.js';
+export { WireProtocol } from './WireProtocol.js';
+export { CommandRouter } from './CommandRouter.js';
+// Export handlers
+export * from './handlers/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy90c19zbWFydGRiL3NlcnZlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3QkFBd0I7QUFFeEIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRW5ELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNqRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHbkQsa0JBQWtCO0FBQ2xCLGNBQWMscUJBQXFCLENBQUMifQ==

package/dist_ts/ts_smartdb/storage/FileStorageAdapter.d.ts

@@ -0,0 +1,85 @@
+import * as plugins from '../plugins.js';
+import type { IStorageAdapter } from './IStorageAdapter.js';
+import type { IStoredDocument, IOpLogEntry, Document } from '../types/interfaces.js';
+/**
+ * File storage adapter options
+ */
+export interface IFileStorageAdapterOptions {
+    /** Enable checksum verification for data integrity */
+    enableChecksums?: boolean;
+    /** Throw error on checksum mismatch (default: false, just log warning) */
+    strictChecksums?: boolean;
+}
+/**
+ * File-based storage adapter for SmartDB
+ * Stores data in JSON files on disk for persistence
+ */
+export declare class FileStorageAdapter implements IStorageAdapter {
+    private basePath;
+    private opLogCounter;
+    private initialized;
+    private fs;
+    private enableChecksums;
+    private strictChecksums;
+    constructor(basePath: string, options?: IFileStorageAdapterOptions);
+    private getDbPath;
+    private getCollectionPath;
+    private getIndexPath;
+    private getOpLogPath;
+    private getMetaPath;
+    private readJsonFile;
+    private writeJsonFile;
+    private restoreObjectIds;
+    /**
+     * Verify document checksum and handle errors
+     */
+    private verifyDocumentChecksum;
+    /**
+     * Add checksum to document before storing
+     */
+    private prepareDocumentForStorage;
+    /**
+     * Remove internal checksum field before returning to user
+     */
+    private cleanDocumentForReturn;
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    listDatabases(): Promise<string[]>;
+    createDatabase(dbName: string): Promise<void>;
+    dropDatabase(dbName: string): Promise<boolean>;
+    databaseExists(dbName: string): Promise<boolean>;
+    listCollections(dbName: string): Promise<string[]>;
+    createCollection(dbName: string, collName: string): Promise<void>;
+    dropCollection(dbName: string, collName: string): Promise<boolean>;
+    collectionExists(dbName: string, collName: string): Promise<boolean>;
+    renameCollection(dbName: string, oldName: string, newName: string): Promise<void>;
+    insertOne(dbName: string, collName: string, doc: Document): Promise<IStoredDocument>;
+    insertMany(dbName: string, collName: string, docsToInsert: Document[]): Promise<IStoredDocument[]>;
+    findAll(dbName: string, collName: string): Promise<IStoredDocument[]>;
+    findByIds(dbName: string, collName: string, ids: Set<string>): Promise<IStoredDocument[]>;
+    findById(dbName: string, collName: string, id: plugins.bson.ObjectId): Promise<IStoredDocument | null>;
+    updateById(dbName: string, collName: string, id: plugins.bson.ObjectId, doc: IStoredDocument): Promise<boolean>;
+    deleteById(dbName: string, collName: string, id: plugins.bson.ObjectId): Promise<boolean>;
+    deleteByIds(dbName: string, collName: string, ids: plugins.bson.ObjectId[]): Promise<number>;
+    count(dbName: string, collName: string): Promise<number>;
+    saveIndex(dbName: string, collName: string, indexName: string, indexSpec: {
+        key: Record<string, any>;
+        unique?: boolean;
+        sparse?: boolean;
+        expireAfterSeconds?: number;
+    }): Promise<void>;
+    getIndexes(dbName: string, collName: string): Promise<Array<{
+        name: string;
+        key: Record<string, any>;
+        unique?: boolean;
+        sparse?: boolean;
+        expireAfterSeconds?: number;
+    }>>;
+    dropIndex(dbName: string, collName: string, indexName: string): Promise<boolean>;
+    appendOpLog(entry: IOpLogEntry): Promise<void>;
+    getOpLogAfter(ts: plugins.bson.Timestamp, limit?: number): Promise<IOpLogEntry[]>;
+    getLatestOpLogTimestamp(): Promise<plugins.bson.Timestamp | null>;
+    generateTimestamp(): plugins.bson.Timestamp;
+    createSnapshot(dbName: string, collName: string): Promise<IStoredDocument[]>;
+    hasConflicts(dbName: string, collName: string, ids: plugins.bson.ObjectId[], snapshotTime: plugins.bson.Timestamp): Promise<boolean>;
+}