@akanjs/document 0.0.39 → 0.0.40

package/src/dbDecorators.js

@@ -0,0 +1,153 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dbDecorators_exports = {};
+__export(dbDecorators_exports, {
+  Database: () => Database,
+  DocumentDatabaseStorage: () => DocumentDatabaseStorage,
+  InputDatabaseStorage: () => InputDatabaseStorage,
+  MiddlewareDatabaseStorage: () => MiddlewareDatabaseStorage,
+  ModelDatabaseStorage: () => ModelDatabaseStorage,
+  beyond: () => beyond,
+  by: () => by,
+  dbOf: () => dbOf,
+  getAllDatabaseModelNames: () => getAllDatabaseModelNames,
+  inside: () => inside,
+  into: () => into
+});
+module.exports = __toCommonJS(dbDecorators_exports);
+var import_constant = require("@akanjs/constant");
+const dbOf = /* @__PURE__ */ __name((refName, Input, Doc, Model2, Middleware, Obj, Insight, Filter, Summary) => {
+  return {
+    refName,
+    Input,
+    Doc,
+    Model: Model2,
+    Middleware,
+    Obj,
+    Insight,
+    Filter,
+    Summary
+  };
+}, "dbOf");
+class InputDatabaseStorage {
+  static {
+    __name(this, "InputDatabaseStorage");
+  }
+}
+class DocumentDatabaseStorage {
+  static {
+    __name(this, "DocumentDatabaseStorage");
+  }
+}
+class ModelDatabaseStorage {
+  static {
+    __name(this, "ModelDatabaseStorage");
+  }
+}
+class MiddlewareDatabaseStorage {
+  static {
+    __name(this, "MiddlewareDatabaseStorage");
+  }
+}
+const getAllDatabaseModelNames = /* @__PURE__ */ __name(() => {
+  const modelNames = Reflect.getMetadataKeys(ModelDatabaseStorage.prototype) ?? [];
+  return modelNames;
+}, "getAllDatabaseModelNames");
+const Database = {
+  Input: /* @__PURE__ */ __name((returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = (0, import_constant.getClassMeta)(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, InputDatabaseStorage.prototype);
+    };
+  }, "Input"),
+  Document: /* @__PURE__ */ __name((returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = (0, import_constant.getClassMeta)(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, DocumentDatabaseStorage.prototype);
+    };
+  }, "Document"),
+  Model: /* @__PURE__ */ __name((returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = (0, import_constant.getClassMeta)(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, ModelDatabaseStorage.prototype);
+    };
+  }, "Model"),
+  Middleware: /* @__PURE__ */ __name((returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = (0, import_constant.getClassMeta)(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, MiddlewareDatabaseStorage.prototype);
+    };
+  }, "Middleware")
+};
+const Model = /* @__PURE__ */ __name((docRef, cnst) => {
+  let DefaultModel = class DefaultModel {
+    static {
+      __name(this, "DefaultModel");
+    }
+  };
+  return DefaultModel;
+}, "Model");
+const into = Model;
+const AddModel = /* @__PURE__ */ __name((modelRef, cnst) => {
+  return modelRef;
+}, "AddModel");
+const inside = AddModel;
+const by = /* @__PURE__ */ __name((modelRef, addRef) => {
+  if (!addRef) return InputOrDocument(modelRef);
+  return AddInputOrDocument(modelRef, addRef);
+}, "by");
+const InputOrDocument = /* @__PURE__ */ __name((inputRef) => {
+  return inputRef;
+}, "InputOrDocument");
+const AddInputOrDocument = /* @__PURE__ */ __name((modelRef, addRef) => {
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
+  const addFieldMetas = (0, import_constant.getFieldMetaMap)(addRef);
+  (0, import_constant.setFieldMetaMap)(modelRef, new Map([
+    ...fieldMetaMap,
+    ...addFieldMetas
+  ]));
+  return modelRef;
+}, "AddInputOrDocument");
+const beyond = /* @__PURE__ */ __name((model, doc) => {
+  return class Middleware {
+    static {
+      __name(this, "Middleware");
+    }
+    onSchema(schema) {
+    }
+  };
+}, "beyond");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Database,
+  DocumentDatabaseStorage,
+  InputDatabaseStorage,
+  MiddlewareDatabaseStorage,
+  ModelDatabaseStorage,
+  beyond,
+  by,
+  dbOf,
+  getAllDatabaseModelNames,
+  inside,
+  into
+});

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export { B as BaseMiddleware, a as Database, k as DatabaseModel, D as Doc, b as DocumentDatabaseStorage, I as InputDatabaseStorage, M as Mdl, e as MiddlewareDatabaseStorage, c as ModelDatabaseStorage, S as SchemaOf, j as beyond, h as by, l as databaseModelOf, d as dbOf, g as getAllDatabaseModelNames, f as inside, i as into } from '../dbDecorators-B-tzSGvi.js';
+export { convertAggregateMatch, getDefaultSchemaOptions } from './schema.js';
+export { DataInputOf } from './types.js';
+export { Id, Loader, LoaderMeta, Mixed, ObjectId, createArrayElementLoader, createArrayLoader, createLoader, createQueryLoader, getLoaderMetas } from './dataLoader.js';
+export { FilterQuery as QueryOf } from 'mongoose';
+export { default as DataLoader } from 'dataloader';
+import 'dayjs';
+import '../types-H2HI4YUe.js';
+import 'meilisearch';
+import 'redis';

