@akanjs/constant 0.0.39 → 0.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/constant",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -14,9 +14,5 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {
-    "dayjs": "^1.11.13",
-    "pluralize": "^8.0.0",
-    "reflect-metadata": "^0.2.2"
-  }
+  "dependencies": {}
 }

package/src/baseGql.d.ts

@@ -0,0 +1,14 @@
+import { N as NonFunctionalKeys, B as BaseObject } from '../types-DdO4B_Um.js';
+import { T as Type } from '../types-b-U-yQib.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import 'mongoose';
+
+declare const as: <T>(modelRef: Type<T>) => Type<T>;
+declare const via: <T, LightOrFields extends readonly NonFunctionalKeys<Omit<T, "id" | "createdAt" | "updatedAt" | "removedAt">>[] | Type | undefined = undefined>(modelRef: Type<T>, fieldsOrLightModelRef?: LightOrFields, overwriteRef?: Type, overwriteLightRef?: Type) => LightOrFields extends undefined ? Type<T & BaseObject> : LightOrFields extends Type<infer Light> ? Type<T & Light & BaseObject> : LightOrFields extends readonly NonFunctionalKeys<Omit<T, "id" | "createdAt" | "updatedAt" | "removedAt">>[] ? Type<{ [K in LightOrFields[number]]: T[K]; } & BaseObject> : never;
+declare const from: <A, T1, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown>(modelRef: Type<A>, t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>) => Type<A & T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10>;
+declare const mixModelOf: <T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown, T11 = unknown, T12 = unknown, T13 = unknown, T14 = unknown, T15 = unknown, T16 = unknown, T17 = unknown, T18 = unknown, T19 = unknown, T20 = unknown>(t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>, t11?: Type<T11>, t12?: Type<T12>, t13?: Type<T13>, t14?: Type<T14>, t15?: Type<T15>, t16?: Type<T16>, t17?: Type<T17>, t18?: Type<T18>, t19?: Type<T19>, t20?: Type<T20>) => Type<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10 & T11 & T12 & T13 & T14 & T15 & T16 & T17 & T18 & T19 & T20>;
+declare const over: <T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown, T11 = unknown, T12 = unknown, T13 = unknown, T14 = unknown, T15 = unknown, T16 = unknown, T17 = unknown, T18 = unknown, T19 = unknown, T20 = unknown>(t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>, t11?: Type<T11>, t12?: Type<T12>, t13?: Type<T13>, t14?: Type<T14>, t15?: Type<T15>, t16?: Type<T16>, t17?: Type<T17>, t18?: Type<T18>, t19?: Type<T19>, t20?: Type<T20>) => Type<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10 & T11 & T12 & T13 & T14 & T15 & T16 & T17 & T18 & T19 & T20>;
+
+export { as, from, mixModelOf, over, via };

package/src/baseGql.js

