@thisisagile/easy-mongo 17.25.1 → 17.25.3

package/dist/index.mjs

@@ -1,8 +1,588 @@
-export * from "./AtlasSearchGateway";
-export * from "./Collection";
-export * from "./Lucene";
-export * from "./MongoGateway";
-export * from "./MongoProvider";
-export * from "./Stages";
-export * from "./Utils";
+// src/Stages.ts
+import {
+  asNumber,
+  asString,
+  ifDefined,
+  ifNotEmpty,
+  isDefined,
+  isPresent,
+  isPrimitive,
+  isString,
+  meta as meta2,
+  ofGet,
+  on,
+  toArray,
+  use
+} from "@thisisagile/easy";
+
+// src/Utils.ts
+import { choose, DateTime, isArray, isDate, isDateTime, isIsoDateString, isObject, meta } from "@thisisagile/easy";
+var toMongoType = (input) => choose(input).type(isIsoDateString, (i) => new DateTime(i).toDate()).type(isDateTime, (i) => i.toDate()).type(isArray, (a) => a.map((i) => toMongoType(i))).type(isDate, (d) => d).type(
+  isObject,
+  (o) => Object.fromEntries(
+    meta(o).entries().map(([k, i]) => [k, toMongoType(i)])
+  )
+).else(input);
+
+// src/Stages.ts
+var asc = 1;
+var desc = -1;
+var FilterBuilder = class {
+  constructor(filters) {
+    this.filters = filters;
+  }
+  from = (q = {}) => stages.match.match(
+    meta2(q).entries().reduce((acc, [key, value]) => ({ ...acc, ...ifDefined(this.filters[key], (f) => f(value)) }), {})
+  );
+};
+var SortBuilder = class {
+  constructor(sorts) {
+    this.sorts = sorts;
+  }
+  get keys() {
+    return Object.keys(this.sorts);
+  }
+  from = (s = {}, alt) => stages.sort.sort(this.sorts[s?.s ?? ""] ?? this.sorts[alt ?? ""]);
+};
+var IncludeBuilder = class {
+  constructor(includes) {
+    this.includes = includes;
+  }
+  get keys() {
+    return Object.keys(this.includes);
+  }
+  from = (i = {}, alt) => stages.project.include(...this.includes[i?.i ?? ""] ?? this.includes[alt ?? ""] ?? []);
+};
+var escapeRegex = (s) => s.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+var stages = {
+  root: "$$ROOT",
+  current: "$$CURRENT",
+  id: "_id",
+  decode: {
+    object: (f) => use(Object.entries(f)[0], ([k, v]) => ofGet(v, k)),
+    fields: (f) => Object.entries(f).reduce((res, [k, v]) => on(res, (r) => ifDefined(ofGet(v, k), (nv) => r[k] = nv)), {}),
+    fieldsArrays: (f) => Object.entries(f).reduce((res, [k, v]) => on(res, (r) => r[k] = use(toArray(v), (vs) => vs.map((v2) => ofGet(v2, k)))), {}),
+    id: (f) => isString(f) ? `$${asString(f)}` : isPrimitive(f) ? f : Object.entries(f).map(([k, v]) => ofGet(v, k))[0]
+  },
+  match: {
+    match: (f) => ({ $match: stages.decode.fields(f) }),
+    filter: (filters) => new FilterBuilder(filters),
+    or: (...filters) => ({ $or: toArray(filters).map((f) => stages.decode.object(f)) }),
+    gt: (value) => ({ $gt: value }),
+    gte: (value) => ({ $gte: value }),
+    lt: (value) => ({ $lt: value }),
+    lte: (value) => ({ $lte: value }),
+    isIn: (value, separator = ",") => ({ $in: isString(value) ? value.split(separator) : value }),
+    notIn: (value, separator = ",") => ({ $nin: isString(value) ? value.split(separator) : value }),
+    after: (date) => stages.match.gte(toMongoType(date)),
+    before: (date) => stages.match.lt(toMongoType(date)),
+    anywhere: (q) => ({ $regex: escapeRegex(q), $options: "i" }),
+    money: (currency, value) => (key) => ({
+      [`${key}.currency`]: currency.id,
+      ...stages.decode.fields({ [`${key}.value`]: value })
+    })
+  },
+  sort: {
+    sort: ($sort) => isPresent($sort) ? { $sort } : void 0,
+    sorter: (sorts) => new SortBuilder(sorts),
+    asc: (key) => stages.sort.sort({ [key]: asc }),
+    desc: (key) => stages.sort.sort({ [key]: desc })
+  },
+  group: {
+    group: (fields) => ({
+      by: (by) => ({ $group: Object.assign({ _id: stages.decode.id(by) }, stages.decode.fields(fields)) })
+    }),
+    date: (format = "%Y-%m-%d") => (key) => ({ $dateToString: { date: `$${key}`, format } }),
+    count: () => ({ $count: {} }),
+    sum: (from) => isDefined(from) ? { $sum: `$${from}` } : { $sum: 1 },
+    avg: (from) => ({ $avg: `$${from}` }),
+    multiply: (...multiply) => ({ $multiply: multiply.map((m) => `$${m}`) }),
+    first: (from) => ({ $first: `$${from}` }),
+    last: (from) => ({ $last: `$${from}` }),
+    min: (from) => ({ $min: `$${from}` }),
+    max: (from) => ({ $max: `$${from}` }),
+    addToSet: (from) => ({ $addToSet: `$${from}` }),
+    push: (from = "$ROOT") => ({ $push: `$${from}` }),
+    size: (from) => ({ $size: `$${from}` })
+  },
+  search: {
+    search: (f) => ifDefined(stages.decode.id(f), ($search) => ({ $search })),
+    auto: (value) => (key) => ifDefined(value, (v) => ({ autocomplete: { path: key, query: [v] } })),
+    fuzzy: (value, maxEdits = 1) => (key) => ifDefined(value, (v) => ({
+      text: {
+        query: v,
+        path: key === "wildcard" ? { wildcard: "*" } : key,
+        fuzzy: { maxEdits }
+      }
+    }))
+  },
+  set: {
+    set: (f) => ({ $set: stages.decode.fields(f) }),
+    score: () => ({ $meta: "searchScore" })
+  },
+  skip: {
+    skip: (o = {}) => ifDefined(o.skip, { $skip: asNumber(o.skip) }),
+    take: (o = {}) => ifDefined(o.take, { $limit: asNumber(o.take) })
+  },
+  project: {
+    include: (...includes) => ifNotEmpty(includes, (es) => ({ $project: es.reduce((a, b) => ({ ...a, ...isString(b) ? { [b]: 1 } : b }), {}) })),
+    exclude: (...excludes) => ifNotEmpty(excludes, (es) => ({ $project: es.reduce((a, b) => ({ ...a, ...isString(b) ? { [b]: 0 } : b }), {}) })),
+    includes: (includes) => new IncludeBuilder(includes),
+    project: (project) => ifDefined(project, ($project) => ({ $project })),
+    date: (key, format) => ({ $toDate: `$${key}`, ...ifDefined(format, { format }) }),
+    duration: (from, to) => ({ $divide: [{ $subtract: [stages.project.date(from), stages.project.date(to)] }, 1e3] })
+  },
+  replaceWith: {
+    replaceWith: (f) => ifDefined(f, { $replaceWith: f }),
+    merge: (...objects) => ifNotEmpty(objects, (os) => ({ $mergeObjects: os })),
+    rootAnd: (...objects) => stages.replaceWith.merge(stages.root, ...objects),
+    currentAnd: (...objects) => stages.replaceWith.merge(stages.current, ...objects),
+    reroot: (prop) => ({ $replaceRoot: { newRoot: `$${prop}` } }),
+    concat: (...props) => ifNotEmpty(props, (ps) => ({ $concatArrays: ps.map((p) => `$${p}`) }))
+  },
+  facet: {
+    facet: (f) => ({ $facet: stages.decode.fieldsArrays(f) }),
+    unwind: (from) => (f) => ({ $unwind: `$${from ?? f}` }),
+    count: (from) => (f) => ({ $sortByCount: `$${from ?? f}` }),
+    data: () => []
+  },
+  unwind: {
+    unwind: (prop) => ({ $unwind: `$${prop}` })
+  }
+};
+
+// src/MongoGateway.ts
+import {
+  asJson,
+  ifDefined as ifDefined2,
+  isDefined as isDefined2,
+  isPresent as isPresent2,
+  toArray as toArray2
+} from "@thisisagile/easy";
+var MongoGateway = class {
+  constructor(collection, provider = collection.provider) {
+    this.collection = collection;
+    this.provider = provider;
+  }
+  all(options) {
+    return this.provider.all(options).then((js) => js.map((j) => this.collection.in(j)));
+  }
+  byId(id) {
+    return this.provider.byId(id).then((j) => ifDefined2(j, this.collection.in(j)));
+  }
+  by(key, value, options) {
+    return this.provider.by(key, value, options).then((js) => js.map((j) => this.collection.in(j)));
+  }
+  byIds(...ids) {
+    return this.find(this.collection.id.isIn(...ids));
+  }
+  find(q, options) {
+    return this.provider.find(asJson(q), options).then((js) => js.map((j) => this.collection.in(j)));
+  }
+  search(q, options) {
+    return this.find(this.collection.google(q), options);
+  }
+  filter(options) {
+    return this.all(options);
+  }
+  exists(id) {
+    return this.provider.byId(id).then((i) => isDefined2(i));
+  }
+  aggregate(...filters) {
+    return this.provider.aggregate(toArray2(...filters).filter(isPresent2));
+  }
+  count(...filters) {
+    return this.aggregate(...filters, { $count: "total" }).then((d) => d.first()?.total ?? 0);
+  }
+  match(f) {
+    return this.aggregate(stages.match.match(f));
+  }
+  add(item) {
+    return this.provider.add(this.collection.out(item)).then((j) => this.collection.in(j));
+  }
+  update(item) {
+    return this.provider.update(this.collection.out(item)).then((j) => this.collection.in(j));
+  }
+  remove(id) {
+    return this.provider.remove(id);
+  }
+};
+
+// src/Lucene.ts
+import {
+  entries,
+  ifDefined as ifDefined3,
+  ifNotEmpty as ifNotEmpty2,
+  ifTrue,
+  isDefined as isDefined3,
+  isEmptyObject,
+  isFunction,
+  on as on2,
+  toArray as toArray3,
+  toList
+} from "@thisisagile/easy";
+var should = (query, def) => entries(query).mapDefined(([k, v]) => def[k]?.(v, query)?.should);
+var must = (query, def) => entries(query).mapDefined(([k, v]) => def[k]?.(v, query)?.must);
+var mustNot = (query, def) => entries(query).mapDefined(([k, v]) => def[k]?.(v, query)?.mustNot);
+var filter = (query, def) => entries(query).mapDefined(([k, v]) => def[k]?.(v, query)?.filter);
+var lucene = {
+  clause: (c) => entries(c).reduce((res, [k, v]) => res.add(isFunction(v) ? v(k) : v), toList()),
+  clauses: (cs) => toArray3(cs).flatMap((c) => lucene.clause(c)),
+  compound: (query, def, wildcard = true) => ifNotEmpty2(
+    entries({
+      should: should(query, def),
+      filter: filter(query, def),
+      mustNot: mustNot(query, def),
+      must: must(query, def)
+    }).filter(([_, v]) => v.length > 0),
+    (e) => e.reduce((res, [k, v]) => on2(res, (r) => r[k] = lucene.clauses(v)), should(query, def).length > 0 ? { minimumShouldMatch: 1 } : {}),
+    () => ifTrue(wildcard, () => ({
+      should: lucene.clauses([{ wildcard: lucene.wildcard() }]),
+      minimumShouldMatch: 0
+    }))
+  ),
+  search: (c, index) => ({
+    $search: {
+      ...ifDefined3(index, { index }),
+      compound: entries(c).reduce((res, [k, v]) => on2(res, (r) => r[k] = lucene.clauses(v)), {})
+    }
+  }),
+  searchWithDef: (query, options, count = "total", index) => {
+    const sort = entries(query).mapDefined(([k, v]) => options[k]?.(v, query)?.sort).first();
+    return {
+      $search: {
+        ...ifDefined3(index, { index }),
+        compound: lucene.compound(query, options),
+        ...ifDefined3(sort, { sort }),
+        count: { type: count }
+      }
+    };
+  },
+  searchMeta: (query, def, count = "total", index) => ({
+    $searchMeta: {
+      ...ifDefined3(index, { index }),
+      ...ifTrue(
+        !isEmptyObject(lucene.facets(def)),
+        {
+          facet: {
+            operator: {
+              compound: lucene.compound(query, def)
+            },
+            facets: lucene.facets(def)
+          }
+        },
+        { compound: lucene.compound(query, def) }
+      ),
+      count: { type: count }
+    }
+  }),
+  exists: () => (path) => ({ exists: { path } }),
+  text: (value, fuzzy) => (path) => ifDefined3(value, (v) => ({
+    text: {
+      path: path === "wildcard" ? { wildcard: "*" } : path,
+      query: v,
+      ...ifDefined3(fuzzy, { fuzzy })
+    }
+  })),
+  wildcard: (value, allowAnalyzedField = true) => (path) => ({
+    wildcard: {
+      path: path === "wildcard" ? { wildcard: "*" } : path,
+      query: ifDefined3(value, value, "*"),
+      allowAnalyzedField
+    }
+  }),
+  lt: (value) => (path) => ifDefined3(value, (lt) => ({ range: { path, lt } })),
+  lte: (value) => (path) => ifDefined3(value, (lte) => ({ range: { path, lte } })),
+  gt: (value) => (path) => ifDefined3(value, (gt) => ({ range: { path, gt } })),
+  gte: (value) => (path) => ifDefined3(value, (gte) => ({ range: { path, gte } })),
+  after: (date) => lucene.gte(toMongoType(date)),
+  before: (date) => lucene.lt(toMongoType(date)),
+  between: (after, before, includeLimit) => (path) => {
+    const upperLimit = includeLimit ? { lte: toMongoType(before) } : { lt: toMongoType(before) };
+    return {
+      range: {
+        path,
+        gte: toMongoType(after),
+        ...upperLimit
+      }
+    };
+  },
+  facets: (def) => entries(def).filter(([k, v]) => isDefined3(v(k)?.facet)).map(([k, v]) => ({ [k]: v(k)?.facet })).reduce((acc, v) => ({ ...acc, ...v }), {}),
+  facet: {
+    string: (path, numBuckets = 1e3) => ({
+      type: "string",
+      path,
+      numBuckets
+    }),
+    number: (path, boundaries, alt) => ({
+      type: "number",
+      path,
+      boundaries,
+      ...ifDefined3(alt, (a) => ({ default: a }))
+    }),
+    date: (path, boundaries, alt) => ({
+      type: "date",
+      path,
+      boundaries: boundaries.mapDefined((b) => b.toDate()),
+      ...ifDefined3(alt, (a) => ({ default: a }))
+    })
+  }
+};
+
+// src/AtlasSearchGateway.ts
+import { asNumber as asNumber2, entries as entries2, text, toPageList, tuple2 } from "@thisisagile/easy";
+var { skip, take } = stages.skip;
+var { replaceWith } = stages.replaceWith;
+var { searchWithDef, searchMeta, facets } = lucene;
+var toFilters = (facets2) => entries2(facets2).map(([k, fs]) => ({
+  label: text(k).title.toString(),
+  field: k,
+  values: fs.map((f) => toValue(f))
+}));
+var toValue = (f) => ({ label: f._id ?? "unknown", value: f._id ?? "unknown", count: f.count });
+var AtlasSearchGateway = class extends MongoGateway {
+  constructor(collection, searchDef, sortDef = {}, provider = collection.provider) {
+    super(collection, provider);
+    this.searchDef = searchDef;
+    this.sortDef = sortDef;
+  }
+  query(query, additionalStages = []) {
+    return tuple2(
+      this.aggregate(
+        searchWithDef(query, this.searchDef),
+        skip({ skip: query?.skip ?? 0 }),
+        take({ take: query?.take ?? 250 }),
+        ...additionalStages
+      ),
+      this.aggregate(
+        searchMeta(query, this.searchDef),
+        replaceWith({
+          total: "$count.total",
+          facets: Object.keys(facets(this.searchDef)).reduce((acc, k) => ({ ...acc, [k]: `$facet.${k}.buckets` }), {})
+        })
+      )
+    ).then(([data, meta3]) => ({ data, meta: meta3.first() })).then(
+      ({ data, meta: meta3 }) => toPageList(data, {
+        total: asNumber2(meta3?.total, 0),
+        skip: asNumber2(query?.skip, 0),
+        take: asNumber2(query?.take, 250),
+        sorts: Object.keys(this.sortDef),
+        filters: toFilters(meta3.facets)
+      })
+    );
+  }
+};
+
+// src/Collection.ts
+import {
+  asString as asString3,
+  Database as Database2,
+  Field as Field2,
+  LogicalCondition as LogicalCondition3,
+  Mapper,
+  mappings,
+  ofGet as ofGet2,
+  toCondition,
+  toUuid
+} from "@thisisagile/easy";
+
+// src/MongoProvider.ts
+import {
+  asJson as asJson2,
+  asNumber as asNumber3,
+  asString as asString2,
+  choose as choose2,
+  entries as entries3,
+  Exception,
+  ifTrue as ifTrue2,
+  isArray as isArray2,
+  isDefined as isDefined4,
+  isField,
+  isSortCondition,
+  json,
+  toArray as toArray4,
+  toPageList as toPageList2,
+  tuple2 as tuple22,
+  tuple3,
+  use as use2,
+  when
+} from "@thisisagile/easy";
+import {
+  MongoClient
+} from "mongodb";
+var omitId = (j) => json.delete(j, "_id");
+function omitOptions(obj) {
+  const { maxTimeMS, ...rest } = obj ?? {};
+  return rest;
+}
+var MongoProvider = class _MongoProvider {
+  constructor(coll) {
+    this.coll = coll;
+  }
+  static clients = {};
+  static destroyAll() {
+    return Promise.all(entries3(_MongoProvider.clients).map(([u, c]) => c.then((c2) => c2.close()).then(() => delete _MongoProvider.clients[u]))).then(
+      () => void 0
+    );
+  }
+  static connect(u, db) {
+    return MongoClient.connect(u, {
+      auth: {
+        username: asString2(db.options?.user),
+        password: asString2(db.options?.password)
+      },
+      ...db.options?.maxPoolSize && { maxPoolSize: db.options?.maxPoolSize },
+      ...db.options?.minPoolSize && { minPoolSize: db.options?.minPoolSize },
+      ...db.options?.maxIdleTimeMS && { maxIdleTimeMS: db.options?.maxIdleTimeMS },
+      ...db.options?.socketTimeoutMS && { socketTimeoutMS: db.options?.socketTimeoutMS }
+    }).then((c) => {
+      c.on("error", () => delete _MongoProvider.clients[u]);
+      c.on("close", () => delete _MongoProvider.clients[u]);
+      return c;
+    }).catch((err) => {
+      delete _MongoProvider.clients[u];
+      return Promise.reject(err);
+    });
+  }
+  cluster() {
+    return use2(
+      this.coll.db,
+      (db) => when(db.options?.cluster).not.isDefined.reject(Exception.IsNotValid.because("Missing cluster in database options.")).then((c) => _MongoProvider.clients[c] ?? (_MongoProvider.clients[c] = _MongoProvider.connect(c, db)))
+    );
+  }
+  collection() {
+    return this.cluster().then((c) => c.db(this.coll.db.name)).then((db) => db.collection(asString2(this.coll)));
+  }
+  toMongoJson(query) {
+    return toMongoType(asJson2(query));
+  }
+  withTimeout(options) {
+    return { ...options, maxTimeMS: options?.maxTimeMS ?? this.coll.db?.options?.queryTimeoutMS ?? 3e4 };
+  }
+  find(query, options) {
+    return tuple3(this.collection(), this.toMongoJson(query), this.toFindOptions(options)).then(
+      ([c, q, o]) => tuple22(
+        c.find(q, o),
+        ifTrue2(o.total, () => c.countDocuments(q, { maxTimeMS: this.withTimeout(options).maxTimeMS }))
+      )
+    ).then(([res, total]) => this.toArray(res, { ...omitOptions(options), total }));
+  }
+  all(options) {
+    return this.find({}, options);
+  }
+  byId(id, options) {
+    return this.collection().then((c) => c.findOne(this.toMongoJson({ id }), this.toFindOptions(options)));
+  }
+  by(key, value, options) {
+    return this.find({ [key]: value }, options);
+  }
+  group(qs, options) {
+    return this.aggregate(qs, options);
+  }
+  aggregate(qs, options) {
+    return this.collection().then(
+      (c) => c.aggregate(
+        qs.map((q) => this.toMongoJson(q)),
+        this.withTimeout(options)
+      )
+    ).then((res) => this.toArray(res));
+  }
+  add(item) {
+    return this.collection().then((c) => c.insertOne(omitId(item))).then(() => omitId(item));
+  }
+  update(item) {
+    return this.collection().then((c) => c.updateOne(this.toMongoJson({ id: item.id }), { $set: omitId(item) })).then(() => this.byId(item.id));
+  }
+  remove(id) {
+    return this.collection().then((c) => c.deleteOne(this.toMongoJson({ id }))).then((d) => d.acknowledged);
+  }
+  count(query, options) {
+    return this.collection().then((c) => c.countDocuments(this.toMongoJson(query ?? {}), this.withTimeout(options)));
+  }
+  createIndex(indexes, options) {
+    return this.collection().then((c) => c.createIndex(this.toIndexSpecification(indexes), this.toCreateIndexesOptions(options)));
+  }
+  createPartialIndex(indexes, filter2, options) {
+    return this.createIndex(indexes, { ...options, filter: filter2 });
+  }
+  createTextIndex(indexes, options) {
+    const ii = toArray4(indexes).reduce((i, f) => ({ ...i, [asString2(f)]: "text" }), {});
+    return this.createIndex(ii, { unique: false, ...options });
+  }
+  toFindOptions(options) {
+    return {
+      limit: asNumber3(options?.take ?? 250),
+      ...options?.skip && { skip: asNumber3(options?.skip) },
+      ...options?.sorts && { sort: options?.sorts } || options?.sort && { sort: this.coll.sort(...options?.sort ?? []) },
+      total: isDefined4(options?.skip) || isDefined4(options?.take),
+      projection: options?.projection ?? { _id: 0 },
+      maxTimeMS: this.withTimeout(options).maxTimeMS
+    };
+  }
+  toIndexSpecification(index) {
+    return choose2(index).type(isField, (f) => f.property).type(isSortCondition, (s) => s.toJSON()).type(isArray2, (aa) => aa.map((a) => this.toIndexSpecification(a))).else((i) => i);
+  }
+  toCreateIndexesOptions(options) {
+    return {
+      unique: options?.unique ?? true,
+      ...options?.languageOverride && { language_override: options.languageOverride },
+      ...options?.languageDefault && { default_language: options.languageDefault },
+      ...options?.filter && { partialFilterExpression: toMongoType(asJson2(options.filter)) }
+    };
+  }
+  toArray(cursor, options) {
+    return cursor.toArray().then((r) => toPageList2(r, options));
+  }
+};
+
+// src/Collection.ts
+var Collection = class extends Mapper {
+  map = {
+    ...mappings,
+    field: (name, options) => new Field2(name, options)
+  };
+  id = this.map.field("id", { dflt: toUuid });
+  constructor(options = { startFrom: "source" }) {
+    super(options);
+  }
+  get db() {
+    return Database2.Default;
+  }
+  get provider() {
+    return new MongoProvider(this);
+  }
+  where = (...conditions) => new LogicalCondition3(
+    "and",
+    conditions.map((c) => ofGet2(c, this))
+  ).toJSON();
+  match = (condition) => ({ $match: ofGet2(condition, this).toJSON() });
+  group = (...conditions) => new LogicalCondition3(
+    "group",
+    conditions.map((c) => ofGet2(c, this))
+  ).toJSON();
+  google = (value) => toCondition("$text", "search", value);
+  search = (key) => this.map.field(asString3(key));
+  sort = (...conditions) => conditions.reduce((cs, c) => {
+    cs[c.key] = c.value;
+    return cs;
+  }, {});
+  out(to = {}) {
+    return toMongoType(super.out(to));
+  }
+};
+export {
+  AtlasSearchGateway,
+  Collection,
+  FilterBuilder,
+  IncludeBuilder,
+  MongoGateway,
+  MongoProvider,
+  SortBuilder,
+  asc,
+  desc,
+  lucene,
+  stages,
+  toFilters,
+  toMongoType
+};
 //# sourceMappingURL=index.mjs.map