@ignex/ninox 0.1.5 → 0.1.7

package/dist/index.js

@@ -57,6 +57,17 @@ var probeMongoCapabilities = async (client) => {
   }
 };
 
+// src/utils/redact.ts
+var CONNECTION_CREDENTIALS = /([a-z][a-z0-9+.-]*:\/\/[^/\s:@]*):[^/\s@]*@/gi;
+var SECRET_PAIR = /\b(password|passwd|pwd|secret|token|api[-_]?key|access[-_]?key)=([^&\s;,"')]+)/gi;
+var maskCredentials = (value) => value.replace(CONNECTION_CREDENTIALS, "$1:***@");
+var maskSecretPairs = (value) => value.replace(SECRET_PAIR, "$1=***");
+var redactText = (value, max = 300) => {
+  const single = maskSecretPairs(maskCredentials(value)).split("\n").find((line) => line.trim().length > 0);
+  const text = (single ?? "").trim();
+  return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+};
+
 // src/errors/classes.ts
 var ERROR_HTTP_STATUS = {
   BAD_REQUEST: 400,
@@ -68,22 +79,49 @@ var ERROR_HTTP_STATUS = {
   VALIDATION_FAILED: 422,
   MONGO_TIMEOUT: 504
 };
+var STATUS_MESSAGES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+var genericStatusMessage = (statusCode) => STATUS_MESSAGES[statusCode] ?? (statusCode >= 500 ? "Internal Server Error" : "Request failed");
 var AppError = class extends Error {
   code;
   statusCode;
   extra;
-  constructor(code, message, statusCode = 500, extra) {
+  /**
+   * Whether `message`/`extra` may be sent to a CLIENT.
+   *
+   * Fail-closed: a 4xx message is the caller's contract, a 5xx message is an
+   * operator detail that may quote a driver, a host or a query. Pass `expose`
+   * explicitly to override — only for a 5xx whose text was written for callers
+   * (e.g. `new InfraError("DRAINING", "queue is draining", extra, true)`).
+   */
+  expose;
+  constructor(code, message, statusCode = 500, extra, expose) {
     super(message);
     this.name = "AppError";
     this.code = code;
     this.statusCode = statusCode;
+    this.expose = expose ?? statusCode < 500;
     if (extra !== void 0) this.extra = extra;
   }
   /**
-   * Stable, client-safe serialization for framework error middleware: a
-   * framework can forward `JSON.stringify(error)` (or `error.toJSON()`) straight
-   * to the client — no parsing of server internals. `stack` is dropped; the
-   * shape is always `{ name, code, message, statusCode, ...(extra) }`.
+   * Full, stack-free shape for LOGS and typed consumers:
+   * `{ name, code, message, statusCode, ...(extra) }`.
+   *
+   * It carries the real message, so it is NOT the client path — use
+   * {@link toClientPayload} (or `serializeError`) for anything a caller sees, and
+   * prefer `logger.error({ err })` so pino's own serializer keeps the stack in the
+   * log rather than in a payload.
    */
   toJSON() {
     return {
@@ -94,22 +132,42 @@ var AppError = class extends Error {
       ...this.extra !== void 0 ? { extra: this.extra } : {}
     };
   }
+  /**
+   * The client-safe payload — the same shape as {@link toJSON}, except that a
+   * non-exposed error's `message` is replaced by the canonical reason phrase and
+   * its `extra` is dropped. A framework can forward this (or `serializeError`'s
+   * result) without auditing what the message might contain.
+   *
+   * @param options - `expose: true` forces the real (masked) message + extra.
+   * @returns The client payload.
+   */
+  toClientPayload(options = {}) {
+    const expose = options.expose === true || this.expose;
+    const payload = {
+      name: this.name,
+      code: this.code,
+      message: expose ? maskCredentials(this.message) : genericStatusMessage(this.statusCode),
+      statusCode: this.statusCode
+    };
+    if (expose && this.extra !== void 0) payload.extra = this.extra;
+    return payload;
+  }
 };
 var DomainError = class extends AppError {
-  constructor(code, message, extra) {
-    super(code, message, ERROR_HTTP_STATUS[code] ?? 400, extra);
+  constructor(code, message, extra, expose) {
+    super(code, message, ERROR_HTTP_STATUS[code] ?? 400, extra, expose);
     this.name = "DomainError";
   }
 };
 var InfraError = class extends AppError {
-  constructor(code, message, extra) {
-    super(code, message, ERROR_HTTP_STATUS[code] ?? 500, extra);
+  constructor(code, message, extra, expose) {
+    super(code, message, ERROR_HTTP_STATUS[code] ?? 500, extra, expose);
     this.name = "InfraError";
   }
 };
 var BadRequest = class extends DomainError {
-  constructor(message, extra) {
-    super("BAD_REQUEST", message, extra);
+  constructor(message, extra, expose) {
+    super("BAD_REQUEST", message, extra, expose);
     this.name = "BadRequest";
   }
 };
@@ -279,13 +337,20 @@ var httpStatusForError = (err) => {
   if (isMongoTransientError(err)) return 503;
   return 500;
 };
-var serializeError = (err, ctx = {}) => {
+var serializeError = (err, ctx = {}, options = {}) => {
   const mapped = mapMongoDriverError(err, ctx);
-  if (mapped instanceof AppError) return mapped.toJSON();
-  if (mapped instanceof Error) {
-    return { name: mapped.name, code: "UNKNOWN", message: mapped.message, statusCode: 500 };
+  if (mapped instanceof AppError) return mapped.toClientPayload(options);
+  const statusCode = httpStatusForError(mapped);
+  const name = mapped instanceof Error ? mapped.name : "UnknownError";
+  if (options.expose !== true) {
+    return { name, code: "UNKNOWN", message: genericStatusMessage(statusCode), statusCode };
   }
-  return { name: "UnknownError", code: "UNKNOWN", message: String(mapped), statusCode: 500 };
+  return {
+    name,
+    code: "UNKNOWN",
+    message: redactText(mapped instanceof Error ? mapped.message : String(mapped)),
+    statusCode
+  };
 };
 var cloneDeep = (value) => {
   if (value instanceof Date) return new Date(value.getTime());
@@ -525,6 +590,7 @@ var RefreshTicker = class {
     this.host = host;
     this.intervalMs = tickIntervalMs;
   }
+  host;
   timer;
   intervalMs;
   /** Whether the timer is currently running. */
@@ -618,16 +684,26 @@ var normalizeWatchId = (id) => {
 };
 
 // src/utils/watch-errors.ts
-var isPermanentWatchError = (message) => (
-  // Standalone server: `$changeStream` is not supported at all.
-  /only supported on replica sets/i.test(message) || // Credentials/authorization problems: the user cannot run `aggregate` on
-  // this collection/server. Wrong creds, missing roles, or a user created
-  // without the `read`/`changeStream` privilege will never start working by
-  // retrying — fail once and stop instead of retrying forever.
-  /requires authentication|not authorized|unauthorized|authentication failed|Command .* requires authentication/i.test(
-    message
-  )
-);
+var STANDALONE = /only supported on replica sets|not supported on (?:a )?standalone/i;
+var CREDENTIALS = /requires authentication|not authorized|unauthorized|authentication failed|Command .* requires authentication/i;
+var explainPermanentWatchError = (message) => {
+  if (STANDALONE.test(message)) {
+    return {
+      reason: "standalone",
+      headline: "change streams need a replica set",
+      hint: "Point the connection at a replica set (a single-node replica set is fine for local dev), or set cacheWatch: false / cache: { ttlMs } to run write-through only."
+    };
+  }
+  if (CREDENTIALS.test(message)) {
+    return {
+      reason: "credentials",
+      headline: "the connection is not authorized for change streams",
+      hint: "Change streams need an authenticated user with the read + changeStream privilege (usually granted on the authSource database) \u2014 fix the credentials in .env, then restart."
+    };
+  }
+  return void 0;
+};
+var isPermanentWatchError = (message) => explainPermanentWatchError(message) !== void 0;
 
 // src/cache/hot-cache/watcher.ts
 var resolveDbSafe = (ref, logger) => {
@@ -649,6 +725,7 @@ var WatchCoordinator = class {
   constructor(host) {
     this.host = host;
   }
+  host;
   streams = /* @__PURE__ */ new Map();
   failedStreams = /* @__PURE__ */ new Set();
   stopped = true;
@@ -762,7 +839,7 @@ var WatchCoordinator = class {
           }
         }
         if (isPermanentWatchError(message)) {
-          this.markStreamFailed(key);
+          this.markStreamFailed(key, explainPermanentWatchError(message));
           return;
         }
       }
@@ -771,12 +848,15 @@ var WatchCoordinator = class {
       await sleepJittered(backoff, 1e3, true);
     }
   }
-  markStreamFailed(key) {
+  markStreamFailed(key, verdict) {
     this.failedStreams.add(key);
     if (!this.host.isReplica()) return;
     const planned = this.plannedStreamKeys();
     if (planned.size > 0 && [...planned].every((k) => this.failedStreams.has(k))) {
-      this.host.logger.warn?.({}, "hot cache: change streams unsupported, falling back to ticker");
+      this.host.logger.warn?.(
+        verdict === void 0 ? {} : { reason: verdict.reason, hint: verdict.hint },
+        `hot cache: change streams unsupported${verdict === void 0 ? "" : ` \u2014 ${verdict.headline}`}, falling back to ticker`
+      );
       this.host.fallbackToStandalone();
     }
   }
@@ -1787,6 +1867,7 @@ var QueryBuilder = class _QueryBuilder {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   _filter = {};
   _sort;
   _skip;
@@ -2814,13 +2895,19 @@ var CacheInvalidator = class {
           } catch {
           }
         }
-        if (isPermanentWatchError(message)) {
+        const verdict = explainPermanentWatchError(message);
+        if (verdict) {
           this.disabled = true;
           if (!this.warnedUnsupported) {
             this.warnedUnsupported = true;
             this.logger.warn?.(
-              { collection: ref.collection, error: message },
-              "cacheWatch: change streams unavailable permanently \u2014 the query cache stays write-through only; set cache: { ttlMs } or disable cacheWatch"
+              {
+                collection: ref.collection,
+                reason: verdict.reason,
+                error: message,
+                hint: verdict.hint
+              },
+              `cacheWatch: disabled \u2014 ${verdict.headline}; the query cache stays write-through only`
             );
           }
           return;
@@ -3142,13 +3229,28 @@ var probeDebugQuery = async () => {
     debugQueryCache = null;
   }
 };
+var sanitizeDebugParams = (value) => {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[unserializable]";
+    }
+  }
+};
 var traceDbOp = async (logger, meta, fn, options = {}) => {
   const start = performance.now();
   logger.debug({ ...meta, operation: "start" }, "start");
   try {
-    if (debugQueryCache === void 0) await probeDebugQuery();
-    const debugQuery = debugQueryCache;
-    const result = debugQuery ? await debugQuery(`${meta.collection}.${meta.op}`, void 0, () => fn()) : await fn();
+    let debugQuery = options.debugQuery;
+    if (debugQuery === void 0) {
+      if (debugQueryCache === void 0) await probeDebugQuery();
+      debugQuery = debugQueryCache;
+    }
+    const params = meta.params === void 0 ? void 0 : sanitizeDebugParams(meta.params);
+    const result = debugQuery ? await debugQuery(`${meta.collection}.${meta.op}`, params, () => fn()) : await fn();
     const durationMs = performance.now() - start;
     logger.info({ ...meta, durationMs }, "ok");
     return result;
@@ -3164,11 +3266,12 @@ var traceDbOp = async (logger, meta, fn, options = {}) => {
 // src/service/op-deps.ts
 var makeOpDeps = (logger, dbLabel, resolve, wrapMongoErrors) => {
   const trace = (meta2, fn) => traceDbOp(logger, meta2, fn, { wrapMongoErrors });
-  const meta = (collection, op) => ({
+  const meta = (collection, op, params) => ({
     collection: String(collection),
     physicalCollection: resolve(String(collection)),
     db: dbLabel,
-    op
+    op,
+    ...params !== void 0 ? { params } : {}
   });
   return { trace, meta };
 };
@@ -3214,11 +3317,11 @@ var resolveDriftMode = (perOp, serviceDefault) => {
 };
 
 // src/service/crud-op.ts
-var defineCrudOp = async (deps2, collection, opName, execute, options, write = false) => {
+var defineCrudOp = async (deps2, collection, opName, execute, options, write = false, params) => {
   const resolved = resolveQueryOptions(options);
   const maxAttempts = write && resolved.retryWrites !== true ? 1 : resolved.maxAttempts;
   return deps2.trace(
-    deps2.meta(collection, opName),
+    deps2.meta(collection, opName, params),
     async () => withRetry(async () => execute(resolved), {
       maxAttempts,
       delayMs: resolved.retryDelayMs
@@ -3232,6 +3335,8 @@ var PipelineBuilder = class _PipelineBuilder {
     this.deps = deps2;
     this.stages = stages;
   }
+  deps;
+  stages;
   /** Raw accumulated stages — embeddable into `$lookup` / `$facet` branches. */
   raw() {
     return this.stages;
@@ -3323,7 +3428,9 @@ var PipelineBuilder = class _PipelineBuilder {
       this.deps.logical,
       "mongo.pipeline",
       run,
-      this.deps.options
+      this.deps.options,
+      false,
+      { pipeline: this.stages }
     );
   }
   /** Run the pipeline and return the first output document (or null). */
@@ -3350,7 +3457,9 @@ var PipelineBuilder = class _PipelineBuilder {
       this.deps.logical,
       "mongo.pipeline.first",
       run,
-      this.deps.options
+      this.deps.options,
+      false,
+      { pipeline: this.stages }
     );
   }
   /** Streaming cursor (raw driver cursor; no retry / trace). */
@@ -3470,7 +3579,9 @@ var makeAggregateOps = (ctx) => {
       collection,
       "mongo.aggregate",
       (r) => coll(collection).aggregate(pipeline2, mergeAggOptions2(r.driverOpts, r.sdk)),
-      options
+      options,
+      false,
+      { pipeline: pipeline2 }
     );
   };
   const pipeline = (collection, options) => new PipelineBuilder({
@@ -3556,7 +3667,7 @@ var createCachedAggregate = (ctx) => {
     const noSession = !resolved.sdk.session;
     const useCache = cache !== void 0 && noSession && resolved.cache !== false && isCacheablePipeline(pipeline);
     const shouldDedupe = resolved.dedupe !== false && (resolved.dedupe === true || opts.dedupeReads === true && noSession) && opts.inFlight !== void 0;
-    const runDriver = () => defineCrudOp(deps2, collection, opName, execute, options);
+    const runDriver = () => defineCrudOp(deps2, collection, opName, execute, options, false, { pipeline });
     const key = useCache ? cache.key(
       cacheCollectionKey(client.databaseName, physical),
       stableHash([opName, pipeline, options])
@@ -3905,8 +4016,8 @@ var createCrudContext = (client, dbLabel, logger, opts) => {
   );
   const coll = (name) => client.collection(resolve(String(name)));
   const toDriverFilter = (filter) => filter;
-  const run = (collection, opName, execute, options) => defineCrudOp(deps2, collection, opName, execute, options);
-  const writeRun = (collection, opName, execute, options) => defineCrudOp(deps2, collection, opName, execute, options, true);
+  const run = (collection, opName, execute, options, params) => defineCrudOp(deps2, collection, opName, execute, options, false, params);
+  const writeRun = (collection, opName, execute, options, params) => defineCrudOp(deps2, collection, opName, execute, options, true, params);
   const invalidate = (collection) => {
     opts.cache?.invalidateByCollection(
       cacheCollectionKey(client.databaseName, resolve(String(collection)))
@@ -3942,6 +4053,9 @@ var createCrudContext = (client, dbLabel, logger, opts) => {
   const read = async (collection, opName, filter, options, execute, shape = "none", keyExtra) => {
     const physical = resolve(String(collection));
     const resolved = resolveQueryOptions(options);
+    const sentParams = { filter };
+    if (Object.keys(resolved.driverOpts).length > 0) sentParams.options = resolved.driverOpts;
+    if (keyExtra !== void 0) sentParams.field = keyExtra;
     const noSession = !resolved.sdk.session;
     const useCache = opts.cache !== void 0 && noSession && resolved.cache !== false;
     const shouldDedupe = resolved.dedupe !== false && (resolved.dedupe === true || opts.dedupeReads === true && noSession) && opts.inFlight !== void 0;
@@ -3963,7 +4077,7 @@ var createCrudContext = (client, dbLabel, logger, opts) => {
       );
     };
     const executeWrapped = () => deps2.trace(
-      deps2.meta(collection, opName),
+      deps2.meta(collection, opName, sentParams),
       () => withRetry(() => execute(resolved), {
         maxAttempts: resolved.maxAttempts,
         delayMs: resolved.retryDelayMs
@@ -4292,7 +4406,8 @@ var makeWriteOps = (ctx, readOps) => {
           insertOpts
         );
       },
-      options
+      options,
+      { doc }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterCreate", {
@@ -4325,7 +4440,8 @@ var makeWriteOps = (ctx, readOps) => {
           bulkOpts
         );
       },
-      options
+      options,
+      { docs }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterCreate", {
@@ -4354,7 +4470,8 @@ var makeWriteOps = (ctx, readOps) => {
           updateOpts
         );
       },
-      options
+      options,
+      { filter, update: effective }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterUpdate", {
@@ -4383,7 +4500,8 @@ var makeWriteOps = (ctx, readOps) => {
           updateOpts
         );
       },
-      options
+      options,
+      { filter, update: effective }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterUpdate", {
@@ -4416,7 +4534,8 @@ var makeWriteOps = (ctx, readOps) => {
           fOpts
         );
       },
-      options
+      options,
+      { filter, update: effective }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterUpdate", {
@@ -4449,7 +4568,8 @@ var makeWriteOps = (ctx, readOps) => {
           fOpts
         );
       },
-      options
+      options,
+      { filter, replacement: effective }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterUpdate", {
@@ -4477,7 +4597,8 @@ var makeWriteOps = (ctx, readOps) => {
           repOpts
         );
       },
-      options
+      options,
+      { filter, replacement }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterUpdate", {
@@ -4501,7 +4622,8 @@ var makeWriteOps = (ctx, readOps) => {
         };
         return await coll(collection).deleteOne(toDriverFilter(filter), delOpts);
       },
-      options
+      options,
+      { filter }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterDelete", {
@@ -4525,7 +4647,8 @@ var makeWriteOps = (ctx, readOps) => {
         };
         return await coll(collection).deleteMany(toDriverFilter(filter), delOpts);
       },
-      options
+      options,
+      { filter }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterDelete", {
@@ -4554,7 +4677,8 @@ var makeWriteOps = (ctx, readOps) => {
           fOpts
         );
       },
-      options
+      options,
+      { filter }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterDelete", {
@@ -4586,7 +4710,8 @@ var makeWriteOps = (ctx, readOps) => {
           updateOpts
         );
       },
-      options
+      options,
+      { filter, update: effective }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterDelete", {
@@ -4612,7 +4737,8 @@ var makeWriteOps = (ctx, readOps) => {
         };
         return await coll(collection).updateOne(toDriverFilter(filter), formatted, updateOpts);
       },
-      options
+      options,
+      { filter, update: formatted }
     );
     invalidate(collection);
     await safeAfterHooks(String(collection), "afterUpdate", {
@@ -4644,7 +4770,8 @@ var makeWriteOps = (ctx, readOps) => {
         };
         return await coll(collection).bulkWrite(writes, bulkOpts);
       },
-      options
+      options,
+      { operations }
     );
     invalidate(collection);
     return result;
@@ -4665,7 +4792,8 @@ var makeWriteOps = (ctx, readOps) => {
         };
         return await coll(collection).bulkWrite(operations, bulkOpts);
       },
-      options
+      options,
+      { operations }
     );
     invalidate(collection);
     return result;
@@ -4848,7 +4976,9 @@ var makePaginateCursor = (ctx) => {
         };
         return client.collection(resolve(String(collection))).find(filter, findOpts).sort(effectiveSort).limit(limit + 1).toArray();
       },
-      config.queryOptions
+      config.queryOptions,
+      false,
+      { filter, sort: effectiveSort, limit }
     );
     const hasMore = rows.length > limit;
     const page = backwards ? rows.slice(0, limit).reverse() : rows.slice(0, limit);
@@ -4974,40 +5104,63 @@ var optionSignature = (o) => JSON.stringify([
 ]);
 var indexKeyOf = (key, options) => `${JSON.stringify(Object.keys(key).map((k) => [k, key[k]]))}|${optionSignature(options)}`;
 var makeSchemaOps = (client, _logger, opts) => {
+  const readCollectionValidator = async (physical) => {
+    const info = await client.listCollections({ name: physical }).next();
+    return info?.options?.validator;
+  };
+  const ensureDeclaredIndexes = async (collection, physical, def) => {
+    const declared = def?.indexes ?? [];
+    if (declared.length === 0) return;
+    const handle = client.collection(physical);
+    const existing = new Set(
+      (await handle.listIndexes().toArray()).filter((i) => i.name !== "_id_").map((i) => indexKeyOf(i.key, i))
+    );
+    for (const index of declared) {
+      if (existing.has(indexKeyOf(index.key, index.options))) continue;
+      try {
+        await handle.createIndex(index.key, index.options);
+      } catch (err) {
+        if (err?.code === 85) {
+          throw new Error(
+            `Cannot apply declared index on "${collection}": an index with the same name/key already exists with different options. Run db.syncIndexes("${collection}") to reconcile index drift.`,
+            { cause: err }
+          );
+        }
+        throw err;
+      }
+    }
+  };
   const createSchema = async (collection, createCollectionOptions) => {
     const physical = opts.resolveCollectionName(collection);
     const def = opts.getDefinition(collection);
-    const validator = def?.schema ? toMongoValidator(def.schema) : void 0;
+    const createOptions = {
+      ...createCollectionOptions ?? {},
+      ...def?.schema ? { validator: toMongoValidator(def.schema) } : {}
+    };
+    let created = true;
     try {
-      await client.createCollection(physical, {
-        // Caller options FIRST, derived validator LAST — a stale `validator`
-        // key in the options must not clobber the schema-derived one.
-        ...createCollectionOptions ?? {},
-        ...validator ? { validator } : {}
-      });
+      await client.createCollection(physical, createOptions);
     } catch (err) {
-      if (err?.code === 48) {
-        throw new DomainError("COLLECTION_EXISTS", `Collection "${collection}" already exists`, {
-          physicalCollection: physical
-        });
-      }
-      throw err;
+      if (err?.code !== 48) throw err;
+      created = false;
     }
-    const indexes = def?.indexes ?? [];
-    if (indexes.length > 0) {
+    if (created) {
       try {
-        await client.collection(physical).createIndexes(
-          indexes.map((index) => ({
-            key: index.key,
-            ...index.options ?? {}
-          }))
-        );
+        await ensureDeclaredIndexes(collection, physical, def);
       } catch (err) {
         await client.dropCollection(physical).catch(() => {
         });
         throw err;
       }
+      return;
+    }
+    if (createOptions.validator) {
+      const current = await readCollectionValidator(physical);
+      if (JSON.stringify(current) !== JSON.stringify(createOptions.validator)) {
+        await client.command({ collMod: physical, validator: createOptions.validator });
+      }
     }
+    await ensureDeclaredIndexes(collection, physical, def);
   };
   const updateSchema = async (collection, schema) => {
     const physical = opts.resolveCollectionName(collection);