@akanjs/constant 0.9.43 → 0.9.45

package/cjs/src/baseGql.js

@@ -6,11 +6,11 @@ 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))
+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: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -18,15 +18,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 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_classMeta = require("./classMeta");
 var import_filterMeta = require("./filterMeta");
 var import_scalar = require("./scalar");
 const defaultFieldMeta = {
@@ -40,7 +38,8 @@ const defaultFieldMeta = {
   arrDepth: 0,
   optArrDepth: 0,
   default: null,
-  isMap: false
+  isMap: false,
+  meta: {}
 };
 const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: import_base.ID };
 const createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
@@ -65,7 +64,7 @@ const baseModelOf = (modelRef) => {
   class BaseModel {
     __ModelType__ = "full";
   }
-  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const metadataMap = new Map((0, import_scalar.getFieldMetaMap)(modelRef));
   metadataMap.set("id", idFieldMeta);
   metadataMap.set("createdAt", createdAtFieldMeta);
   metadataMap.set("updatedAt", updatedAtFieldMeta);
@@ -73,47 +72,105 @@ const baseModelOf = (modelRef) => {
   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 {
+const lightModelOf = (objectRef, fields, ...libLightModelRefs) => {
+  const objectFieldMetaMap = (0, import_scalar.getFieldMetaMap)(objectRef);
+  const baseLightModelRef = libLightModelRefs.at(0);
+  const fieldMetaMap = baseLightModelRef ? (0, import_scalar.getFieldMetaMap)(baseLightModelRef) : /* @__PURE__ */ new Map();
+  class BaseLightModel {
     __ModelType__ = "light";
   }
-  map.set("id", metadataMap.get("id"));
+  fieldMetaMap.set("id", idFieldMeta);
+  fieldMetaMap.set("createdAt", createdAtFieldMeta);
+  fieldMetaMap.set("updatedAt", updatedAtFieldMeta);
+  fieldMetaMap.set("removedAt", removedAtFieldMeta);
   for (const field of fields) {
-    map.set(field, metadataMap.get(field));
+    const fieldMeta = objectFieldMetaMap.get(field);
+    if (!fieldMeta)
+      throw new Error(`Field ${field} not found in objectRef`);
+    fieldMetaMap.set(field, fieldMeta);
   }
-  map.set("createdAt", metadataMap.get("createdAt"));
-  map.set("updatedAt", metadataMap.get("updatedAt"));
-  map.set("removedAt", metadataMap.get("removedAt"));
-  Reflect.defineMetadata("fields", map, BaseGql.prototype);
-  return BaseGql;
+  (0, import_common.applyMixins)(BaseLightModel, libLightModelRefs);
+  Reflect.defineMetadata("fields", fieldMetaMap, BaseLightModel.prototype);
+  return BaseLightModel;
 };
-const fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
+const fullModelOf = (modelRef, lightRef, ...libFullModelRefs) => {
   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]));
+  (0, import_common.applyMixins)(modelRef, [...libFullModelRefs, lightRef]);
+  libFullModelRefs.forEach((libFullModelRef) => {
+    (0, import_common.applyMixins)(libFullModelRef, [lightRef, modelRef]);
+  });
+  lightFieldMetaMap.forEach((value, key) => modelFieldMetaMap.set(key, value));
   return modelRef;
 };
