@akanjs/constant 0.0.39 → 0.0.41

package/index.d.ts

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

package/package.json

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

package/src/baseGql.d.ts

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

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/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/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/filterMeta.d.ts

@@ -0,0 +1,61 @@
+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 isFilterModel: (filterRef: Type) => boolean;
+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 const sortOf: <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>;
+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/index.d.ts

@@ -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.d.ts

@@ -0,0 +1,91 @@
+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 isConstantModel: (modelRef: Type) => boolean;
+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/types.d.ts

@@ -0,0 +1,92 @@
+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;
+}
+export type NonFunctionalKeys<T> = keyof T extends (...any: any[]) => any ? never : keyof T;