mongoose-killer 0.1.0

package/dist/cjs/populate.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPopulate = exports.normalizePopulateArg = void 0;
+const normalizePopulateArg = (arg) => {
+    if (!arg)
+        return [];
+    if (typeof arg === "string") {
+        // Mongoose accepts "a b c" → three populates.
+        return arg
+            .split(/\s+/)
+            .filter(Boolean)
+            .map((path) => ({ path }));
+    }
+    if (Array.isArray(arg)) {
+        return arg.flatMap(exports.normalizePopulateArg);
+    }
+    if (typeof arg === "object") {
+        const { path, select, match, populate } = arg;
+        return [
+            {
+                path,
+                select,
+                match,
+                populate: populate ? (0, exports.normalizePopulateArg)(populate) : undefined,
+            },
+        ];
+    }
+    return [];
+};
+exports.normalizePopulateArg = normalizePopulateArg;
+const runPopulate = async (docs, specs, opts) => {
+    for (const spec of specs) {
+        await applySpec(docs, spec, opts);
+    }
+    return docs;
+};
+exports.runPopulate = runPopulate;
+const applySpec = async (docs, spec, opts) => {
+    const cfg = opts.ownerModel.populates[spec.path];
+    if (!cfg) {
+        // No mapping configured for this path → nothing to do. Matches
+        // mongoose's behavior of silently skipping unknown refs.
+        return;
+    }
+    const refModelName = opts.ownerModel.collectionToModelName.get(cfg.collection);
+    if (!refModelName)
+        return;
+    const refModel = opts.ownerModel.getModelByName(refModelName);
+    const isArrayPath = spec.path.includes(".");
+    if (isArrayPath) {
+        await populateArrayPath(docs, spec, refModel, opts);
+    }
+    else {
+        await populateScalarPath(docs, spec, refModel, opts);
+    }
+};
+const populateScalarPath = async (docs, spec, refModel, opts) => {
+    const ids = uniqueIds(docs.map((d) => d?.[spec.path]).filter(isPresent));
+    if (ids.length === 0)
+        return;
+    const filter = { _id: { $in: ids } };
+    if (spec.match)
+        Object.assign(filter, spec.match);
+    const findOpts = {};
+    if (spec.select)
+        findOpts.projection = normalizeProjection(spec.select);
+    if (opts.session)
+        findOpts.session = opts.session;
+    const fetched = await refModel.collection.find(filter, findOpts).toArray();
+    if (spec.populate) {
+        await (0, exports.runPopulate)(fetched, spec.populate, {
+            ownerModel: refModel,
+            session: opts.session,
+        });
+    }
+    const byId = new Map();
+    for (const f of fetched)
+        byId.set(idKey(f._id), f);
+    // Mongoose semantics: if a match filter is present, refs that don't
+    // satisfy it get nulled out (the parent doc still exists, but the
+    // populated field becomes null). Without a match, leave non-matches
+    // alone (the raw ref id stays, matching mongoose's behavior when a
+    // referenced doc has been deleted).
+    const nullifyMisses = !!spec.match;
+    for (const d of docs) {
+        const raw = d?.[spec.path];
+        if (!isPresent(raw))
+            continue;
+        const hit = byId.get(idKey(raw));
+        if (hit)
+            d[spec.path] = hit;
+        else if (nullifyMisses)
+            d[spec.path] = null;
+    }
+};
+// "tags._id" — parent has an array of subdocs, each with an _id
+// field that's a ref. After populate, each subdoc's _id is replaced
+// with the full referenced doc.
+const populateArrayPath = async (docs, spec, refModel, opts) => {
+    const [parent, child] = spec.path.split(".");
+    const allIds = [];
+    for (const d of docs) {
+        const arr = d?.[parent];
+        if (!Array.isArray(arr))
+            continue;
+        for (const sub of arr) {
+            const v = sub?.[child];
+            if (isPresent(v))
+                allIds.push(v);
+        }
+    }
+    const ids = uniqueIds(allIds);
+    if (ids.length === 0)
+        return;
+    const filter = { _id: { $in: ids } };
+    if (spec.match)
+        Object.assign(filter, spec.match);
+    const findOpts = {};
+    if (spec.select)
+        findOpts.projection = normalizeProjection(spec.select);
+    if (opts.session)
+        findOpts.session = opts.session;
+    const fetched = await refModel.collection.find(filter, findOpts).toArray();
+    if (spec.populate) {
+        await (0, exports.runPopulate)(fetched, spec.populate, {
+            ownerModel: refModel,
+            session: opts.session,
+        });
+    }
+    const byId = new Map();
+    for (const f of fetched)
+        byId.set(idKey(f._id), f);
+    const nullifyMisses = !!spec.match;
+    for (const d of docs) {
+        const arr = d?.[parent];
+        if (!Array.isArray(arr))
+            continue;
+        for (const sub of arr) {
+            const raw = sub?.[child];
+            if (!isPresent(raw))
+                continue;
+            const hit = byId.get(idKey(raw));
+            if (hit)
+                sub[child] = hit;
+            else if (nullifyMisses)
+                sub[child] = null;
+        }
+    }
+};
+const isPresent = (v) => v !== null && v !== undefined;
+// ObjectId values aren't === equal even when they represent the same
+// 24 hex chars, so key by their string form.
+const idKey = (v) => {
+    if (v == null)
+        return "";
+    if (typeof v === "string")
+        return v;
+    if (typeof v.toHexString === "function")
+        return v.toHexString();
+    return String(v);
+};
+const uniqueIds = (ids) => {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        const k = idKey(id);
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(id);
+    }
+    return out;
+};
+const normalizeProjection = (sel) => {
+    if (typeof sel !== "string")
+        return sel;
+    const out = {};
+    for (const tok of sel.split(/\s+/).filter(Boolean)) {
+        if (tok.startsWith("-"))
+            out[tok.slice(1)] = 0;
+        else
+            out[tok] = 1;
+    }
+    return out;
+};

