@akanjs/constant 0.9.48 → 0.9.49

package/cjs/src/baseGql.js

@@ -17,7 +17,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var baseGql_exports = {};
 __export(baseGql_exports, {
-  as: () => as,
   via: () => via
 });
 module.exports = __toCommonJS(baseGql_exports);
@@ -25,7 +24,8 @@ 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_constantInfo = require("./constantInfo");
+var import_fieldInfo = require("./fieldInfo");
 var import_scalar = require("./scalar");
 const defaultFieldMeta = {
   fieldType: "property",
@@ -41,162 +41,164 @@ const defaultFieldMeta = {
   isMap: false,
   meta: {}
 };
-const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: import_base.ID };
-const createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
-const updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
-const removedAtFieldMeta = {
-  ...defaultFieldMeta,
-  key: "removedAt",
-  name: "Date",
-  modelRef: Date,
-  nullable: true,
-  default: null
-};
-const extendModel = (modelRef) => {
-  class BaseModel {
-  }
-  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
-  (0, import_scalar.setFieldMetaMap)(BaseModel, metadataMap);
-  return BaseModel;
-};
-const as = extendModel;
-const baseModelOf = (modelRef) => {
-  class BaseModel {
-    __ModelType__ = "full";
+const baseFieldMetaMap = /* @__PURE__ */ new Map([
+  ["id", { ...defaultFieldMeta, key: "id", modelRef: import_base.ID }],
+  ["createdAt", { ...defaultFieldMeta, key: "createdAt", modelRef: Date }],
+  ["updatedAt", { ...defaultFieldMeta, key: "updatedAt", modelRef: Date }],
+  ["removedAt", { ...defaultFieldMeta, key: "removedAt", modelRef: Date, nullable: true, default: null }]
+]);
+const baseInsightFieldMetaMap = /* @__PURE__ */ new Map([
+  ["count", { ...defaultFieldMeta, key: "count", modelRef: import_base.Int, default: 0, accumulate: { $sum: 1 } }]
+]);
+const objectModelOf = (inputRef, fieldMap) => {
+  class ObjectModel {
   }
-  const metadataMap = new Map((0, import_scalar.getFieldMetaMap)(modelRef));
-  metadataMap.set("id", idFieldMeta);
-  metadataMap.set("createdAt", createdAtFieldMeta);
-  metadataMap.set("updatedAt", updatedAtFieldMeta);
-  metadataMap.set("removedAt", removedAtFieldMeta);
-  Reflect.defineMetadata("fields", metadataMap, BaseModel.prototype);
-  return BaseModel;
+  const metadataMap = new Map([...baseFieldMetaMap, ...(0, import_scalar.getFieldMetaMap)(inputRef)]);
+  (0, import_scalar.setFieldMetaMap)(ObjectModel, metadataMap);
+  (0, import_classMeta.setExtendRef)(ObjectModel, inputRef);
+  import_constantInfo.constantInfo.setModelType(ObjectModel, "object");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(ObjectModel, key);
+  });
+  return ObjectModel;
 };
-const lightModelOf = (objectRef, fields, ...libLightModelRefs) => {
+const lightModelOf = (objectRef, fields, fieldMap, ...libLightModelRefs) => {
   const objectFieldMetaMap = (0, import_scalar.getFieldMetaMap)(objectRef);
   const baseLightModelRef = libLightModelRefs.at(0);
-  const fieldMetaMap = baseLightModelRef ? (0, import_scalar.getFieldMetaMap)(baseLightModelRef) : /* @__PURE__ */ new Map();
+  const fieldMetaMap = baseLightModelRef ? (0, import_scalar.getFieldMetaMap)(baseLightModelRef) : new Map([...baseFieldMetaMap]);
   class BaseLightModel {
-    __ModelType__ = "light";
   }
-  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);
+  for (const field2 of fields) {
+    const fieldMeta = objectFieldMetaMap.get(field2);
     if (!fieldMeta)
-      throw new Error(`Field ${field} not found in objectRef`);
-    fieldMetaMap.set(field, fieldMeta);
+      throw new Error(`Field ${field2} not found in objectRef`);
+    fieldMetaMap.set(field2, fieldMeta);
   }
   (0, import_common.applyMixins)(BaseLightModel, libLightModelRefs);
-  Reflect.defineMetadata("fields", fieldMetaMap, BaseLightModel.prototype);
+  (0, import_scalar.setFieldMetaMap)(BaseLightModel, fieldMetaMap);
+  (0, import_classMeta.setExtendRef)(BaseLightModel, objectRef);
+  import_constantInfo.constantInfo.setModelType(BaseLightModel, "light");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseLightModel, key);
+  });
   return BaseLightModel;
 };