@@ -0,0 +1,275 @@
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var baseGql_exports = {};
+__export(baseGql_exports, {
+  as: () => as,
+  from: () => from,
+  mixModelOf: () => mixModelOf,
+  over: () => over,
+  via: () => via
+});
+module.exports = __toCommonJS(baseGql_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_filterMeta = require("./filterMeta");
+var import_scalar = require("./scalar");
+const defaultFieldMeta = {
+  fieldType: "property",
+  immutable: false,
+  select: true,
+  isClass: false,
+  isScalar: true,
+  nullable: false,
+  isArray: false,
+  arrDepth: 0,
+  optArrDepth: 0,
+  default: null,
+  isMap: false
+};
+const idFieldMeta = {
+  ...defaultFieldMeta,
+  key: "id",
+  name: "ID",
+  modelRef: import_base.ID
+};
+const createdAtFieldMeta = {
+  ...defaultFieldMeta,
+  key: "createdAt",
+  name: "Date",
+  modelRef: Date
+};
+const updatedAtFieldMeta = {
+  ...defaultFieldMeta,
+  key: "updatedAt",
+  name: "Date",
+  modelRef: Date
+};
+const removedAtFieldMeta = {
+  ...defaultFieldMeta,
+  key: "removedAt",
+  name: "Date",
+  modelRef: Date,
+  nullable: true,
+  default: null
+};
+const extendModel = /* @__PURE__ */ __name((modelRef) => {
+  let BaseModel = class BaseModel {
+    static {
+      __name(this, "BaseModel");
+    }
+  };
+  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  (0, import_scalar.setFieldMetaMap)(BaseModel, metadataMap);
+  return BaseModel;
+}, "extendModel");
+const as = extendModel;
+const baseModelOf = /* @__PURE__ */ __name((modelRef) => {
+  let BaseModel = class BaseModel {
+    static {
+      __name(this, "BaseModel");
+    }
+    __ModelType__ = "full";
+  };
+  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  metadataMap.set("id", idFieldMeta);
+  metadataMap.set("createdAt", createdAtFieldMeta);
+  metadataMap.set("updatedAt", updatedAtFieldMeta);
+  metadataMap.set("removedAt", removedAtFieldMeta);
+  Reflect.defineMetadata("fields", metadataMap, BaseModel.prototype);
+  return BaseModel;
+}, "baseModelOf");
+const lightModelOf = /* @__PURE__ */ __name((objectRef, fields) => {
+  const map = /* @__PURE__ */ new Map();
+  const metadataMap = (0, import_scalar.getFieldMetaMap)(objectRef);
+  let BaseGql = class BaseGql {
+    static {
+      __name(this, "BaseGql");
+    }
+    __ModelType__ = "light";
+  };
+  [
+    "id",
+    ...fields,
+    "createdAt",
+    "updatedAt",
+    "removedAt"
+  ].forEach((key) => map.set(key, metadataMap.get(key)));
+  Reflect.defineMetadata("fields", map, BaseGql.prototype);
+  return BaseGql;
+}, "lightModelOf");
+const fullModelOf = /* @__PURE__ */ __name((modelRef, lightRef, overwriteRef, overwriteLightRef) => {
+  const modelFieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const lightFieldMetaMap = (0, import_scalar.getFieldMetaMap)(lightRef);
+  (0, import_common.applyMixins)(modelRef, [
+    lightRef
+  ]);
+  if (overwriteRef) {
+    (0, import_common.applyMixins)(overwriteRef, [
+      modelRef
+    ]);
+    (0, import_scalar.setFieldMetaMap)(overwriteRef, modelFieldMetaMap);
+  }
+  if (overwriteLightRef) {
+    (0, import_common.applyMixins)(overwriteLightRef, [
+      lightRef
+    ]);
+    (0, import_scalar.setFieldMetaMap)(overwriteLightRef, lightFieldMetaMap);
+  }
+  (0, import_scalar.setFieldMetaMap)(modelRef, new Map([
+    ...modelFieldMetaMap,
+    ...lightFieldMetaMap
+  ]));
+  return modelRef;
+}, "fullModelOf");
+const via = /* @__PURE__ */ __name((modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) => {
+  if (!fieldsOrLightModelRef) return baseModelOf(modelRef);
+  else if (Array.isArray(fieldsOrLightModelRef)) return lightModelOf(modelRef, fieldsOrLightModelRef);
+  else return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
+}, "via");
+const addModelOf = /* @__PURE__ */ __name((modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
+  const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const metadataMap = new Map([
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10
+  ].filter((t) => !!t).reduce((acc, writeRef) => {
+    const writeMetadataMap = (0, import_scalar.getFieldMetaMap)(writeRef);
+    (0, import_common.applyMixins)(modelRef, [
+      writeRef
+    ]);
+    return new Map([
+      ...acc,
+      ...writeMetadataMap
+    ]);
+  }, modelMetadataMap));
+  (0, import_scalar.setFieldMetaMap)(modelRef, metadataMap);
+  return modelRef;
+}, "addModelOf");
+const addFilterOf = /* @__PURE__ */ __name((filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
+  const filterMeta = (0, import_filterMeta.getFilterMeta)(filterRef);
+  const filterQueryMap = (0, import_filterMeta.getFilterQueryMap)(filterRef);
+  const metadataMap = new Map([
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10
+  ].filter((t) => !!t).reduce((acc, writeRef) => {
+    const writeMetadataMap = (0, import_filterMeta.getFilterQueryMap)(writeRef);
+    (0, import_common.applyMixins)(filterRef, [
+      writeRef
+    ]);
+    writeMetadataMap.forEach((value, key) => {
+      const filterArgMetas = (0, import_filterMeta.getFilterArgMetas)(writeRef, key);
+      (0, import_filterMeta.setFilterArgMetasOnPrototype)(filterRef.prototype, key, filterArgMetas);
+    });
+    return new Map([
+      ...acc,
+      ...writeMetadataMap
+    ]);
+  }, filterQueryMap));
+  const filterSort = [
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10
+  ].filter((t) => !!t).map((t) => (0, import_filterMeta.getFilterSortMap)(t)).reduce((acc, sort) => {
+    Object.assign(acc, sort);
+    return acc;
+  }, filterMeta.sort);
+  (0, import_filterMeta.setFilterKeyMetaMapOnPrototype)(filterRef.prototype, metadataMap);
+  (0, import_filterMeta.setFilterMeta)(filterRef, {
+    ...filterMeta,
+    sort: filterSort
+  });
+  return filterRef;
+}, "addFilterOf");
+const from = /* @__PURE__ */ __name((modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
+  if ((0, import_scalar.isConstantModel)(modelRef)) return addModelOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+  else if ((0, import_filterMeta.isFilterModel)(modelRef)) return addFilterOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+  else throw new Error("Invalid modelRef");
+}, "from");
+const mixModelOf = /* @__PURE__ */ __name((t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) => {
+  let Mix = class Mix {
+    static {
+      __name(this, "Mix");
+    }
+  };
+  const metadataMap = new Map([
+    t1,
+    t2,
+    t3,
+    t4,
+    t5,
+    t6,
+    t7,
+    t8,
+    t9,
+    t10,
+    t11,
+    t12,
+    t13,
+    t14,
+    t15,
+    t16,
+    t17,
+    t18,
+    t19,
+    t20
+  ].filter((t) => !!t).reduce((acc, modelRef) => {
+    const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+    (0, import_common.applyMixins)(Mix, [
+      modelRef
+    ]);
+    return [
+      ...acc,
+      ...modelMetadataMap
+    ];
+  }, []));
+  (0, import_scalar.setFieldMetaMap)(Mix, metadataMap);
+  return Mix;
+}, "mixModelOf");
+const over = mixModelOf;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  as,
+  from,
+  mixModelOf,
+  over,
+  via
+});

