namespace-guard 0.1.2 → 0.4.0

package/README.md

@@ -1,6 +1,7 @@
 # namespace-guard
 
 [![npm version](https://img.shields.io/npm/v/namespace-guard.svg)](https://www.npmjs.com/package/namespace-guard)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/namespace-guard)](https://bundlephobia.com/package/namespace-guard)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
@@ -74,7 +75,7 @@ if (result.available) {
 | Conflict suggestions | Auto-suggest alternatives | Not built |
 | Async validators | Custom hooks (profanity, etc.) | Manual wiring |
 | Batch checking | `checkMany()` | Loop it yourself |
-| ORM agnostic | Prisma, Drizzle, Kysely, Knex, raw SQL | Tied to your ORM |
+| ORM agnostic | Prisma, Drizzle, Kysely, Knex, TypeORM, MikroORM, Sequelize, Mongoose, raw SQL | Tied to your ORM |
 | CLI | `npx namespace-guard check` | None |
 
 ## Adapters
@@ -120,6 +121,47 @@ const knex = Knex({ client: "pg", connection: process.env.DATABASE_URL });
 const adapter = createKnexAdapter(knex);
 ```
 
+### TypeORM
+
+```typescript
+import { DataSource } from "typeorm";
+import { createTypeORMAdapter } from "namespace-guard/adapters/typeorm";
+import { User, Organization } from "./entities";
+
+const dataSource = new DataSource({ /* ... */ });
+const adapter = createTypeORMAdapter(dataSource, { user: User, organization: Organization });
+```
+
+### MikroORM
+
+```typescript
+import { MikroORM } from "@mikro-orm/core";
+import { createMikroORMAdapter } from "namespace-guard/adapters/mikro-orm";
+import { User, Organization } from "./entities";
+
+const orm = await MikroORM.init(config);
+const adapter = createMikroORMAdapter(orm.em, { user: User, organization: Organization });
+```
+
+### Sequelize
+
+```typescript
+import { createSequelizeAdapter } from "namespace-guard/adapters/sequelize";
+import { User, Organization } from "./models";
+
+const adapter = createSequelizeAdapter({ user: User, organization: Organization });
+```
+
+### Mongoose
+
+```typescript
+import { createMongooseAdapter } from "namespace-guard/adapters/mongoose";
+import { User, Organization } from "./models";
+
+// Note: Mongoose sources typically use idColumn: "_id"
+const adapter = createMongooseAdapter({ user: User, organization: Organization });
+```
+
 ### Raw SQL (pg, mysql2, etc.)
 
 ```typescript
@@ -234,6 +276,26 @@ const guard = createNamespaceGuard({
 
 Validators run sequentially and stop at the first rejection. They receive the normalized identifier.
 
+### Built-in Profanity Validator
+
+Use `createProfanityValidator` for a turnkey profanity filter — supply your own word list:
+
+```typescript
+import { createNamespaceGuard, createProfanityValidator } from "namespace-guard";
+
+const guard = createNamespaceGuard({
+  sources: [/* ... */],
+  validators: [
+    createProfanityValidator(["badword", "offensive", "slur"], {
+      message: "Please choose an appropriate name.", // optional custom message
+      checkSubstrings: true,                         // default: true
+    }),
+  ],
+}, adapter);
+```
+
+No words are bundled — use any word list you like (e.g., the `bad-words` npm package, your own list, or an external API wrapped in a custom validator).
+
 ## Conflict Suggestions
 
 When a slug is taken, automatically suggest available alternatives:
@@ -430,52 +492,137 @@ normalize("  @Sarah  "); // "sarah"
 normalize("ACME-Corp"); // "acme-corp"
 ```
 
-## Real-World Example
+## Case-Insensitive Matching
 
-Here's how you might use this in a signup flow:
+By default, slug lookups are case-sensitive. Enable case-insensitive matching to catch collisions regardless of stored casing:
 
 ```typescript
-// In your API route / server action
-async function createUser(handle: string, email: string) {
-  // Normalize first
-  const normalizedHandle = guard.normalize(handle);
+const guard = createNamespaceGuard({
+  sources: [/* ... */],
+  caseInsensitive: true,
+}, adapter);
+```
 
-  // Check availability (will also validate format)
-  const result = await guard.check(normalizedHandle);
+Each adapter handles this differently:
+- **Prisma**: Uses `mode: "insensitive"` on the where clause
+- **Drizzle**: Uses `ilike` instead of `eq` (pass `ilike` to the adapter: `createDrizzleAdapter(db, tables, { eq, ilike })`)
+- **Kysely**: Uses `ilike` operator
+- **Knex**: Uses `LOWER()` in a raw where clause
+- **TypeORM**: Uses `ILike` (pass it to the adapter: `createTypeORMAdapter(dataSource, entities, ILike)`)
+- **MikroORM**: Uses `$ilike` operator
+- **Sequelize**: Uses `LOWER()` via Sequelize helpers (pass `{ where: Sequelize.where, fn: Sequelize.fn, col: Sequelize.col }`)
+- **Mongoose**: Uses collation `{ locale: "en", strength: 2 }`
+- **Raw SQL**: Wraps both sides in `LOWER()`
 
-  if (!result.available) {
-    return { error: result.message };
-  }
+## Caching
+
+Enable in-memory caching to reduce database calls during rapid checks (e.g., live form validation, suggestion generation):
+
+```typescript
+const guard = createNamespaceGuard({
+  sources: [/* ... */],
+  cache: {
+    ttl: 5000, // milliseconds (default: 5000)
+  },
+}, adapter);
+
+// Manually clear the cache after writes
+guard.clearCache();
+
+// Monitor cache performance
+const stats = guard.cacheStats();
+// { size: 12, hits: 48, misses: 12 }
+```
+
+## Framework Integration
+
+### Next.js (Server Actions)
+
+```typescript
+// lib/guard.ts
+import { createNamespaceGuard } from "namespace-guard";
+import { createPrismaAdapter } from "namespace-guard/adapters/prisma";
+import { prisma } from "./db";
+
+export const guard = createNamespaceGuard({
+  reserved: ["admin", "api", "settings"],
+  sources: [
+    { name: "user", column: "handle", scopeKey: "id" },
+    { name: "organization", column: "slug", scopeKey: "id" },
+  ],
+  suggest: {},
+}, createPrismaAdapter(prisma));
+
+// app/signup/actions.ts
+"use server";
+
+import { guard } from "@/lib/guard";
+
+export async function checkHandle(handle: string) {
+  return guard.check(handle);
+}
+
+export async function createUser(handle: string, email: string) {
+  const result = await guard.check(handle);
+  if (!result.available) return { error: result.message };
 
-  // Safe to create
   const user = await prisma.user.create({
-    data: { handle: normalizedHandle, email },
+    data: { handle: guard.normalize(handle), email },
   });
-
   return { user };
 }
 ```
 
-Or in an update flow with ownership scoping:
+### Express Middleware
 
 ```typescript
-async function updateUserHandle(userId: string, newHandle: string) {
-  const normalized = guard.normalize(newHandle);
+import express from "express";
+import { guard } from "./lib/guard";
 
-  // Pass userId to avoid collision with own current handle
-  const result = await guard.check(normalized, { id: userId });
+const app = express();
 
-  if (!result.available) {
-    return { error: result.message };
-  }
+// Reusable middleware
+function validateSlug(req, res, next) {
+  const slug = req.body.handle || req.body.slug;
+  if (!slug) return res.status(400).json({ error: "Slug is required" });
 
-  await prisma.user.update({
-    where: { id: userId },
-    data: { handle: normalized },
+  guard.check(slug, { id: req.user?.id }).then((result) => {
+    if (!result.available) return res.status(409).json(result);
+    req.normalizedSlug = guard.normalize(slug);
+    next();
   });
-
-  return { success: true };
 }
+
+app.post("/api/users", validateSlug, async (req, res) => {
+  const user = await db.user.create({ handle: req.normalizedSlug, ... });
+  res.json({ user });
+});
+```
+
+### tRPC
+
+```typescript
+import { z } from "zod";
+import { router, protectedProcedure } from "./trpc";
+import { guard } from "./lib/guard";
+
+export const namespaceRouter = router({
+  check: protectedProcedure
+    .input(z.object({ slug: z.string() }))
+    .query(async ({ input, ctx }) => {
+      return guard.check(input.slug, { id: ctx.user.id });
+    }),
+
+  claim: protectedProcedure
+    .input(z.object({ slug: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      await guard.assertAvailable(input.slug, { id: ctx.user.id });
+      return ctx.db.user.update({
+        where: { id: ctx.user.id },
+        data: { handle: guard.normalize(input.slug) },
+      });
+    }),
+});
 ```
 
 ## TypeScript
@@ -483,13 +630,17 @@ async function updateUserHandle(userId: string, newHandle: string) {
 Full TypeScript support with exported types:
 
 ```typescript
-import type {
-  NamespaceConfig,
-  NamespaceSource,
-  NamespaceAdapter,
-  NamespaceGuard,
-  CheckResult,
-  OwnershipScope,
+import {
+  createNamespaceGuard,
+  createProfanityValidator,
+  normalize,
+  type NamespaceConfig,
+  type NamespaceSource,
+  type NamespaceAdapter,
+  type NamespaceGuard,
+  type CheckResult,
+  type FindOneOptions,
+  type OwnershipScope,
 } from "namespace-guard";
 ```
 

package/dist/adapters/drizzle.d.mts

@@ -13,7 +13,13 @@ type DrizzleDb = {
         };
     };
 };
-type EqFn = (column: unknown, value: unknown) => unknown;
+type ComparisonFn = (column: unknown, value: unknown) => unknown;
+type DrizzleAdapterOptions = {
+    /** The `eq` function from drizzle-orm */
+    eq: ComparisonFn;
+    /** The `ilike` function from drizzle-orm (required when using caseInsensitive) */
+    ilike?: ComparisonFn;
+};
 /**
  * Create a namespace adapter for Drizzle ORM
  *
@@ -37,6 +43,6 @@ type EqFn = (column: unknown, value: unknown) => unknown;
  * );
  * ```
  */
-declare function createDrizzleAdapter(db: DrizzleDb, tables: Record<string, DrizzleTable>, eq: EqFn): NamespaceAdapter;
+declare function createDrizzleAdapter(db: DrizzleDb, tables: Record<string, DrizzleTable>, eqOrOptions: ComparisonFn | DrizzleAdapterOptions): NamespaceAdapter;
 
 export { createDrizzleAdapter };

package/dist/adapters/drizzle.d.ts

@@ -13,7 +13,13 @@ type DrizzleDb = {
         };
     };
 };
-type EqFn = (column: unknown, value: unknown) => unknown;
+type ComparisonFn = (column: unknown, value: unknown) => unknown;
+type DrizzleAdapterOptions = {
+    /** The `eq` function from drizzle-orm */
+    eq: ComparisonFn;
+    /** The `ilike` function from drizzle-orm (required when using caseInsensitive) */
+    ilike?: ComparisonFn;
+};
 /**
  * Create a namespace adapter for Drizzle ORM
  *
@@ -37,6 +43,6 @@ type EqFn = (column: unknown, value: unknown) => unknown;
  * );
  * ```
  */
-declare function createDrizzleAdapter(db: DrizzleDb, tables: Record<string, DrizzleTable>, eq: EqFn): NamespaceAdapter;
+declare function createDrizzleAdapter(db: DrizzleDb, tables: Record<string, DrizzleTable>, eqOrOptions: ComparisonFn | DrizzleAdapterOptions): NamespaceAdapter;
 
 export { createDrizzleAdapter };

package/dist/adapters/drizzle.js

@@ -23,9 +23,10 @@ __export(drizzle_exports, {
   createDrizzleAdapter: () => createDrizzleAdapter
 });
 module.exports = __toCommonJS(drizzle_exports);
-function createDrizzleAdapter(db, tables, eq) {
+function createDrizzleAdapter(db, tables, eqOrOptions) {
+  const ops = typeof eqOrOptions === "function" ? { eq: eqOrOptions } : eqOrOptions;
   return {
-    async findOne(source, value) {
+    async findOne(source, value, findOptions) {
       const queryHandler = db.query[source.name];
       if (!queryHandler) {
         throw new Error(`Drizzle query handler for "${source.name}" not found. Make sure relational queries are set up.`);
@@ -39,8 +40,15 @@ function createDrizzleAdapter(db, tables, eq) {
         throw new Error(`Column "${source.column}" not found in table "${source.name}"`);
       }
       const idColumn = source.idColumn ?? "id";
+      let compareFn = ops.eq;
+      if (findOptions?.caseInsensitive) {
+        if (!ops.ilike) {
+          throw new Error("caseInsensitive requires passing ilike to createDrizzleAdapter");
+        }
+        compareFn = ops.ilike;
+      }
       return queryHandler.findFirst({
-        where: eq(column, value),
+        where: compareFn(column, value),
         columns: {
           [idColumn]: true,
           ...source.scopeKey && source.scopeKey !== idColumn ? { [source.scopeKey]: true } : {}

package/dist/adapters/drizzle.mjs

@@ -1,7 +1,8 @@
 // src/adapters/drizzle.ts
-function createDrizzleAdapter(db, tables, eq) {
+function createDrizzleAdapter(db, tables, eqOrOptions) {
+  const ops = typeof eqOrOptions === "function" ? { eq: eqOrOptions } : eqOrOptions;
   return {
-    async findOne(source, value) {
+    async findOne(source, value, findOptions) {
       const queryHandler = db.query[source.name];
       if (!queryHandler) {
         throw new Error(`Drizzle query handler for "${source.name}" not found. Make sure relational queries are set up.`);
@@ -15,8 +16,15 @@ function createDrizzleAdapter(db, tables, eq) {
         throw new Error(`Column "${source.column}" not found in table "${source.name}"`);
       }
       const idColumn = source.idColumn ?? "id";
+      let compareFn = ops.eq;
+      if (findOptions?.caseInsensitive) {
+        if (!ops.ilike) {
+          throw new Error("caseInsensitive requires passing ilike to createDrizzleAdapter");
+        }
+        compareFn = ops.ilike;
+      }
       return queryHandler.findFirst({
-        where: eq(column, value),
+        where: compareFn(column, value),
         columns: {
           [idColumn]: true,
           ...source.scopeKey && source.scopeKey !== idColumn ? { [source.scopeKey]: true } : {}

package/dist/adapters/knex.d.mts

@@ -3,6 +3,7 @@ import { NamespaceAdapter } from '../index.mjs';
 type KnexQueryBuilder = {
     select: (columns: string[]) => KnexQueryBuilder;
     where: (column: string, value: unknown) => KnexQueryBuilder;
+    whereRaw: (raw: string, bindings: unknown[]) => KnexQueryBuilder;
     first: () => Promise<Record<string, unknown> | undefined>;
 };
 type KnexInstance = {

package/dist/adapters/knex.d.ts

@@ -3,6 +3,7 @@ import { NamespaceAdapter } from '../index.js';
 type KnexQueryBuilder = {
     select: (columns: string[]) => KnexQueryBuilder;
     where: (column: string, value: unknown) => KnexQueryBuilder;
+    whereRaw: (raw: string, bindings: unknown[]) => KnexQueryBuilder;
     first: () => Promise<Record<string, unknown> | undefined>;
 };
 type KnexInstance = {

package/dist/adapters/knex.js

@@ -25,10 +25,16 @@ __export(knex_exports, {
 module.exports = __toCommonJS(knex_exports);
 function createKnexAdapter(knex) {
   return {
-    async findOne(source, value) {
+    async findOne(source, value, options) {
       const idColumn = source.idColumn ?? "id";
       const columns = source.scopeKey && source.scopeKey !== idColumn ? [idColumn, source.scopeKey] : [idColumn];
-      const row = await knex(source.name).select(columns).where(source.column, value).first();
+      let query = knex(source.name).select(columns);
+      if (options?.caseInsensitive) {
+        query = query.whereRaw(`LOWER(??) = LOWER(?)`, [source.column, value]);
+      } else {
+        query = query.where(source.column, value);
+      }
+      const row = await query.first();
       return row ?? null;
     }
   };

package/dist/adapters/knex.mjs

@@ -1,10 +1,16 @@
 // src/adapters/knex.ts
 function createKnexAdapter(knex) {
   return {
-    async findOne(source, value) {
+    async findOne(source, value, options) {
       const idColumn = source.idColumn ?? "id";
       const columns = source.scopeKey && source.scopeKey !== idColumn ? [idColumn, source.scopeKey] : [idColumn];
-      const row = await knex(source.name).select(columns).where(source.column, value).first();
+      let query = knex(source.name).select(columns);
+      if (options?.caseInsensitive) {
+        query = query.whereRaw(`LOWER(??) = LOWER(?)`, [source.column, value]);
+      } else {
+        query = query.where(source.column, value);
+      }
+      const row = await query.first();
       return row ?? null;
     }
   };

package/dist/adapters/kysely.js

@@ -25,10 +25,16 @@ __export(kysely_exports, {
 module.exports = __toCommonJS(kysely_exports);
 function createKyselyAdapter(db) {
   return {
-    async findOne(source, value) {
+    async findOne(source, value, options) {
       const idColumn = source.idColumn ?? "id";
       const columns = source.scopeKey && source.scopeKey !== idColumn ? [idColumn, source.scopeKey] : [idColumn];
-      const row = await db.selectFrom(source.name).select(columns).where(source.column, "=", value).limit(1).executeTakeFirst();
+      let query = db.selectFrom(source.name).select(columns);
+      if (options?.caseInsensitive) {
+        query = query.where(source.column, "ilike", value);
+      } else {
+        query = query.where(source.column, "=", value);
+      }
+      const row = await query.limit(1).executeTakeFirst();
       return row ?? null;
     }
   };

package/dist/adapters/kysely.mjs

@@ -1,10 +1,16 @@
 // src/adapters/kysely.ts
 function createKyselyAdapter(db) {
   return {
-    async findOne(source, value) {
+    async findOne(source, value, options) {
       const idColumn = source.idColumn ?? "id";
       const columns = source.scopeKey && source.scopeKey !== idColumn ? [idColumn, source.scopeKey] : [idColumn];
-      const row = await db.selectFrom(source.name).select(columns).where(source.column, "=", value).limit(1).executeTakeFirst();
+      let query = db.selectFrom(source.name).select(columns);
+      if (options?.caseInsensitive) {
+        query = query.where(source.column, "ilike", value);
+      } else {
+        query = query.where(source.column, "=", value);
+      }
+      const row = await query.limit(1).executeTakeFirst();
       return row ?? null;
     }
   };

package/dist/adapters/mikro-orm.d.mts

@@ -0,0 +1,34 @@
+import { NamespaceAdapter } from '../index.mjs';
+
+type MikroORMEntityManager = {
+    findOne: (entityName: unknown, where: Record<string, unknown>, options?: {
+        fields?: string[];
+    }) => Promise<Record<string, unknown> | null>;
+};
+/**
+ * Create a namespace adapter for MikroORM
+ *
+ * @example
+ * ```ts
+ * import { MikroORM } from "@mikro-orm/core";
+ * import { createNamespaceGuard } from "namespace-guard";
+ * import { createMikroORMAdapter } from "namespace-guard/adapters/mikro-orm";
+ * import { User, Organization } from "./entities";
+ *
+ * const orm = await MikroORM.init(config);
+ *
+ * const guard = createNamespaceGuard(
+ *   {
+ *     reserved: ["admin", "api", "settings"],
+ *     sources: [
+ *       { name: "user", column: "handle", scopeKey: "id" },
+ *       { name: "organization", column: "slug", scopeKey: "id" },
+ *     ],
+ *   },
+ *   createMikroORMAdapter(orm.em, { user: User, organization: Organization })
+ * );
+ * ```
+ */
+declare function createMikroORMAdapter(em: MikroORMEntityManager, entities: Record<string, unknown>): NamespaceAdapter;
+
+export { createMikroORMAdapter };

package/dist/adapters/mikro-orm.d.ts

@@ -0,0 +1,34 @@
+import { NamespaceAdapter } from '../index.js';
+
+type MikroORMEntityManager = {
+    findOne: (entityName: unknown, where: Record<string, unknown>, options?: {
+        fields?: string[];
+    }) => Promise<Record<string, unknown> | null>;
+};
+/**
+ * Create a namespace adapter for MikroORM
+ *
+ * @example
+ * ```ts
+ * import { MikroORM } from "@mikro-orm/core";
+ * import { createNamespaceGuard } from "namespace-guard";
+ * import { createMikroORMAdapter } from "namespace-guard/adapters/mikro-orm";
+ * import { User, Organization } from "./entities";
+ *
+ * const orm = await MikroORM.init(config);
+ *
+ * const guard = createNamespaceGuard(
+ *   {
+ *     reserved: ["admin", "api", "settings"],
+ *     sources: [
+ *       { name: "user", column: "handle", scopeKey: "id" },
+ *       { name: "organization", column: "slug", scopeKey: "id" },
+ *     ],
+ *   },
+ *   createMikroORMAdapter(orm.em, { user: User, organization: Organization })
+ * );
+ * ```
+ */
+declare function createMikroORMAdapter(em: MikroORMEntityManager, entities: Record<string, unknown>): NamespaceAdapter;
+
+export { createMikroORMAdapter };

package/dist/adapters/mikro-orm.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/mikro-orm.ts
+var mikro_orm_exports = {};
+__export(mikro_orm_exports, {
+  createMikroORMAdapter: () => createMikroORMAdapter
+});
+module.exports = __toCommonJS(mikro_orm_exports);
+function createMikroORMAdapter(em, entities) {
+  return {
+    async findOne(source, value, options) {
+      const entity = entities[source.name];
+      if (!entity) {
+        throw new Error(`MikroORM entity "${source.name}" not found in provided entities object`);
+      }
+      const idColumn = source.idColumn ?? "id";
+      const fields = source.scopeKey && source.scopeKey !== idColumn ? [idColumn, source.scopeKey] : [idColumn];
+      const whereValue = options?.caseInsensitive ? { $ilike: value } : value;
+      return em.findOne(
+        entity,
+        { [source.column]: whereValue },
+        { fields }
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMikroORMAdapter
+});

package/dist/adapters/mikro-orm.mjs

@@ -0,0 +1,22 @@
+// src/adapters/mikro-orm.ts
+function createMikroORMAdapter(em, entities) {
+  return {
+    async findOne(source, value, options) {
+      const entity = entities[source.name];
+      if (!entity) {
+        throw new Error(`MikroORM entity "${source.name}" not found in provided entities object`);
+      }
+      const idColumn = source.idColumn ?? "id";
+      const fields = source.scopeKey && source.scopeKey !== idColumn ? [idColumn, source.scopeKey] : [idColumn];
+      const whereValue = options?.caseInsensitive ? { $ilike: value } : value;
+      return em.findOne(
+        entity,
+        { [source.column]: whereValue },
+        { fields }
+      );
+    }
+  };
+}
+export {
+  createMikroORMAdapter
+};

package/dist/adapters/mongoose.d.mts

@@ -0,0 +1,39 @@
+import { NamespaceAdapter } from '../index.mjs';
+
+type MongooseModel = {
+    findOne: (conditions: Record<string, unknown>, projection?: Record<string, number> | string) => {
+        lean: () => Promise<Record<string, unknown> | null>;
+        collation: (options: Record<string, unknown>) => {
+            lean: () => Promise<Record<string, unknown> | null>;
+        };
+    };
+};
+/**
+ * Create a namespace adapter for Mongoose
+ *
+ * Note: For Mongoose sources, `idColumn` defaults to "_id" instead of "id".
+ *
+ * @example
+ * ```ts
+ * import mongoose from "mongoose";
+ * import { createNamespaceGuard } from "namespace-guard";
+ * import { createMongooseAdapter } from "namespace-guard/adapters/mongoose";
+ *
+ * const User = mongoose.model("User", userSchema);
+ * const Organization = mongoose.model("Organization", orgSchema);
+ *
+ * const guard = createNamespaceGuard(
+ *   {
+ *     reserved: ["admin", "api", "settings"],
+ *     sources: [
+ *       { name: "user", column: "handle", idColumn: "_id", scopeKey: "_id" },
+ *       { name: "organization", column: "slug", idColumn: "_id", scopeKey: "_id" },
+ *     ],
+ *   },
+ *   createMongooseAdapter({ user: User, organization: Organization })
+ * );
+ * ```
+ */
+declare function createMongooseAdapter(models: Record<string, MongooseModel>): NamespaceAdapter;
+
+export { createMongooseAdapter };