@akanjs/constant 0.0.54 → 0.0.55

package/index.mjs

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/constant",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -16,5 +16,11 @@
   },
   "dependencies": {
     "reflect-metadata": "^0.2.2"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/baseGql.mjs

@@ -0,0 +1,154 @@
+import "reflect-metadata";
+import { ID } from "@akanjs/base";
+import { applyMixins } from "@akanjs/common";
+import {
+  getFilterArgMetas,
+  getFilterMeta,
+  getFilterQueryMap,
+  getFilterSortMap,
+  isFilterModel,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta
+} from "./filterMeta";
+import { getFieldMetaMap, isConstantModel, setFieldMetaMap } from "./scalar";
+const defaultFieldMeta = {
+  fieldType: "property",
+  immutable: false,
+  select: true,
+  isClass: false,
+  isScalar: true,
+  nullable: false,
+  isArray: false,
+  arrDepth: 0,
+  optArrDepth: 0,
+  default: null,
+  isMap: false
+};
+const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: 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 = getFieldMetaMap(modelRef);
+  setFieldMetaMap(BaseModel, metadataMap);
+  return BaseModel;
+};
+const as = extendModel;
+const 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;
+};
+const 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;
+};
+const fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
+  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]));
+  return modelRef;
+};
+const 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);
+};
+const 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);
+      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 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);
+      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;
+};
+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/src/classMeta.mjs

@@ -0,0 +1,128 @@
+import "reflect-metadata";
+import { capitalize } from "@akanjs/common";
+import { setFilterMeta } from "./filterMeta";
+import { getClassMeta, getFieldMetas } from "./scalar";
+class InputModelStorage {
+}
+class LightModelStorage {
+}
+class FullModelStorage {
+}
+class ScalarModelStorage {
+}
+class FilterModelStorage {
+}
+const getFullModelRef = (refName) => {
+  const modelRef = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
+  if (!modelRef)
+    throw new Error(`FullModel not found - ${refName}`);
+  return modelRef;
+};
+const getInputModelRef = (refName) => {
+  const modelRef = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
+  if (!modelRef)
+    throw new Error(`InputModel not found - ${refName}`);
+  return modelRef;
+};
+const getScalarModelRef = (refName) => {
+  const modelRef = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
+  if (!modelRef)
+    throw new Error(`ScalarModel not found - ${refName}`);
+  return modelRef;
+};
+const 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()];
+};
+const getFieldEnumMetas = (modelRef) => {
+  const fieldMetas = getFieldMetas(modelRef);
+  return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
+};
+const hasTextField = (modelRef) => {
+  const fieldMetas = getFieldMetas(modelRef);
+  return fieldMetas.some(
+    (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);
+      Reflect.defineMetadata(refName, modelRef, storage.prototype);
+    };
+  };
+};
+const applyFilterMeta = (storage) => {
+  return function(refName) {
+    return function(target) {
+      const modelRef = target;
+      setFilterMeta(modelRef, { refName, sort: {} });
+      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),
+  Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
+  Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
+  Filter: applyFilterMeta(FilterModelStorage)
+};
+const 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;
+};
+const getAllFullModelRefs = () => {
+  const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
+  const modelRefs = modelNames.map(
+    (modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)
+  );
+  return modelRefs;
+};
+const getAllScalarModelRefs = () => {
+  const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
+  const modelRefs = modelNames.map(
+    (modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)
+  );
+  return modelRefs;
+};
+const getAllFilterModelRefs = () => {
+  const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
+  const modelRefs = modelNames.map(
+    (modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)
+  );
+  return modelRefs;
+};
+export {
+  FilterModelStorage,
+  FullModelStorage,
+  InputModelStorage,
+  LightModelStorage,
+  Model,
+  ScalarModelStorage,
+  getAllFilterModelRefs,
+  getAllFullModelRefs,
+  getAllScalarModelRefs,
+  getChildClassRefs,
+  getFieldEnumMetas,
+  getFullModelRef,
+  getInputModelRef,
+  getLightModelRef,
+  getScalarModelRef,
+  hasTextField
+};

package/src/constantDecorator.mjs

@@ -0,0 +1,21 @@
+import "reflect-metadata";
+class CnstStorage {
+}
+const setCnstMeta = (refName, cnst) => {
+  Reflect.defineMetadata(refName, cnst, CnstStorage.prototype);
+};
+const getCnstMeta = (refName) => {
+  const cnst = Reflect.getMetadata(refName, CnstStorage.prototype);
+  if (!cnst)
+    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 };
+  setCnstMeta(refName, cnst);
+  return cnst;
+};
+export {
+  cnstOf,
+  getCnstMeta
+};

package/src/fieldMeta.mjs

@@ -0,0 +1,67 @@
+import { getNonArrayModel, isGqlMap, isGqlScalar, scalarNameMap } from "@akanjs/base";
+import {
+  getClassMeta,
+  getFieldMetaMapOnPrototype,
+  setFieldMetaMapOnPrototype
+} from "./scalar";
+const applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
+  const isArray = arrDepth > 0;
+  const isClass = !isGqlScalar(modelRef);
+  const isMap = isGqlMap(modelRef);
+  const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
+  const name = isClass ? refName : 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);
+  };
+};
+const makeField = (customOption) => (returns, fieldOption) => {
+  const [modelRef, arrDepth] = getNonArrayModel(returns());
+  if (!fieldOption)
+    return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
+  const [opt, optArrDepth] = getNonArrayModel(fieldOption);
+  return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
+};
+const Field = {
+  Prop: makeField({ fieldType: "property" }),
+  Hidden: makeField({ fieldType: "hidden", nullable: true }),
+  Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
+  Resolve: makeField({ fieldType: "resolve" })
+};
+export {
+  Field
+};