package/src/classMeta.d.ts

@@ -0,0 +1,39 @@
+import { E as Enum } from '../base-D8mO_G-C.js';
+import { T as Type } from '../types-b-U-yQib.js';
+
+declare class InputModelStorage {
+}
+declare class LightModelStorage {
+}
+declare class FullModelStorage {
+}
+declare class ScalarModelStorage {
+}
+declare class FilterModelStorage {
+}
+declare const getFullModelRef: (refName: string) => Type;
+declare const getInputModelRef: (refName: string) => Type;
+declare const getScalarModelRef: (refName: string) => Type;
+declare const getChildClassRefs: (target: Type) => Type[];
+declare const getFieldEnumMetas: (modelRef: Type) => {
+    key: string;
+    enum: Enum<string | number>;
+}[];
+declare const hasTextField: (modelRef: Type) => boolean;
+type ClassType = "light" | "full" | "input" | "scalar";
+declare const Model: {
+    Light: (refName: string) => (target: Type) => void;
+    Object: (refName: string) => (target: Type) => void;
+    Full: (refName: string) => (target: Type) => void;
+    Input: (refName: string) => (target: Type) => void;
+    Scalar: (refName: string) => (target: Type) => void;
+    Summary: (refName: string) => (target: Type) => void;
+    Insight: (refName: string) => (target: Type) => void;
+    Filter: (refName: string) => (target: Type) => void;
+};
+declare const getLightModelRef: (modelRef: Type) => Type;
+declare const getAllFullModelRefs: () => Type[];
+declare const getAllScalarModelRefs: () => Type[];
+declare const getAllFilterModelRefs: () => Type[];
+
+export { type ClassType, FilterModelStorage, FullModelStorage, InputModelStorage, LightModelStorage, Model, ScalarModelStorage, getAllFilterModelRefs, getAllFullModelRefs, getAllScalarModelRefs, getChildClassRefs, getFieldEnumMetas, getFullModelRef, getInputModelRef, getLightModelRef, getScalarModelRef, hasTextField };

package/src/classMeta.js

