@akanjs/constant 0.0.97 → 0.0.98

package/index.cjs

@@ -0,0 +1,17 @@
+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 constant_exports = {};
+module.exports = __toCommonJS(constant_exports);
+__reExport(constant_exports, require("./src"), module.exports);

package/index.js

@@ -1,17 +1 @@
-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 constant_exports = {};
-module.exports = __toCommonJS(constant_exports);
-__reExport(constant_exports, require("./src"), module.exports);
+export * from "./src";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akanjs/constant",
-  "version": "0.0.97",
-  "type": "commonjs",
+  "version": "0.0.98",
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },

package/src/baseGql.cjs

@@ -0,0 +1,164 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = (modelRef) => {
+  class BaseModel {
+  }
+  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  (0, import_scalar.setFieldMetaMap)(BaseModel, metadataMap);
+  return BaseModel;
+};
+const as = extendModel;
+const baseModelOf = (modelRef) => {
+  class 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;
+};
+const lightModelOf = (objectRef, fields) => {
+  const map = /* @__PURE__ */ new Map();
+  const metadataMap = (0, import_scalar.getFieldMetaMap)(objectRef);
+  class BaseGql {
+    __ModelType__ = "light";
+  }
+  ["id", ...fields, "createdAt", "updatedAt", "removedAt"].forEach((key) => map.set(key, metadataMap.get(key)));
+  Reflect.defineMetadata("fields", map, BaseGql.prototype);
+  return BaseGql;
+};
+const fullModelOf = (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;
+};
+const via = (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);
+};
+const addModelOf = (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;
+};
+const addFilterOf = (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;
+};
+const from = (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");
+};
+const mixModelOf = (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) => {
+  class 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;
+};
+const over = mixModelOf;

package/src/baseGql.js

@@ -1,34 +1,17 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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");
+import "reflect-metadata";
+import { ID } from "@akanjs/base";
+import { applyMixins } from "@akanjs/common";
+import {
+  getFilterArgMetas,
+  getFilterMeta,
+  getFilterQueryMap,
+  getFilterSortMap,
+  isFilterModel,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta
+} from "./filterMeta";
+import { getFieldMetaMap, isConstantModel, setFieldMetaMap } from "./scalar";
 const defaultFieldMeta = {
   fieldType: "property",
   immutable: false,
@@ -42,7 +25,7 @@ const defaultFieldMeta = {
   default: null,
   isMap: false
 };
-const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: import_base.ID };
+const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
 const createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
 const updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
 const removedAtFieldMeta = {
@@ -56,8 +39,8 @@ const removedAtFieldMeta = {
 const extendModel = (modelRef) => {
   class BaseModel {
   }
-  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
-  (0, import_scalar.setFieldMetaMap)(BaseModel, metadataMap);
+  const metadataMap = getFieldMetaMap(modelRef);
+  setFieldMetaMap(BaseModel, metadataMap);
   return BaseModel;
 };
 const as = extendModel;
@@ -65,7 +48,7 @@ const baseModelOf = (modelRef) => {
   class BaseModel {
     __ModelType__ = "full";
   }
-  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const metadataMap = getFieldMetaMap(modelRef);
   metadataMap.set("id", idFieldMeta);
   metadataMap.set("createdAt", createdAtFieldMeta);
   metadataMap.set("updatedAt", updatedAtFieldMeta);
@@ -75,7 +58,7 @@ const baseModelOf = (modelRef) => {
 };
 const lightModelOf = (objectRef, fields) => {
   const map = /* @__PURE__ */ new Map();
-  const metadataMap = (0, import_scalar.getFieldMetaMap)(objectRef);
+  const metadataMap = getFieldMetaMap(objectRef);
   class BaseGql {
     __ModelType__ = "light";
   }
@@ -84,18 +67,18 @@ const lightModelOf = (objectRef, fields) => {
   return BaseGql;
 };
 const fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
-  const modelFieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
-  const lightFieldMetaMap = (0, import_scalar.getFieldMetaMap)(lightRef);
-  (0, import_common.applyMixins)(modelRef, [lightRef]);
+  const modelFieldMetaMap = getFieldMetaMap(modelRef);
+  const lightFieldMetaMap = getFieldMetaMap(lightRef);
+  applyMixins(modelRef, [lightRef]);
   if (overwriteRef) {
-    (0, import_common.applyMixins)(overwriteRef, [modelRef]);
-    (0, import_scalar.setFieldMetaMap)(overwriteRef, modelFieldMetaMap);
+    applyMixins(overwriteRef, [modelRef]);
+    setFieldMetaMap(overwriteRef, modelFieldMetaMap);
   }
   if (overwriteLightRef) {
-    (0, import_common.applyMixins)(overwriteLightRef, [lightRef]);
-    (0, import_scalar.setFieldMetaMap)(overwriteLightRef, lightFieldMetaMap);
+    applyMixins(overwriteLightRef, [lightRef]);
+    setFieldMetaMap(overwriteLightRef, lightFieldMetaMap);
   }
-  (0, import_scalar.setFieldMetaMap)(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
+  setFieldMetaMap(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
   return modelRef;
 };
 const via = (modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) => {
@@ -107,43 +90,43 @@ const via = (modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) =
     return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
 };
 const addModelOf = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
-  const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const modelMetadataMap = 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]);
+      const writeMetadataMap = getFieldMetaMap(writeRef);
+      applyMixins(modelRef, [writeRef]);
       return new Map([...acc, ...writeMetadataMap]);
     }, modelMetadataMap)
   );
