@push.rocks/smartmongo 2.0.14 → 2.2.0

package/dist_ts/congodb/storage/OpLog.js

@@ -0,0 +1,221 @@
+import * as plugins from '../congodb.plugins.js';
+/**
+ * Operation Log for tracking all mutations
+ * Used primarily for change stream support
+ */
+export class OpLog {
+    storage;
+    counter = 0;
+    listeners = [];
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Generate a new timestamp for oplog entries
+     */
+    generateTimestamp() {
+        this.counter++;
+        return new plugins.bson.Timestamp({ t: Math.floor(Date.now() / 1000), i: this.counter });
+    }
+    /**
+     * Generate a resume token from a timestamp
+     */
+    generateResumeToken(ts) {
+        // Create a resume token similar to MongoDB's format
+        // It's a base64-encoded BSON document containing the timestamp
+        const tokenData = {
+            _data: Buffer.from(JSON.stringify({
+                ts: { t: ts.high, i: ts.low },
+                version: 1,
+            })).toString('base64'),
+        };
+        return tokenData;
+    }
+    /**
+     * Parse a resume token to get the timestamp
+     */
+    parseResumeToken(token) {
+        try {
+            const data = JSON.parse(Buffer.from(token._data, 'base64').toString('utf-8'));
+            return new plugins.bson.Timestamp({ t: data.ts.t, i: data.ts.i });
+        }
+        catch {
+            throw new Error('Invalid resume token');
+        }
+    }
+    /**
+     * Record an insert operation
+     */
+    async recordInsert(dbName, collName, document, txnInfo) {
+        const entry = {
+            ts: this.generateTimestamp(),
+            op: 'i',
+            ns: `${dbName}.${collName}`,
+            o: document,
+            ...txnInfo,
+        };
+        await this.storage.appendOpLog(entry);
+        this.notifyListeners(entry);
+        return entry;
+    }
+    /**
+     * Record an update operation
+     */
+    async recordUpdate(dbName, collName, filter, update, txnInfo) {
+        const entry = {
+            ts: this.generateTimestamp(),
+            op: 'u',
+            ns: `${dbName}.${collName}`,
+            o: update,
+            o2: filter,
+            ...txnInfo,
+        };
+        await this.storage.appendOpLog(entry);
+        this.notifyListeners(entry);
+        return entry;
+    }
+    /**
+     * Record a delete operation
+     */
+    async recordDelete(dbName, collName, filter, txnInfo) {
+        const entry = {
+            ts: this.generateTimestamp(),
+            op: 'd',
+            ns: `${dbName}.${collName}`,
+            o: filter,
+            ...txnInfo,
+        };
+        await this.storage.appendOpLog(entry);
+        this.notifyListeners(entry);
+        return entry;
+    }
+    /**
+     * Record a command (drop, rename, etc.)
+     */
+    async recordCommand(dbName, command) {
+        const entry = {
+            ts: this.generateTimestamp(),
+            op: 'c',
+            ns: `${dbName}.$cmd`,
+            o: command,
+        };
+        await this.storage.appendOpLog(entry);
+        this.notifyListeners(entry);
+        return entry;
+    }
+    /**
+     * Get oplog entries after a timestamp
+     */
+    async getEntriesAfter(ts, limit) {
+        return this.storage.getOpLogAfter(ts, limit);
+    }
+    /**
+     * Get the latest timestamp
+     */
+    async getLatestTimestamp() {
+        return this.storage.getLatestOpLogTimestamp();
+    }
+    /**
+     * Subscribe to oplog changes (for change streams)
+     */
+    subscribe(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const idx = this.listeners.indexOf(listener);
+            if (idx >= 0) {
+                this.listeners.splice(idx, 1);
+            }
+        };
+    }
+    /**
+     * Notify all listeners of a new entry
+     */
+    notifyListeners(entry) {
+        for (const listener of this.listeners) {
+            try {
+                listener(entry);
+            }
+            catch (error) {
+                console.error('Error in oplog listener:', error);
+            }
+        }
+    }
+    /**
+     * Convert an oplog entry to a change stream document
+     */
+    opLogEntryToChangeEvent(entry, fullDocument, fullDocumentBeforeChange) {
+        const [db, coll] = entry.ns.split('.');
+        const resumeToken = this.generateResumeToken(entry.ts);
+        const baseEvent = {
+            _id: resumeToken,
+            ns: { db, coll: coll === '$cmd' ? undefined : coll },
+            clusterTime: entry.ts,
+        };
+        switch (entry.op) {
+            case 'i':
+                return {
+                    ...baseEvent,
+                    operationType: 'insert',
+                    fullDocument: fullDocument || entry.o,
+                    documentKey: entry.o._id ? { _id: entry.o._id } : undefined,
+                };
+            case 'u':
+                const updateEvent = {
+                    ...baseEvent,
+                    operationType: 'update',
+                    documentKey: entry.o2?._id ? { _id: entry.o2._id } : undefined,
+                };
+                if (fullDocument) {
+                    updateEvent.fullDocument = fullDocument;
+                }
+                if (fullDocumentBeforeChange) {
+                    updateEvent.fullDocumentBeforeChange = fullDocumentBeforeChange;
+                }
+                // Parse update description
+                if (entry.o.$set || entry.o.$unset) {
+                    updateEvent.updateDescription = {
+                        updatedFields: entry.o.$set || {},
+                        removedFields: entry.o.$unset ? Object.keys(entry.o.$unset) : [],
+                    };
+                }
+                return updateEvent;
+            case 'd':
+                return {
+                    ...baseEvent,
+                    operationType: 'delete',
+                    documentKey: entry.o._id ? { _id: entry.o._id } : undefined,
+                    fullDocumentBeforeChange,
+                };
+            case 'c':
+                if (entry.o.drop) {
+                    return {
+                        ...baseEvent,
+                        operationType: 'drop',
+                        ns: { db, coll: entry.o.drop },
+                    };
+                }
+                if (entry.o.dropDatabase) {
+                    return {
+                        ...baseEvent,
+                        operationType: 'dropDatabase',
+                    };
+                }
+                if (entry.o.renameCollection) {
+                    return {
+                        ...baseEvent,
+                        operationType: 'rename',
+                    };
+                }
+                return {
+                    ...baseEvent,
+                    operationType: 'invalidate',
+                };
+            default:
+                return {
+                    ...baseEvent,
+                    operationType: 'invalidate',
+                };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/congodb/types/interfaces.d.ts

@@ -0,0 +1,363 @@
+import type * as plugins from '../congodb.plugins.js';
+export type Document = Record<string, any>;
+export interface WithId<TSchema> {
+    _id: plugins.bson.ObjectId;
+}
+export interface ICongoClientOptions {
+    /** Storage adapter type: 'memory' or 'file' */
+    storageType?: 'memory' | 'file';
+    /** Path for file-based storage */
+    storagePath?: string;
+    /** Enable persistence for memory adapter */
+    persist?: boolean;
+    /** Path for persistence file when using memory adapter */
+    persistPath?: string;
+}
+export interface IParsedConnectionString {
+    protocol: 'congo';
+    storageType: 'memory' | 'file';
+    options: {
+        persist?: string;
+        path?: string;
+    };
+}
+export interface IInsertOneOptions {
+    /** Session for transaction support */
+    session?: IClientSession;
+    /** Custom write concern */
+    writeConcern?: IWriteConcern;
+}
+export interface IInsertManyOptions extends IInsertOneOptions {
+    /** If true, inserts are ordered and stop on first error */
+    ordered?: boolean;
+}
+export interface IFindOptions<TSchema = Document> {
+    /** Projection to apply */
+    projection?: Partial<Record<keyof TSchema | string, 0 | 1 | boolean>>;
+    /** Sort specification */
+    sort?: ISortSpecification;
+    /** Number of documents to skip */
+    skip?: number;
+    /** Maximum number of documents to return */
+    limit?: number;
+    /** Session for transaction support */
+    session?: IClientSession;
+    /** Hint for index usage */
+    hint?: string | Document;
+}
+export interface IUpdateOptions {
+    /** Create document if it doesn't exist */
+    upsert?: boolean;
+    /** Session for transaction support */
+    session?: IClientSession;
+    /** Array filters for positional updates */
+    arrayFilters?: Document[];
+    /** Custom write concern */
+    writeConcern?: IWriteConcern;
+    /** Hint for index usage */
+    hint?: string | Document;
+}
+export interface IReplaceOptions extends IUpdateOptions {
+}
+export interface IDeleteOptions {
+    /** Session for transaction support */
+    session?: IClientSession;
+    /** Custom write concern */
+    writeConcern?: IWriteConcern;
+    /** Hint for index usage */
+    hint?: string | Document;
+}
+export interface IFindOneAndUpdateOptions extends IUpdateOptions {
+    /** Return the document before or after the update */
+    returnDocument?: 'before' | 'after';
+    /** Projection to apply */
+    projection?: Document;
+    /** Sort specification to determine which document to modify */
+    sort?: ISortSpecification;
+}
+export interface IFindOneAndReplaceOptions extends IFindOneAndUpdateOptions {
+}
+export interface IFindOneAndDeleteOptions {
+    /** Projection to apply */
+    projection?: Document;
+    /** Sort specification to determine which document to delete */
+    sort?: ISortSpecification;
+    /** Session for transaction support */
+    session?: IClientSession;
+}
+export interface IInsertOneResult {
+    acknowledged: boolean;
+    insertedId: plugins.bson.ObjectId;
+}
+export interface IInsertManyResult {
+    acknowledged: boolean;
+    insertedCount: number;
+    insertedIds: Record<number, plugins.bson.ObjectId>;
+}
+export interface IUpdateResult {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    upsertedCount: number;
+    upsertedId: plugins.bson.ObjectId | null;
+}
+export interface IDeleteResult {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+export interface IModifyResult<TSchema> {
+    value: TSchema | null;
+    ok: 1 | 0;
+    lastErrorObject?: {
+        n: number;
+        updatedExisting?: boolean;
+        upserted?: plugins.bson.ObjectId;
+    };
+}
+export type ISortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+export type ISortSpecification = Record<string, ISortDirection> | [string, ISortDirection][];
+export interface IIndexSpecification {
+    key: Record<string, 1 | -1 | 'text' | '2dsphere'>;
+    name?: string;
+    unique?: boolean;
+    sparse?: boolean;
+    expireAfterSeconds?: number;
+    background?: boolean;
+    partialFilterExpression?: Document;
+}
+export interface IIndexInfo {
+    v: number;
+    key: Record<string, 1 | -1 | string>;
+    name: string;
+    unique?: boolean;
+    sparse?: boolean;
+    expireAfterSeconds?: number;
+}
+export interface ICreateIndexOptions {
+    unique?: boolean;
+    sparse?: boolean;
+    expireAfterSeconds?: number;
+    name?: string;
+    background?: boolean;
+    partialFilterExpression?: Document;
+}
+export interface IWriteConcern {
+    w?: number | 'majority';
+    j?: boolean;
+    wtimeout?: number;
+}
+export interface IAggregateOptions {
+    /** Allow disk use for large aggregations */
+    allowDiskUse?: boolean;
+    /** Maximum time in ms */
+    maxTimeMS?: number;
+    /** Session for transaction support */
+    session?: IClientSession;
+    /** Batch size for cursor */
+    batchSize?: number;
+    /** Collation settings */
+    collation?: ICollation;
+    /** Hint for index usage */
+    hint?: string | Document;
+    /** Comment for profiling */
+    comment?: string;
+}
+export interface ICollation {
+    locale: string;
+    caseLevel?: boolean;
+    caseFirst?: string;
+    strength?: number;
+    numericOrdering?: boolean;
+    alternate?: string;
+    maxVariable?: string;
+    backwards?: boolean;
+}
+export interface IChangeStreamOptions {
+    /** Resume after this token */
+    resumeAfter?: IResumeToken;
+    /** Start at this operation time */
+    startAtOperationTime?: plugins.bson.Timestamp;
+    /** Start after this token */
+    startAfter?: IResumeToken;
+    /** Full document lookup mode */
+    fullDocument?: 'default' | 'updateLookup' | 'whenAvailable' | 'required';
+    /** Full document before change */
+    fullDocumentBeforeChange?: 'off' | 'whenAvailable' | 'required';
+    /** Batch size */
+    batchSize?: number;
+    /** Maximum await time in ms */
+    maxAwaitTimeMS?: number;
+}
+export interface IResumeToken {
+    _data: string;
+}
+export type ChangeStreamOperationType = 'insert' | 'update' | 'replace' | 'delete' | 'drop' | 'rename' | 'dropDatabase' | 'invalidate';
+export interface IChangeStreamDocument<TSchema = Document> {
+    _id: IResumeToken;
+    operationType: ChangeStreamOperationType;
+    fullDocument?: TSchema;
+    fullDocumentBeforeChange?: TSchema;
+    ns: {
+        db: string;
+        coll?: string;
+    };
+    documentKey?: {
+        _id: plugins.bson.ObjectId;
+    };
+    updateDescription?: {
+        updatedFields?: Document;
+        removedFields?: string[];
+        truncatedArrays?: Array<{
+            field: string;
+            newSize: number;
+        }>;
+    };
+    clusterTime?: plugins.bson.Timestamp;
+    txnNumber?: number;
+    lsid?: {
+        id: plugins.bson.Binary;
+        uid: plugins.bson.Binary;
+    };
+}
+export interface IClientSession {
+    id: {
+        id: plugins.bson.Binary;
+    };
+    inTransaction(): boolean;
+    startTransaction(options?: ITransactionOptions): void;
+    commitTransaction(): Promise<void>;
+    abortTransaction(): Promise<void>;
+    withTransaction<T>(fn: () => Promise<T>, options?: ITransactionOptions): Promise<T>;
+    endSession(): Promise<void>;
+}
+export interface ITransactionOptions {
+    readConcern?: IReadConcern;
+    writeConcern?: IWriteConcern;
+    readPreference?: string;
+    maxCommitTimeMS?: number;
+}
+export interface IReadConcern {
+    level: 'local' | 'available' | 'majority' | 'linearizable' | 'snapshot';
+}
+export interface IBulkWriteOptions {
+    ordered?: boolean;
+    session?: IClientSession;
+    writeConcern?: IWriteConcern;
+}
+export interface IBulkWriteOperation<TSchema = Document> {
+    insertOne?: {
+        document: TSchema;
+    };
+    updateOne?: {
+        filter: Document;
+        update: Document;
+        upsert?: boolean;
+        arrayFilters?: Document[];
+        hint?: Document | string;
+    };
+    updateMany?: {
+        filter: Document;
+        update: Document;
+        upsert?: boolean;
+        arrayFilters?: Document[];
+        hint?: Document | string;
+    };
+    replaceOne?: {
+        filter: Document;
+        replacement: TSchema;
+        upsert?: boolean;
+        hint?: Document | string;
+    };
+    deleteOne?: {
+        filter: Document;
+        hint?: Document | string;
+    };
+    deleteMany?: {
+        filter: Document;
+        hint?: Document | string;
+    };
+}
+export interface IBulkWriteResult {
+    acknowledged: boolean;
+    insertedCount: number;
+    matchedCount: number;
+    modifiedCount: number;
+    deletedCount: number;
+    upsertedCount: number;
+    insertedIds: Record<number, plugins.bson.ObjectId>;
+    upsertedIds: Record<number, plugins.bson.ObjectId>;
+}
+export interface IStoredDocument extends Document {
+    _id: plugins.bson.ObjectId;
+}
+export interface IOpLogEntry {
+    ts: plugins.bson.Timestamp;
+    op: 'i' | 'u' | 'd' | 'c' | 'n';
+    ns: string;
+    o: Document;
+    o2?: Document;
+    txnNumber?: number;
+    lsid?: {
+        id: plugins.bson.Binary;
+    };
+}
+export interface IDatabaseInfo {
+    name: string;
+    sizeOnDisk: number;
+    empty: boolean;
+}
+export interface ICollectionInfo {
+    name: string;
+    type: 'collection' | 'view';
+    options: Document;
+    info: {
+        readOnly: boolean;
+        uuid?: plugins.bson.Binary;
+    };
+    idIndex?: IIndexInfo;
+}
+export interface IServerStatus {
+    host: string;
+    version: string;
+    process: string;
+    pid: number;
+    uptime: number;
+    uptimeMillis: number;
+    uptimeEstimate: number;
+    localTime: Date;
+    mem: {
+        resident: number;
+        virtual: number;
+    };
+    connections: {
+        current: number;
+        available: number;
+        totalCreated: number;
+    };
+    ok: 1;
+}
+export interface ICollectionStats {
+    ns: string;
+    count: number;
+    size: number;
+    avgObjSize: number;
+    storageSize: number;
+    totalIndexSize: number;
+    indexSizes: Record<string, number>;
+    nindexes: number;
+    ok: 1;
+}
+export interface ICountDocumentsOptions {
+    skip?: number;
+    limit?: number;
+    session?: IClientSession;
+    hint?: string | Document;
+    maxTimeMS?: number;
+}
+export interface IEstimatedDocumentCountOptions {
+    maxTimeMS?: number;
+}
+export interface IDistinctOptions {
+    session?: IClientSession;
+    maxTimeMS?: number;
+}

package/dist_ts/congodb/types/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2NvbmdvZGIvdHlwZXMvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist_ts/index.d.ts

@@ -1,4 +1,5 @@
 import * as plugins from './smartmongo.plugins.js';
+export * as congodb from './congodb/index.js';
 export declare class SmartMongo {
     static createAndStart(replCountArg?: number): Promise<SmartMongo>;
     private _readyDeferred;

package/dist_ts/index.js

@@ -1,5 +1,7 @@
 import { commitinfo } from './00_commitinfo_data.js';
 import * as plugins from './smartmongo.plugins.js';
+// Export CongoDB module
+export * as congodb from './congodb/index.js';
 export class SmartMongo {
     // STATIC
     static async createAndStart(replCountArg = 1) {
@@ -7,11 +9,11 @@ export class SmartMongo {
         await smartMongoInstance.start(replCountArg);
         return smartMongoInstance;
     }
-    constructor() {
-        // INSTANCE
-        this._readyDeferred = plugins.smartpromise.defer();
-        this.readyPromise = this._readyDeferred.promise;
-    }
+    // INSTANCE
+    _readyDeferred = plugins.smartpromise.defer();
+    readyPromise = this._readyDeferred.promise;
+    mongoReplicaSet;
+    constructor() { }
     async start(countArg = 1) {
         this.mongoReplicaSet = await plugins.mongoPlugin.MongoMemoryReplSet.create({
             replSet: { count: countArg },
@@ -56,4 +58,4 @@ export class SmartMongo {
         await this.stop();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/npmextra.json

@@ -1,5 +1,5 @@
 {
-  "gitzone": {
+  "@git.zone/cli": {
     "projectType": "npm",
     "module": {
       "githost": "code.foss.global",
@@ -18,13 +18,23 @@
         "database management",
         "typescript"
       ]
-    }
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
+    },
+    "services": [
+      "mongodb",
+      "minio"
+    ]
   },
-  "npmci": {
-    "npmGlobalTools": [],
-    "npmAccessLevel": "public"
-  },
-  "tsdoc": {
+  "@git.zone/tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
   }
 }