-const fullModelOf = (modelRef, lightRef, ...libFullModelRefs) => {
-  const modelFieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
-  const lightFieldMetaMap = (0, import_scalar.getFieldMetaMap)(lightRef);
-  (0, import_common.applyMixins)(modelRef, [...libFullModelRefs, lightRef]);
+const fullModelOf = (objectRef, lightRef, fieldMap, ...libFullModelRefs) => {
+  const fullRef = libFullModelRefs.at(0) ?? class FullModel {
+  };
+  const fieldMetaMap = new Map([...(0, import_scalar.getFieldMetaMap)(objectRef), ...(0, import_scalar.getFieldMetaMap)(lightRef)]);
+  (0, import_common.applyMixins)(fullRef, [objectRef, lightRef, ...libFullModelRefs]);
   libFullModelRefs.forEach((libFullModelRef) => {
-    (0, import_common.applyMixins)(libFullModelRef, [lightRef, modelRef]);
+    (0, import_common.applyMixins)(libFullModelRef, [objectRef, lightRef]);
+  });
+  (0, import_scalar.setFieldMetaMap)(fullRef, fieldMetaMap);
+  (0, import_classMeta.setExtendRef)(fullRef, objectRef);
+  import_constantInfo.constantInfo.setModelType(fullRef, "full");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(fullRef, key);
   });
-  lightFieldMetaMap.forEach((value, key) => modelFieldMetaMap.set(key, value));
-  return modelRef;
+  return fullRef;
 };
-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");
+const makeBaseScalar = (fieldMap) => {
+  class BaseScalar {
   }
-  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);
+  import_constantInfo.constantInfo.setModelType(BaseScalar, "scalar");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseScalar, key);
+  });
+  return BaseScalar;
+};
+function via(firstRefOrBuildField, secondRefOrFieldsOrBuildField, thirdRefOrResolveField, ...extendRefs) {
+  if (!firstRefOrBuildField.prototype || !import_constantInfo.constantInfo.getModelType(firstRefOrBuildField, { allowEmpty: true })) {
+    const buildField = firstRefOrBuildField;
+    const fieldMap = buildField(import_fieldInfo.field);
+    const extendInputRefs = [
+      ...secondRefOrFieldsOrBuildField ? [secondRefOrFieldsOrBuildField] : [],
+      ...thirdRefOrResolveField ? [thirdRefOrResolveField] : [],
+      ...extendRefs
+    ];
+    if (!secondRefOrFieldsOrBuildField)
+      return makeBaseScalar(fieldMap);
     else
-      throw new Error("Invalid modelRef args");
-  } else if (classMeta.modelType === "insight")
-    return extendModelInsights(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
-  else
-    throw new Error("Invalid modelRef");
+      return extendModelInputs(fieldMap, ...extendInputRefs);
+  }
+  if (Array.isArray(secondRefOrFieldsOrBuildField)) {
+    const resolveField = thirdRefOrResolveField;
+    const fieldMap = resolveField(import_fieldInfo.resolve);
+    return lightModelOf(
+      firstRefOrBuildField,
+      secondRefOrFieldsOrBuildField,
+      fieldMap,
+      ...extendRefs
+    );
+  }
+  if (!secondRefOrFieldsOrBuildField.prototype || !import_constantInfo.constantInfo.getModelType(secondRefOrFieldsOrBuildField, { allowEmpty: true })) {
+    const buildField = secondRefOrFieldsOrBuildField;
+    const fieldMap = buildField(import_fieldInfo.field);
+    if (import_constantInfo.constantInfo.isScalar(firstRefOrBuildField)) {
+      if (!thirdRefOrResolveField)
+        return objectModelOf(firstRefOrBuildField, fieldMap);
+      else
+        return extendModelObjects(
+          firstRefOrBuildField,
+          fieldMap,
+          thirdRefOrResolveField,
+          ...extendRefs
+        );
+    }
+    if (import_constantInfo.constantInfo.isFull(firstRefOrBuildField)) {
+      const extendInsightRefs = [
+        ...thirdRefOrResolveField ? [thirdRefOrResolveField] : [],
+        ...extendRefs
+      ];
+      return extendModelInsights(fieldMap, ...extendInsightRefs);
+    }
+  } else {
+    const objectRef = firstRefOrBuildField;
+    const lightRef = secondRefOrFieldsOrBuildField;
+    const resolveField = thirdRefOrResolveField;
+    const fieldMap = resolveField(import_fieldInfo.resolve);
+    return fullModelOf(objectRef, lightRef, fieldMap, ...extendRefs);
+  }
+  throw new Error(
+    `Invalid modelRef args ${firstRefOrBuildField} ${secondRefOrFieldsOrBuildField} ${extendRefs.join(", ")}`
+  );
 }
