@akanjs/constant 0.9.42 → 0.9.44

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,56 +72,117 @@ 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";
   }
-  ["id", ...fields, "createdAt", "updatedAt", "removedAt"].forEach((key) => map.set(key, metadataMap.get(key)));
-  Reflect.defineMetadata("fields", map, BaseGql.prototype);
-  return BaseGql;
+  fieldMetaMap.set("id", idFieldMeta);
+  fieldMetaMap.set("createdAt", createdAtFieldMeta);
+  fieldMetaMap.set("updatedAt", updatedAtFieldMeta);
+  fieldMetaMap.set("removedAt", removedAtFieldMeta);
+  for (const field of fields) {
+    const fieldMeta = objectFieldMetaMap.get(field);
+    if (!fieldMeta)
+      throw new Error(`Field ${field} not found in objectRef`);
+    fieldMetaMap.set(field, fieldMeta);
+  }
+  (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;
 };
-const via = (modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) => {
-  if (!fieldsOrLightModelRef)
-    return baseModelOf(modelRef);
-  else if (Array.isArray(fieldsOrLightModelRef))
-    return lightModelOf(modelRef, fieldsOrLightModelRef);
+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, ...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
-    return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
+    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, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
+const addModelOf = (modelRef, ...types) => {
   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)
-  );
+  const metadataMap = types.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 addFilterOf = (filterRef, ...types) => {
   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) => {
+    types.reduce((acc, writeRef) => {
       const writeMetadataMap = (0, import_filterMeta.getFilterQueryMap)(writeRef);
       (0, import_common.applyMixins)(filterRef, [writeRef]);
       writeMetadataMap.forEach((value, key) => {
@@ -132,7 +192,7 @@ const addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
       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 = types.filter(Boolean).map((t) => (0, import_filterMeta.getFilterSortMap)(t)).reduce((acc, sort) => {
     Object.assign(acc, sort);
     return acc;
   }, filterMeta.sort);
@@ -140,25 +200,3 @@ const addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
   (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/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

@@ -18,7 +18,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var constantDecorator_exports = {};
 __export(constantDecorator_exports, {
   cnstOf: () => cnstOf,
-  getCnstMeta: () => getCnstMeta
+  getCnstMeta: () => getCnstMeta,
+  scalarCnstOf: () => scalarCnstOf
 });
 module.exports = __toCommonJS(constantDecorator_exports);
 var import_reflect_metadata = require("reflect-metadata");
@@ -33,8 +34,34 @@ const getCnstMeta = (refName) => {
     throw new Error(`No cnst meta for ${refName}`);
   return cnst;
 };
-const cnstOf = (refName, Input, Full, Light, Insight, Filter, Summary) => {
-  const cnst = { refName, Input, Full, Light, Insight, Filter, Summary };
+const cnstOf = (refName, Input, Full, Light, Insight, Filter) => {
+  const cnst = {
+    refName,
+    Input,
+    Full,
+    Light,
+    Insight,
+    Filter,
+    _CapitalizedT: null,
+    _Default: null,
+    _DefaultInput: null,
+    _DefaultState: null,
+    _DefaultStateInput: null,
+    _Doc: null,
+    _DocInput: null,
+    _QueryOfDoc: null,
+    _Query: null,
+    _Sort: null
+  };
   setCnstMeta(refName, cnst);
   return cnst;
 };
+const scalarCnstOf = (refName, Model) => {
+  const cnst = {
+    refName,
+    Model,
+    _Default: null,
+    _Doc: null
+  };
+  return cnst;
+};

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/cjs/src/types.js

@@ -20,17 +20,11 @@ __export(types_exports, {
   DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
   MAX_INT: () => MAX_INT,
   Responsive: () => Responsive,
-  defaultListOption: () => defaultListOption,
   responsiveWidths: () => responsiveWidths,
   unsetDate: () => unsetDate
 });
 module.exports = __toCommonJS(types_exports);
 var import_base = require("@akanjs/base");
-const defaultListOption = {
-  limit: 20,
-  skip: 0,
-  sort: "latest"
-};
 const DEFAULT_PAGE_SIZE = 20;
 const unsetDate = (0, import_base.dayjs)(/* @__PURE__ */ new Date("0000"));
 const MAX_INT = 2147483647;