callman-core 1.10.0 → 1.11.0

package/dist/host/connections.d.ts

@@ -0,0 +1,67 @@
+import type { ScriptDbExecutionInput, ScriptDbExecutionResult, ScriptRedisCapability } from "../script/types.js";
+import type { DbConnectionType, DbConnectionMode } from "./db/types.js";
+import type { RedisCommandExecutionResult, RedisCommandPhase } from "./redis/types.js";
+export interface DbConnectionRuntime {
+    kind: "db";
+    id: string;
+    name: string;
+    type: DbConnectionType;
+    connectionMode?: DbConnectionMode;
+    connectionString?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    serviceName?: string;
+    username?: string;
+    password?: string;
+    ssl?: boolean;
+}
+export interface RedisConnectionRuntime {
+    kind: "redis";
+    id: string;
+    name: string;
+    host: string;
+    port: number;
+    password?: string;
+    dbIndex?: number;
+    ssl?: boolean;
+}
+export type ConnectionRuntime = DbConnectionRuntime | RedisConnectionRuntime;
+export type ConnectionRuntimeMap = Record<string, ConnectionRuntime>;
+export interface DbNodeConfig {
+    enabled?: boolean;
+    connectionId?: string | null;
+    query?: string;
+}
+export interface RequestDatabaseRuntimeConfig {
+    preRequest?: DbNodeConfig;
+    postResponse?: DbNodeConfig;
+}
+export interface RequestRedisRuntimeConfig {
+    enabled?: boolean;
+    connectionId?: string | null;
+    preCommands?: string[];
+    postCommands?: string[];
+}
+export interface ScriptTemplateContext {
+    response?: unknown | null;
+    env?: Record<string, string>;
+    global?: Record<string, string>;
+}
+export declare const buildDbExecuteCapability: (connections: ConnectionRuntimeMap) => (input: ScriptDbExecutionInput) => Promise<ScriptDbExecutionResult>;
+export declare const runConfiguredDbQuery: (input: {
+    connections: ConnectionRuntimeMap;
+    config: DbNodeConfig | undefined;
+    phase: "pre" | "post";
+    context: ScriptTemplateContext;
+}) => Promise<ScriptDbExecutionResult | null>;
+export declare const runRedisCommandsForPhase: (input: {
+    connections: ConnectionRuntimeMap;
+    connectionId: string | null | undefined;
+    commands: string[];
+    phase: RedisCommandPhase;
+    context: ScriptTemplateContext;
+}) => Promise<RedisCommandExecutionResult[]>;
+export declare const buildRedisValueCache: (results: RedisCommandExecutionResult[]) => Record<string, unknown>;
+export declare const buildRedisCapability: (pre: RedisCommandExecutionResult[], post: RedisCommandExecutionResult[]) => ScriptRedisCapability;
+//# sourceMappingURL=connections.d.ts.map

package/dist/host/connections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../src/host/connections.ts"],"names":[],"mappings":"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"}

package/dist/host/connections.js

