@akanjs/constant 0.9.42 → 0.9.44

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,56 +57,117 @@ 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";
   }
-  ["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);
+  }
+  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;
 };
-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 = 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, ...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
-    return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
+    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, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
+const addModelOf = (modelRef, ...types) => {
   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 = getFieldMetaMap(writeRef);
-      applyMixins(modelRef, [writeRef]);
-      return new Map([...acc, ...writeMetadataMap]);
-    }, modelMetadataMap)
-  );
+  const metadataMap = types.reduce((acc, writeRef) => {
+    const writeMetadataMap = getFieldMetaMap(writeRef);
+    applyMixins(modelRef, [writeRef]);
+    return new Map([...acc, ...writeMetadataMap]);
+  }, modelMetadataMap);
   setFieldMetaMap(modelRef, metadataMap);
   return modelRef;
 };
-const addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
+const addFilterOf = (filterRef, ...types) => {
   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) => {
+    types.reduce((acc, writeRef) => {
       const writeMetadataMap = getFilterQueryMap(writeRef);
       applyMixins(filterRef, [writeRef]);
       writeMetadataMap.forEach((value, key) => {
@@ -115,7 +177,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) => getFilterSortMap(t)).reduce((acc, sort) => {
+  const filterSort = types.filter(Boolean).map((t) => getFilterSortMap(t)).reduce((acc, sort) => {
     Object.assign(acc, sort);
     return acc;
   }, filterMeta.sort);
@@ -123,32 +185,7 @@ const addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
   setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
   return filterRef;
 };
-const from = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
-  if (isConstantModel(modelRef))
-    return addModelOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
-  else if (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 = 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,12 +10,39 @@ 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;
+};
 export {
   cnstOf,
-  getCnstMeta
+  getCnstMeta,
+  scalarCnstOf
 };

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

@@ -1,9 +1,4 @@
 import { dayjs, enumOf } from "@akanjs/base";
-const defaultListOption = {
-  limit: 20,
-  skip: 0,
-  sort: "latest"
-};
 const DEFAULT_PAGE_SIZE = 20;
 const unsetDate = dayjs(/* @__PURE__ */ new Date("0000"));
 const MAX_INT = 2147483647;
@@ -13,7 +8,6 @@ export {
   DEFAULT_PAGE_SIZE,
   MAX_INT,
   Responsive,
-  defaultListOption,
   responsiveWidths,
   unsetDate
 };

package/package.json

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

package/src/baseGql.d.ts

@@ -1,8 +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>;
-export declare const via: <T, LightOrFields extends readonly NonFunctionalKeys<Omit<T, "id" | "createdAt" | "updatedAt" | "removedAt">>[] | Type | undefined = undefined>(modelRef: Type<T>, fieldsOrLightModelRef?: LightOrFields, overwriteRef?: Type, overwriteLightRef?: Type) => LightOrFields extends undefined ? Type<Prettify<T & BaseObject>> : LightOrFields extends Type<infer Light> ? Type<Prettify<T & Light & BaseObject>> : LightOrFields extends readonly NonFunctionalKeys<Omit<T, "id" | "createdAt" | "updatedAt" | "removedAt">>[] ? Type<Prettify<{ [K in LightOrFields[number]]: T[K]; } & BaseObject>> : never;
-export declare const from: <A, T1, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown>(modelRef: Type<A>, t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>) => Type<A & T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10>;
-export declare const mixModelOf: <T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown, T11 = unknown, T12 = unknown, T13 = unknown, T14 = unknown, T15 = unknown, T16 = unknown, T17 = unknown, T18 = unknown, T19 = unknown, T20 = unknown>(t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>, t11?: Type<T11>, t12?: Type<T12>, t13?: Type<T13>, t14?: Type<T14>, t15?: Type<T15>, t16?: Type<T16>, t17?: Type<T17>, t18?: Type<T18>, t19?: Type<T19>, t20?: Type<T20>) => Type<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10 & T11 & T12 & T13 & T14 & T15 & T16 & T17 & T18 & T19 & T20>;
-export declare const over: <T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown, T11 = unknown, T12 = unknown, T13 = unknown, T14 = unknown, T15 = unknown, T16 = unknown, T17 = unknown, T18 = unknown, T19 = unknown, T20 = unknown>(t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>, t11?: Type<T11>, t12?: Type<T12>, t13?: Type<T13>, t14?: Type<T14>, t15?: Type<T15>, t16?: Type<T16>, t17?: Type<T17>, t18?: Type<T18>, t19?: Type<T19>, t20?: Type<T20>) => Type<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10 & T11 & T12 & T13 & T14 & T15 & T16 & T17 & T18 & T19 & T20>;
+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, 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,14 +1,30 @@
 import "reflect-metadata";
-import type { Type } from "@akanjs/base";
-import type { FilterType } 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> {
+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;
+    _DefaultState: _DefaultState;
+    _DefaultStateInput: _DefaultStateInput;
+    _Doc: _Doc;
+    _DocInput: _DocInput;
+    _QueryOfDoc: _QueryOfDoc;
+    _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>;
+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>;
+    _Default: _Default;
+    _Doc: _Doc;
+}
+export declare const scalarCnstOf: <T extends string, Model>(refName: T, Model: Type<Model>) => ScalarConstantModel<T, 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;
     };