@nxgt/mongo 0.1.0 → 0.3.0

package/dist/index.js

@@ -25,162 +25,7 @@ function stampsOf(definition) {
     deletedBy: has("deletedBy")
   };
 }
-// src/definition/fields.ts
-import { ObjectId } from "mongodb";
-import { z } from "zod";
-function isObjectId(value) {
-  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
-}
-function objectId() {
-  return z.custom(isObjectId, { error: "must be an ObjectId" }).meta({ bsonType: "objectId" });
-}
-function id() {
-  return objectId().default(() => new ObjectId);
-}
-function timestamps() {
-  return {
-    createdAt: z.date().default(() => new Date),
-    updatedAt: z.date().default(() => new Date)
-  };
-}
-function softDelete() {
-  return { deletedAt: z.date().nullable().default(null) };
-}
-function optimisticLock() {
-  return { version: z.int().nonnegative().default(0) };
-}
-function actors(actor = objectId()) {
-  return {
-    createdBy: actor.nullable().default(null),
-    updatedBy: actor.nullable().default(null),
-    deletedBy: actor.nullable().default(null)
-  };
-}
-var STAMP_FIELDS = {
-  id: "_id",
-  createdAt: "createdAt",
-  updatedAt: "updatedAt",
-  deletedAt: "deletedAt",
-  version: "version",
-  createdBy: "createdBy",
-  updatedBy: "updatedBy",
-  deletedBy: "deletedBy"
-};
-// src/definition/json-schema.ts
-import { z as z2 } from "zod";
-var MONGO_JSON_SCHEMA_KEYWORDS = new Set([
-  "additionalItems",
-  "additionalProperties",
-  "allOf",
-  "anyOf",
-  "bsonType",
-  "dependencies",
-  "description",
-  "enum",
-  "exclusiveMaximum",
-  "exclusiveMinimum",
-  "items",
-  "maxItems",
-  "maxLength",
-  "maxProperties",
-  "maximum",
-  "minItems",
-  "minLength",
-  "minProperties",
-  "minimum",
-  "multipleOf",
-  "not",
-  "oneOf",
-  "pattern",
-  "patternProperties",
-  "properties",
-  "required",
-  "title",
-  "type",
-  "uniqueItems"
-]);
-var SCHEMA_MAPS = new Set([
-  "properties",
-  "patternProperties",
-  "dependencies"
-]);
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var INTEGER_BSON_TYPES = ["int", "long", "double"];
-function convertIntegerType(node) {
-  const type = node.type;
-  if (type === "integer") {
-    delete node.type;
-    node.bsonType = [...INTEGER_BSON_TYPES];
-    node.multipleOf ??= 1;
-    return;
-  }
-  if (Array.isArray(type) && type.includes("integer")) {
-    delete node.type;
-    node.bsonType = [
-      ...type.filter((one) => one !== "integer"),
-      ...INTEGER_BSON_TYPES
-    ];
-    node.multipleOf ??= 1;
-  }
-}
-function refName(ref) {
-  return ref.replace(/^#\/(definitions|\$defs)\//, "");
-}
-function inline(value, defs, stack) {
-  if (Array.isArray(value)) {
-    return value.map((one) => inline(one, defs, stack));
-  }
-  if (!isRecord(value))
-    return value;
-  if (typeof value.$ref === "string") {
-    const name = refName(value.$ref);
-    if (stack.includes(name)) {
-      throw new TypeError(`toMongoJsonSchema: "${name}" refers to itself. MongoDB's $jsonSchema ` + "has no $ref, so a recursive schema cannot be a validator. Give the " + "collection no validator, or model the field as an object with no " + "schema of its own.");
-    }
-    const target = defs[name];
-    if (!isRecord(target)) {
-      throw new TypeError(`toMongoJsonSchema: cannot resolve ${value.$ref}, which zod emitted`);
-    }
-    const { $ref: _ref, ...siblings } = value;
-    return {
-      ...inline(target, defs, [...stack, name]),
-      ...inline(siblings, defs, stack)
-    };
-  }
-  const out = {};
-  for (const [key, inner] of Object.entries(value)) {
-    if (!MONGO_JSON_SCHEMA_KEYWORDS.has(key))
-      continue;
-    if (SCHEMA_MAPS.has(key) && isRecord(inner)) {
-      const mapped = {};
-      for (const [name, schema] of Object.entries(inner)) {
-        mapped[name] = inline(schema, defs, stack);
-      }
-      out[key] = mapped;
-      continue;
-    }
-    out[key] = inline(inner, defs, stack);
-  }
-  convertIntegerType(out);
-  return out;
-}
-function toMongoJsonSchema(schema) {
-  const json = z2.toJSONSchema(schema, {
-    target: "draft-4",
-    io: "output",
-    unrepresentable: "any",
-    override: (ctx) => {
-      const type = ctx.zodSchema._zod.def.type;
-      if (type === "date" && ctx.jsonSchema.bsonType === undefined) {
-        ctx.jsonSchema.bsonType = "date";
-      }
-    }
-  });
-  const definitions = isRecord(json.definitions) ? json.definitions : isRecord(json.$defs) ? json.$defs : {};
-  return inline(json, definitions, []);
-}
+
 // src/errors/data-error.ts
 class DataError extends Error {
   constructor(message = "Database error", options = {}) {
@@ -232,6 +77,14 @@ class OptimisticLockError extends DataError {
   }
 }
 
+class InvalidIdError extends DataError {
+  constructor(message = "Invalid id", options = {}) {
+    super(message, options);
+    this.name = "InvalidIdError";
+    this.code = "INVALID_ID";
+  }
+}
+
 class InvalidCursorError extends DataError {
   constructor(message = "Invalid cursor", options = {}) {
     super(message, options);
@@ -239,8 +92,9 @@ class InvalidCursorError extends DataError {
     this.code = "INVALID_CURSOR";
   }
 }
+
 // src/errors/to-data-error.ts
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asArray(value) {
@@ -256,8 +110,8 @@ function indexFromMessage(message) {
 }
 function keysOfDuplicate(error) {
   const pattern = error.keyPattern;
-  if (isRecord2(pattern)) {
-    const values = isRecord2(error.keyValue) ? error.keyValue : undefined;
+  if (isRecord(pattern)) {
+    const values = isRecord(error.keyValue) ? error.keyValue : undefined;
     return { keys: Object.keys(pattern), values };
   }
   const inMessage = text(error.errmsg)?.match(/dup key:\s*\{([^}]*)\}/)?.[1];
@@ -268,8 +122,8 @@ function keysOfDuplicate(error) {
 }
 function firstWriteError(error) {
   for (const write of asArray(error.writeErrors)) {
-    const inner = isRecord2(write) && isRecord2(write.err) ? write.err : write;
-    if (isRecord2(inner))
+    const inner = isRecord(write) && isRecord(write.err) ? write.err : write;
+    if (isRecord(inner))
       return inner;
   }
   return;
@@ -277,11 +131,11 @@ function firstWriteError(error) {
 function issuesOf(details, path = []) {
   const issues = [];
   for (const rule of asArray(details)) {
-    if (!isRecord2(rule))
+    if (!isRecord(rule))
       continue;
     if (rule.propertiesNotSatisfied !== undefined) {
       for (const property of asArray(rule.propertiesNotSatisfied)) {
-        if (!isRecord2(property))
+        if (!isRecord(property))
           continue;
         const name = text(property.propertyName) ?? "";
         const nested = issuesOf(property.details, [...path, name]);
@@ -317,7 +171,7 @@ function issuesOf(details, path = []) {
 function toDataError(error, context = {}) {
   if (error instanceof DataError)
     return error;
-  if (!isRecord2(error))
+  if (!isRecord(error))
     return error;
   const source = firstWriteError(error) ?? error;
   const code = typeof source.code === "number" ? source.code : typeof error.code === "number" ? error.code : undefined;
@@ -337,15 +191,16 @@ function toDataError(error, context = {}) {
     return new ConflictError(`Duplicate key on ${named}${context.collection ? ` in "${context.collection}"` : ""}`, { ...common, index, keys, values });
   }
   if (code === 121) {
-    const errInfo = isRecord2(source.errInfo) ? source.errInfo : undefined;
+    const errInfo = isRecord(source.errInfo) ? source.errInfo : undefined;
     const issues = issuesOf(errInfo?.details);
     return new ValidationError(`Document failed validation${context.collection ? ` in "${context.collection}"` : ""}${issues.length > 0 ? `: ${issues.map((i) => `${i.path} ${i.reason}`).join(", ")}` : ""}`, { ...common, issues, keys: issues.map((issue) => issue.path) });
   }
   return new DataError(message || `MongoDB error ${code}`, common);
 }
+
 // src/pagination/cursor.ts
-import { ObjectId as ObjectId2 } from "mongodb";
-function isObjectId2(value) {
+import { ObjectId } from "mongodb";
+function isObjectId(value) {
   return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
 }
 function replacer(key, value) {
@@ -354,7 +209,7 @@ function replacer(key, value) {
     return { $date: raw.toISOString() };
   if (typeof raw === "bigint")
     return { $bigint: raw.toString() };
-  if (isObjectId2(raw))
+  if (isObjectId(raw))
     return { $oid: raw.toHexString() };
   return value;
 }
@@ -368,7 +223,7 @@ function reviver(_key, value) {
       if (typeof tagged.$bigint === "string")
         return BigInt(tagged.$bigint);
       if (typeof tagged.$oid === "string")
-        return new ObjectId2(tagged.$oid);
+        return new ObjectId(tagged.$oid);
     }
   }
   return value;
@@ -406,6 +261,7 @@ function decodeCursor(cursor, expectedKey) {
   }
   return { key, values };
 }
+
 // src/pagination/page.ts
 var DEFAULT_PAGE_SIZE = 20;
 var DEFAULT_MAX_PAGE_SIZE = 100;
@@ -432,6 +288,123 @@ function toPage(items, total, window) {
 function cursorLimit(limit, maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
   return Math.min(positiveInteger("limit", limit ?? DEFAULT_PAGE_SIZE), maxPageSize);
 }
+
+// src/definition/json-schema.ts
+import { z } from "zod";
+var MONGO_JSON_SCHEMA_KEYWORDS = new Set([
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "bsonType",
+  "dependencies",
+  "description",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "items",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "maximum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "minimum",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "properties",
+  "required",
+  "title",
+  "type",
+  "uniqueItems"
+]);
+var SCHEMA_MAPS = new Set([
+  "properties",
+  "patternProperties",
+  "dependencies"
+]);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var INTEGER_BSON_TYPES = ["int", "long", "double"];
+function convertIntegerType(node) {
+  const type = node.type;
+  if (type === "integer") {
+    delete node.type;
+    node.bsonType = [...INTEGER_BSON_TYPES];
+    node.multipleOf ??= 1;
+    return;
+  }
+  if (Array.isArray(type) && type.includes("integer")) {
+    delete node.type;
+    node.bsonType = [
+      ...type.filter((one) => one !== "integer"),
+      ...INTEGER_BSON_TYPES
+    ];
+    node.multipleOf ??= 1;
+  }
+}
+function refName(ref) {
+  return ref.replace(/^#\/(definitions|\$defs)\//, "");
+}
+function inline(value, defs, stack) {
+  if (Array.isArray(value)) {
+    return value.map((one) => inline(one, defs, stack));
+  }
+  if (!isRecord2(value))
+    return value;
+  if (typeof value.$ref === "string") {
+    const name = refName(value.$ref);
+    if (stack.includes(name)) {
+      throw new TypeError(`toMongoJsonSchema: "${name}" refers to itself. MongoDB's $jsonSchema ` + "has no $ref, so a recursive schema cannot be a validator. Give the " + "collection no validator, or model the field as an object with no " + "schema of its own.");
+    }
+    const target = defs[name];
+    if (!isRecord2(target)) {
+      throw new TypeError(`toMongoJsonSchema: cannot resolve ${value.$ref}, which zod emitted`);
+    }
+    const { $ref: _ref, ...siblings } = value;
+    return {
+      ...inline(target, defs, [...stack, name]),
+      ...inline(siblings, defs, stack)
+    };
+  }
+  const out = {};
+  for (const [key, inner] of Object.entries(value)) {
+    if (!MONGO_JSON_SCHEMA_KEYWORDS.has(key))
+      continue;
+    if (SCHEMA_MAPS.has(key) && isRecord2(inner)) {
+      const mapped = {};
+      for (const [name, schema] of Object.entries(inner)) {
+        mapped[name] = inline(schema, defs, stack);
+      }
+      out[key] = mapped;
+      continue;
+    }
+    out[key] = inline(inner, defs, stack);
+  }
+  convertIntegerType(out);
+  return out;
+}
+function toMongoJsonSchema(schema) {
+  const json = z.toJSONSchema(schema, {
+    target: "draft-4",
+    io: "output",
+    unrepresentable: "any",
+    override: (ctx) => {
+      const type = ctx.zodSchema._zod.def.type;
+      if (type === "date" && ctx.jsonSchema.bsonType === undefined) {
+        ctx.jsonSchema.bsonType = "date";
+      }
+    }
+  });
+  const definitions = isRecord2(json.definitions) ? json.definitions : isRecord2(json.$defs) ? json.$defs : {};
+  return inline(json, definitions, []);
+}
+
 // src/sync/index-diff.ts
 var COLLATION_DEFAULTS = {
   caseLevel: false,
@@ -655,7 +628,7 @@ async function syncCollections(db, definitions, options = {}) {
   return reports;
 }
 
-// src/repository/create-repository.ts
+// src/collection/get-collection.ts
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -671,13 +644,25 @@ function mergeFilters(a, b) {
     return left;
   return { $and: [left, right] };
 }
-function createRepository(db, definition, options = {}) {
+function databaseOf(source, name) {
+  const client = source;
+  if (typeof client.db === "function")
+    return client.db(name);
+  const db = source;
+  if (name !== undefined && db.databaseName !== name) {
+    throw new TypeError(`getCollection: given a Db for "${db.databaseName}", and a db option of ` + `"${name}". Pass the client, or the database you mean.`);
+  }
+  return db;
+}
+function getCollection(source, definition, options = {}) {
+  const db = databaseOf(source, options.db);
   return build(db, definition, options);
 }
 function build(db, definition, options) {
   const name = definition.name;
   const collection = db.collection(name);
   const shape = definition.schema.shape;
+  const hasOwnId = "id" in shape;
   const stamps = stampsOf(definition);
   const session = options.session;
   const actor = options.actor;
@@ -687,10 +672,10 @@ function build(db, definition, options) {
   const touches = options.touchUpdatedAt ?? stamps.updatedAt;
   const locks = options.optimisticLock ?? stamps.version;
   if (options.softDelete === true && !stamps.deletedAt) {
-    throw new TypeError(`createRepository: softDelete needs a "deletedAt" field, and "${name}" has none`);
+    throw new TypeError(`getCollection: softDelete needs a "deletedAt" field, and "${name}" has none`);
   }
   if (options.optimisticLock === true && !stamps.version) {
-    throw new TypeError(`createRepository: optimisticLock needs a "version" field, and "${name}" has none`);
+    throw new TypeError(`getCollection: optimisticLock needs a "version" field, and "${name}" has none`);
   }
   const run = async (fn) => {
     try {
@@ -702,6 +687,17 @@ function build(db, definition, options) {
   const sessionOption = session ? { session } : {};
   const live = (withDeleted) => softDeletes && !withDeleted ? { deletedAt: null } : undefined;
   const scoped = (filter, withDeleted) => mergeFilters(isRecord3(filter) ? filter : undefined, live(withDeleted));
+  const withId = (document) => {
+    if (hasOwnId || !isRecord3(document) || document._id === undefined || Object.hasOwn(document, "id")) {
+      return document;
+    }
+    Object.defineProperty(document, "id", {
+      get: () => String(document._id),
+      enumerable: true,
+      configurable: true
+    });
+    return document;
+  };
   const notFound = (id) => new NotFoundError(`No document in "${name}" with _id ${String(id)}`, {
     collection: name,
     id
@@ -713,6 +709,8 @@ function build(db, definition, options) {
   };
   const toDocument = (values) => {
     const stamped = { ...values };
+    if (!hasOwnId)
+      delete stamped.id;
     if (actor !== undefined) {
       if (stamps.createdBy && stamped.createdBy === undefined) {
         stamped.createdBy = actor;
@@ -754,10 +752,13 @@ function build(db, definition, options) {
     }
     return update;
   };
-  const findOne = async (filter, projection) => run(async () => collection.findOne(filter, {
-    ...sessionOption,
-    ...projection ? { projection } : {}
-  }));
+  const findOne = async (filter, projection) => run(async () => {
+    const found = await collection.findOne(filter, {
+      ...sessionOption,
+      ...projection ? { projection } : {}
+    });
+    return found === null ? null : withId(found);
+  });
   async function findById(id, opts = {}) {
     const found = await findOne(scoped({ _id: id }, opts.withDeleted));
     return found ?? undefined;
@@ -780,7 +781,8 @@ function build(db, definition, options) {
         cursor = cursor.skip(opts.skip);
       if (opts.limit !== undefined)
         cursor = cursor.limit(opts.limit);
-      return cursor.toArray();
+      const found = await cursor.toArray();
+      return found.map((document) => withId(document));
     });
   }
   async function countDocuments(filter, opts = {}) {
@@ -794,7 +796,7 @@ function build(db, definition, options) {
       returnDocument: "after"
     }));
     if (updated)
-      return updated;
+      return withId(updated);
     if (expectedVersion !== undefined) {
       const current = await findOne({ _id: id });
       if (current) {
@@ -812,7 +814,7 @@ function build(db, definition, options) {
     const deleted = await run(async () => collection.findOneAndDelete({ _id: id }, { ...sessionOption }));
     if (!deleted)
       throw notFound(id);
-    return deleted;
+    return withId(deleted);
   }
   async function hardDeleteMany(filter) {
     requireFilter("hardDeleteMany", filter);
@@ -823,12 +825,12 @@ function build(db, definition, options) {
       return result.deletedCount;
     });
   }
-  const repository = {
+  const api = {
     definition,
     db,
-    collection,
+    raw: collection,
     session,
-    with: (other) => build(db, definition, { ...options, session: other }),
+    withSession: (other) => build(db, definition, { ...options, session: other }),
     as: (who) => build(db, definition, { ...options, actor: who }),
     sync: (syncOptions = {}) => syncCollection(db, definition, { ...sessionOption, ...syncOptions }),
     findById,
@@ -842,7 +844,7 @@ function build(db, definition, options) {
       const document = toDocument(values);
       return run(async () => {
         await collection.insertOne(document, { ...sessionOption });
-        return document;
+        return withId(document);
       });
     },
     async createMany(values) {
@@ -853,7 +855,7 @@ function build(db, definition, options) {
         await collection.insertMany(documents, {
           ...sessionOption
         });
-        return documents;
+        return documents.map((document) => withId(document));
       });
     },
     async update(id, patch, opts = {}) {
@@ -988,8 +990,102 @@ function build(db, definition, options) {
       return { items, nextCursor: encodeCursor({ key: cursorKey, values }) };
     }
   };
-  return repository;
+  return new Proxy(api, {
+    get(target, key, receiver) {
+      if (Reflect.has(target, key))
+        return Reflect.get(target, key, receiver);
+      const value = collection[key];
+      return typeof value === "function" ? value.bind(collection) : value;
+    },
+    has(target, key) {
+      return Reflect.has(target, key) || key in collection;
+    }
+  });
 }
+// src/definition/fields.ts
+import { ObjectId as ObjectId3 } from "mongodb";
+import { z as z3 } from "zod";
+
+// src/definition/object-id.ts
+import { ObjectId as ObjectId2 } from "mongodb";
+import { z as z2 } from "zod";
+var HEX_24 = /^[0-9a-fA-F]{24}$/;
+function isObjectId2(value) {
+  return typeof value === "object" && value !== null && value._bsontype === "ObjectId";
+}
+function isObjectIdString(value) {
+  return typeof value === "string" && HEX_24.test(value);
+}
+function isValidObjectId(value) {
+  return isObjectId2(value) || isObjectIdString(value);
+}
+function tryObjectId(value) {
+  if (isObjectId2(value))
+    return value;
+  if (isObjectIdString(value))
+    return ObjectId2.createFromHexString(value);
+  return;
+}
+function describe(value) {
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  if (typeof value === "string")
+    return `the string ${JSON.stringify(value)}`;
+  return `a ${typeof value}`;
+}
+function toObjectId(value, field = "_id") {
+  const made = tryObjectId(value);
+  if (made)
+    return made;
+  throw new InvalidIdError(`${field}: expected an ObjectId or its 24-character hex string, got ${describe(value)}`, { id: value, keys: [field] });
+}
+function toObjectIds(values, field = "_id") {
+  return [...values].map((value) => toObjectId(value, field));
+}
+function objectIdParam() {
+  return z2.custom(isValidObjectId, {
+    error: "must be an ObjectId or its 24-character hex string"
+  }).transform((value) => toObjectId(value));
+}
+
+// src/definition/fields.ts
+function objectId() {
+  return z3.custom(isObjectId2, { error: "must be an ObjectId" }).meta({ bsonType: "objectId" });
+}
+function id() {
+  return objectId().default(() => new ObjectId3);
+}
+function timestamps() {
+  return {
+    createdAt: z3.date().default(() => new Date),
+    updatedAt: z3.date().default(() => new Date)
+  };
+}
+function softDelete() {
+  return { deletedAt: z3.date().nullable().default(null) };
+}
+function optimisticLock() {
+  return { version: z3.int().nonnegative().default(0) };
+}
+function actors(actor = objectId()) {
+  return {
+    createdBy: actor.nullable().default(null),
+    updatedBy: actor.nullable().default(null),
+    deletedBy: actor.nullable().default(null)
+  };
+}
+var STAMP_FIELDS = {
+  id: "_id",
+  createdAt: "createdAt",
+  updatedAt: "updatedAt",
+  deletedAt: "deletedAt",
+  version: "version",
+  createdBy: "createdBy",
+  updatedBy: "updatedBy",
+  deletedBy: "deletedBy"
+};
 // src/transaction/with-transaction.ts
 function isSession(host) {
   return typeof host.inTransaction === "function";
@@ -1021,24 +1117,29 @@ export {
   DEFAULT_PAGE_SIZE,
   DataError,
   InvalidCursorError,
+  InvalidIdError,
   MONGO_JSON_SCHEMA_KEYWORDS,
   NotFoundError,
   OptimisticLockError,
   STAMP_FIELDS,
   ValidationError,
   actors,
-  createRepository,
   cursorLimit,
   decodeCursor,
   defineCollection,
   diffIndexes,
   encodeCursor,
+  getCollection,
   hasValidator,
   id,
   indexMatches,
   indexNameOf,
+  isObjectId2 as isObjectId,
+  isObjectIdString,
+  isValidObjectId,
   normalizeIndex,
   objectId,
+  objectIdParam,
   optimisticLock,
   pageWindow,
   softDelete,
@@ -1048,10 +1149,13 @@ export {
   timestamps,
   toDataError,
   toMongoJsonSchema,
+  toObjectId,
+  toObjectIds,
   toPage,
+  tryObjectId,
   validationMatches,
   withTransaction
 };
 
-//# debugId=44372BBBC1BF50A464756E2164756E21
+//# debugId=3B847E76D4AAF66F64756E2164756E21
 //# sourceMappingURL=index.js.map