-function via(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) {
-  if (!fieldsOrLightModelRef)
-    return baseModelOf(modelRef);
+function via(modelRef, fieldsOrLightModelRef, ...fullOrLightModelRefs) {
+  const classMeta = (0, import_scalar.getClassMeta)(modelRef);
+  if (!fieldsOrLightModelRef) {
+    if (classMeta.type === "input") {
+      const objectRefName = classMeta.refName.slice(0, -5) + "Object";
+      const isFullModelRefDefined = (0, import_classMeta.getFullModelRefs)(objectRefName).length > 0;
+      if (isFullModelRefDefined)
+        return extendModelInputs(modelRef);
+      else
+        return baseModelOf(modelRef);
+    } else if (classMeta.modelType === "insight")
+      return extendModelInsights(modelRef);
+    else
+      throw new Error("Invalid modelRef args");
+  }
   if (Array.isArray(fieldsOrLightModelRef))
-    return lightModelOf(modelRef, fieldsOrLightModelRef);
-  return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
+    return lightModelOf(modelRef, fieldsOrLightModelRef, ...fullOrLightModelRefs);
+  const secondArgModelRef = fieldsOrLightModelRef;
+  const secondArgClassMeta = (0, import_scalar.getClassMeta)(secondArgModelRef);
+  if (classMeta.type === "input") {
+    if (secondArgClassMeta.type === "input")
+      return extendModelInputs(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+    else if (secondArgClassMeta.type === "full")
+      return extendModelObjects(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+    else
+      throw new Error("Invalid modelRef args");
+  } else if (classMeta.type === "full") {
+    if (secondArgClassMeta.type === "light")
+      return fullModelOf(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+    else
+      throw new Error("Invalid modelRef args");
+  } else if (classMeta.modelType === "insight")
+    return extendModelInsights(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+  else
+    throw new Error("Invalid modelRef");
 }
+const extendModelInputs = (...libInputModelRefs) => {
+  const baseInputModelRef = libInputModelRefs.at(0);
+  const fieldMetaMap = baseInputModelRef ? (0, import_scalar.getFieldMetaMap)(baseInputModelRef) : /* @__PURE__ */ new Map();
+  class BaseInput {
+    __ModelType__ = "input";
+  }
+  (0, import_scalar.setFieldMetaMap)(BaseInput, fieldMetaMap);
+  return BaseInput;
+};
+const extendModelObjects = (inputRef, ...libObjectModelRefs) => {
+  const baseObjectModelRef = libObjectModelRefs.at(0);
+  const inputFieldMetaMap = (0, import_scalar.getFieldMetaMap)(inputRef);
+  const fieldMetaMap = baseObjectModelRef ? (0, import_scalar.getFieldMetaMap)(baseObjectModelRef) : /* @__PURE__ */ new Map();
+  class BaseInput {
+    __ModelType__ = "object";
+  }
+  inputFieldMetaMap.forEach((value, key) => fieldMetaMap.set(key, value));
+  (0, import_scalar.setFieldMetaMap)(BaseInput, fieldMetaMap);
+  return BaseInput;
+};
+const extendModelInsights = (...insightModelRefs) => {
+  const baseInsightModelRef = insightModelRefs.at(0);
+  const insightFieldMetaMap = baseInsightModelRef ? (0, import_scalar.getFieldMetaMap)(baseInsightModelRef) : /* @__PURE__ */ new Map();
+  class BaseInsight {
+    __ModelType__ = "insight";
+  }
+  (0, import_scalar.setFieldMetaMap)(BaseInsight, insightFieldMetaMap);
+  return BaseInsight;
+};
 const addModelOf = (modelRef, ...types) => {
   const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
-  const metadataMap = types.filter(Boolean).reduce((acc, writeRef) => {
+  const metadataMap = types.reduce((acc, writeRef) => {
     const writeMetadataMap = (0, import_scalar.getFieldMetaMap)(writeRef);
     (0, import_common.applyMixins)(modelRef, [writeRef]);
     return new Map([...acc, ...writeMetadataMap]);
@@ -125,7 +182,7 @@ const addFilterOf = (filterRef, ...types) => {
   const filterMeta = (0, import_filterMeta.getFilterMeta)(filterRef);
   const filterQueryMap = (0, import_filterMeta.getFilterQueryMap)(filterRef);
   const metadataMap = new Map(
-    types.filter(Boolean).reduce((acc, writeRef) => {
+    types.reduce((acc, writeRef) => {
       const writeMetadataMap = (0, import_filterMeta.getFilterQueryMap)(writeRef);
       (0, import_common.applyMixins)(filterRef, [writeRef]);
       writeMetadataMap.forEach((value, key) => {
@@ -143,25 +200,3 @@ const addFilterOf = (filterRef, ...types) => {
   (0, import_filterMeta.setFilterMeta)(filterRef, { ...filterMeta, sort: filterSort });
   return filterRef;
 };
-const from = (modelRef, ...types) => {
-  if ((0, import_scalar.isConstantModel)(modelRef))
-    return addModelOf(modelRef, ...types);
-  else if ((0, import_filterMeta.isFilterModel)(modelRef))
-    return addFilterOf(modelRef, ...types);
-  else
-    throw new Error("Invalid modelRef");
-};
-const mixModelOf = (...types) => {
-  class Mix {
-  }
-  const metadataMap = new Map(
-    types.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/cjs/src/classMeta.js

@@ -17,21 +17,19 @@ var __copyProps = (to, from, except, desc) => {
 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,
+  getFullModelRefs: () => getFullModelRefs,
   getInputModelRef: () => getInputModelRef,
+  getInputModelRefs: () => getInputModelRefs,
   getLightModelRef: () => getLightModelRef,
   getScalarModelRef: () => getScalarModelRef,
+  getScalarModelRefs: () => getScalarModelRefs,
   hasTextField: () => hasTextField
 });
 module.exports = __toCommonJS(classMeta_exports);
@@ -50,23 +48,38 @@ class ScalarModelStorage {
 class FilterModelStorage {
 }
 const getFullModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
+  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
+  const modelRef = modelRefs?.[0];
   if (!modelRef)
     throw new Error(`FullModel not found - ${refName}`);
   return modelRef;
 };
+const getFullModelRefs = (refName) => {
+  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
+  return modelRefs ?? [];
+};
 const getInputModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), InputModelStorage.prototype);
+  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), InputModelStorage.prototype);
+  const modelRef = modelRefs?.[0];
   if (!modelRef)
     throw new Error(`InputModel not found - ${refName}`);
   return modelRef;
 };
+const getInputModelRefs = (refName) => {
+  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), InputModelStorage.prototype);
+  return modelRefs ?? [];
+};
 const getScalarModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), ScalarModelStorage.prototype);
+  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), ScalarModelStorage.prototype);
+  const modelRef = modelRefs?.[0];
   if (!modelRef)
     throw new Error(`ScalarModel not found - ${refName}`);
   return modelRef;
 };
+const getScalarModelRefs = (refName) => {
+  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), ScalarModelStorage.prototype);
+  return modelRefs ?? [];
+};
 const getChildClassRefs = (target) => {
   const metadatas = (0, import_scalar.getFieldMetas)(target);
   const refMap = /* @__PURE__ */ new Map();
@@ -92,7 +105,11 @@ const applyClassMeta = (type, modelType, storage) => {
       const modelRef = target;
       const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
       Reflect.defineMetadata("class", classMeta, modelRef.prototype);
-      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), storage.prototype);
+      if (modelRefs)
+        modelRefs.push(modelRef);
+      else
+        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
     };
   };
 };
@@ -101,7 +118,11 @@ const applyFilterMeta = (storage) => {
     return function(target) {
       const modelRef = target;
       (0, import_filterMeta.setFilterMeta)(modelRef, { refName, sort: {} });
-      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), storage.prototype);
+      if (modelRefs)
+        modelRefs.push(modelRef);
+      else
+        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
     };
   };
 };
@@ -111,7 +132,6 @@ const Model = {
   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)
 };