@@ -0,0 +1,156 @@
+// Bridges resolved connection runtimes (from the pipeline bundle) into the
+// script capabilities callman-core's executor understands. This is the glue
+// that lets the collection runner execute `pm.db.query`, pre-/post-request DB
+// nodes, and Redis commands locally — the same surface the Electron host wires
+// up, but driven by connections the runner receives instead of an in-process
+// store.
+import { executeQuery } from "./db/queryExecutor.js";
+import { executeRedisCommands } from "./redis/redisService.js";
+const toDbConnectionInput = (runtime) => ({
+    id: runtime.id,
+    name: runtime.name,
+    type: runtime.type,
+    connectionMode: runtime.connectionMode ??
+        (runtime.connectionString?.trim() ? "connectionString" : "detailed"),
+    connectionString: runtime.connectionString,
+    host: runtime.host ?? "",
+    port: runtime.port ?? 0,
+    database: runtime.database,
+    serviceName: runtime.serviceName,
+    username: runtime.username ?? "",
+    password: runtime.password ?? "",
+    ssl: runtime.ssl,
+});
+const toRedisConnectionInput = (runtime) => ({
+    id: runtime.id,
+    name: runtime.name,
+    type: "redis",
+    host: runtime.host,
+    port: runtime.port,
+    password: runtime.password,
+    dbIndex: runtime.dbIndex,
+});
+const toScriptDbResult = (result) => ({
+    success: result.success,
+    error: result.error ?? null,
+    phase: result.phase,
+    connectionId: result.connectionId,
+    connectionName: result.connectionName,
+    connectionType: result.connectionType,
+    query: result.query,
+    resolvedQuery: result.resolvedQuery,
+    rows: result.rows,
+    rowCount: result.rowCount,
+    durationMs: result.durationMs,
+    executedAt: result.executedAt,
+});
+const buildMissingConnectionResult = (input) => ({
+    success: false,
+    error: `Database connection "${input.connectionId}" was not found in the run bundle`,
+    phase: input.phase,
+    connectionId: input.connectionId,
+    connectionName: "",
+    connectionType: "mongo",
+    query: input.query,
+    resolvedQuery: input.query,
+    rows: [],
+    rowCount: 0,
+    durationMs: 0,
+    executedAt: new Date().toISOString(),
+});
+// ── DB capability ───────────────────────────────────────────────────
+// Builds the `execute` callback powering `pm.db.query(...)`. Resolves the
+// connectionId against the bundle, runs the query against the right driver,
+// and maps the result into the canonical `ScriptDbExecutionResult`.
+export const buildDbExecuteCapability = (connections) => async (input) => {
+    const runtime = connections[input.connectionId];
+    if (!runtime || runtime.kind !== "db") {
+        return buildMissingConnectionResult({
+            connectionId: input.connectionId,
+            query: input.query,
+            phase: input.phase,
+        });
+    }
+    const result = await executeQuery({
+        connectionId: input.connectionId,
+        connection: toDbConnectionInput(runtime),
+        query: input.query,
+        phase: input.phase,
+        context: {
+            response: input.context?.response ?? null,
+            env: input.context?.env ?? {},
+            global: input.context?.global ?? {},
+        },
+    });
+    return toScriptDbResult(result);
+};
+// Runs a configured pre-request / post-response DB node, producing the result
+// surfaced as `pm.db.pre` / `pm.db.post`. Returns null when the node is
+// disabled or incomplete (so it's never wired into the capability).
+export const runConfiguredDbQuery = async (input) => {
+    const { config } = input;
+    if (!config?.enabled || !config.connectionId || !config.query?.trim()) {
+        return null;
+    }
+    const execute = buildDbExecuteCapability(input.connections);
+    return execute({
+        connectionId: config.connectionId,
+        query: config.query,
+        phase: input.phase,
+        context: {
+            response: input.context.response ?? null,
+            env: input.context.env ?? {},
+            global: input.context.global ?? {},
+        },
+    });
+};
+// ── Redis capability ────────────────────────────────────────────────
+export const runRedisCommandsForPhase = async (input) => {
+    const connectionId = input.connectionId?.trim() ?? "";
+    const commands = (input.commands ?? []).map((command) => command.trim()).filter(Boolean);
+    if (!connectionId || commands.length === 0) {
+        return [];
+    }
+    const runtime = input.connections[connectionId];
+    const connection = runtime && runtime.kind === "redis" ? toRedisConnectionInput(runtime) : undefined;
+    return executeRedisCommands({
+        connectionId,
+        connection,
+        commands,
+        phase: input.phase,
+        context: {
+            response: input.context.response ?? null,
+            env: input.context.env ?? {},
+            global: input.context.global ?? {},
+        },
+    });
+};
+// Mirror of the desktop `buildRedisValueCache`
+// (`pmanfrontend/src/features/redis/lib/redisAssertions.ts`). Maps successful
+// command results to a `key → value` map for `pm.redis.get(key)`.
+export const buildRedisValueCache = (results) => {
+    const cache = {};
+    for (const result of results) {
+        if (!result.success || !result.key) {
+            continue;
+        }
+        if (result.commandName === "GET" || result.commandName === "SET") {
+            cache[result.key] = result.result;
+            continue;
+        }
+        if (result.commandName === "DEL") {
+            cache[result.key] = null;
+            continue;
+        }
+        if (result.commandName === "EXISTS" && result.result === false) {
+            cache[result.key] = null;
+        }
+    }
+    return cache;
+};
+// Assembles the read-only `pm.redis` capability from pre/post command results.
+export const buildRedisCapability = (pre, post) => ({
+    values: buildRedisValueCache([...pre, ...post]),
+    results: { pre, post },
+});
+//# sourceMappingURL=connections.js.map

package/dist/host/connections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../src/host/connections.ts"],"names":[],"mappings":"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"}

package/dist/host/db/mongoAdapter.d.ts

@@ -0,0 +1,7 @@
+import type { DbConnection } from "./types.js";
+export declare const testMongoConnection: (connection: DbConnection) => Promise<void>;
+export declare const executeMongoQuery: (connection: DbConnection, query: unknown) => Promise<{
+    rows: unknown[];
+    rowCount: number;
+}>;
+//# sourceMappingURL=mongoAdapter.d.ts.map