@@ -0,0 +1,187 @@
+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 classMeta_exports = {};
+__export(classMeta_exports, {
+  FilterModelStorage: () => FilterModelStorage,
+  FullModelStorage: () => FullModelStorage,
+  InputModelStorage: () => InputModelStorage,
+  LightModelStorage: () => LightModelStorage,
+  Model: () => Model,
+  ScalarModelStorage: () => ScalarModelStorage,
+  getAllFilterModelRefs: () => getAllFilterModelRefs,
+  getAllFullModelRefs: () => getAllFullModelRefs,
+  getAllScalarModelRefs: () => getAllScalarModelRefs,
+  getChildClassRefs: () => getChildClassRefs,
+  getFieldEnumMetas: () => getFieldEnumMetas,
+  getFullModelRef: () => getFullModelRef,
+  getInputModelRef: () => getInputModelRef,
+  getLightModelRef: () => getLightModelRef,
+  getScalarModelRef: () => getScalarModelRef,
+  hasTextField: () => hasTextField
+});
+module.exports = __toCommonJS(classMeta_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@akanjs/common");
+var import_filterMeta = require("./filterMeta");
+var import_scalar = require("./scalar");
+class InputModelStorage {
+  static {
+    __name(this, "InputModelStorage");
+  }
+}
+class LightModelStorage {
+  static {
+    __name(this, "LightModelStorage");
+  }
+}
+class FullModelStorage {
+  static {
+    __name(this, "FullModelStorage");
+  }
+}
+class ScalarModelStorage {
+  static {
+    __name(this, "ScalarModelStorage");
+  }
+}
+class FilterModelStorage {
+  static {
+    __name(this, "FilterModelStorage");
+  }
+}
+const getFullModelRef = /* @__PURE__ */ __name((refName) => {
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
+  if (!modelRef) throw new Error(`FullModel not found - ${refName}`);
+  return modelRef;
+}, "getFullModelRef");
+const getInputModelRef = /* @__PURE__ */ __name((refName) => {
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), InputModelStorage.prototype);
+  if (!modelRef) throw new Error(`InputModel not found - ${refName}`);
+  return modelRef;
+}, "getInputModelRef");
+const getScalarModelRef = /* @__PURE__ */ __name((refName) => {
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), ScalarModelStorage.prototype);
+  if (!modelRef) throw new Error(`ScalarModel not found - ${refName}`);
+  return modelRef;
+}, "getScalarModelRef");
+const getChildClassRefs = /* @__PURE__ */ __name((target) => {
+  const metadatas = (0, import_scalar.getFieldMetas)(target);
+  const refMap = /* @__PURE__ */ new Map();
+  const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
+    return [
+      ...acc,
+      metadata.modelRef,
+      ...getChildClassRefs(metadata.modelRef)
+    ];
+  }, []);
+  childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set((0, import_scalar.getClassMeta)(modelRef).refName, modelRef));
+  return [
+    ...refMap.values()
+  ];
+}, "getChildClassRefs");
+const getFieldEnumMetas = /* @__PURE__ */ __name((modelRef) => {
+  const fieldMetas = (0, import_scalar.getFieldMetas)(modelRef);
+  return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({
+    key: fieldMeta.key,
+    enum: fieldMeta.enum
+  }));
+}, "getFieldEnumMetas");
+const hasTextField = /* @__PURE__ */ __name((modelRef) => {
+  const fieldMetas = (0, import_scalar.getFieldMetas)(modelRef);
+  return fieldMetas.some((fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef));
+}, "hasTextField");
+const applyClassMeta = /* @__PURE__ */ __name((type, modelType, storage) => {
+  return function(refName) {
+    return function(target) {
+      const modelRef = target;
+      const classMeta = {
+        refName,
+        type,
+        modelType,
+        modelRef,
+        hasTextField: hasTextField(modelRef)
+      };
+      Reflect.defineMetadata("class", classMeta, modelRef.prototype);
+      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+    };
+  };
+}, "applyClassMeta");
+const applyFilterMeta = /* @__PURE__ */ __name((storage) => {
+  return function(refName) {
+    return function(target) {
+      const modelRef = target;
+      (0, import_filterMeta.setFilterMeta)(modelRef, {
+        refName,
+        sort: {}
+      });
+      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+    };
+  };
+}, "applyFilterMeta");
+const Model = {
+  Light: applyClassMeta("light", "data", LightModelStorage),
+  Object: applyClassMeta("full", "ephemeral", FullModelStorage),
+  Full: applyClassMeta("full", "data", FullModelStorage),
+  Input: applyClassMeta("input", "data", InputModelStorage),
+  Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
+  Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
+  Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
+  Filter: applyFilterMeta(FilterModelStorage)
+};
+const getLightModelRef = /* @__PURE__ */ __name((modelRef) => {
+  const classMeta = (0, import_scalar.getClassMeta)(modelRef);
+  if (classMeta.type !== "full") return modelRef;
+  const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
+  if (!lightModelRef) throw new Error(`LightModel not found - ${classMeta.refName}`);
+  return lightModelRef;
+}, "getLightModelRef");
+const getAllFullModelRefs = /* @__PURE__ */ __name(() => {
+  const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype));
+  return modelRefs;
+}, "getAllFullModelRefs");
+const getAllScalarModelRefs = /* @__PURE__ */ __name(() => {
+  const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype));
+  return modelRefs;
+}, "getAllScalarModelRefs");
+const getAllFilterModelRefs = /* @__PURE__ */ __name(() => {
+  const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype));
+  return modelRefs;
+}, "getAllFilterModelRefs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FilterModelStorage,
+  FullModelStorage,
+  InputModelStorage,
+  LightModelStorage,
+  Model,
+  ScalarModelStorage,
+  getAllFilterModelRefs,
+  getAllFullModelRefs,
+  getAllScalarModelRefs,
+  getChildClassRefs,
+  getFieldEnumMetas,
+  getFullModelRef,
+  getInputModelRef,
+  getLightModelRef,
+  getScalarModelRef,
+  hasTextField
+});