@@ -119,29 +139,24 @@ const getLightModelRef = (modelRef) => {
   const classMeta = (0, import_scalar.getClassMeta)(modelRef);
   if (classMeta.type !== "full")
     return modelRef;
-  const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
+  const lightModelRefs = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
+  const lightModelRef = lightModelRefs?.at(-1);
   if (!lightModelRef)
     throw new Error(`LightModel not found - ${classMeta.refName}`);
   return lightModelRef;
 };
 const getAllFullModelRefs = () => {
   const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)
-  );
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)).flat();
   return modelRefs;
 };
 const getAllScalarModelRefs = () => {
   const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)
-  );
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)).flat();
   return modelRefs;
 };
 const getAllFilterModelRefs = () => {
   const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)
-  );
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)).flat();
   return modelRefs;
 };

package/cjs/src/constantDecorator.js

@@ -34,7 +34,7 @@ const getCnstMeta = (refName) => {
     throw new Error(`No cnst meta for ${refName}`);
   return cnst;
 };
-const cnstOf = (refName, Input, Full, Light, Insight, Filter, Summary) => {
+const cnstOf = (refName, Input, Full, Light, Insight, Filter) => {
   const cnst = {
     refName,
     Input,
@@ -42,7 +42,6 @@ const cnstOf = (refName, Input, Full, Light, Insight, Filter, Summary) => {
     Light,
     Insight,
     Filter,
-    Summary,
     _CapitalizedT: null,
     _Default: null,
     _DefaultInput: null,

package/cjs/src/fieldMeta.js

@@ -46,7 +46,6 @@ const applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
       select: option.select ?? true,
       minlength: option.minlength,
       maxlength: option.maxlength,
-      query: option.query,
       accumulate: option.accumulate,
       example: option.example,
       validate: option.validate,
@@ -60,7 +59,8 @@ const applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
       optArrDepth: optionArrDepth,
       isMap,
       of: option.of,
-      text: option.text
+      text: option.text,
+      meta: option.meta ?? {}
     };
     const metadataMap = (0, import_scalar.getFieldMetaMapOnPrototype)(prototype);
     metadataMap.set(key, metadata);

package/cjs/src/filterMeta.js

@@ -44,6 +44,7 @@ __export(filterMeta_exports, {
 });
 module.exports = __toCommonJS(filterMeta_exports);
 var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
 var import_scalar = require("./scalar");
 const isFilterModel = (filterRef) => {
   return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
@@ -57,8 +58,9 @@ const getFilterMeta = (filterRef) => {
 const setFilterMeta = (filterRef, filterMeta) => {
   const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
   if (existingFilterMeta)
-    Object.assign(filterMeta.sort, existingFilterMeta.sort);
-  Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+    Object.assign(existingFilterMeta, { ...filterMeta, sort: { ...existingFilterMeta.sort, ...filterMeta.sort } });
+  else
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
 };
 const getFilterKeyMetaMapOnPrototype = (prototype) => {
   const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
@@ -124,7 +126,7 @@ const Filter = {
   // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
   Arg: applyFilterArgMeta
 };
-const sortOf = (modelRef, sort) => {
+const sortOf = (modelRef, sort, ...libFilterRefs) => {
   const fieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
   const statusFieldMeta = fieldMetaMap.get("status");
   if (!statusFieldMeta)
@@ -151,6 +153,16 @@ const sortOf = (modelRef, sort) => {
     refName: "BaseFilter",
     sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
   });
+  (0, import_common.applyMixins)(BaseFilter2, libFilterRefs);
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(BaseFilter2.prototype);
+  libFilterRefs.forEach((libFilterRef) => {
+    const libFilterKeyMetaMap = getFilterKeyMetaMapOnPrototype(libFilterRef.prototype);
+    libFilterKeyMetaMap.forEach((value, key) => {
+      const libFilterArgMetas = getFilterArgMetas(libFilterRef, key);
+      filterKeyMetaMap.set(key, value);
+      setFilterArgMetasOnPrototype(BaseFilter2.prototype, key, libFilterArgMetas);
+    });
+  });
   return BaseFilter2;
 };
 function BaseFilter(modelRef, sort) {

package/cjs/src/scalar.js

@@ -23,7 +23,6 @@ __export(scalar_exports, {
   getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
   getFieldMetas: () => getFieldMetas,
   getGqlTypeStr: () => getGqlTypeStr,
-  getQueryMap: () => getQueryMap,
   getScalarExample: () => getScalarExample,
   isConstantModel: () => isConstantModel,
   scalarExampleMap: () => scalarExampleMap,
@@ -66,22 +65,16 @@ const isConstantModel = (modelRef) => {
 const getFieldMetaMap = (modelRef) => {
   const [target] = (0, import_base.getNonArrayModel)(modelRef);
   const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
+  return metadataMap;
 };
 const setFieldMetaMap = (modelRef, metadataMap) => {
   const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
+  Reflect.defineMetadata("fields", metadataMap, target.prototype);
 };
 const getFieldMetaMapOnPrototype = (prototype) => {
   const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
+  return metadataMap;
 };
 const setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
-  Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
-};
-const getQueryMap = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return Object.fromEntries(
-    fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map((fieldMeta) => [fieldMeta.key, fieldMeta.query])
-  );
+  Reflect.defineMetadata("fields", metadataMap, prototype);
 };

package/esm/src/baseGql.js

@@ -1,17 +1,17 @@
 import "reflect-metadata";
 import { ID } from "@akanjs/base";
 import { applyMixins } from "@akanjs/common";
+import { getFullModelRefs } from "./classMeta";
 import {
   getFilterArgMetas,
   getFilterMeta,
   getFilterQueryMap,
   getFilterSortMap,
-  isFilterModel,
   setFilterArgMetasOnPrototype,
   setFilterKeyMetaMapOnPrototype,
   setFilterMeta
 } from "./filterMeta";
-import { getFieldMetaMap, isConstantModel, setFieldMetaMap } from "./scalar";
+import { getClassMeta, getFieldMetaMap, setFieldMetaMap } from "./scalar";
 const defaultFieldMeta = {
   fieldType: "property",
   immutable: false,
@@ -23,7 +23,8 @@ const defaultFieldMeta = {
   arrDepth: 0,
   optArrDepth: 0,
   default: null,
-  isMap: false
+  isMap: false,
+  meta: {}
 };
 const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
 const createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
@@ -48,7 +49,7 @@ const baseModelOf = (modelRef) => {
   class BaseModel {
     __ModelType__ = "full";
   }
-  const metadataMap = getFieldMetaMap(modelRef);
+  const metadataMap = new Map(getFieldMetaMap(modelRef));
   metadataMap.set("id", idFieldMeta);
   metadataMap.set("createdAt", createdAtFieldMeta);
   metadataMap.set("updatedAt", updatedAtFieldMeta);
@@ -56,47 +57,105 @@ const baseModelOf = (modelRef) => {
   Reflect.defineMetadata("fields", metadataMap, BaseModel.prototype);
   return BaseModel;
 };
-const lightModelOf = (objectRef, fields) => {
-  const map = /* @__PURE__ */ new Map();
-  const metadataMap = getFieldMetaMap(objectRef);
-  class BaseGql {
+const lightModelOf = (objectRef, fields, ...libLightModelRefs) => {
+  const objectFieldMetaMap = getFieldMetaMap(objectRef);
+  const baseLightModelRef = libLightModelRefs.at(0);
+  const fieldMetaMap = baseLightModelRef ? getFieldMetaMap(baseLightModelRef) : /* @__PURE__ */ new Map();
+  class BaseLightModel {
     __ModelType__ = "light";
   }
-  map.set("id", metadataMap.get("id"));
+  fieldMetaMap.set("id", idFieldMeta);
+  fieldMetaMap.set("createdAt", createdAtFieldMeta);
+  fieldMetaMap.set("updatedAt", updatedAtFieldMeta);
+  fieldMetaMap.set("removedAt", removedAtFieldMeta);
   for (const field of fields) {
-    map.set(field, metadataMap.get(field));
+    const fieldMeta = objectFieldMetaMap.get(field);
+    if (!fieldMeta)
+      throw new Error(`Field ${field} not found in objectRef`);
+    fieldMetaMap.set(field, fieldMeta);
   }
-  map.set("createdAt", metadataMap.get("createdAt"));
-  map.set("updatedAt", metadataMap.get("updatedAt"));
-  map.set("removedAt", metadataMap.get("removedAt"));
-  Reflect.defineMetadata("fields", map, BaseGql.prototype);
-  return BaseGql;
+  applyMixins(BaseLightModel, libLightModelRefs);
+  Reflect.defineMetadata("fields", fieldMetaMap, BaseLightModel.prototype);
+  return BaseLightModel;
 };
-const fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
+const fullModelOf = (modelRef, lightRef, ...libFullModelRefs) => {
   const modelFieldMetaMap = getFieldMetaMap(modelRef);
   const lightFieldMetaMap = getFieldMetaMap(lightRef);
-  applyMixins(modelRef, [lightRef]);
-  if (overwriteRef) {
-    applyMixins(overwriteRef, [modelRef]);
-    setFieldMetaMap(overwriteRef, modelFieldMetaMap);
-  }
-  if (overwriteLightRef) {
-    applyMixins(overwriteLightRef, [lightRef]);
-    setFieldMetaMap(overwriteLightRef, lightFieldMetaMap);
-  }
-  setFieldMetaMap(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
+  applyMixins(modelRef, [...libFullModelRefs, lightRef]);
+  libFullModelRefs.forEach((libFullModelRef) => {
+    applyMixins(libFullModelRef, [lightRef, modelRef]);
+  });
+  lightFieldMetaMap.forEach((value, key) => modelFieldMetaMap.set(key, value));
   return modelRef;
 };
-function via(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) {
-  if (!fieldsOrLightModelRef)
-    return baseModelOf(modelRef);
+function via(modelRef, fieldsOrLightModelRef, ...fullOrLightModelRefs) {
+  const classMeta = getClassMeta(modelRef);
+  if (!fieldsOrLightModelRef) {
+    if (classMeta.type === "input") {
+      const objectRefName = classMeta.refName.slice(0, -5) + "Object";
+      const isFullModelRefDefined = getFullModelRefs(objectRefName).length > 0;
+      if (isFullModelRefDefined)
+        return extendModelInputs(modelRef);
+      else
+        return baseModelOf(modelRef);
+    } else if (classMeta.modelType === "insight")
+      return extendModelInsights(modelRef);
+    else
+      throw new Error("Invalid modelRef args");
+  }
   if (Array.isArray(fieldsOrLightModelRef))
-    return lightModelOf(modelRef, fieldsOrLightModelRef);
-  return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
+    return lightModelOf(modelRef, fieldsOrLightModelRef, ...fullOrLightModelRefs);
+  const secondArgModelRef = fieldsOrLightModelRef;
+  const secondArgClassMeta = getClassMeta(secondArgModelRef);
+  if (classMeta.type === "input") {
+    if (secondArgClassMeta.type === "input")
+      return extendModelInputs(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+    else if (secondArgClassMeta.type === "full")
+      return extendModelObjects(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+    else
+      throw new Error("Invalid modelRef args");
+  } else if (classMeta.type === "full") {
+    if (secondArgClassMeta.type === "light")
+      return fullModelOf(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+    else
+      throw new Error("Invalid modelRef args");
+  } else if (classMeta.modelType === "insight")
+    return extendModelInsights(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+  else
+    throw new Error("Invalid modelRef");
 }
+const extendModelInputs = (...libInputModelRefs) => {
+  const baseInputModelRef = libInputModelRefs.at(0);
+  const fieldMetaMap = baseInputModelRef ? getFieldMetaMap(baseInputModelRef) : /* @__PURE__ */ new Map();
+  class BaseInput {
+    __ModelType__ = "input";
+  }
+  setFieldMetaMap(BaseInput, fieldMetaMap);
+  return BaseInput;
+};
+const extendModelObjects = (inputRef, ...libObjectModelRefs) => {
+  const baseObjectModelRef = libObjectModelRefs.at(0);
+  const inputFieldMetaMap = getFieldMetaMap(inputRef);
+  const fieldMetaMap = baseObjectModelRef ? getFieldMetaMap(baseObjectModelRef) : /* @__PURE__ */ new Map();
+  class BaseInput {
+    __ModelType__ = "object";
+  }
+  inputFieldMetaMap.forEach((value, key) => fieldMetaMap.set(key, value));
+  setFieldMetaMap(BaseInput, fieldMetaMap);
+  return BaseInput;
+};
+const extendModelInsights = (...insightModelRefs) => {
+  const baseInsightModelRef = insightModelRefs.at(0);
+  const insightFieldMetaMap = baseInsightModelRef ? getFieldMetaMap(baseInsightModelRef) : /* @__PURE__ */ new Map();
+  class BaseInsight {
+    __ModelType__ = "insight";
+  }
+  setFieldMetaMap(BaseInsight, insightFieldMetaMap);
+  return BaseInsight;
+};
 const addModelOf = (modelRef, ...types) => {
   const modelMetadataMap = getFieldMetaMap(modelRef);
-  const metadataMap = types.filter(Boolean).reduce((acc, writeRef) => {
+  const metadataMap = types.reduce((acc, writeRef) => {
     const writeMetadataMap = getFieldMetaMap(writeRef);
     applyMixins(modelRef, [writeRef]);
     return new Map([...acc, ...writeMetadataMap]);
@@ -108,7 +167,7 @@ const addFilterOf = (filterRef, ...types) => {
   const filterMeta = getFilterMeta(filterRef);
   const filterQueryMap = getFilterQueryMap(filterRef);
   const metadataMap = new Map(
-    types.filter(Boolean).reduce((acc, writeRef) => {
+    types.reduce((acc, writeRef) => {
       const writeMetadataMap = getFilterQueryMap(writeRef);
       applyMixins(filterRef, [writeRef]);
       writeMetadataMap.forEach((value, key) => {
@@ -126,32 +185,7 @@ const addFilterOf = (filterRef, ...types) => {
   setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
   return filterRef;
 };
-const from = (modelRef, ...types) => {
-  if (isConstantModel(modelRef))
-    return addModelOf(modelRef, ...types);
-  else if (isFilterModel(modelRef))
-    return addFilterOf(modelRef, ...types);
-  else
-    throw new Error("Invalid modelRef");
-};
-const mixModelOf = (...types) => {
-  class Mix {
-  }
-  const metadataMap = new Map(
-    types.reduce((acc, modelRef) => {
-      const modelMetadataMap = getFieldMetaMap(modelRef);
-      applyMixins(Mix, [modelRef]);
-      return [...acc, ...modelMetadataMap];
-    }, [])
-  );
-  setFieldMetaMap(Mix, metadataMap);
-  return Mix;
-};
-const over = mixModelOf;
 export {
   as,
-  from,
-  mixModelOf,
-  over,
   via
 };

package/esm/src/classMeta.js

@@ -13,23 +13,38 @@ class ScalarModelStorage {
 class FilterModelStorage {
 }
 const getFullModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
+  const modelRefs = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
+  const modelRef = modelRefs?.[0];
   if (!modelRef)
     throw new Error(`FullModel not found - ${refName}`);
   return modelRef;
 };
+const getFullModelRefs = (refName) => {
+  const modelRefs = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
+  return modelRefs ?? [];
+};
 const getInputModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
+  const modelRefs = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
+  const modelRef = modelRefs?.[0];
   if (!modelRef)
     throw new Error(`InputModel not found - ${refName}`);
   return modelRef;
 };
+const getInputModelRefs = (refName) => {
+  const modelRefs = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
+  return modelRefs ?? [];
+};
 const getScalarModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
+  const modelRefs = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
+  const modelRef = modelRefs?.[0];
   if (!modelRef)
     throw new Error(`ScalarModel not found - ${refName}`);
   return modelRef;
 };
+const getScalarModelRefs = (refName) => {
+  const modelRefs = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
+  return modelRefs ?? [];
+};
 const getChildClassRefs = (target) => {
   const metadatas = getFieldMetas(target);
   const refMap = /* @__PURE__ */ new Map();
@@ -55,7 +70,11 @@ const applyClassMeta = (type, modelType, storage) => {
       const modelRef = target;
       const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
       Reflect.defineMetadata("class", classMeta, modelRef.prototype);
-      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      const modelRefs = Reflect.getMetadata(capitalize(refName), storage.prototype);
+      if (modelRefs)
+        modelRefs.push(modelRef);
+      else
+        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
     };
   };
 };
@@ -64,7 +83,11 @@ const applyFilterMeta = (storage) => {
     return function(target) {
       const modelRef = target;
       setFilterMeta(modelRef, { refName, sort: {} });
-      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      const modelRefs = Reflect.getMetadata(capitalize(refName), storage.prototype);
+      if (modelRefs)
+        modelRefs.push(modelRef);
+      else
+        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
     };
   };
 };
@@ -74,7 +97,6 @@ const Model = {
   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)
 };
@@ -82,47 +104,40 @@ const getLightModelRef = (modelRef) => {
   const classMeta = getClassMeta(modelRef);
   if (classMeta.type !== "full")
     return modelRef;
-  const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
+  const lightModelRefs = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
+  const lightModelRef = lightModelRefs?.at(-1);
   if (!lightModelRef)
     throw new Error(`LightModel not found - ${classMeta.refName}`);
   return lightModelRef;
 };
 const getAllFullModelRefs = () => {
   const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)
-  );
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)).flat();
   return modelRefs;
 };
 const getAllScalarModelRefs = () => {
   const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)
-  );
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)).flat();
   return modelRefs;
 };
 const getAllFilterModelRefs = () => {
   const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)
-  );
+  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)).flat();
   return modelRefs;
 };
 export {
-  FilterModelStorage,
-  FullModelStorage,
-  InputModelStorage,
-  LightModelStorage,
   Model,
-  ScalarModelStorage,
   getAllFilterModelRefs,
   getAllFullModelRefs,
   getAllScalarModelRefs,
   getChildClassRefs,
   getFieldEnumMetas,
   getFullModelRef,
+  getFullModelRefs,
   getInputModelRef,
+  getInputModelRefs,
   getLightModelRef,
   getScalarModelRef,
+  getScalarModelRefs,
   hasTextField
 };

package/esm/src/constantDecorator.js

@@ -10,7 +10,7 @@ const getCnstMeta = (refName) => {
     throw new Error(`No cnst meta for ${refName}`);
   return cnst;
 };
-const cnstOf = (refName, Input, Full, Light, Insight, Filter, Summary) => {
+const cnstOf = (refName, Input, Full, Light, Insight, Filter) => {
   const cnst = {
     refName,
     Input,
@@ -18,7 +18,6 @@ const cnstOf = (refName, Input, Full, Light, Insight, Filter, Summary) => {
     Light,
     Insight,
     Filter,
-    Summary,
     _CapitalizedT: null,
     _Default: null,
     _DefaultInput: null,

package/esm/src/fieldMeta.js

@@ -28,7 +28,6 @@ const applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
       select: option.select ?? true,
       minlength: option.minlength,
       maxlength: option.maxlength,
-      query: option.query,
       accumulate: option.accumulate,
       example: option.example,
       validate: option.validate,
@@ -42,7 +41,8 @@ const applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
       optArrDepth: optionArrDepth,
       isMap,
       of: option.of,
-      text: option.text
+      text: option.text,
+      meta: option.meta ?? {}
     };
     const metadataMap = getFieldMetaMapOnPrototype(prototype);
     metadataMap.set(key, metadata);

package/esm/src/filterMeta.js

@@ -11,6 +11,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 import { getNonArrayModel } from "@akanjs/base";
+import { applyMixins } from "@akanjs/common";
 import {
   getFieldMetaMap
 } from "./scalar";
@@ -26,8 +27,9 @@ const getFilterMeta = (filterRef) => {
 const setFilterMeta = (filterRef, filterMeta) => {
   const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
   if (existingFilterMeta)
-    Object.assign(filterMeta.sort, existingFilterMeta.sort);
-  Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+    Object.assign(existingFilterMeta, { ...filterMeta, sort: { ...existingFilterMeta.sort, ...filterMeta.sort } });
+  else
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
 };
 const getFilterKeyMetaMapOnPrototype = (prototype) => {
   const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
@@ -93,7 +95,7 @@ const Filter = {
   // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
   Arg: applyFilterArgMeta
 };
-const sortOf = (modelRef, sort) => {
+const sortOf = (modelRef, sort, ...libFilterRefs) => {
   const fieldMetaMap = getFieldMetaMap(modelRef);
   const statusFieldMeta = fieldMetaMap.get("status");
   if (!statusFieldMeta)
@@ -120,6 +122,16 @@ const sortOf = (modelRef, sort) => {
     refName: "BaseFilter",
     sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
   });
+  applyMixins(BaseFilter2, libFilterRefs);
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(BaseFilter2.prototype);
+  libFilterRefs.forEach((libFilterRef) => {
+    const libFilterKeyMetaMap = getFilterKeyMetaMapOnPrototype(libFilterRef.prototype);
+    libFilterKeyMetaMap.forEach((value, key) => {
+      const libFilterArgMetas = getFilterArgMetas(libFilterRef, key);
+      filterKeyMetaMap.set(key, value);
+      setFilterArgMetasOnPrototype(BaseFilter2.prototype, key, libFilterArgMetas);
+    });
+  });
   return BaseFilter2;
 };
 function BaseFilter(modelRef, sort) {

package/esm/src/scalar.js

@@ -41,24 +41,18 @@ const isConstantModel = (modelRef) => {
 const getFieldMetaMap = (modelRef) => {
   const [target] = getNonArrayModel(modelRef);
   const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
+  return metadataMap;
 };
 const setFieldMetaMap = (modelRef, metadataMap) => {
   const [target] = getNonArrayModel(modelRef);
-  Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
+  Reflect.defineMetadata("fields", metadataMap, target.prototype);
 };
 const getFieldMetaMapOnPrototype = (prototype) => {
   const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
+  return metadataMap;
 };
 const setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
-  Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
-};
-const getQueryMap = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return Object.fromEntries(
-    fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map((fieldMeta) => [fieldMeta.key, fieldMeta.query])
-  );
+  Reflect.defineMetadata("fields", metadataMap, prototype);
 };
 export {
   fieldTypes,
@@ -67,7 +61,6 @@ export {
   getFieldMetaMapOnPrototype,
   getFieldMetas,
   getGqlTypeStr,
-  getQueryMap,
   getScalarExample,
   isConstantModel,
   scalarExampleMap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/constant",
-  "version": "0.9.43",
+  "version": "0.9.45",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"

package/src/baseGql.d.ts

@@ -1,17 +1,10 @@
 import "reflect-metadata";
-import { BaseObject, type Prettify, Type } from "@akanjs/base";
+import { BaseObject, type MergeAllTypes, type Prettify, Type } from "@akanjs/base";
 import type { NonFunctionalKeys } from "./types";
 export declare const as: <T>(modelRef: Type<T>) => Type<T>;
 type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
 type OmitBase<T> = Omit<T, BaseFields>;
 export declare function via<T>(modelRef: Type<T>): Type<Prettify<T & BaseObject>>;
-export declare function via<T, Light>(modelRef: Type<T>, lightModelRef: Type<Light>, overwriteRef?: Type, overwriteLightRef?: Type): Type<Prettify<T & Light & BaseObject>>;
-export declare function via<T, K extends NonFunctionalKeys<OmitBase<T>>>(modelRef: Type<T>, fields: readonly K[]): Type<Prettify<Pick<T, K> & BaseObject>>;
-type TypesFromArray<T extends Type[]> = {
-    [K in keyof T]: T[K] extends Type<infer U> ? U : never;
-}[number];
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export declare const from: <A, T extends Type[]>(modelRef: Type<A>, ...types: T) => Type<A & UnionToIntersection<TypesFromArray<T>>>;
-export declare const mixModelOf: <T extends Type[]>(...types: T) => Type<UnionToIntersection<TypesFromArray<T>>>;
-export declare const over: <T extends Type[]>(...types: T) => Type<UnionToIntersection<TypesFromArray<T>>>;
+export declare function via<T, Light, FullModels extends Type[]>(modelRef: Type<T>, lightModelRef: Type<Light>, ...fullModelRefs: FullModels): Type<Prettify<MergeAllTypes<FullModels> & T & Light & BaseObject>>;
+export declare function via<T, K extends NonFunctionalKeys<OmitBase<T>>, LightModels extends Type[]>(modelRef: Type<T>, fields: readonly K[], ...lightModelRefs: LightModels): Type<Prettify<MergeAllTypes<LightModels> & Pick<T, K> & BaseObject>>;
 export {};

package/src/classMeta.d.ts

@@ -1,18 +1,11 @@
 import "reflect-metadata";
 import { type Enum, type Type } from "@akanjs/base";
-export declare class InputModelStorage {
-}
-export declare class LightModelStorage {
-}
-export declare class FullModelStorage {
-}
-export declare class ScalarModelStorage {
-}
-export declare class FilterModelStorage {
-}
 export declare const getFullModelRef: (refName: string) => Type;
+export declare const getFullModelRefs: (refName: string) => Type[];
 export declare const getInputModelRef: (refName: string) => Type;
+export declare const getInputModelRefs: (refName: string) => Type[];
 export declare const getScalarModelRef: (refName: string) => Type;
+export declare const getScalarModelRefs: (refName: string) => Type[];
 export declare const getChildClassRefs: (target: Type) => Type[];
 export declare const getFieldEnumMetas: (modelRef: Type) => {
     key: string;
@@ -26,7 +19,6 @@ export declare const Model: {
     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;
 };

package/src/constantDecorator.d.ts

@@ -1,15 +1,14 @@
 import "reflect-metadata";
-import type { Type } from "@akanjs/base";
-import type { DefaultOf, DocumentModel, FilterType, GetActionObject, GetStateObject, QueryOf, SortOf } from "./types";
+import type { GetActionObject, GetStateObject, Type } from "@akanjs/base";
+import type { DefaultOf, DocumentModel, FilterType, QueryOf, SortOf } from "./types";
 export declare const getCnstMeta: (refName: string) => ConstantModel<any, any, any, any, any, any>;
-export interface ConstantModel<T extends string, Input, Full, Light, Insight, Filter extends FilterType, Summary = any, _CapitalizedT extends string = Capitalize<T>, _Default = DefaultOf<Full>, _DefaultInput = DefaultOf<Input>, _DefaultState = GetStateObject<Full>, _DefaultStateInput = GetStateObject<Input>, _Doc = DocumentModel<Full>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<_Doc>, _Query = GetActionObject<Filter>, _Sort = SortOf<Filter>> {
+export interface ConstantModel<T extends string, Input, Full, Light, Insight, Filter extends FilterType, _CapitalizedT extends string = Capitalize<T>, _Default = DefaultOf<Full>, _DefaultInput = DefaultOf<Input>, _DefaultState = GetStateObject<Full>, _DefaultStateInput = GetStateObject<Input>, _Doc = DocumentModel<Full>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<_Doc>, _Query = GetActionObject<Filter>, _Sort = SortOf<Filter>> {
     refName: T;
     Input: Type<Input>;
     Full: Type<Full>;
     Light: Type<Light>;
     Insight: Type<Insight>;
     Filter: Type<Filter>;
-    Summary?: Type<Summary>;
     _CapitalizedT: _CapitalizedT;
     _Default: _Default;
     _DefaultInput: _DefaultInput;
@@ -21,7 +20,7 @@ export interface ConstantModel<T extends string, Input, Full, Light, Insight, Fi
     _Query: _Query;
     _Sort: _Sort;
 }
-export 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, Capitalize<T>, DefaultOf<Full>, DefaultOf<Input>, GetStateObject<Full>, GetStateObject<Input>, DocumentModel<Full>, DocumentModel<Input>, QueryOf<DocumentModel<Full>>, GetActionObject<Filter>, SortOf<Filter>>;
+export declare const cnstOf: <T extends string, Input, Full, Light, Insight, Filter extends FilterType>(refName: T, Input: Type<Input>, Full: Type<Full>, Light: Type<Light>, Insight: Type<Insight>, Filter: Type<Filter>) => ConstantModel<T, Input, Full, Light, Insight, Filter, Capitalize<T>, DefaultOf<Full>, DefaultOf<Input>, GetStateObject<Full>, GetStateObject<Input>, DocumentModel<Full>, DocumentModel<Input>, QueryOf<DocumentModel<Full>>, GetActionObject<Filter>, SortOf<Filter>>;
 export interface ScalarConstantModel<T extends string, Model, _Default = DefaultOf<Model>, _Doc = DocumentModel<Model>> {
     refName: T;
     Model: Type<Model>;

package/src/filterMeta.d.ts

@@ -1,4 +1,4 @@
-import { type Prettify, type Type } from "@akanjs/base";
+import { type MergeAllTypes, type Prettify, type Type } from "@akanjs/base";
 import { type ConstantFilterMeta, type FilterArgMeta, type FilterArgProps, type FilterKeyMeta, type FilterKeyProps, type ReturnType } from "./scalar";
 import type { QueryOf, SortType } from "./types";
 export declare const isFilterModel: (filterRef: Type) => boolean;
@@ -19,7 +19,7 @@ export declare const Filter: {
     Arg: (name: string, returns: ReturnType, argOption?: FilterArgProps | FilterArgProps[]) => (prototype: object, key: string, idx: number) => void;
 };
 export type BaseFilterKey = "latest" | "oldest" | "any" | "byStatuses";
-export declare const sortOf: <Sort extends SortType>(modelRef: Type, sort: Sort) => Type<Prettify<{
+export declare const sortOf: <Sort extends SortType, LibFilters extends Type[]>(modelRef: Type, sort: Sort, ...libFilterRefs: LibFilters) => Type<Prettify<MergeAllTypes<LibFilters> & {
     latest: {
         createdAt: number;
     };

package/src/scalar.d.ts

@@ -1,7 +1,7 @@
 import "reflect-metadata";
 import { type Dayjs, type Enum, Float, type GqlScalar, ID, Int, JSON, type SingleFieldType, type Type, Upload } from "@akanjs/base";
 import type { AccumulatorOperator } from "mongoose";
-import { type QueryOf, type SortType } from "./types";
+import { type SortType } from "./types";
 export declare const scalarExampleMap: Map<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor, string | number | boolean | object>;
 export declare const getScalarExample: (ref: GqlScalar) => string | number | boolean | object | null;
 export declare const getGqlTypeStr: (ref: GqlScalar) => string;
@@ -9,7 +9,7 @@ export interface ConstantClassMeta {
     refName: string;
     modelRef: any;
     type: "input" | "full" | "light" | "scalar";
-    modelType: "data" | "ephemeral" | "summary" | "insight";
+    modelType: "data" | "ephemeral" | "insight";
     hasTextField: boolean;
 }
 export interface ConstantFilterMeta {
@@ -40,7 +40,11 @@ export interface FilterArgMeta extends FilterArgProps {
 export declare const fieldTypes: readonly ["email", "password", "url"];
 export type FieldType = (typeof fieldTypes)[number];
 export type ReturnType<T extends SingleFieldType = SingleFieldType> = (of?: any) => T | [T] | [[T]] | Map<string, any>;
-export interface ConstantFieldProps {
+export interface ConstantFieldProps<Metadata extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> {
     nullable?: boolean;
     ref?: string;
     refPath?: string;
@@ -55,14 +59,18 @@ export interface ConstantFieldProps {
     select?: boolean;
     minlength?: number;
     maxlength?: number;
-    query?: QueryOf<any> | (() => QueryOf<any>);
     accumulate?: AccumulatorOperator;
     example?: string | number | boolean | Dayjs | string[] | number[] | boolean[] | Dayjs[];
     of?: GqlScalar;
     validate?: (value: any, model: any) => boolean;
     text?: "search" | "filter";
+    meta?: Metadata;
 }
-export type ConstantFieldMeta = ConstantFieldProps & {
+export type ConstantFieldMeta<Metadata extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = ConstantFieldProps<Metadata> & {
     nullable: boolean;
     default: any;
     fieldType: "property" | "hidden" | "resolve";
@@ -78,6 +86,7 @@ export type ConstantFieldMeta = ConstantFieldProps & {
     isArray: boolean;
     optArrDepth: number;
     isMap: boolean;
+    meta: Metadata;
 };
 export declare const getClassMeta: (modelRef: Type) => ConstantClassMeta;
 export declare const getFieldMetas: (modelRef: Type) => ConstantFieldMeta[];
@@ -86,6 +95,3 @@ export declare const getFieldMetaMap: (modelRef: Type) => Map<string, ConstantFi
 export declare const setFieldMetaMap: (modelRef: Type, metadataMap: Map<string, ConstantFieldMeta>) => void;
 export declare const getFieldMetaMapOnPrototype: (prototype: object) => Map<string, ConstantFieldMeta>;
 export declare const setFieldMetaMapOnPrototype: (prototype: object, metadataMap: Map<string, ConstantFieldMeta>) => void;
-export declare const getQueryMap: (modelRef: Type) => {
-    [key: string]: QueryOf<any> | undefined | (() => QueryOf<any>);
-};

package/src/types.d.ts

@@ -1,15 +1,9 @@
-import { type BaseObject, Dayjs, enumOf } from "@akanjs/base";
+import { type BaseObject, Dayjs, enumOf, type GetStateObject } from "@akanjs/base";
 import type { FilterQuery, HydratedDocument, ProjectionType } from "mongoose";
 export type { FilterQuery as QueryOf };
 type ObjectToId<O> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? Dayjs : O extends {
     [key: string]: any;
 } ? DocumentModel<O> : O;
-export type GetStateObject<T> = {
-    [K in keyof T as T[K] extends (...args: any) => any ? never : K extends "prototype" ? never : K]: T[K];
-};
-export type GetActionObject<T> = {
-    [K in keyof T as T[K] extends (...args: any) => any ? (K extends "prototype" ? never : K) : never]: T[K];
-};
 type NullToUndefinedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
     [K in StateKeys as null extends T[K] ? never : K]: ObjectToId<T[K]>;
 } & {