@ebarahona/loopback-connector-mongodb 1.0.0

package/dist/connector/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/connector/errors.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACH,MAAa,mBAAoB,SAAQ,KAAK;IAE5C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QAFC,SAAI,GAAG,qBAAqB,CAAC;IAG/C,CAAC;CACF;AALD,kDAKC"}

package/dist/connector/index.d.ts

@@ -0,0 +1,6 @@
+export { MongoConnector, initialize } from './mongo.connector';
+export { MongoConnectorError } from './errors';
+export { buildWhere, buildSort, buildFields } from './query-builder';
+export { toObjectId, isObjectIdString, toDecimal128, binaryToBuffer, coerceId, } from './coercion';
+export { toDatabase, fromDatabase, getDatabaseColumnName, getIdPropertyName, } from './property-mapping';
+export type { ModelDefinition, PropertyDefinition } from './property-mapping';

package/dist/connector/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdPropertyName = exports.getDatabaseColumnName = exports.fromDatabase = exports.toDatabase = exports.coerceId = exports.binaryToBuffer = exports.toDecimal128 = exports.isObjectIdString = exports.toObjectId = exports.buildFields = exports.buildSort = exports.buildWhere = exports.MongoConnectorError = exports.initialize = exports.MongoConnector = void 0;
+var mongo_connector_1 = require("./mongo.connector");
+Object.defineProperty(exports, "MongoConnector", { enumerable: true, get: function () { return mongo_connector_1.MongoConnector; } });
+Object.defineProperty(exports, "initialize", { enumerable: true, get: function () { return mongo_connector_1.initialize; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "MongoConnectorError", { enumerable: true, get: function () { return errors_1.MongoConnectorError; } });
+var query_builder_1 = require("./query-builder");
+Object.defineProperty(exports, "buildWhere", { enumerable: true, get: function () { return query_builder_1.buildWhere; } });
+Object.defineProperty(exports, "buildSort", { enumerable: true, get: function () { return query_builder_1.buildSort; } });
+Object.defineProperty(exports, "buildFields", { enumerable: true, get: function () { return query_builder_1.buildFields; } });
+var coercion_1 = require("./coercion");
+Object.defineProperty(exports, "toObjectId", { enumerable: true, get: function () { return coercion_1.toObjectId; } });
+Object.defineProperty(exports, "isObjectIdString", { enumerable: true, get: function () { return coercion_1.isObjectIdString; } });
+Object.defineProperty(exports, "toDecimal128", { enumerable: true, get: function () { return coercion_1.toDecimal128; } });
+Object.defineProperty(exports, "binaryToBuffer", { enumerable: true, get: function () { return coercion_1.binaryToBuffer; } });
+Object.defineProperty(exports, "coerceId", { enumerable: true, get: function () { return coercion_1.coerceId; } });
+var property_mapping_1 = require("./property-mapping");
+Object.defineProperty(exports, "toDatabase", { enumerable: true, get: function () { return property_mapping_1.toDatabase; } });
+Object.defineProperty(exports, "fromDatabase", { enumerable: true, get: function () { return property_mapping_1.fromDatabase; } });
+Object.defineProperty(exports, "getDatabaseColumnName", { enumerable: true, get: function () { return property_mapping_1.getDatabaseColumnName; } });
+Object.defineProperty(exports, "getIdPropertyName", { enumerable: true, get: function () { return property_mapping_1.getIdPropertyName; } });
+//# sourceMappingURL=index.js.map

package/dist/connector/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/connector/index.ts"],"names":[],"mappings":";;;AAAA,qDAA6D;AAArD,iHAAA,cAAc,OAAA;AAAE,6GAAA,UAAU,OAAA;AAClC,mCAA6C;AAArC,6GAAA,mBAAmB,OAAA;AAC3B,iDAAmE;AAA3D,2GAAA,UAAU,OAAA;AAAE,0GAAA,SAAS,OAAA;AAAE,4GAAA,WAAW,OAAA;AAC1C,uCAMoB;AALlB,sGAAA,UAAU,OAAA;AACV,4GAAA,gBAAgB,OAAA;AAChB,wGAAA,YAAY,OAAA;AACZ,0GAAA,cAAc,OAAA;AACd,oGAAA,QAAQ,OAAA;AAEV,uDAK4B;AAJ1B,8GAAA,UAAU,OAAA;AACV,gHAAA,YAAY,OAAA;AACZ,yHAAA,qBAAqB,OAAA;AACrB,qHAAA,iBAAiB,OAAA"}

package/dist/connector/mongo.connector.d.ts

@@ -0,0 +1,171 @@
+import type { MongoClient, Db, Collection, ClientSession, TransactionOptions } from 'mongodb';
+import type { MongoConnectorConfig } from '../types';
+import type { ModelDefinition } from './property-mapping';
+import { MongoConnectionManager } from '../helpers/connection-manager';
+import { MongoConnectorError } from './errors';
+export { MongoConnectorError };
+/**
+ * MongoDB connector for LoopBack 4.
+ *
+ * Implements the loopback-connector Connector interface using the
+ * native MongoDB Node.js driver 7.x.
+ *
+ * Uses a shared MongoConnectionManager for connection lifecycle.
+ * When used via MongoComponent, the same manager is shared with
+ * MongoService. When used standalone via juggler DataSource, the
+ * connector creates its own manager.
+ *
+ * @public
+ */
+export declare class MongoConnector {
+    name: string;
+    settings: MongoConnectorConfig;
+    dataSource?: Record<string, unknown>;
+    private connectionManager;
+    private readonly ownsConnectionManager;
+    private _models;
+    /**
+     * @param settings - Connector configuration
+     * @param connectionManager - Optional shared connection manager.
+     *   When provided (e.g. by MongoComponent), the connector uses
+     *   the shared MongoClient and does NOT own disconnect.
+     *   When omitted (standalone juggler use), the connector creates
+     *   and owns its own manager.
+     */
+    constructor(settings: MongoConnectorConfig, connectionManager?: MongoConnectionManager);
+    /**
+     * Install per-instance shims for the juggler 6.x DAO bridge.
+     *
+     * Juggler 6.x's `invokeConnectorMethod` invokes connector methods
+     * with `connector[method](modelName, ...args, opts?, cb)`, ignores
+     * any returned promise, and waits for `cb(err, result)` to fire.
+     * The class methods themselves stay strictly promise-returning;
+     * the shim simply extracts a trailing callback (if present) and
+     * relays settlement to it without altering the call's promise
+     * return value.
+     *
+     * This is the only place in the connector that inspects an
+     * argument to see if it's a function.
+     */
+    private installJugglerBridge;
+    /**
+     * Connect to MongoDB. Delegates to the connection manager.
+     * Idempotent and concurrency-safe.
+     */
+    connect(): Promise<Db>;
+    /**
+     * Disconnect from MongoDB.
+     *
+     * Only disconnects if this connector owns its connection manager
+     * (standalone juggler DataSource use). When the manager is shared
+     * via MongoComponent, the lifecycle observer owns disconnect --
+     * calling this is a no-op.
+     */
+    disconnect(): Promise<void>;
+    ping(): Promise<void>;
+    /**
+     * Get the shared connection manager.
+     */
+    getConnectionManager(): MongoConnectionManager;
+    /**
+     * Get the native MongoClient instance.
+     */
+    getClient(): MongoClient | undefined;
+    /**
+     * Get the native Db instance.
+     */
+    getDb(): Db | undefined;
+    define(modelDefinition: ModelDefinition): void;
+    getModelDefinition(modelName: string): ModelDefinition | undefined;
+    create(modelName: string, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    find(modelName: string, id: unknown, options?: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+    all(modelName: string, filter?: Record<string, unknown>, options?: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    updateAll(modelName: string, where: Record<string, unknown> | undefined, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<{
+        count: number;
+    }>;
+    deleteAll(modelName: string, where: Record<string, unknown> | undefined, options?: Record<string, unknown>): Promise<{
+        count: number;
+    }>;
+    count(modelName: string, where?: Record<string, unknown>, options?: Record<string, unknown>): Promise<number>;
+    replaceById(modelName: string, id: unknown, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<{
+        count: number;
+    }>;
+    updateOrCreate(modelName: string, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Find a document matching `filter` or create it from `data`.
+     *
+     * @experimental
+     *
+     * KNOWN LIMITATION: on a duplicate-key conflict (error 11000), the
+     * follow-up lookup re-uses the caller's `filter`. If the conflicting
+     * unique index covers a field NOT in `filter`, the returned document
+     * may be unrelated to the duplicate. Use `upsert` via
+     * `updateOrCreate()` or the connector's raw `replaceOne` for stricter
+     * semantics until this is addressed in a future release.
+     */
+    findOrCreate(modelName: string, filter: Record<string, unknown>, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<[Record<string, unknown>, boolean]>;
+    exists(modelName: string, id: unknown, options?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Juggler alias for updateAll.
+     */
+    update(modelName: string, where: Record<string, unknown> | undefined, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<{
+        count: number;
+    }>;
+    /**
+     * Juggler alias for deleteAll.
+     */
+    destroyAll(modelName: string, where: Record<string, unknown> | undefined, options?: Record<string, unknown>): Promise<{
+        count: number;
+    }>;
+    /**
+     * Juggler: update specific attributes on a single document by id.
+     */
+    updateAttributes(modelName: string, id: unknown, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Juggler: save (upsert) a document.
+     */
+    save(modelName: string, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private static readonly SAFE_COMMANDS;
+    /**
+     * Raw-driver escape hatch. Calls the named MongoDB Collection method
+     * directly with the provided args.
+     *
+     * The `SAFE_COMMANDS` allowlist controls which methods may be called;
+     * argument shape is NOT validated. Malformed args can cause data
+     * loss (e.g. an empty filter on `deleteMany`). Prefer the typed
+     * helpers on `MongoService` or the connector's CRUD methods.
+     *
+     * @experimental
+     * @throws MongoConnectorError if the command is not in the allowlist
+     *   or is not a function on the Collection.
+     */
+    execute(modelName: string, command: string, ...args: unknown[]): Promise<unknown>;
+    /**
+     * Begin a MongoDB transaction and return the underlying session.
+     *
+     * NOTE: this method does NOT auto-retry on `TransientTransactionError`
+     * or `UnknownTransactionCommitResult`. The juggler shape mandates
+     * separate begin/commit/rollback. For new code, prefer
+     * `MongoService.withTransaction()`, which wraps the retry loop
+     * automatically.
+     */
+    beginTransaction(options?: TransactionOptions): Promise<ClientSession>;
+    commit(session: ClientSession): Promise<void>;
+    rollback(session: ClientSession): Promise<void>;
+    collectionForModel(modelName: string): Collection;
+    private getCollection;
+    private buildUpdate;
+    private fromDb;
+    private extractSessionOptions;
+}
+/**
+ * Initialize function for loopback-datasource-juggler.
+ * Creates a standalone connector with its own connection manager.
+ *
+ * Juggler invokes this with `(dataSource, callback)` and expects
+ * the callback to signal "setup done." This is the one place the
+ * connector still exposes a callback contract.
+ *
+ * @public
+ */
+export declare function initialize(dataSource: Record<string, unknown>, callback?: (err: Error | null) => void): void;