package/src/constantDecorator.d.ts

@@ -0,0 +1,20 @@
+import { T as Type } from '../types-b-U-yQib.js';
+import { F as FilterType } from '../types-DdO4B_Um.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import 'mongoose';
+
+declare const getCnstMeta: (refName: string) => ConstantModel<any, any, any, any, any, any>;
+interface ConstantModel<T extends string, Input, Full, Light, Insight, Filter extends FilterType, Summary = any> {
+    refName: T;
+    Input: Type<Input>;
+    Full: Type<Full>;
+    Light: Type<Light>;
+    Insight: Type<Insight>;
+    Filter: Type<Filter>;
+    Summary?: Type<Summary>;
+}
+declare const cnstOf: <T extends string, Input, Full, Light, Insight, Filter extends FilterType, Summary>(refName: T, Input: Type<Input>, Full: Type<Full>, Light: Type<Light>, Insight: Type<Insight>, Filter: Type<Filter>, Summary?: Type<Summary>) => ConstantModel<T, Input, Full, Light, Insight, Filter, Summary>;
+
+export { type ConstantModel, cnstOf, getCnstMeta };

package/src/constantDecorator.js

@@ -0,0 +1,56 @@
+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 constantDecorator_exports = {};
+__export(constantDecorator_exports, {
+  cnstOf: () => cnstOf,
+  getCnstMeta: () => getCnstMeta
+});
+module.exports = __toCommonJS(constantDecorator_exports);
+var import_reflect_metadata = require("reflect-metadata");
+let CnstStorage = class CnstStorage2 {
+  static {
+    __name(this, "CnstStorage");
+  }
+};
+const setCnstMeta = /* @__PURE__ */ __name((refName, cnst) => {
+  Reflect.defineMetadata(refName, cnst, CnstStorage.prototype);
+}, "setCnstMeta");
+const getCnstMeta = /* @__PURE__ */ __name((refName) => {
+  const cnst = Reflect.getMetadata(refName, CnstStorage.prototype);
+  if (!cnst) throw new Error(`No cnst meta for ${refName}`);
+  return cnst;
+}, "getCnstMeta");
+const cnstOf = /* @__PURE__ */ __name((refName, Input, Full, Light, Insight, Filter, Summary) => {
+  const cnst = {
+    refName,
+    Input,
+    Full,
+    Light,
+    Insight,
+    Filter,
+    Summary
+  };
+  setCnstMeta(refName, cnst);
+  return cnst;
+}, "cnstOf");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cnstOf,
+  getCnstMeta
+});

package/src/fieldMeta.d.ts

@@ -0,0 +1,17 @@
+import { ReturnType, ConstantFieldProps } from './scalar.js';
+import '../base-D8mO_G-C.js';
+import '../types-DdO4B_Um.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import '../types-b-U-yQib.js';
+import 'mongoose';
+
+declare const Field: {
+    Prop: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+    Hidden: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+    Secret: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+    Resolve: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+};
+
+export { Field };