package/src/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./dbDecorators"), module.exports);
+__reExport(src_exports, require("./schema"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./database"), module.exports);
+__reExport(src_exports, require("./dataLoader"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./dbDecorators"),
+  ...require("./schema"),
+  ...require("./types"),
+  ...require("./database"),
+  ...require("./dataLoader")
+});

package/src/schema.d.ts

@@ -0,0 +1,32 @@
+import { FilterQuery, ProjectionType, PipelineStage } from 'mongoose';
+
+declare const getDefaultSchemaOptions: <TSchema, TDocument>() => {
+    toJSON: {
+        getters: boolean;
+        virtuals: boolean;
+    };
+    toObject: {
+        getters: boolean;
+        virtuals: boolean;
+    };
+    _id: boolean;
+    id: boolean;
+    timestamps: boolean;
+    methods: {
+        refresh: () => Promise<any>;
+    };
+    statics: {
+        pickOne: (query: FilterQuery<TSchema>, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+        pickById: (docId: string | undefined, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+        sample: (query: FilterQuery<TSchema>, size?: number, aggregations?: PipelineStage[]) => Promise<TDocument[]>;
+        sampleOne: (query: FilterQuery<TSchema>, aggregations?: PipelineStage[]) => Promise<TDocument | null>;
+        addSummary: (prefix?: string, num?: number) => Promise<void>;
+        moveSummary: (prev: string, next: string, num?: number) => Promise<void>;
+        subSummary: (prefix?: string, num?: number) => Promise<void>;
+    };
+};
+declare const convertAggregateMatch: (query: any) => {
+    [k: string]: any;
+};
+
+export { convertAggregateMatch, getDefaultSchemaOptions };

package/src/schema.js

@@ -0,0 +1,156 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  convertAggregateMatch: () => convertAggregateMatch,
+  getDefaultSchemaOptions: () => getDefaultSchemaOptions
+});
+module.exports = __toCommonJS(schema_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_mongoose = require("mongoose");
+const getDefaultSchemaOptions = /* @__PURE__ */ __name(() => ({
+  toJSON: {
+    getters: false,
+    virtuals: true
+  },
+  toObject: {
+    getters: false,
+    virtuals: true
+  },
+  _id: true,
+  id: true,
+  timestamps: true,
+  methods: {
+    refresh: /* @__PURE__ */ __name(async function() {
+      Object.assign(this, await this.constructor.findById(this._id));
+      return this;
+    }, "refresh")
+  },
+  statics: {
+    pickOne: /* @__PURE__ */ __name(async function(query, projection) {
+      const doc = await this.findOne(query, projection);
+      if (!doc) throw new Error("No Document");
+      return doc;
+    }, "pickOne"),
+    pickById: /* @__PURE__ */ __name(async function(docId, projection) {
+      if (!docId) throw new Error("No Document ID");
+      const doc = await this.findById(docId, projection);
+      if (!doc) throw new Error("No Document");
+      return doc;
+    }, "pickById"),
+    sample: /* @__PURE__ */ __name(async function(query, size = 1, aggregations = []) {
+      const objs = await this.aggregate([
+        {
+          $match: convertAggregateMatch(query)
+        },
+        {
+          $sample: {
+            size
+          }
+        },
+        ...aggregations
+      ]);
+      return objs.map((obj) => new this(obj));
+    }, "sample"),
+    sampleOne: /* @__PURE__ */ __name(async function(query, aggregations = []) {
+      const obj = await this.aggregate([
+        {
+          $match: convertAggregateMatch(query)
+        },
+        {
+          $sample: {
+            size: 1
+          }
+        },
+        ...aggregations
+      ]);
+      return obj.length ? new this(obj[0]) : null;
+    }, "sampleOne"),
+    addSummary: /* @__PURE__ */ __name(async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({
+            ...acc,
+            [`${cur}${this.modelName}`]: num
+          }), {})
+        }
+      } : {
+        $inc: {
+          [`${prefix}${this.modelName}`]: num
+        }
+      };
+      await this.db.collection("summaries").updateOne({
+        status: "active"
+      }, update);
+    }, "addSummary"),
+    moveSummary: /* @__PURE__ */ __name(async function(prev, next, num = 1) {
+      await this.db.collection("summaries").updateOne({
+        status: "active"
+      }, {
+        $inc: {
+          [`${prev}${this.modelName}`]: -num,
+          [`${next}${this.modelName}`]: num
+        }
+      });
+    }, "moveSummary"),
+    subSummary: /* @__PURE__ */ __name(async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({
+            ...acc,
+            [`${cur}${this.modelName}`]: -num
+          }), {})
+        }
+      } : {
+        $inc: {
+          [`${prefix}${this.modelName}`]: -num
+        }
+      };
+      await this.db.collection("summaries").updateOne({
+        status: "active"
+      }, update);
+    }, "subSummary")
+  }
+}), "getDefaultSchemaOptions");
+const convertOperatorValue = /* @__PURE__ */ __name((value) => {
+  if (Array.isArray(value)) return value.map((v) => convertOperatorValue(v));
+  else if (!value) return value;
+  else if ((0, import_mongoose.isValidObjectId)(value)) return new import_mongoose.Types.ObjectId(value);
+  else if ((0, import_common.isValidDate)(value)) return (0, import_base.dayjs)(value).toDate();
+  else if (value.constructor !== Object) return value;
+  else if (typeof value !== "object") return value;
+  else return Object.fromEntries(Object.entries(value).map(([key, value2]) => [
+    key,
+    convertOperatorValue(value2)
+  ]));
+}, "convertOperatorValue");
+const convertAggregateMatch = /* @__PURE__ */ __name((query) => {
+  return Object.fromEntries(Object.entries(query).map(([key, value]) => {
+    return [
+      key,
+      convertOperatorValue(value)
+    ];
+  }));
+}, "convertAggregateMatch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertAggregateMatch,
+  getDefaultSchemaOptions
+});

package/src/types.d.ts

@@ -0,0 +1,7 @@
+type DataInputOf<Input, Obj> = {
+    [K in keyof Input as Input[K] extends any[] ? never : K]: Input[K];
+} & {
+    [K in keyof Input as Input[K] extends any[] ? K : never]?: Input[K];
+} & Partial<Obj>;
+
+export type { DataInputOf };

package/src/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/types-H2HI4YUe.d.ts

@@ -0,0 +1,3 @@
+type Type<T = any> = new (...args: any[]) => T;
+
+export type { Type as T };