@frogfish/k2db 1.0.1 → 1.0.3

package/data.d.ts

@@ -0,0 +1,92 @@
+import { DB, BaseDocument } from "./db";
+export declare class Data {
+    private db;
+    private owner;
+    constructor(db: DB, owner: string);
+    /**
+     * Retrieves a single document by UUID.
+     * @param collectionName - Name of the collection.
+     * @param uuid - UUID of the document.
+     */
+    get(collectionName: string, uuid: string): Promise<BaseDocument>;
+    /**
+     * Retrieves a single document matching the criteria.
+     * @param collectionName - Name of the collection.
+     * @param criteria - Search criteria.
+     * @param fields - Optional fields to include.
+     */
+    findOne(collectionName: string, criteria: any, fields?: Array<string>): Promise<BaseDocument | null>;
+    /**
+     * Finds documents based on filter with optional parameters and pagination.
+     */
+    find(collectionName: string, filter: any, params?: any, skip?: number, limit?: number): Promise<BaseDocument[]>;
+    /**
+     * Aggregates documents based on criteria with pagination support.
+     */
+    aggregate(collectionName: string, criteria: any[], skip?: number, limit?: number): Promise<BaseDocument[]>;
+    /**
+     * Creates a new document in the collection.
+     */
+    create(collectionName: string, data: Partial<BaseDocument>): Promise<{
+        id: string;
+    }>;
+    /**
+     * Updates multiple documents based on criteria.
+     */
+    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>, replace?: boolean): Promise<any>;
+    /**
+     * Updates a single document by UUID.
+     */
+    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean, objectTypeName?: string): Promise<any>;
+    /**
+     * Removes (soft deletes) multiple documents based on criteria.
+     */
+    deleteAll(collectionName: string, criteria: any): Promise<any>;
+    /**
+     * Removes (soft deletes) a single document by UUID.
+     */
+    delete(collectionName: string, id: string): Promise<{
+        id: string;
+    }>;
+    /**
+     * Permanently deletes a document that has been soft-deleted.
+     */
+    purge(collectionName: string, id: string): Promise<{
+        id: string;
+    }>;
+    /**
+     * Restores a soft-deleted document.
+     */
+    restore(collectionName: string, criteria: any): Promise<{
+        status: string;
+        modified: number;
+    }>;
+    /**
+     * Counts documents based on criteria.
+     */
+    count(collectionName: string, criteria: any): Promise<{
+        count: number;
+    }>;
+    /**
+     * Drops an entire collection.
+     */
+    drop(collectionName: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Executes a transaction with the provided operations.
+     */
+    executeTransaction(operations: (session: any) => Promise<void>): Promise<void>;
+    /**
+     * Creates an index on the specified collection.
+     */
+    createIndex(collectionName: string, indexSpec: any, options?: any): Promise<void>;
+    /**
+     * Drops the entire database.
+     */
+    dropDatabase(): Promise<void>;
+    /**
+     * Checks the health of the database connection.
+     */
+    isHealthy(): Promise<boolean>;
+}

package/data.js

@@ -0,0 +1,118 @@
+"use strict";
+// src/Data.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Data = void 0;
+class Data {
+    constructor(db, owner) {
+        this.db = db;
+        this.owner = owner;
+    }
+    /**
+     * Retrieves a single document by UUID.
+     * @param collectionName - Name of the collection.
+     * @param uuid - UUID of the document.
+     */
+    async get(collectionName, uuid) {
+        return this.db.get(collectionName, uuid);
+    }
+    /**
+     * Retrieves a single document matching the criteria.
+     * @param collectionName - Name of the collection.
+     * @param criteria - Search criteria.
+     * @param fields - Optional fields to include.
+     */
+    async findOne(collectionName, criteria, fields) {
+        return this.db.findOne(collectionName, criteria, fields);
+    }
+    /**
+     * Finds documents based on filter with optional parameters and pagination.
+     */
+    async find(collectionName, filter, params, skip, limit) {
+        return this.db.find(collectionName, filter, params, skip, limit);
+    }
+    /**
+     * Aggregates documents based on criteria with pagination support.
+     */
+    async aggregate(collectionName, criteria, skip, limit) {
+        return this.db.aggregate(collectionName, criteria, skip, limit);
+    }
+    /**
+     * Creates a new document in the collection.
+     */
+    async create(collectionName, data) {
+        return this.db.create(collectionName, this.owner, data);
+    }
+    /**
+     * Updates multiple documents based on criteria.
+     */
+    async updateAll(collectionName, criteria, values, replace) {
+        return this.db.updateAll(collectionName, criteria, values, replace);
+    }
+    /**
+     * Updates a single document by UUID.
+     */
+    async update(collectionName, id, data, replace, objectTypeName) {
+        return this.db.update(collectionName, id, data, replace, objectTypeName);
+    }
+    /**
+     * Removes (soft deletes) multiple documents based on criteria.
+     */
+    async deleteAll(collectionName, criteria) {
+        return this.db.deleteAll(collectionName, criteria);
+    }
+    /**
+     * Removes (soft deletes) a single document by UUID.
+     */
+    async delete(collectionName, id) {
+        return this.db.delete(collectionName, id);
+    }
+    /**
+     * Permanently deletes a document that has been soft-deleted.
+     */
+    async purge(collectionName, id) {
+        return this.db.purge(collectionName, id);
+    }
+    /**
+     * Restores a soft-deleted document.
+     */
+    async restore(collectionName, criteria) {
+        return this.db.restore(collectionName, criteria);
+    }
+    /**
+     * Counts documents based on criteria.
+     */
+    async count(collectionName, criteria) {
+        return this.db.count(collectionName, criteria);
+    }
+    /**
+     * Drops an entire collection.
+     */
+    async drop(collectionName) {
+        return this.db.drop(collectionName);
+    }
+    /**
+     * Executes a transaction with the provided operations.
+     */
+    async executeTransaction(operations) {
+        return this.db.executeTransaction(operations);
+    }
+    /**
+     * Creates an index on the specified collection.
+     */
+    async createIndex(collectionName, indexSpec, options) {
+        return this.db.createIndex(collectionName, indexSpec, options);
+    }
+    /**
+     * Drops the entire database.
+     */
+    async dropDatabase() {
+        return this.db.dropDatabase();
+    }
+    /**
+     * Checks the health of the database connection.
+     */
+    async isHealthy() {
+        return this.db.isHealthy();
+    }
+}
+exports.Data = Data;

package/db.d.ts

@@ -167,7 +167,7 @@ export declare class DB {
      * @param collectionName - The name of the collection to validate.
      * @throws {K2Error} - If the collection name is invalid.
      */
-    private validateCollectionName;
+    validateCollectionName(collectionName: string): void;
     /**
      * Optional: Checks the health of the database connection.
      */

package/db.js

@@ -1,5 +1,5 @@
 "use strict";
-// src/MongoDBProtocol.ts
+// src/db.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frogfish/k2db",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A data handling library for K2 applications.",
   "main": "error.js",
   "types": "error.d.ts",

package/config.js

@@ -1 +0,0 @@
-"use strict";