package/dist/host/db/mongoAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoAdapter.d.ts","sourceRoot":"","sources":["../../../src/host/db/mongoAdapter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAid/C,eAAO,MAAM,mBAAmB,GAAU,YAAY,YAAY,KAAG,OAAO,CAAC,IAAI,CAWhF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,YAAY,YAAY,EACxB,OAAO,OAAO,KACb,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA6F/C,CAAC"}

package/dist/host/db/mongoAdapter.js

@@ -0,0 +1,426 @@
+// MongoDB adapter. Ported from `pmanfrontend/electron/db/mongoAdapter.ts`.
+// The only change vs. the desktop original is driver loading: instead of
+// `createRequire`, the `mongodb` / `bson` packages are loaded lazily via
+// `loadOptionalModule` so callman-core stays driver-agnostic.
+import { loadOptionalModule, loadOptionalModuleOrNull } from "../lazy.js";
+const unwrap = (mod) => (mod && mod.default && !mod.MongoClient ? mod.default : mod);
+const loadMongoDriver = async () => {
+    try {
+        return unwrap(await loadOptionalModule("mongodb"));
+    }
+    catch {
+        throw new Error("MongoDB driver (`mongodb`) is not installed. Install `mongodb` to use Mongo connections.");
+    }
+};
+// `bson` is a soft dependency (only needed to render Decimal128 from a plain
+// object). It ships with `mongodb`, but we load it independently and cache it
+// synchronously so the recursive value normaliser can stay sync.
+let cachedBson = null;
+let bsonLoaded = false;
+const ensureBson = async () => {
+    if (!bsonLoaded) {
+        cachedBson = unwrap(await loadOptionalModuleOrNull("bson"));
+        bsonLoaded = true;
+    }
+    return cachedBson;
+};
+const buildMongoUri = (connection) => {
+    if (connection.connectionString?.trim()) {
+        return connection.connectionString.trim();
+    }
+    const username = encodeURIComponent(connection.username);
+    const password = encodeURIComponent(connection.password);
+    const database = connection.database?.trim() || "admin";
+    return `mongodb://${username}:${password}@${connection.host.trim()}:${connection.port}/${database}`;
+};
+const getMongoDatabaseName = (connection) => {
+    if (connection.database?.trim()) {
+        return connection.database.trim();
+    }
+    if (connection.connectionString?.trim()) {
+        try {
+            const uri = connection.connectionString.trim();
+            const normalizedUri = uri.startsWith("mongodb+srv://")
+                ? uri.replace("mongodb+srv://", "https://")
+                : uri.replace("mongodb://", "http://");
+            const parsedUrl = new URL(normalizedUri);
+            const pathname = parsedUrl.pathname.replace(/^\/+/, "").trim();
+            if (pathname) {
+                return pathname;
+            }
+        }
+        catch {
+            return "admin";
+        }
+    }
+    return "admin";
+};
+const ensureMongoCommand = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("Mongo query must be a JSON object. Example: {\"collection\":\"users\",\"operation\":\"find\",\"filter\":{}}");
+    }
+    const command = value;
+    if (!command.collection?.trim()) {
+        throw new Error("Mongo query must include a collection name");
+    }
+    if (!command.operation?.trim()) {
+        throw new Error("Mongo query must include an operation");
+    }
+    return command;
+};
+const formatUuidFromBytes = (bytes) => {
+    const hex = Buffer.from(bytes).toString("hex");
+    return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        hex.slice(12, 16),
+        hex.slice(16, 20),
+        hex.slice(20, 32),
+    ].join("-");
+};
+const normalizeBinaryBytes = (bytes, preferUuid = false) => {
+    if (preferUuid && bytes.byteLength === 16) {
+        return formatUuidFromBytes(bytes);
+    }
+    return Buffer.from(bytes).toString("hex");
+};
+const toUint8Array = (value) => {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    return null;
+};
+const toUint8ArrayFromIndexedObject = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0 ||
+        !entries.every(([key, entryValue]) => /^\d+$/.test(key) && typeof entryValue === "number" && Number.isInteger(entryValue))) {
+        return null;
+    }
+    return Uint8Array.from(entries
+        .sort(([leftKey], [rightKey]) => Number(leftKey) - Number(rightKey))
+        .map(([, byteValue]) => byteValue));
+};
+const isMongoObjectId = (value) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (candidate._bsontype === "ObjectId" ||
+        typeof candidate.toHexString === "function");
+};
+const getMongoBsonType = (value) => {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    return typeof value._bsontype === "string"
+        ? (value._bsontype)
+        : null;
+};
+const normalizeMongoNumericValue = (value) => {
+    const rawValue = typeof value.valueOf === "function" ? value.valueOf() : undefined;
+    if (typeof rawValue === "number") {
+        return rawValue;
+    }
+    if (typeof rawValue === "bigint") {
+        return rawValue <= BigInt(Number.MAX_SAFE_INTEGER) &&
+            rawValue >= BigInt(Number.MIN_SAFE_INTEGER)
+            ? Number(rawValue)
+            : rawValue.toString();
+    }
+    if (typeof rawValue === "string") {
+        const parsedNumber = Number(rawValue);
+        if (rawValue.trim() &&
+            Number.isFinite(parsedNumber) &&
+            Number.isSafeInteger(parsedNumber) &&
+            String(parsedNumber) === rawValue) {
+            return parsedNumber;
+        }
+        return rawValue;
+    }
+    return typeof value.toString === "function" ? value.toString() : String(value);
+};
+const normalizePlainDecimal128Object = (value) => {
+    if (!("bytes" in value)) {
+        return null;
+    }
+    const bytes = toUint8Array(value.bytes) ?? toUint8ArrayFromIndexedObject(value.bytes);
+    if (!bytes || bytes.byteLength !== 16) {
+        return null;
+    }
+    if (!cachedBson?.Decimal128) {
+        return null;
+    }
+    try {
+        return new cachedBson.Decimal128(bytes).toString();
+    }
+    catch {
+        return null;
+    }
+};
+const normalizeMongoSpecialObject = (value) => {
+    const bsonType = getMongoBsonType(value);
+    if (!bsonType) {
+        return normalizePlainDecimal128Object(value);
+    }
+    if (bsonType === "ObjectId") {
+        return isMongoObjectId(value) ? value.toHexString() : String(value);
+    }
+    if (bsonType === "Decimal128") {
+        return typeof value.toString === "function" ? value.toString() : String(value);
+    }
+    if (bsonType === "Long" || bsonType === "Int32" || bsonType === "Double") {
+        return normalizeMongoNumericValue(value);
+    }
+    if (bsonType === "Timestamp") {
+        const seconds = typeof value.getHighBits === "function"
+            ? value.getHighBits()
+            : null;
+        const increment = typeof value.getLowBits === "function"
+            ? value.getLowBits()
+            : null;
+        if (seconds !== null || increment !== null) {
+            return {
+                seconds,
+                increment,
+            };
+        }
+        return typeof value.toString === "function" ? value.toString() : String(value);
+    }
+    if (bsonType === "Binary" || bsonType === "UUID") {
+        const rawBytes = toUint8Array(value.buffer) ??
+            (typeof value.value === "function" ? toUint8Array(value.value()) : null);
+        const subtype = typeof value.sub_type === "number"
+            ? value.sub_type
+            : typeof value.subtype === "number"
+                ? value.subtype
+                : null;
+        if (rawBytes) {
+            return normalizeBinaryBytes(rawBytes, bsonType === "UUID" || subtype === 3 || subtype === 4);
+        }
+        return typeof value.toString === "function" ? value.toString() : String(value);
+    }
+    if (bsonType === "BSONRegExp") {
+        const pattern = typeof value.pattern === "string" ? value.pattern : "";
+        const options = typeof value.options === "string" ? value.options : "";
+        return `/${pattern}/${options}`;
+    }
+    if (bsonType === "DBRef") {
+        return {
+            $ref: typeof value.collection === "string" ? value.collection : "",
+            $id: normalizeMongoValue(value.oid ?? null),
+            ...(typeof value.db === "string" ? { $db: value.db } : {}),
+        };
+    }
+    if (bsonType === "Code") {
+        return {
+            code: typeof value.code === "string" ? value.code : String(value.code ?? ""),
+            ...(value.scope && typeof value.scope === "object"
+                ? { scope: normalizeMongoValue(value.scope) }
+                : {}),
+        };
+    }
+    if (bsonType === "MinKey" || bsonType === "MaxKey") {
+        return bsonType;
+    }
+    return null;
+};
+const normalizeMongoValue = (value) => {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (isMongoObjectId(value)) {
+        return value.toHexString();
+    }
+    const binaryValue = toUint8Array(value);
+    if (binaryValue) {
+        return normalizeBinaryBytes(binaryValue);
+    }
+    if (Array.isArray(value)) {
+        return value.map(normalizeMongoValue);
+    }
+    if (typeof value === "object") {
+        const normalizedSpecialObject = normalizeMongoSpecialObject(value);
+        if (normalizedSpecialObject !== null) {
+            return normalizedSpecialObject;
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+            key,
+            normalizeMongoValue(entryValue),
+        ]));
+    }
+    return String(value);
+};
+const normalizeMongoResult = (value) => {
+    if (Array.isArray(value)) {
+        const rows = value.map(normalizeMongoValue);
+        return {
+            rows,
+            rowCount: rows.length,
+        };
+    }
+    if (value === null || value === undefined) {
+        return {
+            rows: [],
+            rowCount: 0,
+        };
+    }
+    return {
+        rows: [normalizeMongoValue(value)],
+        rowCount: 1,
+    };
+};
+const OBJECTID_HEX_PATTERN = /^[a-f\d]{24}$/i;
+const coerceMongoFilterValue = (value, ObjectId) => {
+    if (typeof value === "string" && OBJECTID_HEX_PATTERN.test(value)) {
+        try {
+            return new ObjectId(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => coerceMongoFilterValue(item, ObjectId));
+    }
+    if (typeof value === "object" && value !== null) {
+        const obj = value;
+        // Support Extended JSON $oid syntax: { "$oid": "hexstring" }
+        if (typeof obj.$oid === "string") {
+            try {
+                return new ObjectId(obj.$oid);
+            }
+            catch {
+                return value;
+            }
+        }
+        return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, coerceMongoFilterValue(v, ObjectId)]));
+    }
+    return value;
+};
+const coerceMongoFilter = (filter, ObjectId) => {
+    if (!filter) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(filter).map(([key, value]) => [key, coerceMongoFilterValue(value, ObjectId)]));
+};
+export const testMongoConnection = async (connection) => {
+    const { MongoClient } = await loadMongoDriver();
+    const client = new MongoClient(buildMongoUri(connection));
+    await client.connect();
+    try {
+        await client.db(getMongoDatabaseName(connection)).command({ ping: 1 });
+    }
+    finally {
+        await client.close();
+    }
+};
+export const executeMongoQuery = async (connection, query) => {
+    const { MongoClient, ObjectId } = await loadMongoDriver();
+    await ensureBson();
+    const command = ensureMongoCommand(query);
+    const client = new MongoClient(buildMongoUri(connection));
+    await client.connect();
+    try {
+        const db = client.db(getMongoDatabaseName(connection));
+        const collection = db.collection(command.collection);
+        const options = command.options ?? {};
+        const filter = coerceMongoFilter(command.filter, ObjectId);
+        switch (command.operation) {
+            case "find": {
+                const cursor = collection.find(filter, {
+                    ...options,
+                    projection: command.projection,
+                    sort: command.sort,
+                    skip: command.skip,
+                    limit: command.limit,
+                });
+                const rows = (await cursor.toArray()).map(normalizeMongoValue);
+                return {
+                    rows,
+                    rowCount: rows.length,
+                };
+            }
+            case "findOne": {
+                const row = await collection.findOne(filter, {
+                    ...options,
+                    projection: command.projection,
+                    sort: command.sort,
+                    skip: command.skip,
+                });
+                return normalizeMongoResult(row);
+            }
+            case "aggregate": {
+                const rows = (await collection.aggregate(command.pipeline ?? [], options).toArray()).map(normalizeMongoValue);
+                return {
+                    rows,
+                    rowCount: rows.length,
+                };
+            }
+            case "insertOne": {
+                const result = await collection.insertOne(command.document ?? {}, options);
+                return normalizeMongoResult({
+                    acknowledged: result.acknowledged,
+                    insertedId: result.insertedId,
+                });
+            }
+            case "updateOne": {
+                const result = await collection.updateOne(filter, command.update ?? {}, options);
+                return normalizeMongoResult({
+                    acknowledged: result.acknowledged,
+                    matchedCount: result.matchedCount,
+                    modifiedCount: result.modifiedCount,
+                    upsertedId: result.upsertedId ?? null,
+                });
+            }
+            case "deleteOne": {
+                const result = await collection.deleteOne(filter, options);
+                return normalizeMongoResult({
+                    acknowledged: result.acknowledged,
+                    deletedCount: result.deletedCount,
+                });
+            }
+            case "deleteMany": {
+                const result = await collection.deleteMany(filter, options);
+                return normalizeMongoResult({
+                    acknowledged: result.acknowledged,
+                    deletedCount: result.deletedCount,
+                });
+            }
+            case "countDocuments": {
+                const count = await collection.countDocuments(command.filter ?? {}, options);
+                return normalizeMongoResult({
+                    count,
+                });
+            }
+            default:
+                throw new Error(`Unsupported Mongo operation: ${command.operation}`);
+        }
+    }
+    finally {
+        await client.close();
+    }
+};
+//# sourceMappingURL=mongoAdapter.js.map