-  (0, import_scalar.setFieldMetaMap)(modelRef, metadataMap);
+  setFieldMetaMap(modelRef, metadataMap);
   return modelRef;
 };
 const addFilterOf = (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 filterMeta = getFilterMeta(filterRef);
+  const filterQueryMap = 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]);
+      const writeMetadataMap = getFilterQueryMap(writeRef);
+      applyMixins(filterRef, [writeRef]);
       writeMetadataMap.forEach((value, key) => {
-        const filterArgMetas = (0, import_filterMeta.getFilterArgMetas)(writeRef, key);
-        (0, import_filterMeta.setFilterArgMetasOnPrototype)(filterRef.prototype, key, filterArgMetas);
+        const filterArgMetas = getFilterArgMetas(writeRef, key);
+        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) => {
+  const filterSort = [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).map((t) => 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 });
+  setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
+  setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
   return filterRef;
 };
 const from = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
-  if ((0, import_scalar.isConstantModel)(modelRef))
+  if (isConstantModel(modelRef))
     return addModelOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
-  else if ((0, import_filterMeta.isFilterModel)(modelRef))
+  else if (isFilterModel(modelRef))
     return addFilterOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
   else
     throw new Error("Invalid modelRef");
@@ -153,12 +136,19 @@ const mixModelOf = (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14,
   }
   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]);
+      const modelMetadataMap = getFieldMetaMap(modelRef);
+      applyMixins(Mix, [modelRef]);
       return [...acc, ...modelMetadataMap];
     }, [])
   );
-  (0, import_scalar.setFieldMetaMap)(Mix, metadataMap);
+  setFieldMetaMap(Mix, metadataMap);
   return Mix;
 };
 const over = mixModelOf;
+export {
+  as,
+  from,
+  mixModelOf,
+  over,
+  via
+};

package/src/{classMeta.mjs → classMeta.cjs}

@@ -1,7 +1,44 @@
-import "reflect-metadata";
-import { capitalize } from "@akanjs/common";
-import { setFilterMeta } from "./filterMeta";
-import { getClassMeta, getFieldMetas } from "./scalar";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 {
 }
 class LightModelStorage {
@@ -13,38 +50,38 @@ class ScalarModelStorage {
 class FilterModelStorage {
 }
 const getFullModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
   if (!modelRef)
     throw new Error(`FullModel not found - ${refName}`);
   return modelRef;
 };
 const getInputModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), InputModelStorage.prototype);
   if (!modelRef)
     throw new Error(`InputModel not found - ${refName}`);
   return modelRef;
 };
 const getScalarModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), ScalarModelStorage.prototype);
   if (!modelRef)
     throw new Error(`ScalarModel not found - ${refName}`);
   return modelRef;
 };
 const getChildClassRefs = (target) => {
-  const metadatas = getFieldMetas(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(getClassMeta(modelRef).refName, 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()];
 };
 const getFieldEnumMetas = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
+  const fieldMetas = (0, import_scalar.getFieldMetas)(modelRef);
   return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
 };
 const hasTextField = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
+  const fieldMetas = (0, import_scalar.getFieldMetas)(modelRef);
   return fieldMetas.some(
     (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
   );
@@ -63,7 +100,7 @@ const applyFilterMeta = (storage) => {
   return function(refName) {
     return function(target) {
       const modelRef = target;
-      setFilterMeta(modelRef, { refName, sort: {} });
+      (0, import_filterMeta.setFilterMeta)(modelRef, { refName, sort: {} });
       Reflect.defineMetadata(refName, modelRef, storage.prototype);
     };
   };
@@ -79,7 +116,7 @@ const Model = {
   Filter: applyFilterMeta(FilterModelStorage)
 };
 const getLightModelRef = (modelRef) => {
-  const classMeta = getClassMeta(modelRef);
+  const classMeta = (0, import_scalar.getClassMeta)(modelRef);
   if (classMeta.type !== "full")
     return modelRef;
   const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
@@ -108,21 +145,3 @@ const getAllFilterModelRefs = () => {
   );
   return modelRefs;
 };
-export {
-  FilterModelStorage,
-  FullModelStorage,
-  InputModelStorage,
-  LightModelStorage,
-  Model,
-  ScalarModelStorage,
-  getAllFilterModelRefs,
-  getAllFullModelRefs,
-  getAllScalarModelRefs,
-  getChildClassRefs,
-  getFieldEnumMetas,
-  getFullModelRef,
-  getInputModelRef,
-  getLightModelRef,
-  getScalarModelRef,
-  hasTextField
-};