-const extendModelInputs = (...libInputModelRefs) => {
+const extendModelInputs = (fieldMap, ...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);
+  import_constantInfo.constantInfo.setModelType(BaseInput, "scalar");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseInput, key);
+  });
   return BaseInput;
 };
-const extendModelObjects = (inputRef, ...libObjectModelRefs) => {
+const extendModelObjects = (inputRef, fieldMap, ...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);
+  import_constantInfo.constantInfo.setModelType(BaseInput, "object");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseInput, key);
+  });
   return BaseInput;
 };
-const extendModelInsights = (...insightModelRefs) => {
+const extendModelInsights = (fieldMap, ...insightModelRefs) => {
   const baseInsightModelRef = insightModelRefs.at(0);
-  const insightFieldMetaMap = baseInsightModelRef ? (0, import_scalar.getFieldMetaMap)(baseInsightModelRef) : /* @__PURE__ */ new Map();
+  const insightFieldMetaMap = baseInsightModelRef ? (0, import_scalar.getFieldMetaMap)(baseInsightModelRef) : new Map([...baseInsightFieldMetaMap]);
   class BaseInsight {
-    __ModelType__ = "insight";
   }
   (0, import_scalar.setFieldMetaMap)(BaseInsight, insightFieldMetaMap);
+  import_constantInfo.constantInfo.setModelType(BaseInsight, "insight");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseInsight, key);
+  });
   return BaseInsight;
 };
-const addModelOf = (modelRef, ...types) => {
-  const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
-  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, ...types) => {
-  const filterMeta = (0, import_filterMeta.getFilterMeta)(filterRef);
-  const filterQueryMap = (0, import_filterMeta.getFilterQueryMap)(filterRef);
-  const metadataMap = new Map(
-    types.reduce((acc, writeRef) => {
-      const writeMetadataMap = (0, import_filterMeta.getFilterQueryMap)(writeRef);
-      (0, import_common.applyMixins)(filterRef, [writeRef]);
-      writeMetadataMap.forEach((value, key) => {
-        const filterArgMetas = (0, import_filterMeta.getFilterArgMetas)(writeRef, key);
-        (0, import_filterMeta.setFilterArgMetasOnPrototype)(filterRef.prototype, key, filterArgMetas);
-      });
-      return new Map([...acc, ...writeMetadataMap]);
-    }, filterQueryMap)
-  );
-  const filterSort = types.filter(Boolean).map((t) => (0, import_filterMeta.getFilterSortMap)(t)).reduce((acc, sort) => {
-    Object.assign(acc, sort);
-    return acc;
-  }, filterMeta.sort);
-  (0, import_filterMeta.setFilterKeyMetaMapOnPrototype)(filterRef.prototype, metadataMap);
-  (0, import_filterMeta.setFilterMeta)(filterRef, { ...filterMeta, sort: filterSort });
-  return filterRef;
-};

package/cjs/src/classMeta.js

@@ -17,68 +17,24 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var classMeta_exports = {};
 __export(classMeta_exports, {
-  Model: () => Model,
-  getAllFilterModelRefs: () => getAllFilterModelRefs,
-  getAllFullModelRefs: () => getAllFullModelRefs,
-  getAllScalarModelRefs: () => getAllScalarModelRefs,
   getChildClassRefs: () => getChildClassRefs,
+  getExtendRef: () => getExtendRef,
   getFieldEnumMetas: () => getFieldEnumMetas,
-  getFullModelRef: () => getFullModelRef,
-  getFullModelRefs: () => getFullModelRefs,
-  getInputModelRef: () => getInputModelRef,
-  getInputModelRefs: () => getInputModelRefs,
-  getLightModelRef: () => getLightModelRef,
-  getScalarModelRef: () => getScalarModelRef,
-  getScalarModelRefs: () => getScalarModelRefs,
-  hasTextField: () => hasTextField
+  hasTextField: () => hasTextField,
+  setExtendRef: () => setExtendRef
 });
 module.exports = __toCommonJS(classMeta_exports);
 var import_reflect_metadata = require("reflect-metadata");