package/dist/cjs/types.d.ts

@@ -0,0 +1,14 @@
+import type { Db } from "mongodb";
+export type PopulateConfig = Record<string, Record<string, {
+    collection: string;
+}>>;
+export type CastIdsConflictPolicy = "throw" | "firstWins" | "lastWins" | "defaultWins";
+export type CreateGetModelOpts = {
+    db: Db;
+    models: Record<string, string>;
+    populates?: PopulateConfig;
+    autoCastIds?: boolean;
+    castIdsConflictPolicy?: CastIdsConflictPolicy;
+};
+export type GetModel = (name: string) => any;
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,MAAM,MAAM,cAAc,GAAG,MAAM,CACjC,MAAM,EACN,MAAM,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CACvC,CAAC;AAUF,MAAM,MAAM,qBAAqB,GAC7B,OAAO,GACP,WAAW,GACX,UAAU,GACV,aAAa,CAAC;AAElB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,EAAE,CAAC;IACP,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,cAAc,CAAC;IAS3B,WAAW,CAAC,EAAE,OAAO,CAAC;IAGtB,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAC"}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/CastIdsConflictError.js

@@ -0,0 +1,23 @@
+// Thrown at query exec time when a single Query has had both
+// `.castIds()` and `.skipCastIds()` called on it AND the configured
+// conflict policy is "throw".
+//
+// Exported as a named class so callers can do `instanceof` in error
+// handlers. The static `is(err)` helper is here for callers that
+// receive errors across module-boundaries (different bundles can
+// produce instanceof-incompatible classes with the same name).
+export class CastIdsConflictError extends Error {
+    name = "CastIdsConflictError";
+    castIdsCallCount;
+    skipCastIdsCallCount;
+    constructor(opts) {
+        super(`Conflicting calls on the same Query: ${opts.castIdsCallCount}× .castIds() and ${opts.skipCastIdsCallCount}× .skipCastIds(). ` +
+            `The configured castIdsConflictPolicy is "throw" — pass createGetModel({ castIdsConflictPolicy: "lastWins" | "firstWins" | "defaultWins" }) to resolve conflicts automatically, or remove one of the calls.`);
+        this.castIdsCallCount = opts.castIdsCallCount;
+        this.skipCastIdsCallCount = opts.skipCastIdsCallCount;
+    }
+    static is(err) {
+        return (err instanceof Error &&
+            err.name === "CastIdsConflictError");
+    }
+}

package/dist/esm/Model.js

