@akanjs/constant 0.0.46 → 0.0.48

package/index.js

@@ -2,618 +2,16 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
+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;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-
-// pkgs/@akanjs/constant/index.ts
 var constant_exports = {};
-__export(constant_exports, {
-  BaseFilter: () => BaseFilter,
-  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
-  Field: () => Field,
-  Filter: () => Filter,
-  FilterModelStorage: () => FilterModelStorage,
-  FullModelStorage: () => FullModelStorage,
-  InputModelStorage: () => InputModelStorage,
-  LightModelStorage: () => LightModelStorage,
-  Model: () => Model,
-  ScalarModelStorage: () => ScalarModelStorage,
-  as: () => as,
-  cnstOf: () => cnstOf,
-  defaultListOption: () => defaultListOption,
-  fieldTypes: () => fieldTypes,
-  from: () => from,
-  getAllFilterModelRefs: () => getAllFilterModelRefs,
-  getAllFullModelRefs: () => getAllFullModelRefs,
-  getAllScalarModelRefs: () => getAllScalarModelRefs,
-  getChildClassRefs: () => getChildClassRefs,
-  getClassMeta: () => getClassMeta,
-  getCnstMeta: () => getCnstMeta,
-  getFieldEnumMetas: () => getFieldEnumMetas,
-  getFieldMetaMap: () => getFieldMetaMap,
-  getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
-  getFieldMetas: () => getFieldMetas,
-  getFilterArgMetas: () => getFilterArgMetas,
-  getFilterKeyMetaMapOnPrototype: () => getFilterKeyMetaMapOnPrototype,
-  getFilterMeta: () => getFilterMeta,
-  getFilterQuery: () => getFilterQuery,
-  getFilterQueryMap: () => getFilterQueryMap,
-  getFilterSort: () => getFilterSort,
-  getFilterSortMap: () => getFilterSortMap,
-  getFullModelRef: () => getFullModelRef,
-  getGqlTypeStr: () => getGqlTypeStr,
-  getInputModelRef: () => getInputModelRef,
-  getLightModelRef: () => getLightModelRef,
-  getQueryMap: () => getQueryMap,
-  getScalarExample: () => getScalarExample,
-  getScalarModelRef: () => getScalarModelRef,
-  hasTextField: () => hasTextField,
-  isConstantModel: () => isConstantModel,
-  isFilterModel: () => isFilterModel,
-  mixModelOf: () => mixModelOf,
-  over: () => over,
-  scalarExampleMap: () => scalarExampleMap,
-  setFieldMetaMap: () => setFieldMetaMap,
-  setFieldMetaMapOnPrototype: () => setFieldMetaMapOnPrototype,
-  setFilterArgMetasOnPrototype: () => setFilterArgMetasOnPrototype,
-  setFilterKeyMetaMapOnPrototype: () => setFilterKeyMetaMapOnPrototype,
-  setFilterMeta: () => setFilterMeta,
-  sortOf: () => sortOf,
-  via: () => via
-});
 module.exports = __toCommonJS(constant_exports);