package/src/filterMeta.mjs

@@ -0,0 +1,169 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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);
+import { getNonArrayModel } from "@akanjs/base";
+import {
+  getFieldMetaMap
+} from "./scalar";
+const isFilterModel = (filterRef) => {
+  return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
+};
+const getFilterMeta = (filterRef) => {
+  const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (!filterMeta)
+    throw new Error("filterMeta is not defined");
+  return filterMeta;
+};
+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);
+};
+const getFilterKeyMetaMapOnPrototype = (prototype) => {
+  const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+};
+const setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
+  Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+};
+const applyFilterKeyMeta = (option) => {
+  return (prototype, key, descriptor) => {
+    const metadata = { key, ...option, descriptor };
+    const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
+    metadataMap.set(key, metadata);
+    setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
+  };
+};
+const makeFilter = (customOption) => (fieldOption) => {
+  return applyFilterKeyMeta({ ...customOption, ...fieldOption });
+};
+const getFilterArgMetasOnPrototype = (prototype, key) => {
+  const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+  return filterArgMetas;
+};
+const setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
+  Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+};
+const getFilterArgMetas = (filterRef, key) => {
+  const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
+  return filterArgMetas;
+};
+const applyFilterArgMeta = (name, returns, argOption) => {
+  return (prototype, key, idx) => {
+    const [modelRef, arrDepth] = getNonArrayModel(returns());
+    const [opt, optArrDepth] = getNonArrayModel(argOption ?? {});
+    const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
+    const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
+    filterArgMetas[idx] = filterArgMeta;
+    setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
+  };
+};
+const 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;
+};
+const getFilterQueryMap = (filterRef) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  return filterKeyMetaMap;
+};
+const getFilterSort = (filterRef, key) => {
+  const filterMeta = getFilterMeta(filterRef);
+  const sort = filterMeta.sort[key];
+  return sort;
+};
+const getFilterSortMap = (filterRef) => {
+  const filterMeta = getFilterMeta(filterRef);
+  return filterMeta.sort;
+};
+const Filter = {
+  Mongo: makeFilter({ type: "mongo" }),
+  // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
+  Arg: applyFilterArgMeta
+};
+const 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;
+}
+export {
+  BaseFilter,
+  Filter,
+  getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype,
+  getFilterMeta,
+  getFilterQuery,
+  getFilterQueryMap,
+  getFilterSort,
+  getFilterSortMap,
+  isFilterModel,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta,
+  sortOf
+};

package/src/index.mjs

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./fieldMeta";
+export * from "./scalar";
+export * from "./constantDecorator";
+export * from "./filterMeta";
+export * from "./baseGql";
+export * from "./classMeta";

package/src/scalar.mjs

@@ -0,0 +1,76 @@
+import "reflect-metadata";
+import {
+  Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  JSON,
+  scalarNameMap,
+  Upload
+} from "@akanjs/base";
+const scalarExampleMap = /* @__PURE__ */ new Map([
+  [ID, "1234567890abcdef12345678"],
+  [Int, 0],
+  [Float, 0],
+  [String, "String"],
+  [Boolean, true],
+  [Date, (/* @__PURE__ */ new Date()).toISOString()],
+  [Upload, "FileUpload"],
+  [JSON, {}],
+  [Map, {}]
+]);
+const getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
+const getGqlTypeStr = (ref) => scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
+const fieldTypes = ["email", "password", "url"];
+const getClassMeta = (modelRef) => {
+  const [target] = getNonArrayModel(modelRef);
+  const classMeta = Reflect.getMetadata("class", target.prototype);
+  if (!classMeta)
+    throw new Error(`No ClassMeta for this target ${target.name}`);
+  return classMeta;
+};
+const getFieldMetas = (modelRef) => {
+  const [target] = 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));
+};
+const isConstantModel = (modelRef) => {
+  return Reflect.getMetadata("class", modelRef.prototype) !== void 0;
+};
+const getFieldMetaMap = (modelRef) => {
+  const [target] = getNonArrayModel(modelRef);
+  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+};
+const setFieldMetaMap = (modelRef, metadataMap) => {
+  const [target] = getNonArrayModel(modelRef);
+  Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
+};
+const getFieldMetaMapOnPrototype = (prototype) => {
+  const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(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])
+  );
+};
+export {
+  fieldTypes,
+  getClassMeta,
+  getFieldMetaMap,
+  getFieldMetaMapOnPrototype,
+  getFieldMetas,
+  getGqlTypeStr,
+  getQueryMap,
+  getScalarExample,
+  isConstantModel,
+  scalarExampleMap,
+  setFieldMetaMap,
+  setFieldMetaMapOnPrototype
+};

package/src/types.mjs

@@ -0,0 +1,10 @@
+const defaultListOption = {
+  limit: 20,
+  skip: 0,
+  sort: "latest"
+};
+const DEFAULT_PAGE_SIZE = 20;
+export {
+  DEFAULT_PAGE_SIZE,
+  defaultListOption
+};