@@ -0,0 +1,201 @@
+import { ObjectId } from "bson";
+import { Query } from "./Query.js";
+import { runPopulate, normalizePopulateArg } from "./populate.js";
+// Mongoose `Model` is half class, half magic. We mimic the surface the
+// codebase actually uses (per inventory): the static entry verbs.
+// Instances are not a thing — call sites never `new Model()`.
+export class Model {
+    name;
+    collection;
+    populates;
+    collectionToModelName;
+    getModelByName;
+    autoCastIds;
+    castIdsConflictPolicy;
+    // Mongoose exposes Model.db as a Connection-like object, and
+    // Connection.db is the native Db handle. Some libraries reach
+    // through `Model.db.db` to grab the native Db and issue a raw
+    // `db.collection(name).findOne({})` — bypassing the ODM (often
+    // to avoid lossy type handling like mongoose's historical
+    // Decimal128 quirks).
+    //
+    // We mimic that two-hop shape: `model.db` is a wrapper object whose
+    // `.db` is the native Db. Anything else hanging off Connection is
+    // not currently used by any call site, so we leave it unset.
+    db;
+    constructor(init) {
+        this.name = init.name;
+        this.collection = init.collection;
+        this.populates = init.populates;
+        this.collectionToModelName = init.collectionToModelName;
+        this.getModelByName = init.getModelByName;
+        this.autoCastIds = init.autoCastIds;
+        this.castIdsConflictPolicy = init.castIdsConflictPolicy;
+        this.db = { db: init.db };
+    }
+    // ---- query entry verbs --------------------------------------------
+    find(filter = {}, projection, options) {
+        const q = new Query({ model: this, op: "find", filter, options });
+        if (projection)
+            q.select(projection);
+        if (options?.sort)
+            q.sort(options.sort);
+        if (options?.limit !== undefined)
+            q.limit(options.limit);
+        if (options?.skip !== undefined)
+            q.skip(options.skip);
+        return q;
+    }
+    findOne(filter = {}, projection, options) {
+        const q = new Query({ model: this, op: "findOne", filter, options });
+        if (projection)
+            q.select(projection);
+        return q;
+    }
+    findById(id, projection, options) {
+        return this.findOne({ _id: coerceId(id) }, projection, options);
+    }
+    findOneAndUpdate(filter, update, options) {
+        return new Query({
+            model: this,
+            op: "findOneAndUpdate",
+            filter,
+            update,
+            options,
+        });
+    }
+    findByIdAndUpdate(id, update, options) {
+        return this.findOneAndUpdate({ _id: coerceId(id) }, update, options);
+    }
+    findOneAndDelete(filter, options) {
+        return new Query({
+            model: this,
+            op: "findOneAndDelete",
+            filter,
+            options,
+        });
+    }
+    findByIdAndDelete(id, options) {
+        return this.findOneAndDelete({ _id: coerceId(id) }, options);
+    }
+    updateOne(filter, update, options) {
+        return new Query({
+            model: this,
+            op: "updateOne",
+            filter,
+            update,
+            options,
+        });
+    }
+    updateMany(filter, update, options) {
+        return new Query({
+            model: this,
+            op: "updateMany",
+            filter,
+            update,
+            options,
+        });
+    }
+    deleteOne(filter, options) {
+        return new Query({
+            model: this,
+            op: "deleteOne",
+            filter,
+            options,
+        });
+    }
+    deleteMany(filter, options) {
+        return new Query({
+            model: this,
+            op: "deleteMany",
+            filter,
+            options,
+        });
+    }
+    countDocuments(filter = {}, options) {
+        return new Query({
+            model: this,
+            op: "countDocuments",
+            filter,
+            options,
+        });
+    }
+    distinct(field, filter = {}, options) {
+        return new Query({
+            model: this,
+            op: "distinct",
+            filter,
+            distinctField: field,
+            options,
+        });
+    }
+    exists(filter, options) {
+        return new Query({
+            model: this,
+            op: "exists",
+            filter,
+            options,
+        });
+    }
+    aggregate(pipeline = [], options) {
+        return new Query({
+            model: this,
+            op: "aggregate",
+            pipeline,
+            options,
+        });
+    }
+    // ---- writes that aren't chains ------------------------------------
+    // Mongoose's create returns the inserted doc(s) with _id set.
+    // Inventory uses both forms: create(doc) and create([docs], options).
+    async create(input, options) {
+        if (Array.isArray(input)) {
+            const docs = input.map(prepInsert);
+            if (docs.length === 0)
+                return [];
+            await this.collection.insertMany(docs, options ?? {});
+            return docs;
+        }
+        const doc = prepInsert(input);
+        await this.collection.insertOne(doc, options ?? {});
+        return doc;
+    }
+    async insertMany(docs, options) {
+        const prepared = docs.map(prepInsert);
+        if (prepared.length === 0)
+            return [];
+        await this.collection.insertMany(prepared, options ?? {});
+        return prepared;
+    }
+    async bulkWrite(ops, options) {
+        return this.collection.bulkWrite(ops, options ?? {});
+    }
+    // Static populate: takes pre-fetched doc(s) and decorates them.
+    // Used in a handful of inventory sites for ad-hoc populate after
+    // a custom aggregation.
+    async populate(docs, arg) {
+        const isArr = Array.isArray(docs);
+        const arr = isArr ? docs : [docs];
+        if (arr.length === 0)
+            return docs;
+        const specs = normalizePopulateArg(arg);
+        const populated = await runPopulate(arr, specs, {
+            ownerModel: this,
+            session: undefined,
+        });
+        return isArr ? populated : populated[0];
+    }
+}
+// Mongoose auto-assigns _id on insert; the driver does the same, but
+// only if _id is missing. We let the driver handle it — no work here.
+// Kept as a hook in case we ever need to deep-clone or strip Mongoose-
+// only fields.
+const prepInsert = (doc) => doc;
+const coerceId = (id) => {
+    if (id instanceof ObjectId)
+        return id;
+    if (typeof id === "string" && /^[0-9a-fA-F]{24}$/.test(id)) {
+        return new ObjectId(id);
+    }
+    return id;
+};