-var import_common = require("@akanjs/common");
-var import_filterMeta = require("./filterMeta");
+var import_constantInfo = require("./constantInfo");
 var import_scalar = require("./scalar");
-class InputModelStorage {
-}
-class LightModelStorage {
-}
-class FullModelStorage {
-}
-class ScalarModelStorage {
-}
-class FilterModelStorage {
-}
-const getFullModelRef = (refName) => {
-  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 setExtendRef = (modelRef, extendRef) => {
+  Reflect.defineMetadata("akan:extend", extendRef, modelRef.prototype);
 };
-const getFullModelRefs = (refName) => {
-  const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
-  return modelRefs ?? [];
-};
-const getInputModelRef = (refName) => {
-  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 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 getExtendRef = (modelRef, { allowEmpty } = {}) => {
+  const extendRef = Reflect.getMetadata("akan:extend", modelRef.prototype);
+  if (!extendRef && !allowEmpty)
+    throw new Error(`ExtendRef not found - ${modelRef.name}`);
+  return extendRef;
 };
 const getChildClassRefs = (target) => {
   const metadatas = (0, import_scalar.getFieldMetas)(target);
@@ -86,7 +42,7 @@ const getChildClassRefs = (target) => {
   const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
     return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
   }, []);
-  childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set((0, import_scalar.getClassMeta)(modelRef).refName, modelRef));
+  childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(import_constantInfo.constantInfo.getRefName(modelRef), modelRef));
   return [...refMap.values()];
 };
 const getFieldEnumMetas = (modelRef) => {
@@ -99,64 +55,3 @@ const hasTextField = (modelRef) => {
     (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
   );
 };
-const applyClassMeta = (type, modelType, storage) => {
-  return function(refName) {
-    return function(target) {
-      const modelRef = target;
-      const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
-      Reflect.defineMetadata("class", classMeta, modelRef.prototype);
-      const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), storage.prototype);
-      if (modelRefs)
-        modelRefs.push(modelRef);
-      else
-        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
-    };
-  };
-};
-const applyFilterMeta = (storage) => {
-  return function(refName) {
-    return function(target) {
-      const modelRef = target;
-      (0, import_filterMeta.setFilterMeta)(modelRef, { refName, sort: {} });
-      const modelRefs = Reflect.getMetadata((0, import_common.capitalize)(refName), storage.prototype);
-      if (modelRefs)
-        modelRefs.push(modelRef);
-      else
-        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
-    };
-  };
-};
-const Model = {
-  Light: applyClassMeta("light", "data", LightModelStorage),
-  Object: applyClassMeta("full", "ephemeral", FullModelStorage),
-  Full: applyClassMeta("full", "data", FullModelStorage),
-  Input: applyClassMeta("input", "data", InputModelStorage),
-  Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
-  Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
-  Filter: applyFilterMeta(FilterModelStorage)
-};
-const getLightModelRef = (modelRef) => {
-  const classMeta = (0, import_scalar.getClassMeta)(modelRef);
-  if (classMeta.type !== "full")
-    return modelRef;
-  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)).flat();
-  return modelRefs;
-};
-const getAllScalarModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(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)).flat();
-  return modelRefs;
-};