-
-// pkgs/@akanjs/constant/src/types.ts
-var defaultListOption = {
-  limit: 20,
-  skip: 0,
-  sort: "latest"
-};
-var DEFAULT_PAGE_SIZE = 20;
-
-// pkgs/@akanjs/constant/src/fieldMeta.ts
-var import_base2 = require("@akanjs/base");
-
-// pkgs/@akanjs/constant/src/scalar.ts
-var import_reflect_metadata = require("reflect-metadata");
-var import_base = require("@akanjs/base");
-var scalarExampleMap = /* @__PURE__ */ new Map([
-  [import_base.ID, "1234567890abcdef12345678"],
-  [import_base.Int, 0],
-  [import_base.Float, 0],
-  [String, "String"],
-  [Boolean, true],
-  [Date, (/* @__PURE__ */ new Date()).toISOString()],
-  [import_base.Upload, "FileUpload"],
-  [import_base.JSON, {}],
-  [Map, {}]
-]);
-var getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
-var getGqlTypeStr = (ref) => import_base.scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
-var fieldTypes = ["email", "password", "url"];
-var getClassMeta = (modelRef) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  const classMeta = Reflect.getMetadata("class", target.prototype);
-  if (!classMeta)
-    throw new Error(`No ClassMeta for this target ${target.name}`);
-  return classMeta;
-};
-var getFieldMetas = (modelRef) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
-  const keySortMap = { id: -1, createdAt: 1, updatedAt: 2, removedAt: 3 };
-  return [...metadataMap.values()].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
-};
-var isConstantModel = (modelRef) => {
-  return Reflect.getMetadata("class", modelRef.prototype) !== void 0;
-};
-var getFieldMetaMap = (modelRef) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
-};
-var setFieldMetaMap = (modelRef, metadataMap) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
-};
-var getFieldMetaMapOnPrototype = (prototype) => {
-  const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
-};
-var setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
-  Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
-};
-var getQueryMap = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return Object.fromEntries(
-    fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map((fieldMeta) => [fieldMeta.key, fieldMeta.query])
-  );
-};
-
-// pkgs/@akanjs/constant/src/fieldMeta.ts
-var applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
-  const isArray = arrDepth > 0;
-  const isClass = !(0, import_base2.isGqlScalar)(modelRef);
-  const isMap = (0, import_base2.isGqlMap)(modelRef);
-  const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
-  const name = isClass ? refName : import_base2.scalarNameMap.get(modelRef) ?? "Unknown";
-  if (isMap && !option.of)
-    throw new Error("Map type must have 'of' option");
-  return (prototype, key) => {
-    const metadata = {
-      nullable: option.nullable ?? false,
-      ref: option.ref,
-      refPath: option.refPath,
-      refType: option.refType,
-      default: option.default ?? (isArray ? [] : null),
-      type: option.type,
-      fieldType: option.fieldType ?? "property",
-      immutable: option.immutable ?? false,
-      min: option.min,
-      max: option.max,
-      enum: option.enum,
-      select: option.select ?? true,
-      minlength: option.minlength,
-      maxlength: option.maxlength,
-      query: option.query,
-      accumulate: option.accumulate,
-      example: option.example,
-      validate: option.validate,
-      key,
-      name,
-      isClass,
-      isScalar: type === "scalar",
-      modelRef,
-      arrDepth,
-      isArray,
-      optArrDepth: optionArrDepth,
-      isMap,
-      of: option.of,
-      text: option.text
-    };
-    const metadataMap = getFieldMetaMapOnPrototype(prototype);
-    metadataMap.set(key, metadata);
-    setFieldMetaMapOnPrototype(prototype, metadataMap);
-  };
-};
-var makeField = (customOption) => (returns, fieldOption) => {
-  const [modelRef, arrDepth] = (0, import_base2.getNonArrayModel)(returns());
-  if (!fieldOption)
-    return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
-  const [opt, optArrDepth] = (0, import_base2.getNonArrayModel)(fieldOption);
-  return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
-};
-var Field = {
-  Prop: makeField({ fieldType: "property" }),
-  Hidden: makeField({ fieldType: "hidden", nullable: true }),
-  Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
-  Resolve: makeField({ fieldType: "resolve" })
-};
-
-// pkgs/@akanjs/constant/src/constantDecorator.ts
-var import_reflect_metadata2 = require("reflect-metadata");
-var CnstStorage = class {
-};
-var setCnstMeta = (refName, cnst) => {
-  Reflect.defineMetadata(refName, cnst, CnstStorage.prototype);
-};
-var getCnstMeta = (refName) => {
-  const cnst = Reflect.getMetadata(refName, CnstStorage.prototype);
-  if (!cnst)
-    throw new Error(`No cnst meta for ${refName}`);
-  return cnst;
-};
-var cnstOf = (refName, Input, Full, Light, Insight, Filter2, Summary) => {
-  const cnst = { refName, Input, Full, Light, Insight, Filter: Filter2, Summary };
-  setCnstMeta(refName, cnst);
-  return cnst;
-};
-
-// pkgs/@akanjs/constant/src/filterMeta.ts
-var import_base3 = require("@akanjs/base");
-var isFilterModel = (filterRef) => {
-  return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
-};
-var getFilterMeta = (filterRef) => {
-  const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
-  if (!filterMeta)
-    throw new Error("filterMeta is not defined");
-  return filterMeta;
-};
-var setFilterMeta = (filterRef, filterMeta) => {
-  const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
-  if (existingFilterMeta)
-    Object.assign(filterMeta.sort, existingFilterMeta.sort);
-  Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
-};
-var getFilterKeyMetaMapOnPrototype = (prototype) => {
-  const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
-  return new Map(metadataMap);
-};
-var setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
-  Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
-};
-var applyFilterKeyMeta = (option) => {
-  return (prototype, key, descriptor) => {
-    const metadata = { key, ...option, descriptor };
-    const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
-    metadataMap.set(key, metadata);
-    setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
-  };
-};
-var makeFilter = (customOption) => (fieldOption) => {
-  return applyFilterKeyMeta({ ...customOption, ...fieldOption });
-};
-var getFilterArgMetasOnPrototype = (prototype, key) => {
-  const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
-  return filterArgMetas;
-};
-var setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
-  Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
-};
-var getFilterArgMetas = (filterRef, key) => {
-  const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
-  return filterArgMetas;
-};
-var applyFilterArgMeta = (name, returns, argOption) => {
-  return (prototype, key, idx) => {
-    const [modelRef, arrDepth] = (0, import_base3.getNonArrayModel)(returns());
-    const [opt, optArrDepth] = (0, import_base3.getNonArrayModel)(argOption ?? {});
-    const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
-    const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
-    filterArgMetas[idx] = filterArgMeta;
-    setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
-  };
-};
-var getFilterQuery = (filterRef, key) => {
-  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
-  const filterKeyMeta = filterKeyMetaMap.get(key);
-  if (!filterKeyMeta?.descriptor.value)
-    throw new Error(`filterKeyMeta is not defined for key: ${key}`);
-  return filterKeyMeta.descriptor.value;
-};
-var getFilterQueryMap = (filterRef) => {
-  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
-  return filterKeyMetaMap;
-};
-var getFilterSort = (filterRef, key) => {
-  const filterMeta = getFilterMeta(filterRef);
-  const sort = filterMeta.sort[key];
-  return sort;
-};
-var getFilterSortMap = (filterRef) => {
-  const filterMeta = getFilterMeta(filterRef);
-  return filterMeta.sort;
-};
-var Filter = {
-  Mongo: makeFilter({ type: "mongo" }),
-  // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
-  Arg: applyFilterArgMeta
-};
-var sortOf = (modelRef, sort) => {
-  const fieldMetaMap = getFieldMetaMap(modelRef);
-  const statusFieldMeta = fieldMetaMap.get("status");
-  if (!statusFieldMeta)
-    throw new Error(`No status field meta fount in ${modelRef.name}`);
-  class BaseFilter2 {
-    latest = { createdAt: -1 };
-    oldest = { createdAt: 1 };
-    any() {
-      return { removedAt: { $exists: false } };
-    }
-    byStatuses(statuses) {
-      return statuses?.length ? { status: { $in: statuses } } : {};
-    }
-  }
-  __decorateClass([
-    Filter.Mongo()
-  ], BaseFilter2.prototype, "any", 1);
-  __decorateClass([
-    Filter.Mongo(),
-    __decorateParam(0, Filter.Arg("statuses", () => [String], { nullable: true, enum: statusFieldMeta?.enum }))
-  ], BaseFilter2.prototype, "byStatuses", 1);
-  Object.assign(BaseFilter2.prototype, sort);
-  setFilterMeta(BaseFilter2, {
-    refName: "BaseFilter",
-    sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
-  });
-  return BaseFilter2;
-};
-function BaseFilter(modelRef, sort) {
-  const fieldMetaMap = getFieldMetaMap(modelRef);
-  const statusFieldMeta = fieldMetaMap.get("status");
-  if (!statusFieldMeta)
-    throw new Error(`No status field meta fount in ${modelRef.name}`);
-  class BaseFilter2 {
-    latest = { createdAt: -1 };
-    oldest = { createdAt: 1 };
-    any() {
-      return { removedAt: { $exists: false } };
-    }
-    byStatuses(statuses) {
-      return statuses?.length ? { status: { $in: statuses } } : {};
-    }
-  }
-  __decorateClass([
-    Filter.Mongo()
-  ], BaseFilter2.prototype, "any", 1);
-  __decorateClass([
-    Filter.Mongo(),
-    __decorateParam(0, Filter.Arg("statuses", () => [String], { nullable: true, enum: statusFieldMeta?.enum }))
-  ], BaseFilter2.prototype, "byStatuses", 1);
-  Object.assign(BaseFilter2.prototype, sort);
-  setFilterMeta(BaseFilter2, {
-    refName: "BaseFilter",
-    sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
-  });
-  return BaseFilter2;
-}
-
-// pkgs/@akanjs/constant/src/baseGql.ts
-var import_reflect_metadata3 = require("reflect-metadata");
-var import_base4 = require("@akanjs/base");
-var import_common = require("@akanjs/common");
-var defaultFieldMeta = {
-  fieldType: "property",
-  immutable: false,
-  select: true,
-  isClass: false,
-  isScalar: true,
-  nullable: false,
-  isArray: false,
-  arrDepth: 0,
-  optArrDepth: 0,
-  default: null,
-  isMap: false
-};
-var idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: import_base4.ID };
-var createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
-var updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
-var removedAtFieldMeta = {
-  ...defaultFieldMeta,
-  key: "removedAt",
-  name: "Date",
-  modelRef: Date,
-  nullable: true,
-  default: null
-};
-var extendModel = (modelRef) => {
-  class BaseModel {
-  }
-  const metadataMap = getFieldMetaMap(modelRef);
-  setFieldMetaMap(BaseModel, metadataMap);
-  return BaseModel;
-};
-var as = extendModel;
-var baseModelOf = (modelRef) => {
-  class BaseModel {
-    __ModelType__ = "full";
-  }
-  const metadataMap = 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;
-};
-var lightModelOf = (objectRef, fields) => {
-  const map = /* @__PURE__ */ new Map();
-  const metadataMap = getFieldMetaMap(objectRef);
-  class BaseGql {
-    __ModelType__ = "light";
-  }
-  ["id", ...fields, "createdAt", "updatedAt", "removedAt"].forEach((key) => map.set(key, metadataMap.get(key)));
-  Reflect.defineMetadata("fields", map, BaseGql.prototype);
-  return BaseGql;
-};
-var fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
-  const modelFieldMetaMap = getFieldMetaMap(modelRef);
-  const lightFieldMetaMap = getFieldMetaMap(lightRef);
-  (0, import_common.applyMixins)(modelRef, [lightRef]);
-  if (overwriteRef) {
-    (0, import_common.applyMixins)(overwriteRef, [modelRef]);
-    setFieldMetaMap(overwriteRef, modelFieldMetaMap);
-  }
-  if (overwriteLightRef) {
-    (0, import_common.applyMixins)(overwriteLightRef, [lightRef]);
-    setFieldMetaMap(overwriteLightRef, lightFieldMetaMap);
-  }
-  setFieldMetaMap(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
-  return modelRef;
-};
-var via = (modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) => {
-  if (!fieldsOrLightModelRef)
-    return baseModelOf(modelRef);
-  else if (Array.isArray(fieldsOrLightModelRef))
-    return lightModelOf(modelRef, fieldsOrLightModelRef);
-  else
-    return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
-};
-var addModelOf = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
-  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);
-      (0, import_common.applyMixins)(modelRef, [writeRef]);
-      return new Map([...acc, ...writeMetadataMap]);
-    }, modelMetadataMap)
-  );
-  setFieldMetaMap(modelRef, metadataMap);
-  return modelRef;
-};
-var addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
-  const filterMeta = getFilterMeta(filterRef);
-  const filterQueryMap = getFilterQueryMap(filterRef);
-  const metadataMap = new Map(
-    [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
-      const writeMetadataMap = getFilterQueryMap(writeRef);
-      (0, import_common.applyMixins)(filterRef, [writeRef]);
-      writeMetadataMap.forEach((value, key) => {
-        const filterArgMetas = getFilterArgMetas(writeRef, key);
-        setFilterArgMetasOnPrototype(filterRef.prototype, key, filterArgMetas);
-      });
-      return new Map([...acc, ...writeMetadataMap]);
-    }, filterQueryMap)
-  );
-  const filterSort = [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).map((t) => getFilterSortMap(t)).reduce((acc, sort) => {
-    Object.assign(acc, sort);
-    return acc;
-  }, filterMeta.sort);
-  setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
-  setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
-  return filterRef;
-};
-var 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");
-};
-var 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);
-      (0, import_common.applyMixins)(Mix, [modelRef]);
-      return [...acc, ...modelMetadataMap];
-    }, [])
-  );
-  setFieldMetaMap(Mix, metadataMap);
-  return Mix;
-};
-var over = mixModelOf;
-
-// pkgs/@akanjs/constant/src/classMeta.ts
-var import_reflect_metadata4 = require("reflect-metadata");
-var import_common2 = require("@akanjs/common");
-var InputModelStorage = class {
-};
-var LightModelStorage = class {
-};
-var FullModelStorage = class {
-};
-var ScalarModelStorage = class {
-};
-var FilterModelStorage = class {
-};
-var getFullModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata((0, import_common2.capitalize)(refName), FullModelStorage.prototype);
-  if (!modelRef)
-    throw new Error(`FullModel not found - ${refName}`);
-  return modelRef;
-};
-var getInputModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata((0, import_common2.capitalize)(refName), InputModelStorage.prototype);
-  if (!modelRef)
-    throw new Error(`InputModel not found - ${refName}`);
-  return modelRef;
-};
-var getScalarModelRef = (refName) => {
-  const modelRef = Reflect.getMetadata((0, import_common2.capitalize)(refName), ScalarModelStorage.prototype);
-  if (!modelRef)
-    throw new Error(`ScalarModel not found - ${refName}`);
-  return modelRef;
-};
-var getChildClassRefs = (target) => {
-  const metadatas = getFieldMetas(target);
-  const refMap = /* @__PURE__ */ new Map();
-  const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
-    return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
-  }, []);
-  childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(getClassMeta(modelRef).refName, modelRef));
-  return [...refMap.values()];
-};
-var getFieldEnumMetas = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
-};
-var hasTextField = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return fieldMetas.some(
-    (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
-  );
-};
-var 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);
-      Reflect.defineMetadata(refName, modelRef, storage.prototype);
-    };
-  };
-};
-var applyFilterMeta = (storage) => {
-  return function(refName) {
-    return function(target) {
-      const modelRef = target;
-      setFilterMeta(modelRef, { refName, sort: {} });
-      Reflect.defineMetadata(refName, modelRef, storage.prototype);
-    };
-  };
-};
-var 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),
-  Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
-  Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
-  Filter: applyFilterMeta(FilterModelStorage)
-};
-var getLightModelRef = (modelRef) => {
-  const classMeta = getClassMeta(modelRef);
-  if (classMeta.type !== "full")
-    return modelRef;
-  const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
-  if (!lightModelRef)
-    throw new Error(`LightModel not found - ${classMeta.refName}`);
-  return lightModelRef;
-};
-var getAllFullModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)
-  );
-  return modelRefs;
-};
-var getAllScalarModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)
-  );
-  return modelRefs;
-};
-var getAllFilterModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
-  const modelRefs = modelNames.map(
-    (modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)
-  );
-  return modelRefs;
-};
+__reExport(constant_exports, require("./src"), module.exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/constant",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"