@akanjs/constant 0.0.4

package/README.md

@@ -0,0 +1,11 @@
+# akan
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build akan` to build the library.
+
+## Running unit tests
+
+Run `nx test akan` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

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

package/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constant_exports = {};
+module.exports = __toCommonJS(constant_exports);
+__reExport(constant_exports, require("./src"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./src")
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@akanjs/constant",
+  "version": "0.0.4",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akan-team/akanjs.git",
+    "directory": "pkgs/@akanjs/constant"
+  },
+  "dependencies": {
+    "@urql/core": "5.1.0",
+    "dayjs": "1.11.13",
+    "mongoose": "8.9.3",
+    "pluralize": "8.0.0",
+    "reflect-metadata": "0.2.2",
+    "tunnel-ssh": "5.2.0"
+  },
+  "main": "./index.js"
+}

package/src/baseGql.d.ts

@@ -0,0 +1,13 @@
+import "reflect-metadata";
+import { BaseObject, Type } from "@akanjs/base";
+export declare function ExtendModel<T>(modelRef: Type<T>): Type<T>;
+export declare function BaseModel<T>(modelRef: Type<T>): Type<T & BaseObject>;
+export declare function AddModel<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 function AddFilter<A, T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown>(filterRef: 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 function MixModels<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 NonFunctionalKeys<T> = keyof T extends (...any: any[]) => any ? never : keyof T;
+export declare function Light<T, F extends NonFunctionalKeys<Omit<T, "id" | "createdAt" | "updatedAt" | "removedAt">>>(objectRef: Type<T>, fields: readonly F[]): Type<{
+    [K in F]: T[K];
+} & BaseObject>;
+export declare function Full<A, B = undefined>(modelRef: Type<A>, lightRef: Type<B>, overwriteRef?: Type, overwriteLightRef?: Type): Type<Omit<A, keyof B> & B>;
+export {};

package/src/baseGql.js

@@ -0,0 +1,158 @@
+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 baseGql_exports = {};
+__export(baseGql_exports, {
+  AddFilter: () => AddFilter,
+  AddModel: () => AddModel,
+  BaseModel: () => BaseModel,
+  ExtendModel: () => ExtendModel,
+  Full: () => Full,
+  Light: () => Light,
+  MixModels: () => MixModels
+});
+module.exports = __toCommonJS(baseGql_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_filterMeta = require("./filterMeta");
+var import_scalar = require("./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: 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
+};
+function ExtendModel(modelRef) {
+  class BaseModel2 {
+  }
+  const metadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  (0, import_scalar.setFieldMetaMap)(BaseModel2, metadataMap);
+  return BaseModel2;
+}
+function BaseModel(modelRef) {
+  class BaseModel2 {
+    __ModelType__ = "full";
+  }
+  const metadataMap = (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, BaseModel2.prototype);
+  return BaseModel2;
+}
+function AddModel(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) {
+  const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const metadataMap = new Map(
+    [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
+      const writeMetadataMap = (0, import_scalar.getFieldMetaMap)(writeRef);
+      (0, import_common.applyMixins)(modelRef, [writeRef]);
+      return new Map([...acc, ...writeMetadataMap]);
+    }, modelMetadataMap)
+  );
+  (0, import_scalar.setFieldMetaMap)(modelRef, metadataMap);
+  return modelRef;
+}
+function AddFilter(filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) {
+  const filterMeta = (0, import_filterMeta.getFilterMeta)(filterRef);
+  const filterQueryMap = (0, import_filterMeta.getFilterQueryMap)(filterRef);
+  const metadataMap = new Map(
+    [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
+      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 = [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).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;
+}
+function MixModels(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) {
+  class Mix {
+  }
+  const metadataMap = new Map(
+    [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20].filter((t) => !!t).reduce((acc, modelRef) => {
+      const modelMetadataMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+      (0, import_common.applyMixins)(Mix, [modelRef]);
+      return [...acc, ...modelMetadataMap];
+    }, [])
+  );
+  (0, import_scalar.setFieldMetaMap)(Mix, metadataMap);
+  return Mix;
+}
+function Light(objectRef, fields) {
+  const map = /* @__PURE__ */ new Map();
+  const metadataMap = (0, import_scalar.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;
+}
+function Full(modelRef, lightRef, overwriteRef, overwriteLightRef) {
+  const modelFieldMetaMap = (0, import_scalar.getFieldMetaMap)(modelRef);
+  const lightFieldMetaMap = (0, import_scalar.getFieldMetaMap)(lightRef);
+  (0, import_common.applyMixins)(modelRef, [lightRef]);
+  if (overwriteRef) {
+    (0, import_common.applyMixins)(overwriteRef, [modelRef]);
+    (0, import_scalar.setFieldMetaMap)(overwriteRef, modelFieldMetaMap);
+  }
+  if (overwriteLightRef) {
+    (0, import_common.applyMixins)(overwriteLightRef, [lightRef]);
+    (0, import_scalar.setFieldMetaMap)(overwriteLightRef, lightFieldMetaMap);
+  }
+  (0, import_scalar.setFieldMetaMap)(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
+  return modelRef;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddFilter,
+  AddModel,
+  BaseModel,
+  ExtendModel,
+  Full,
+  Light,
+  MixModels
+});

package/src/base_temp.d.ts

@@ -0,0 +1,3 @@
+export { BaseModel as Model, Full, Light, AddModel, MixModels, ExtendModel, AddFilter } from "./baseGql";
+export { BaseFilter as Filter } from "./filterMeta";
+export { enumOf as enum, type EnumType as Enum } from "@akanjs/base";

package/src/base_temp.js

@@ -0,0 +1,45 @@
+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 base_temp_exports = {};
+__export(base_temp_exports, {
+  AddFilter: () => import_baseGql.AddFilter,
+  AddModel: () => import_baseGql.AddModel,
+  ExtendModel: () => import_baseGql.ExtendModel,
+  Filter: () => import_filterMeta.BaseFilter,
+  Full: () => import_baseGql.Full,
+  Light: () => import_baseGql.Light,
+  MixModels: () => import_baseGql.MixModels,
+  Model: () => import_baseGql.BaseModel,
+  enum: () => import_base.enumOf
+});
+module.exports = __toCommonJS(base_temp_exports);
+var import_baseGql = require("./baseGql");
+var import_filterMeta = require("./filterMeta");
+var import_base = require("@akanjs/base");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddFilter,
+  AddModel,
+  ExtendModel,
+  Filter,
+  Full,
+  Light,
+  MixModels,
+  Model,
+  enum: null
+});

package/src/classMeta.d.ts

@@ -0,0 +1,36 @@
+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 getInputModelRef: (refName: string) => Type;
+export declare const getScalarModelRef: (refName: string) => Type;
+export declare const getChildClassRefs: (target: Type) => Type[];
+export declare const getFieldEnumMetas: (modelRef: Type) => {
+    key: string;
+    enum: Enum<string | number>;
+}[];
+export declare const hasTextField: (modelRef: Type) => boolean;
+export type ClassType = "light" | "full" | "input" | "scalar";
+export declare const Model: {
+    Light: (refName: string) => (target: Type) => void;
+    Object: (refName: string) => (target: Type) => void;
+    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;
+};
+export declare const getLightModelRef: (modelRef: Type) => Type;
+export declare const getAllFullModelRefs: () => Type[];
+export declare const getAllScalarModelRefs: () => Type[];
+export declare const getAllFilterModelRefs: () => Type[];

package/src/classMeta.js

@@ -0,0 +1,166 @@
+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 classMeta_exports = {};
+__export(classMeta_exports, {
+  FilterModelStorage: () => FilterModelStorage,
+  FullModelStorage: () => FullModelStorage,
+  InputModelStorage: () => InputModelStorage,
+  LightModelStorage: () => LightModelStorage,
+  Model: () => Model,
+  ScalarModelStorage: () => ScalarModelStorage,
+  getAllFilterModelRefs: () => getAllFilterModelRefs,
+  getAllFullModelRefs: () => getAllFullModelRefs,
+  getAllScalarModelRefs: () => getAllScalarModelRefs,
+  getChildClassRefs: () => getChildClassRefs,
+  getFieldEnumMetas: () => getFieldEnumMetas,
+  getFullModelRef: () => getFullModelRef,
+  getInputModelRef: () => getInputModelRef,
+  getLightModelRef: () => getLightModelRef,
+  getScalarModelRef: () => getScalarModelRef,
+  hasTextField: () => hasTextField
+});
+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_scalar = require("./scalar");
+class InputModelStorage {
+}
+class LightModelStorage {
+}
+class FullModelStorage {
+}
+class ScalarModelStorage {
+}
+class FilterModelStorage {
+}
+const getFullModelRef = (refName) => {
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), FullModelStorage.prototype);
+  if (!modelRef)
+    throw new Error(`FullModel not found - ${refName}`);
+  return modelRef;
+};
+const getInputModelRef = (refName) => {
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), InputModelStorage.prototype);
+  if (!modelRef)
+    throw new Error(`InputModel not found - ${refName}`);
+  return modelRef;
+};
+const getScalarModelRef = (refName) => {
+  const modelRef = Reflect.getMetadata((0, import_common.capitalize)(refName), ScalarModelStorage.prototype);
+  if (!modelRef)
+    throw new Error(`ScalarModel not found - ${refName}`);
+  return modelRef;
+};
+const getChildClassRefs = (target) => {
+  const metadatas = (0, import_scalar.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((0, import_scalar.getClassMeta)(modelRef).refName, modelRef));
+  return [...refMap.values()];
+};
+const getFieldEnumMetas = (modelRef) => {
+  const fieldMetas = (0, import_scalar.getFieldMetas)(modelRef);
+  return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
+};
+const hasTextField = (modelRef) => {
+  const fieldMetas = (0, import_scalar.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;
+      (0, import_filterMeta.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 = (0, import_scalar.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FilterModelStorage,
+  FullModelStorage,
+  InputModelStorage,
+  LightModelStorage,
+  Model,
+  ScalarModelStorage,
+  getAllFilterModelRefs,
+  getAllFullModelRefs,
+  getAllScalarModelRefs,
+  getChildClassRefs,
+  getFieldEnumMetas,
+  getFullModelRef,
+  getInputModelRef,
+  getLightModelRef,
+  getScalarModelRef,
+  hasTextField
+});

package/src/constantDecorator.d.ts

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+import type { Type } from "@akanjs/base";
+import type { FilterType } 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> {
+    refName: T;
+    Input: Type<Input>;
+    Full: Type<Full>;
+    Light: Type<Light>;
+    Insight: Type<Insight>;
+    Filter: Type<Filter>;
+    Summary?: Type<Summary>;
+}
+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>;

package/src/constantDecorator.js

@@ -0,0 +1,45 @@
+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 constantDecorator_exports = {};
+__export(constantDecorator_exports, {
+  cnstOf: () => cnstOf,
+  getCnstMeta: () => getCnstMeta
+});
+module.exports = __toCommonJS(constantDecorator_exports);
+var import_reflect_metadata = require("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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cnstOf,
+  getCnstMeta
+});

package/src/fieldMeta.d.ts

@@ -0,0 +1,7 @@
+import { ConstantFieldProps, ReturnType } from "./scalar";
+export declare const Field: {
+    Prop: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+    Hidden: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+    Secret: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+    Resolve: (returns: ReturnType, fieldOption?: Omit<ConstantFieldProps, "fieldType" | "select"> | Omit<ConstantFieldProps, "nullable" | "fieldType" | "select">[]) => PropertyDecorator;
+};

package/src/fieldMeta.js

@@ -0,0 +1,86 @@
+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 fieldMeta_exports = {};
+__export(fieldMeta_exports, {
+  Field: () => Field
+});
+module.exports = __toCommonJS(fieldMeta_exports);
+var import_base = require("@akanjs/base");
+var import_scalar = require("./scalar");
+const applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
+  const isArray = arrDepth > 0;
+  const isClass = !(0, import_base.isGqlScalar)(modelRef);
+  const isMap = (0, import_base.isGqlMap)(modelRef);
+  const { refName, type } = isClass ? (0, import_scalar.getClassMeta)(modelRef) : { refName: "", type: "scalar" };
+  const name = isClass ? refName : import_base.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 = (0, import_scalar.getFieldMetaMapOnPrototype)(prototype);
+    metadataMap.set(key, metadata);
+    (0, import_scalar.setFieldMetaMapOnPrototype)(prototype, metadataMap);
+  };
+};
+const makeField = (customOption) => (returns, fieldOption) => {
+  const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(returns());
+  if (!fieldOption)
+    return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
+  const [opt, optArrDepth] = (0, import_base.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" })
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field
+});

package/src/filterMeta.d.ts

@@ -0,0 +1,40 @@
+import { 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 getFilterMeta: (filterRef: Type) => ConstantFilterMeta;
+export declare const setFilterMeta: (filterRef: Type, filterMeta: ConstantFilterMeta) => void;
+export declare const getFilterKeyMetaMapOnPrototype: (prototype: object) => Map<string, FilterKeyMeta>;
+export declare const setFilterKeyMetaMapOnPrototype: (prototype: object, metadataMap: Map<string, FilterKeyMeta>) => void;
+export declare const setFilterArgMetasOnPrototype: (prototype: object, key: string, filterArgMetas: FilterArgMeta[]) => void;
+export declare const getFilterArgMetas: (filterRef: Type, key: string) => FilterArgMeta[];
+export declare const getFilterQuery: (filterRef: Type, key: string) => (...args: any[]) => QueryOf<any>;
+export declare const getFilterQueryMap: (filterRef: Type) => Map<string, FilterKeyMeta>;
+export declare const getFilterSort: (filterRef: Type, key: string) => {
+    [key: string]: number;
+};
+export declare const getFilterSortMap: (filterRef: Type) => SortType;
+export declare const Filter: {
+    Mongo: (fieldOption?: Omit<FilterKeyProps, "type">) => (prototype: object, key: string, descriptor: PropertyDescriptor) => void;
+    Arg: (name: string, returns: ReturnType, argOption?: FilterArgProps | FilterArgProps[]) => (prototype: object, key: string, idx: number) => void;
+};
+export type BaseFilterKey = "latest" | "oldest" | "any" | "byStatuses";
+export declare function BaseFilter<Sort extends SortType>(modelRef: Type, sort: Sort): Type<{
+    latest: {
+        createdAt: number;
+    };
+    oldest: {
+        createdAt: number;
+    };
+    any(): {
+        removedAt: {
+            $exists: boolean;
+        };
+    };
+    byStatuses(statuses: string[] | null): {
+        status: {
+            $in: string[];
+        };
+    } | {
+        status?: undefined;
+    };
+} & Sort>;

package/src/filterMeta.js

@@ -0,0 +1,165 @@
+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 __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);
+var filterMeta_exports = {};
+__export(filterMeta_exports, {
+  BaseFilter: () => BaseFilter,
+  Filter: () => Filter,
+  getFilterArgMetas: () => getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype: () => getFilterKeyMetaMapOnPrototype,
+  getFilterMeta: () => getFilterMeta,
+  getFilterQuery: () => getFilterQuery,
+  getFilterQueryMap: () => getFilterQueryMap,
+  getFilterSort: () => getFilterSort,
+  getFilterSortMap: () => getFilterSortMap,
+  setFilterArgMetasOnPrototype: () => setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype: () => setFilterKeyMetaMapOnPrototype,
+  setFilterMeta: () => setFilterMeta
+});
+module.exports = __toCommonJS(filterMeta_exports);
+var import_base = require("@akanjs/base");
+var import_scalar = require("./scalar");
+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] = (0, import_base.getNonArrayModel)(returns());
+    const [opt, optArrDepth] = (0, import_base.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
+};
+function BaseFilter(modelRef, sort) {
+  const fieldMetaMap = (0, import_scalar.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseFilter,
+  Filter,
+  getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype,
+  getFilterMeta,
+  getFilterQuery,
+  getFilterQueryMap,
+  getFilterSort,
+  getFilterSortMap,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta
+});

package/src/index.d.ts

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

package/src/index.js

@@ -0,0 +1,52 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  base: () => base
+});
+module.exports = __toCommonJS(src_exports);
+var base = __toESM(require("./base_temp"));
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./fieldMeta"), module.exports);
+__reExport(src_exports, require("./scalar"), module.exports);
+__reExport(src_exports, require("./constantDecorator"), module.exports);
+__reExport(src_exports, require("./filterMeta"), module.exports);
+__reExport(src_exports, require("./baseGql"), module.exports);
+__reExport(src_exports, require("./classMeta"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base,
+  ...require("./types"),
+  ...require("./fieldMeta"),
+  ...require("./scalar"),
+  ...require("./constantDecorator"),
+  ...require("./filterMeta"),
+  ...require("./baseGql"),
+  ...require("./classMeta")
+});

package/src/scalar.d.ts

@@ -0,0 +1,90 @@
+import "reflect-metadata";
+import { type Dayjs, type Enum, Float, type GqlScalar, ID, Int, JSON, type SingleFieldType, type Type, Upload } from "@akanjs/base";
+import type { AccumulatorOperator } from "mongoose";
+import { type QueryOf, type SortType } from "./types";
+export declare const scalarExampleMap: Map<MapConstructor | typeof Int | typeof Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor, string | number | boolean | object>;
+export declare const getScalarExample: (ref: GqlScalar) => string | number | boolean | object | null;
+export declare const getGqlTypeStr: (ref: GqlScalar) => string;
+export interface ConstantClassMeta {
+    refName: string;
+    modelRef: any;
+    type: "input" | "full" | "light" | "scalar";
+    modelType: "data" | "ephemeral" | "summary" | "insight";
+    hasTextField: boolean;
+}
+export interface ConstantFilterMeta {
+    refName: string;
+    sort: SortType;
+}
+export interface FilterKeyProps {
+    type?: "mongo" | "meili";
+}
+export interface FilterKeyMeta extends FilterKeyProps {
+    key: string;
+    descriptor: PropertyDescriptor;
+}
+export interface FilterArgProps {
+    nullable?: boolean;
+    ref?: string;
+    default?: string | number | boolean | object | null | (() => string | number | boolean | object | null);
+    renderOption?: (value: any) => string;
+    enum?: Enum<string | number>;
+}
+export interface FilterArgMeta extends FilterArgProps {
+    name: string;
+    modelRef: Type;
+    arrDepth: number;
+    isArray: boolean;
+    optArrDepth: number;
+}
+export declare const fieldTypes: readonly ["email", "password", "url"];
+export type FieldType = (typeof fieldTypes)[number];
+export type ReturnType<T extends SingleFieldType = SingleFieldType> = (of?: any) => T | [T] | [[T]] | Map<string, any>;
+export interface ConstantFieldProps {
+    nullable?: boolean;
+    ref?: string;
+    refPath?: string;
+    refType?: "child" | "parent" | "relation";
+    default?: string | number | boolean | object | null | Enum<string | number>;
+    type?: FieldType;
+    fieldType?: "property" | "hidden" | "resolve";
+    immutable?: boolean;
+    min?: number;
+    max?: number;
+    enum?: Enum<string | number>;
+    select?: boolean;
+    minlength?: number;
+    maxlength?: number;
+    query?: QueryOf<any> | (() => QueryOf<any>);
+    accumulate?: AccumulatorOperator;
+    example?: string | number | boolean | Dayjs | string[] | number[] | boolean[] | Dayjs[];
+    of?: GqlScalar;
+    validate?: (value: any, model: any) => boolean;
+    text?: "search" | "filter";
+}
+export type ConstantFieldMeta = ConstantFieldProps & {
+    nullable: boolean;
+    default: any;
+    fieldType: "property" | "hidden" | "resolve";
+    immutable: boolean;
+    select: boolean;
+} & {
+    key: string;
+    name: string;
+    isClass: boolean;
+    isScalar: boolean;
+    modelRef: Type;
+    arrDepth: number;
+    isArray: boolean;
+    optArrDepth: number;
+    isMap: boolean;
+};
+export declare const getClassMeta: (modelRef: Type) => ConstantClassMeta;
+export declare const getFieldMetas: (modelRef: Type) => ConstantFieldMeta[];
+export declare const getFieldMetaMap: (modelRef: Type) => Map<string, ConstantFieldMeta>;
+export declare const setFieldMetaMap: (modelRef: Type, metadataMap: Map<string, ConstantFieldMeta>) => void;
+export declare const getFieldMetaMapOnPrototype: (prototype: object) => Map<string, ConstantFieldMeta>;
+export declare const setFieldMetaMapOnPrototype: (prototype: object, metadataMap: Map<string, ConstantFieldMeta>) => void;
+export declare const getQueryMap: (modelRef: Type) => {
+    [key: string]: QueryOf<any> | undefined | (() => QueryOf<any>);
+};

package/src/scalar.js

@@ -0,0 +1,97 @@
+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 scalar_exports = {};
+__export(scalar_exports, {
+  fieldTypes: () => fieldTypes,
+  getClassMeta: () => getClassMeta,
+  getFieldMetaMap: () => getFieldMetaMap,
+  getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
+  getFieldMetas: () => getFieldMetas,
+  getGqlTypeStr: () => getGqlTypeStr,
+  getQueryMap: () => getQueryMap,
+  getScalarExample: () => getScalarExample,
+  scalarExampleMap: () => scalarExampleMap,
+  setFieldMetaMap: () => setFieldMetaMap,
+  setFieldMetaMapOnPrototype: () => setFieldMetaMapOnPrototype
+});
+module.exports = __toCommonJS(scalar_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_base = require("@akanjs/base");
+const 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, {}]
+]);
+const getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
+const getGqlTypeStr = (ref) => import_base.scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
+const fieldTypes = ["email", "password", "url"];
+const 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;
+};
+const 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));
+};
+const getFieldMetaMap = (modelRef) => {
+  const [target] = (0, import_base.getNonArrayModel)(modelRef);
+  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+};
+const setFieldMetaMap = (modelRef, metadataMap) => {
+  const [target] = (0, import_base.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])
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fieldTypes,
+  getClassMeta,
+  getFieldMetaMap,
+  getFieldMetaMapOnPrototype,
+  getFieldMetas,
+  getGqlTypeStr,
+  getQueryMap,
+  getScalarExample,
+  scalarExampleMap,
+  setFieldMetaMap,
+  setFieldMetaMapOnPrototype
+});

package/src/types.d.ts

@@ -0,0 +1,91 @@
+import { type BaseObject, Dayjs } from "@akanjs/base";
+import type { FilterQuery, HydratedDocument, ProjectionType } from "mongoose";
+export type { FilterQuery as QueryOf };
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type OptionalKeys<T> = T extends {
+    [key: string]: any;
+} ? {
+    [K in keyof T]-?: null extends T[K] ? K : never;
+}[keyof T] : never;
+type ObjectToId<O, D = Dayjs> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? D : O extends {
+    [key: string]: any;
+} ? DocumentModel<O> : O;
+export interface SortType {
+    [key: string]: {
+        [key: string]: number;
+    };
+}
+export type SortOf<Filter> = keyof GetStateObject<Filter>;
+export type FilterType = Record<string, any>;
+export interface ListQueryOption<Sort, Obj> {
+    skip?: number | null;
+    limit?: number | null;
+    sort?: Sort | null;
+    sample?: number;
+    select?: ProjectionType<Obj>;
+}
+export interface FindQueryOption<Sort, Obj> {
+    skip?: number | null;
+    sort?: Sort | null;
+    sample?: boolean;
+    select?: ProjectionType<Obj>;
+}
+export type DocumentModel<T, D = Dayjs> = T extends (infer S)[] ? DocumentModel<S>[] : T extends string ? T : T extends number ? T : T extends boolean ? T : T extends Dayjs ? T : T extends Map<infer K, infer V> ? Map<K, DocumentModel<V, D>> : Optional<{
+    [K in keyof GetStateObject<T>]: T[K] extends infer S ? S extends null ? undefined : ObjectToId<T[K], D> : never;
+}, OptionalKeys<GetStateObject<T>>>;
+export interface ListOption {
+    limit?: number;
+    skip?: number;
+    sort?: string;
+}
+export declare const defaultListOption: ListOption;
+export type GetPlainObject<T, O extends string> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? never : K extends keyof HydratedDocument<any> ? never : K]: T[K];
+}, O>;
+export type GetStateObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? never : K]: T[K];
+}, "prototype">;
+export type GetActionObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? K : never]: T[K];
+}, "prototype">;
+export interface ProtoFile {
+    id: string;
+    filename: string;
+    abstractData: string | null;
+    imageSize: [number, number];
+    progress: number | null;
+    url: string;
+    size: number;
+    status: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+    mimetype: string;
+    encoding: string;
+    origin: string | null;
+    lastModifiedAt: Dayjs;
+}
+export interface ProtoAppInfo {
+    appId: string | null;
+    appName: string;
+    deviceId: string | null;
+    platform: "ios" | "android" | null;
+    major: number;
+    minor: number;
+    patch: number;
+    branch: string;
+    buildNum: string | null;
+    versionOs: string | null;
+    isEmulator: boolean | null;
+}
+export interface ProtoPatch {
+    source: ProtoFile;
+    build: ProtoFile;
+    appBuild: ProtoFile | null;
+    status: "active" | "expired";
+    at: Dayjs;
+}
+export declare const DEFAULT_PAGE_SIZE = 20;
+export interface TextDoc {
+    [key: string]: string | TextDoc;
+}

package/src/types.js

@@ -0,0 +1,34 @@
+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 types_exports = {};
+__export(types_exports, {
+  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
+  defaultListOption: () => defaultListOption
+});
+module.exports = __toCommonJS(types_exports);
+const defaultListOption = {
+  limit: 20,
+  skip: 0,
+  sort: "latest"
+};
+const DEFAULT_PAGE_SIZE = 20;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PAGE_SIZE,
+  defaultListOption
+});