package/cjs/src/constantInfo.js

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constantInfo_exports = {};
+__export(constantInfo_exports, {
+  cnstOf: () => cnstOf,
+  constantInfo: () => constantInfo,
+  scalarCnstOf: () => scalarCnstOf
+});
+module.exports = __toCommonJS(constantInfo_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_base = require("@akanjs/base");
+var import__ = require(".");
+var import_immerify = require("./immerify");
+const constantInfo = {
+  database: /* @__PURE__ */ new Map(),
+  scalar: /* @__PURE__ */ new Map(),
+  modelRefNameMap: /* @__PURE__ */ new Map(),
+  getRefName(modelRef, { allowEmpty } = {}) {
+    const refName = constantInfo.modelRefNameMap.get(modelRef);
+    if (!refName && !allowEmpty)
+      throw new Error(`No ref name for modelRef: ${modelRef}`);
+    return refName;
+  },
+  getModelType(modelRef, { allowEmpty } = {}) {
+    const modelType = Reflect.getMetadata("akan:modeltype", modelRef.prototype);
+    if (!modelType && !allowEmpty)
+      throw new Error(`No model type for modelRef: ${modelRef}`);
+    return modelType;
+  },
+  setModelType(modelRef, modelType) {
+    Reflect.defineMetadata("akan:modeltype", modelType, modelRef.prototype);
+  },
+  isObject(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "object";
+  },
+  isFull(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "full";
+  },
+  isLight(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "light";
+  },
+  isInsight(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "insight";
+  },
+  isFilter(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "filter";
+  },
+  isScalar(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "scalar";
+  },
+  setDatabase(refName, cnst) {
+    constantInfo.database.set(refName, cnst);
+  },
+  getDatabase(refName, { allowEmpty } = {}) {
+    const info = constantInfo.database.get(refName);
+    if (!info && !allowEmpty)
+      throw new Error(`No database constant model info for ${refName}`);
+    return info;
+  },
+  setScalar(refName, cnst) {
+    if (constantInfo.scalar.has(refName))
+      return;
+    constantInfo.scalar.set(refName, cnst);
+  },
+  getScalar(refName, { allowEmpty } = {}) {
+    const model = constantInfo.scalar.get(refName);
+    if (!model && !allowEmpty)
+      throw new Error(`No scalar constant model for ${refName}`);
+    return model;
+  },
+  getModelRef(refName, modelType) {
+    if (modelType === "scalar") {
+      if (import_base.gqlScalarMap.has(refName))
+        return import_base.gqlScalarMap.get(refName);
+      else
+        return constantInfo.getScalar(refName).model;
+    } else
+      return constantInfo.getDatabase(refName)[modelType];
+  }
+};
+const cnstOf = (refName, Input, Full, Light, Insight, option = {}) => {
+  [Input, Full, Light, Insight].forEach((modelRef) => {
+    constantInfo.modelRefNameMap.set(modelRef, refName);
+  });
+  constantInfo.setModelType(Input, "input");
+  constantInfo.setModelType(Full, "full");
+  constantInfo.setModelType(Light, "light");
+  constantInfo.setModelType(Insight, "insight");
+  const cnst = {
+    refName,
+    input: Input,
+    full: Full,
+    light: Light,
+    insight: Insight,
+    crystalize: (0, import__.makeCrystalize)(Full, option),
+    lightCrystalize: (0, import__.makeCrystalize)(Light, option),
+    crystalizeInsight: (0, import__.makeCrystalize)(Insight, option),
+    purify: (0, import__.makePurify)(Input, option),
+    getDefault: () => (0, import_immerify.immerify)(Full, Object.assign(new Full(), (0, import__.makeDefault)(Full, option))),
+    getDefaultInsight: () => (0, import_immerify.immerify)(Insight, Object.assign(new Insight(), (0, import__.makeDefault)(Insight, option))),
+    _CapitalizedT: null,
+    _Default: null,
+    _DefaultInput: null,
+    _DefaultState: null,
+    _DefaultStateInput: null,
+    _DefaultInsight: null,
+    _PurifiedInput: null,
+    _Doc: null,
+    _DocInput: null,
+    _QueryOfDoc: null
+  };
+  constantInfo.setDatabase(refName, cnst);
+  return cnst;
+};
+const scalarCnstOf = (refName, Model) => {
+  constantInfo.setModelType(Model, "scalar");
+  constantInfo.modelRefNameMap.set(Model, refName);
+  const cnst = {
+    refName,
+    model: Model,
+    crystalize: (0, import__.makeCrystalize)(Model),
+    purify: (0, import__.makePurify)(Model),
+    getDefault: () => (0, import_immerify.immerify)(Model, Object.assign(new Model(), (0, import__.makeDefault)(Model))),
+    _Default: null,
+    _Doc: null,
+    _PurifiedInput: null
+  };
+  constantInfo.setScalar(refName, cnst);
+  return cnst;
+};