@maykonpaulo/maestro-provider-mongodb 1.0.0-next.1

package/README.md

@@ -0,0 +1,86 @@
+# @maykonpaulo/maestro-provider-mongodb
+
+A MongoDB provider for [`@maykonpaulo/maestro-core`](https://www.npmjs.com/package/@maykonpaulo/maestro-core) — the first **document/schema-less family** provider, per [ADR 0007 — Universal Provider Strategy](../../docs/adr/0007-universal-provider-strategy.md). It implements all three of the core's provider contracts against a real MongoDB database:
+
+- `IntrospectionProvider` — discovers collections and infers each one's shape by **sampling** documents (there is no fixed schema to read). Every entity is reported with `schemaless: true`.
+- `DatasourceProvider` — real `list`/`findById`/`create`/`update`/`delete`/`count`, translated to native MongoDB queries (filters, sort, search, pagination).
+- `SchemaWriteProvider` — `ensureEntity` creates the collection if it does not exist yet (idempotent).
+
+## Why a separate package instead of a dialect of `@maykonpaulo/maestro-provider-sql`
+
+MongoDB's query model (documents, no fixed columns, no `information_schema`) is genuinely different from the relational family — it cannot share the SQL query-building layer the relational dialects reuse. ADR 0007 groups providers by *paradigm*, not by exact product: this package is the whole document-store family for now, the way `@maykonpaulo/maestro-provider-sql` is the whole relational family.
+
+## Installation
+
+```bash
+npm install @maykonpaulo/maestro-provider-mongodb @maykonpaulo/maestro-core
+```
+
+`@maykonpaulo/maestro-core` and `mongodb` are peer dependencies — install the versions your project already uses.
+
+## Usage
+
+```ts
+import { runIntrospectionProvider } from '@maykonpaulo/maestro-core';
+import { createMongoProvider } from '@maykonpaulo/maestro-provider-mongodb';
+
+const provider = createMongoProvider({ uri: 'mongodb://localhost:27017', database: 'app' });
+
+// Introspection — samples documents, validated/normalized via the core
+const { result } = await runIntrospectionProvider(provider);
+
+// Real CRUD against the same database
+const created = await provider.create({ table: 'users', primaryKey: '_id', data: { name: 'Ada' } });
+const page = await provider.list({ table: 'users', primaryKey: '_id', pagination: { strategy: 'page', page: 1, pageSize: 20 } });
+
+// Create the collection if it isn't there yet
+await provider.ensureEntity({ entity: { table: 'tags', fields: [] } });
+```
+
+### Configuration
+
+```ts
+export interface MongoProviderOptions {
+  uri?: string;              // a mongodb://... connection string
+  client?: MongoClient;      // an already-connected client — for tests/embedding; caller owns its lifecycle
+  database: string;          // required — Mongo has no "current database" to infer
+  maxDocuments?: number;     // caps documents read per collection during introspection — unset by default (scans the whole collection)
+}
+```
+
+Exactly one of `uri` or `client` must be provided.
+
+## `_id` handling
+
+MongoDB always assigns a native `ObjectId` to `_id` unless the caller supplies one. This provider follows that default:
+
+- `create()` with `primaryKey: '_id'` and no `_id` in `data` lets Mongo generate a native `ObjectId` — the shape any pre-existing real collection almost certainly already uses. The returned record's `_id` is the `ObjectId`'s string form.
+- `findById`/`update`/`delete` with `primaryKey: '_id'` accept a 24-hex-character id and match it against **both** a stored `ObjectId` and a stored plain string, so records created by this provider (which may hold either shape) and records that already existed in a real database (`ObjectId`) both resolve correctly.
+- A non-`_id` primary key (e.g. `slug`) is always treated as a plain value — Mongo has no special type for it. `create()` still generates a `randomUUID()` string when the caller doesn't supply one, matching every other provider in this monorepo.
+
+## What is introspected
+
+Since there is no system catalog, introspection **reads every document in every collection by default**
+(`maxDocuments` is unset unless you explicitly cap it for a very large collection) and infers:
+
+- **Fields** — the union of keys observed across all scanned documents, each with the most-recently-seen non-null type.
+- **Nullability** — `true` whenever a scanned document omitted the field or held `null`/`undefined` for it, or whenever fewer documents than were scanned actually carried the field.
+- **Primary key** — `_id` is always marked `isPrimaryKey: true`.
+- **`schemaless: true`** on every entity (ADR 0007, DA-13) — signals to any consumer (CLI, declarative config generator, a future admin UI) that these fields are a likely shape, not a guarantee, unlike a relational provider's catalog-read columns. This is not about incomplete coverage of *existing* data — a full scan sees every document currently in the collection — it is an honest acknowledgment that MongoDB itself enforces no shape, so a document written a moment later can still introduce a field or type this result never saw. That is a property of the database, not a shortcut this provider takes.
+
+## What is *not* introspected (known limitations)
+
+- **Relations** — MongoDB has no foreign-key constraint to read. Guessing one from a field-naming convention (e.g. `userId`) would claim a confidence level (`'definite'`/`'inferred'`) this provider cannot honestly back for a schemaless source, so `relations` is always `[]`.
+- **Indices** — not introspected in this version.
+- **Nested/embedded document shape** — a field holding a sub-document is reported as a single `'json'`-typed field; its inner structure is not recursively sampled.
+
+## Schema creation (`ensureEntity`)
+
+Unlike a relational `CREATE TABLE`, a MongoDB collection carries no column definitions — `entity.fields` is not applied to the created collection, since there is nothing in Mongo's own model to apply it to. `ensureEntity` simply creates the (empty) collection if it doesn't already exist; the collection then accepts documents of whatever shape is written to it, per MongoDB's schemaless model.
+
+## Testing
+
+Tests run against a **real, ephemeral MongoDB server** started per test run via
+[`mongodb-memory-server`](https://github.com/typegoose/mongodb-memory-server) (downloads a real `mongod`
+binary once, then runs fully offline/in-process) — no Docker, no shared external database. See
+`tests/mongo-provider.test.ts`.

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { IntrospectionProvider, DatasourceProvider, SchemaWriteProvider } from '@maykonpaulo/maestro-core';
+import { MongoClient } from 'mongodb';
+
+/**
+ * Configuration for `createMongoProvider`. Either `uri` (a `mongodb://...` connection string) or an
+ * already-connected `client` must be provided — `client` exists mainly for tests/embedding, mirroring
+ * the `database`-instance pattern used by the `sqlite` dialect in `@maykonpaulo/maestro-provider-sql`.
+ */
+interface MongoProviderOptions {
+    uri?: string;
+    client?: MongoClient;
+    database: string;
+    /**
+     * Caps how many documents introspection reads per collection. **Unset by default — the entire
+     * collection is scanned**, since MongoDB has no catalog to substitute for actually reading the data.
+     * Only set this for a very large collection where a full scan is genuinely too slow; doing so trades
+     * completeness for speed and should be a deliberate choice, not the default.
+     */
+    maxDocuments?: number;
+}
+
+interface MongoProvider extends IntrospectionProvider, DatasourceProvider, SchemaWriteProvider {
+    /**
+     * Closes the underlying `MongoClient`, but only when this provider opened it itself (from `uri`) —
+     * a caller-supplied `client` is never closed here, since the caller owns its lifecycle. Call this
+     * when you're done with the provider (e.g. before the process exits, or in a test's teardown) so the
+     * connection doesn't linger.
+     */
+    close(): Promise<void>;
+}
+/** Factory for {@link MongoProvider}, mirroring `createSqlProvider`'s shape. */
+declare function createMongoProvider(options: MongoProviderOptions): MongoProvider;
+
+export { type MongoProvider, type MongoProviderOptions, createMongoProvider };

package/dist/index.js

@@ -0,0 +1,305 @@
+// src/mongoConnection.ts
+var mongoModulePromise;
+function loadMongo() {
+  mongoModulePromise ??= import("mongodb");
+  return mongoModulePromise;
+}
+async function openMongoDb(options) {
+  if (!options.uri && !options.client) {
+    throw new Error('MongoProvider: either "uri" or "client" must be provided.');
+  }
+  if (!options.database) {
+    throw new Error('MongoProvider: "database" is required.');
+  }
+  const maxDocuments = options.maxDocuments;
+  if (options.client) {
+    return { db: options.client.db(options.database), maxDocuments };
+  }
+  const mongodb = await loadMongo();
+  const client = new mongodb.MongoClient(options.uri);
+  await client.connect();
+  return { db: client.db(options.database), maxDocuments, ownedClient: client };
+}
+
+// src/MongoIntrospection.ts
+import { ObjectId } from "mongodb";
+var INTERNAL_COLLECTION_PREFIX = "system.";
+function inferValueType(value) {
+  if (value instanceof ObjectId) return "string";
+  if (value instanceof Date) return "datetime";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+  if (typeof value === "object" && value !== null) return "json";
+  return "string";
+}
+async function scanEntity(db, collectionName, maxDocuments) {
+  let cursor = db.collection(collectionName).find({});
+  if (maxDocuments !== void 0) cursor = cursor.limit(maxDocuments);
+  const documents = await cursor.toArray();
+  const fields = /* @__PURE__ */ new Map();
+  let scannedCount = 0;
+  for (const doc of documents) {
+    scannedCount += 1;
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const [key, value] of Object.entries(doc)) {
+      seenKeys.add(key);
+      const isNull = value === null || value === void 0;
+      const existing = fields.get(key);
+      if (!existing) {
+        fields.set(key, { type: isNull ? "string" : inferValueType(value), seenNull: isNull, seenCount: 1 });
+        continue;
+      }
+      existing.seenCount += 1;
+      if (isNull) existing.seenNull = true;
+      else existing.type = inferValueType(value);
+    }
+    for (const [key, sample] of fields) {
+      if (!seenKeys.has(key)) sample.seenNull = true;
+    }
+  }
+  const fieldSchemas = [...fields.entries()].map(([name, sample]) => ({
+    name,
+    nativeType: sample.type,
+    type: sample.type,
+    nullable: sample.seenNull || sample.seenCount < scannedCount,
+    isPrimaryKey: name === "_id"
+  }));
+  return { table: collectionName, fields: fieldSchemas, schemaless: true };
+}
+async function introspectMongo(db, maxDocuments) {
+  const collections = await db.listCollections(void 0, { nameOnly: true }).toArray();
+  const names = collections.map((c) => c.name).filter((name) => !name.startsWith(INTERNAL_COLLECTION_PREFIX)).sort();
+  const entities = await Promise.all(names.map((name) => scanEntity(db, name, maxDocuments)));
+  return { entities, relations: [] };
+}
+async function mongoCollectionExists(db, name) {
+  const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();
+  return collections.length > 0;
+}
+
+// src/MongoDatasource.ts
+import { randomUUID } from "crypto";
+import { ObjectId as ObjectId2 } from "mongodb";
+import { MaestroError, ErrorCode } from "@maykonpaulo/maestro-core";
+var OBJECT_ID_PATTERN = /^[0-9a-fA-F]{24}$/;
+function idFilterValue(primaryKey, id) {
+  if (primaryKey === "_id" && OBJECT_ID_PATTERN.test(id)) {
+    return { $in: [new ObjectId2(id), id] };
+  }
+  return id;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildFilterClause(filter) {
+  const { field, value } = filter;
+  switch (filter.operator) {
+    case "equals":
+      return { [field]: value };
+    case "notEquals":
+      return { [field]: { $ne: value } };
+    case "contains":
+      return { [field]: { $regex: escapeRegex(String(value ?? "")), $options: "i" } };
+    case "startsWith":
+      return { [field]: { $regex: `^${escapeRegex(String(value ?? ""))}`, $options: "i" } };
+    case "endsWith":
+      return { [field]: { $regex: `${escapeRegex(String(value ?? ""))}$`, $options: "i" } };
+    case "gt":
+      return { [field]: { $gt: value } };
+    case "gte":
+      return { [field]: { $gte: value } };
+    case "lt":
+      return { [field]: { $lt: value } };
+    case "lte":
+      return { [field]: { $lte: value } };
+    case "between": {
+      const [min, max] = value;
+      return { [field]: { $gte: min, $lte: max } };
+    }
+    case "in":
+      return { [field]: { $in: value } };
+    case "notIn":
+      return { [field]: { $nin: value } };
+    case "isNull":
+      return { [field]: null };
+    case "isNotNull":
+      return { [field]: { $ne: null } };
+    case "isTrue":
+      return { [field]: true };
+    case "isFalse":
+      return { [field]: false };
+    default:
+      return {};
+  }
+}
+function buildFilter(context) {
+  const clauses = (context.filters ?? []).map(buildFilterClause);
+  if (context.search?.term && context.search.fields.length) {
+    clauses.push({
+      $or: context.search.fields.map((field) => ({
+        [field]: { $regex: escapeRegex(context.search.term), $options: "i" }
+      }))
+    });
+  }
+  if (!clauses.length) return {};
+  return clauses.length === 1 ? clauses[0] : { $and: clauses };
+}
+function buildSort(sort) {
+  if (!sort?.length) return void 0;
+  return Object.fromEntries(sort.map((s) => [s.field, s.direction === "desc" ? -1 : 1]));
+}
+function serializeDocument(doc) {
+  const record = {};
+  for (const [key, value] of Object.entries(doc)) {
+    record[key] = value instanceof ObjectId2 ? value.toString() : value;
+  }
+  return record;
+}
+async function listDocuments(db, context) {
+  const collection = db.collection(context.table);
+  const filter = buildFilter(context);
+  const sort = buildSort(context.sort);
+  const total = await collection.countDocuments(filter);
+  let cursor = collection.find(filter);
+  if (sort) cursor = cursor.sort(sort);
+  const pagination = context.pagination;
+  let page;
+  let pageSize;
+  let cursorOffset;
+  let cursorLimit;
+  if (pagination?.strategy === "page") {
+    page = pagination.page;
+    pageSize = pagination.pageSize;
+    cursor = cursor.skip((page - 1) * pageSize).limit(pageSize);
+  } else if (pagination?.strategy === "offset") {
+    cursor = cursor.skip(pagination.offset).limit(pagination.limit);
+  } else if (pagination?.strategy === "cursor") {
+    cursorOffset = pagination.cursor ? parseInt(pagination.cursor, 10) : 0;
+    cursorLimit = pagination.limit;
+    cursor = cursor.skip(cursorOffset).limit(cursorLimit);
+  }
+  const documents = await cursor.toArray();
+  const records = documents.map(serializeDocument);
+  if (page !== void 0 && pageSize !== void 0) {
+    return { records, total, page, pageSize, totalPages: Math.ceil(total / pageSize) };
+  }
+  if (cursorOffset !== void 0 && cursorLimit !== void 0) {
+    const nextOffset = cursorOffset + cursorLimit;
+    return { records, total, nextCursor: nextOffset < total ? String(nextOffset) : void 0 };
+  }
+  return { records, total };
+}
+async function countDocumentsForContext(db, context) {
+  return db.collection(context.table).countDocuments(buildFilter(context));
+}
+async function findDocumentById(db, context) {
+  const doc = await db.collection(context.table).findOne({ [context.primaryKey]: idFilterValue(context.primaryKey, context.id) });
+  return doc ? serializeDocument(doc) : null;
+}
+async function createDocument(db, context) {
+  const collection = db.collection(context.table);
+  const providedId = context.data[context.primaryKey];
+  if (context.primaryKey === "_id" && providedId === void 0) {
+    const { insertedId } = await collection.insertOne({ ...context.data });
+    return { ...context.data, _id: insertedId.toString() };
+  }
+  const id = String(providedId ?? randomUUID());
+  const record = { ...context.data, [context.primaryKey]: id };
+  await collection.insertOne(record);
+  return serializeDocument(record);
+}
+async function updateDocument(db, context) {
+  const existing = await findDocumentById(db, {
+    table: context.table,
+    primaryKey: context.primaryKey,
+    id: context.id
+  });
+  if (!existing) {
+    throw new MaestroError(ErrorCode.NOT_FOUND, `Record '${context.id}' not found in collection '${context.table}'.`);
+  }
+  const updates = { ...context.data };
+  delete updates[context.primaryKey];
+  if (Object.keys(updates).length) {
+    await db.collection(context.table).updateOne(
+      { [context.primaryKey]: idFilterValue(context.primaryKey, context.id) },
+      { $set: updates }
+    );
+  }
+  return { ...existing, ...context.data, [context.primaryKey]: context.id };
+}
+async function deleteDocument(db, context) {
+  const result = await db.collection(context.table).deleteOne({ [context.primaryKey]: idFilterValue(context.primaryKey, context.id) });
+  if (result.deletedCount === 0) {
+    throw new MaestroError(ErrorCode.NOT_FOUND, `Record '${context.id}' not found in collection '${context.table}'.`);
+  }
+}
+
+// src/MongoSchemaWrite.ts
+async function ensureMongoEntity(db, entity) {
+  if (await mongoCollectionExists(db, entity.table)) {
+    return { created: false };
+  }
+  await db.createCollection(entity.table);
+  return { created: true };
+}
+
+// src/MongoProvider.ts
+var MongoProviderImpl = class {
+  constructor(options) {
+    this.options = options;
+    if (!options.uri && !options.client) {
+      throw new Error('MongoProvider: either "uri" or "client" must be provided.');
+    }
+    if (!options.database) {
+      throw new Error('MongoProvider: "database" is required.');
+    }
+  }
+  options;
+  name = "mongodb";
+  handlePromise;
+  getHandle() {
+    this.handlePromise ??= openMongoDb(this.options);
+    return this.handlePromise;
+  }
+  async getDb() {
+    return (await this.getHandle()).db;
+  }
+  async introspect(_context) {
+    const { db, maxDocuments } = await this.getHandle();
+    return introspectMongo(db, maxDocuments);
+  }
+  async list(context) {
+    return listDocuments(await this.getDb(), context);
+  }
+  async findById(context) {
+    return findDocumentById(await this.getDb(), context);
+  }
+  async create(context) {
+    return createDocument(await this.getDb(), context);
+  }
+  async update(context) {
+    return updateDocument(await this.getDb(), context);
+  }
+  async delete(context) {
+    await deleteDocument(await this.getDb(), context);
+  }
+  async count(context) {
+    return countDocumentsForContext(await this.getDb(), context);
+  }
+  async ensureEntity(context) {
+    return ensureMongoEntity(await this.getDb(), context.entity);
+  }
+  async close() {
+    if (!this.handlePromise) return;
+    const { ownedClient } = await this.handlePromise;
+    if (ownedClient) await ownedClient.close();
+  }
+};
+function createMongoProvider(options) {
+  return new MongoProviderImpl(options);
+}
+export {
+  createMongoProvider
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mongoConnection.ts","../src/MongoIntrospection.ts","../src/MongoDatasource.ts","../src/MongoSchemaWrite.ts","../src/MongoProvider.ts"],"sourcesContent":["import type * as MongoModule from 'mongodb';\nimport type { Db, MongoClient } from 'mongodb';\n\n/**\n * Configuration for `createMongoProvider`. Either `uri` (a `mongodb://...` connection string) or an\n * already-connected `client` must be provided — `client` exists mainly for tests/embedding, mirroring\n * the `database`-instance pattern used by the `sqlite` dialect in `@maykonpaulo/maestro-provider-sql`.\n */\nexport interface MongoProviderOptions {\n  uri?: string;\n  client?: MongoClient;\n  database: string;\n  /**\n   * Caps how many documents introspection reads per collection. **Unset by default — the entire\n   * collection is scanned**, since MongoDB has no catalog to substitute for actually reading the data.\n   * Only set this for a very large collection where a full scan is genuinely too slow; doing so trades\n   * completeness for speed and should be a deliberate choice, not the default.\n   */\n  maxDocuments?: number;\n}\n\nlet mongoModulePromise: Promise<typeof MongoModule> | undefined;\n\n/** Loads the `mongodb` driver lazily — never imported at this package's build/publish time, only when the provider is actually used. */\nfunction loadMongo(): Promise<typeof MongoModule> {\n  mongoModulePromise ??= import('mongodb');\n  return mongoModulePromise;\n}\n\nexport interface MongoHandle {\n  db: Db;\n  maxDocuments: number | undefined;\n  /** Present only when this provider opened its own client (not a caller-supplied `client`) — closed on demand by the caller if desired. Never closed automatically. */\n  ownedClient?: MongoClient;\n}\n\nexport async function openMongoDb(options: MongoProviderOptions): Promise<MongoHandle> {\n  if (!options.uri && !options.client) {\n    throw new Error('MongoProvider: either \"uri\" or \"client\" must be provided.');\n  }\n  if (!options.database) {\n    throw new Error('MongoProvider: \"database\" is required.');\n  }\n  const maxDocuments = options.maxDocuments;\n  if (options.client) {\n    return { db: options.client.db(options.database), maxDocuments };\n  }\n  const mongodb = await loadMongo();\n  const client = new mongodb.MongoClient(options.uri!);\n  await client.connect();\n  return { db: client.db(options.database), maxDocuments, ownedClient: client };\n}\n","import type { Db } from 'mongodb';\nimport { ObjectId } from 'mongodb';\nimport type {\n  IntrospectionResult,\n  EntityIntrospectionSchema,\n  FieldIntrospectionSchema,\n  FieldType,\n} from '@maykonpaulo/maestro-core';\n\nconst INTERNAL_COLLECTION_PREFIX = 'system.';\n\n/** Infers a `FieldType` from a sampled JS/BSON value — never from a schema, since documents have none. */\nfunction inferValueType(value: unknown): FieldType {\n  if (value instanceof ObjectId) return 'string';\n  if (value instanceof Date) return 'datetime';\n  if (Array.isArray(value)) return 'array';\n  if (typeof value === 'boolean') return 'boolean';\n  if (typeof value === 'number') return Number.isInteger(value) ? 'integer' : 'number';\n  if (typeof value === 'object' && value !== null) return 'json';\n  return 'string';\n}\n\ninterface FieldSample {\n  type: FieldType;\n  seenNull: boolean;\n  seenCount: number;\n}\n\n/**\n * Scans every document in `collection` (or up to `maxDocuments`, when the caller explicitly caps it for\n * a very large collection) and infers a likely shape: the union of keys observed, each field's\n * most-recently-seen non-null type, and `nullable: true` whenever a document either omitted the field\n * or held `null`/`undefined` for it. This reads the whole collection by default — not a partial guess\n * from a handful of documents — precisely because MongoDB has no catalog to read instead; every\n * returned field still carries `schemaless: true` at the entity level (ADR 0007, DA-13), since a\n * document written *after* this scan could still introduce a field or type this result never saw.\n */\nasync function scanEntity(db: Db, collectionName: string, maxDocuments: number | undefined): Promise<EntityIntrospectionSchema> {\n  let cursor = db.collection(collectionName).find({});\n  if (maxDocuments !== undefined) cursor = cursor.limit(maxDocuments);\n  const documents = await cursor.toArray();\n  const fields = new Map<string, FieldSample>();\n  let scannedCount = 0;\n\n  for (const doc of documents) {\n    scannedCount += 1;\n    const seenKeys = new Set<string>();\n    for (const [key, value] of Object.entries(doc)) {\n      seenKeys.add(key);\n      const isNull = value === null || value === undefined;\n      const existing = fields.get(key);\n      if (!existing) {\n        fields.set(key, { type: isNull ? 'string' : inferValueType(value), seenNull: isNull, seenCount: 1 });\n        continue;\n      }\n      existing.seenCount += 1;\n      if (isNull) existing.seenNull = true;\n      else existing.type = inferValueType(value);\n    }\n    // Any field seen in an earlier document but absent from this one is nullable (missing == null in Mongo semantics).\n    for (const [key, sample] of fields) {\n      if (!seenKeys.has(key)) sample.seenNull = true;\n    }\n  }\n\n  const fieldSchemas: FieldIntrospectionSchema[] = [...fields.entries()].map(([name, sample]) => ({\n    name,\n    nativeType: sample.type,\n    type: sample.type,\n    nullable: sample.seenNull || sample.seenCount < scannedCount,\n    isPrimaryKey: name === '_id',\n  }));\n\n  return { table: collectionName, fields: fieldSchemas, schemaless: true };\n}\n\n/**\n * Discovers collections and infers each one's field shape by scanning documents — MongoDB has no\n * system catalog describing a fixed schema, so this is the only way to introspect it. Every document in\n * every collection is read by default (`maxDocuments` is `undefined` unless the caller explicitly caps\n * it), not a small fixed sample — the result is as complete as a schemaless source can honestly be. No\n * relations are inferred: Mongo has no foreign-key constraint to read, and guessing one from\n * field-naming conventions (e.g. `userId`) would be a confidence level this contract does not represent\n * for a schemaless source.\n */\nexport async function introspectMongo(db: Db, maxDocuments: number | undefined): Promise<IntrospectionResult> {\n  const collections = await db.listCollections(undefined, { nameOnly: true }).toArray();\n  const names = collections\n    .map((c) => c.name)\n    .filter((name) => !name.startsWith(INTERNAL_COLLECTION_PREFIX))\n    .sort();\n  const entities = await Promise.all(names.map((name) => scanEntity(db, name, maxDocuments)));\n  return { entities, relations: [] };\n}\n\nexport async function mongoCollectionExists(db: Db, name: string): Promise<boolean> {\n  const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();\n  return collections.length > 0;\n}\n","import { randomUUID } from 'node:crypto';\nimport { ObjectId } from 'mongodb';\nimport type { Db, Document, Filter, Sort } from 'mongodb';\nimport type {\n  DatasourceQueryContext,\n  DatasourceFindContext,\n  DatasourceWriteContext,\n  DatasourceUpdateContext,\n  DatasourceDeleteContext,\n  ListResult,\n  FilterDescriptor,\n  SortDescriptor,\n} from '@maykonpaulo/maestro-core';\nimport { MaestroError, ErrorCode } from '@maykonpaulo/maestro-core';\n\nconst OBJECT_ID_PATTERN = /^[0-9a-fA-F]{24}$/;\n\n/**\n * Renders `_id` lookups tolerant of both representations a collection may hold: a native `ObjectId`\n * (the Mongo default, and the shape any pre-existing real collection almost certainly already uses) or\n * a plain string (what this provider's own `create()` assigns when the caller doesn't supply one and\n * the primary key isn't `_id`). Non-`_id` primary keys are always plain values — Mongo has no special\n * type for them.\n */\nfunction idFilterValue(primaryKey: string, id: string): unknown {\n  if (primaryKey === '_id' && OBJECT_ID_PATTERN.test(id)) {\n    return { $in: [new ObjectId(id), id] };\n  }\n  return id;\n}\n\nfunction escapeRegex(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\nfunction buildFilterClause(filter: FilterDescriptor): Document {\n  const { field, value } = filter;\n  switch (filter.operator) {\n    case 'equals':\n      return { [field]: value };\n    case 'notEquals':\n      return { [field]: { $ne: value } };\n    case 'contains':\n      return { [field]: { $regex: escapeRegex(String(value ?? '')), $options: 'i' } };\n    case 'startsWith':\n      return { [field]: { $regex: `^${escapeRegex(String(value ?? ''))}`, $options: 'i' } };\n    case 'endsWith':\n      return { [field]: { $regex: `${escapeRegex(String(value ?? ''))}$`, $options: 'i' } };\n    case 'gt':\n      return { [field]: { $gt: value } };\n    case 'gte':\n      return { [field]: { $gte: value } };\n    case 'lt':\n      return { [field]: { $lt: value } };\n    case 'lte':\n      return { [field]: { $lte: value } };\n    case 'between': {\n      const [min, max] = value as [unknown, unknown];\n      return { [field]: { $gte: min, $lte: max } };\n    }\n    case 'in':\n      return { [field]: { $in: value as unknown[] } };\n    case 'notIn':\n      return { [field]: { $nin: value as unknown[] } };\n    case 'isNull':\n      return { [field]: null };\n    case 'isNotNull':\n      return { [field]: { $ne: null } };\n    case 'isTrue':\n      return { [field]: true };\n    case 'isFalse':\n      return { [field]: false };\n    default:\n      return {};\n  }\n}\n\nfunction buildFilter(context: Pick<DatasourceQueryContext, 'filters' | 'search'>): Filter<Document> {\n  const clauses: Document[] = (context.filters ?? []).map(buildFilterClause);\n  if (context.search?.term && context.search.fields.length) {\n    clauses.push({\n      $or: context.search.fields.map((field) => ({\n        [field]: { $regex: escapeRegex(context.search!.term), $options: 'i' },\n      })),\n    });\n  }\n  if (!clauses.length) return {};\n  return clauses.length === 1 ? clauses[0] : { $and: clauses };\n}\n\nfunction buildSort(sort?: SortDescriptor[]): Sort | undefined {\n  if (!sort?.length) return undefined;\n  return Object.fromEntries(sort.map((s) => [s.field, s.direction === 'desc' ? -1 : 1]));\n}\n\n/** Converts a Mongo `ObjectId` value at any top-level field (typically `_id`) to its string form, so records match the plain `Record<string, unknown>` shape every other provider returns. */\nfunction serializeDocument(doc: Document): Record<string, unknown> {\n  const record: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(doc)) {\n    record[key] = value instanceof ObjectId ? value.toString() : value;\n  }\n  return record;\n}\n\nexport async function listDocuments(\n  db: Db,\n  context: DatasourceQueryContext,\n): Promise<ListResult<Record<string, unknown>>> {\n  const collection = db.collection(context.table);\n  const filter = buildFilter(context);\n  const sort = buildSort(context.sort);\n  const total = await collection.countDocuments(filter);\n\n  let cursor = collection.find(filter);\n  if (sort) cursor = cursor.sort(sort);\n\n  const pagination = context.pagination;\n  let page: number | undefined;\n  let pageSize: number | undefined;\n  let cursorOffset: number | undefined;\n  let cursorLimit: number | undefined;\n\n  if (pagination?.strategy === 'page') {\n    page = pagination.page;\n    pageSize = pagination.pageSize;\n    cursor = cursor.skip((page - 1) * pageSize).limit(pageSize);\n  } else if (pagination?.strategy === 'offset') {\n    cursor = cursor.skip(pagination.offset).limit(pagination.limit);\n  } else if (pagination?.strategy === 'cursor') {\n    cursorOffset = pagination.cursor ? parseInt(pagination.cursor, 10) : 0;\n    cursorLimit = pagination.limit;\n    cursor = cursor.skip(cursorOffset).limit(cursorLimit);\n  }\n\n  const documents = await cursor.toArray();\n  const records = documents.map(serializeDocument);\n\n  if (page !== undefined && pageSize !== undefined) {\n    return { records, total, page, pageSize, totalPages: Math.ceil(total / pageSize) };\n  }\n  if (cursorOffset !== undefined && cursorLimit !== undefined) {\n    const nextOffset = cursorOffset + cursorLimit;\n    return { records, total, nextCursor: nextOffset < total ? String(nextOffset) : undefined };\n  }\n  return { records, total };\n}\n\nexport async function countDocumentsForContext(db: Db, context: DatasourceQueryContext): Promise<number> {\n  return db.collection(context.table).countDocuments(buildFilter(context));\n}\n\nexport async function findDocumentById(\n  db: Db,\n  context: DatasourceFindContext,\n): Promise<Record<string, unknown> | null> {\n  const doc = await db\n    .collection(context.table)\n    .findOne({ [context.primaryKey]: idFilterValue(context.primaryKey, context.id) } as Filter<Document>);\n  return doc ? serializeDocument(doc) : null;\n}\n\nexport async function createDocument(\n  db: Db,\n  context: DatasourceWriteContext,\n): Promise<Record<string, unknown>> {\n  const collection = db.collection(context.table);\n  const providedId = context.data[context.primaryKey];\n\n  if (context.primaryKey === '_id' && providedId === undefined) {\n    // Let Mongo assign a native ObjectId — the idiomatic default, and what every other collection in\n    // a real, pre-existing database already does.\n    const { insertedId } = await collection.insertOne({ ...context.data } as Document);\n    return { ...context.data, _id: insertedId.toString() };\n  }\n\n  const id = String(providedId ?? randomUUID());\n  const record = { ...context.data, [context.primaryKey]: id };\n  // insertOne mutates its argument, adding a native `_id` ObjectId when the document doesn't already\n  // carry one (true here whenever `primaryKey` isn't `_id`) — serialize before returning so the shape\n  // matches what findById/list report for the same document.\n  await collection.insertOne(record as Document);\n  return serializeDocument(record);\n}\n\nexport async function updateDocument(\n  db: Db,\n  context: DatasourceUpdateContext,\n): Promise<Record<string, unknown>> {\n  const existing = await findDocumentById(db, {\n    table: context.table,\n    primaryKey: context.primaryKey,\n    id: context.id,\n  });\n  if (!existing) {\n    throw new MaestroError(ErrorCode.NOT_FOUND, `Record '${context.id}' not found in collection '${context.table}'.`);\n  }\n  const updates = { ...context.data };\n  delete updates[context.primaryKey];\n  if (Object.keys(updates).length) {\n    await db\n      .collection(context.table)\n      .updateOne(\n        { [context.primaryKey]: idFilterValue(context.primaryKey, context.id) } as Filter<Document>,\n        { $set: updates },\n      );\n  }\n  return { ...existing, ...context.data, [context.primaryKey]: context.id };\n}\n\nexport async function deleteDocument(db: Db, context: DatasourceDeleteContext): Promise<void> {\n  const result = await db\n    .collection(context.table)\n    .deleteOne({ [context.primaryKey]: idFilterValue(context.primaryKey, context.id) } as Filter<Document>);\n  if (result.deletedCount === 0) {\n    throw new MaestroError(ErrorCode.NOT_FOUND, `Record '${context.id}' not found in collection '${context.table}'.`);\n  }\n}\n","import type { Db } from 'mongodb';\nimport type { EntityIntrospectionSchema, SchemaWriteResult } from '@maykonpaulo/maestro-core';\nimport { mongoCollectionExists } from './MongoIntrospection.js';\n\n/**\n * Creates the collection for `entity` if it does not already exist. Idempotent. Unlike a relational\n * `CREATE TABLE`, Mongo collections carry no column definitions — `entity.fields` is not applied to the\n * created collection (there is nothing to apply it to); the collection simply starts accepting\n * documents of whatever shape is written to it, per MongoDB's schemaless model.\n */\nexport async function ensureMongoEntity(db: Db, entity: EntityIntrospectionSchema): Promise<SchemaWriteResult> {\n  if (await mongoCollectionExists(db, entity.table)) {\n    return { created: false };\n  }\n  await db.createCollection(entity.table);\n  return { created: true };\n}\n","import type { Db } from 'mongodb';\nimport type {\n  IntrospectionProvider,\n  IntrospectionContext,\n  IntrospectionResult,\n  DatasourceProvider,\n  DatasourceQueryContext,\n  DatasourceFindContext,\n  DatasourceWriteContext,\n  DatasourceUpdateContext,\n  DatasourceDeleteContext,\n  ListResult,\n  SchemaWriteProvider,\n  SchemaWriteContext,\n  SchemaWriteResult,\n} from '@maykonpaulo/maestro-core';\nimport type { MongoProviderOptions, MongoHandle } from './mongoConnection.js';\nimport { openMongoDb } from './mongoConnection.js';\nimport { introspectMongo } from './MongoIntrospection.js';\nimport { listDocuments, findDocumentById, createDocument, updateDocument, deleteDocument, countDocumentsForContext } from './MongoDatasource.js';\nimport { ensureMongoEntity } from './MongoSchemaWrite.js';\n\nexport interface MongoProvider extends IntrospectionProvider, DatasourceProvider, SchemaWriteProvider {\n  /**\n   * Closes the underlying `MongoClient`, but only when this provider opened it itself (from `uri`) —\n   * a caller-supplied `client` is never closed here, since the caller owns its lifecycle. Call this\n   * when you're done with the provider (e.g. before the process exits, or in a test's teardown) so the\n   * connection doesn't linger.\n   */\n  close(): Promise<void>;\n}\n\n/**\n * The first document/schema-less family provider (ADR 0007, DA-13): implements `IntrospectionProvider`\n * (sampling-based, `schemaless: true`), `DatasourceProvider` (real CRUD via the native `mongodb`\n * driver) and `SchemaWriteProvider` (`ensureEntity` creates the collection if missing) over the same\n * `Db` handle, opened lazily once and reused for the life of this instance. The `mongodb` driver is\n * loaded dynamically — it is never a mandatory dependency of consumers who don't install this package.\n */\nclass MongoProviderImpl implements MongoProvider {\n  readonly name = 'mongodb';\n\n  private handlePromise: Promise<MongoHandle> | undefined;\n\n  constructor(private readonly options: MongoProviderOptions) {\n    if (!options.uri && !options.client) {\n      throw new Error('MongoProvider: either \"uri\" or \"client\" must be provided.');\n    }\n    if (!options.database) {\n      throw new Error('MongoProvider: \"database\" is required.');\n    }\n  }\n\n  private getHandle(): Promise<MongoHandle> {\n    this.handlePromise ??= openMongoDb(this.options);\n    return this.handlePromise;\n  }\n\n  private async getDb(): Promise<Db> {\n    return (await this.getHandle()).db;\n  }\n\n  async introspect(_context?: IntrospectionContext): Promise<IntrospectionResult> {\n    const { db, maxDocuments } = await this.getHandle();\n    return introspectMongo(db, maxDocuments);\n  }\n\n  async list(context: DatasourceQueryContext): Promise<ListResult<Record<string, unknown>>> {\n    return listDocuments(await this.getDb(), context);\n  }\n\n  async findById(context: DatasourceFindContext): Promise<Record<string, unknown> | null> {\n    return findDocumentById(await this.getDb(), context);\n  }\n\n  async create(context: DatasourceWriteContext): Promise<Record<string, unknown>> {\n    return createDocument(await this.getDb(), context);\n  }\n\n  async update(context: DatasourceUpdateContext): Promise<Record<string, unknown>> {\n    return updateDocument(await this.getDb(), context);\n  }\n\n  async delete(context: DatasourceDeleteContext): Promise<void> {\n    await deleteDocument(await this.getDb(), context);\n  }\n\n  async count(context: DatasourceQueryContext): Promise<number> {\n    return countDocumentsForContext(await this.getDb(), context);\n  }\n\n  async ensureEntity(context: SchemaWriteContext): Promise<SchemaWriteResult> {\n    return ensureMongoEntity(await this.getDb(), context.entity);\n  }\n\n  async close(): Promise<void> {\n    if (!this.handlePromise) return;\n    const { ownedClient } = await this.handlePromise;\n    if (ownedClient) await ownedClient.close();\n  }\n}\n\n/** Factory for {@link MongoProvider}, mirroring `createSqlProvider`'s shape. */\nexport function createMongoProvider(options: MongoProviderOptions): MongoProvider {\n  return new MongoProviderImpl(options);\n}\n"],"mappings":"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","names":["ObjectId"]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@maykonpaulo/maestro-provider-mongodb",
+  "version": "1.0.0-next.1",
+  "description": "MongoDB provider for @maykonpaulo/maestro-core — schema-inferred introspection (sampling), real CRUD, and missing-collection creation, per ADR 0007 (the first document/schema-less family provider).",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "mongodb": "^6.0.0 || ^7.0.0",
+    "@maykonpaulo/maestro-core": "0.7.0-next.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "mongodb": "^7.4.0",
+    "mongodb-memory-server": "^11.2.0",
+    "rimraf": "^6.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.0.0",
+    "@maykonpaulo/maestro-core": "0.7.0-next.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests",
+    "clean": "rimraf dist"
+  }
+}