@akanjs/signal 0.9.47 → 0.9.49

package/src/fetchInfo.d.ts

@@ -0,0 +1,19 @@
+import { Client } from "./client";
+import { SerializedSignal } from "./signalInfo";
+declare global {
+    var builtFetch: typeof global.fetch & {
+        client: Client;
+    } & {
+        [key: string]: (...args: any[]) => Promise<any>;
+    };
+}
+export declare const serviceFetchOf: <Fetch = {
+    [key: string]: any;
+}>(signal: SerializedSignal) => Fetch;
+export declare const databaseFetchOf: <Fetch = {
+    [key: string]: any;
+}>(signal: SerializedSignal, option?: {
+    overwrite?: {
+        [key: string]: any;
+    };
+}) => Fetch;

package/src/gql.d.ts

@@ -1,24 +1,16 @@
 import { DataList, type GetActionObject, type GetStateObject, type MergeAll, type MergedValues, type Prettify, type PromiseOrObject, Type, Upload } from "@akanjs/base";
 import { FetchPolicy } from "@akanjs/common";
-import { ConstantModel, DefaultOf, DocumentModel, FilterType, ProtoFile, QueryOf, type ScalarConstantModel, SortOf } from "@akanjs/constant";
+import { ConstantModel, DefaultOf, DocumentModel, ProtoFile, QueryOf } from "@akanjs/constant";
+import type { FilterType, SortOf } from "@akanjs/document";
+import { AnyVariables } from "@urql/core";
 import { type Client } from ".";
-import { type ArgMeta, type DefaultSignal, type GqlMeta, type SliceMeta } from "./signalDecorators";
+import { type DefaultSignal, type SliceMeta } from "./signalDecorators";
 export declare class GqlStorage {
 }
-export declare class FragmentStorage {
-}
-export declare class PurifyStorage {
-}
-export declare class DefaultStorage {
-}
-export declare class CrystalizeStorage {
-}
-export type PurifyFunc<Input, _DefaultInput = DefaultOf<Input>, _DocInput = DocumentModel<Input>> = (self: _DefaultInput, isChild?: boolean) => _DocInput | null;
-export type CrystalizeFunc<Model> = (self: GetStateObject<Model>, isChild?: boolean) => Model;
 export interface FetchInitForm<Input, Full, Filter extends FilterType, _DefaultInput = DefaultOf<Input>, _Sort = SortOf<Filter>> {
     page?: number;
     limit?: number;
-    sort?: _Sort | symbol;
+    sort?: _Sort;
     default?: Partial<_DefaultInput>;
     invalidate?: boolean;
     insight?: boolean;
@@ -57,13 +49,6 @@ export type ServerEdit<T extends string, Model> = {
     [K in `${T}ViewAt`]: Date;
 };
 export type ClientEdit<T extends string, Model> = PromiseOrObject<ServerEdit<T, Model>>;
-export type GqlScalarUtil<T extends string, Input, Model, Default, DefaultInput, Doc, DocInput, _CapitalizedT extends string = Capitalize<T>> = {
-    [K in `default${_CapitalizedT}`]: Default;
-} & {
-    [K in `purify${_CapitalizedT}`]: PurifyFunc<Input, DefaultInput, DocInput>;
-} & {
-    [K in `crystalize${_CapitalizedT}`]: CrystalizeFunc<Model>;
-};
 type RemoveLast3<T extends any[]> = T extends [...infer Rest, any, any, any] ? Rest : T;
 export type FilterListArgs<Args extends any[]> = PartialNullableArgs<ConvertArgs<RemoveLast3<FilterInternalArgs<Args>>>>;
 type FetchOption<Input, Full, Filter extends FilterType, _DefaultInput = DefaultOf<Input>, _Sort = SortOf<Filter>> = FetchPolicy & FetchInitForm<Input, Full, Filter, _DefaultInput, _Sort>;
@@ -89,10 +74,6 @@ type InitReturn<T extends string, Light extends {
 type BasicMethods<T extends string, Input, Full, Light extends {
     id: string;
 }, Insight, _CapitalizedT extends string = Capitalize<T>> = {
-    [K in `lightCrystalize${_CapitalizedT}`]: CrystalizeFunc<Light>;
-} & {
-    [K in `default${_CapitalizedT}Insight`]: Insight;
-} & {
     [K in `add${_CapitalizedT}Files`]: (fileList: FileList, parentId?: string, option?: FetchPolicy) => Promise<ProtoFile[]>;
 } & {
     [K in `merge${_CapitalizedT}`]: (modelOrId: Full | string, data: Partial<DocumentModel<Input>>, option?: FetchPolicy) => Promise<Full>;
@@ -139,7 +120,7 @@ export type DbGraphQL<T extends string, Input, Full, Light extends {
 }, Insight, Filter extends FilterType, Fetch, Signal, _CapitalizedT extends string = Capitalize<T>, _Default = DefaultOf<Full>, _DefaultInput = DefaultOf<Input>, _DefaultState = GetStateObject<Full>, _DefaultStateInput = GetStateObject<Input>, _Doc = DocumentModel<Full>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<DocumentModel<Full>>, _Query = GetActionObject<Filter>, _Sort = SortOf<Filter>, _DynamicSliceArgMap = DynamicSliceArgMap<T, Input, Full, Filter, Signal, _CapitalizedT, _DefaultInput, _Sort>> = {
     refName: string;
     slices: SliceMeta[];
-} & GetWsMessageOf<Signal> & GetWsPubsubOf<Signal> & GqlScalarUtil<T, Input, Full, _Default, _DefaultInput, _Doc, _DocInput, _CapitalizedT> & BasicMethods<T, Input, Full, Light, Insight, _CapitalizedT> & ViewEditMethods<T, Full, _CapitalizedT> & InitMethods<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _QueryOfDoc, _DefaultInput, _Sort> & Fetch & DynamicListMethods<T, Input, Full, Light, Insight, Filter, Signal, _CapitalizedT, _DefaultInput, _Sort, _DynamicSliceArgMap>;
+} & GetWsMessageOf<Signal> & GetWsPubsubOf<Signal> & BasicMethods<T, Input, Full, Light, Insight, _CapitalizedT> & ViewEditMethods<T, Full, _CapitalizedT> & InitMethods<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _QueryOfDoc, _DefaultInput, _Sort> & Fetch & DynamicListMethods<T, Input, Full, Light, Insight, Filter, Signal, _CapitalizedT, _DefaultInput, _Sort, _DynamicSliceArgMap>;
 type IsInternalArg<T> = T extends {
     __InternalArg__: any;
 } ? true : false;
@@ -180,41 +161,24 @@ type GenerateSubscribeMethod<Fn> = Fn extends (...args: infer Args) => infer R ?
 export type GetWsPubsubOf<Sig> = {
     [K in keyof Sig as K extends string ? HasMarker<Sig[K], "Subscribe"> extends true ? `subscribe${Capitalize<K>}` : never : never]: GenerateSubscribeMethod<Sig[K]>;
 };
-export declare const scalarUtilOf: <T extends string, Model, _Default, _Doc>(cnst: ScalarConstantModel<T, Model, _Default, _Doc>) => GqlScalarUtil<T, Model, Model, _Default, _Default, _Doc, _Doc>;
 type LightWeightFetch<Fetch, Full, Light> = {
     [K in keyof Fetch]: Fetch[K] extends (...args: infer Args) => Promise<Full[]> ? (...args: Args) => Promise<Light[]> : Fetch[K];
 };
 export declare const getGqlOnStorage: (refName: string) => {
     [key: string]: any;
 };
+export declare const setGqlOnStorage: (refName: string, modelGql: any) => void;
 export declare const gqlOf: <T extends string, Input, Full extends {
     id: string;
 }, Light extends {
     id: string;
-}, Insight, Filter extends FilterType, Signal, _CapitalizedT extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _Doc, _DocInput, _QueryOfDoc, _Query, _Sort, _SignalAction = GetActionObject<Signal>>(constant: ConstantModel<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _Doc, _DocInput, _QueryOfDoc, _Query, _Sort>, sigRef: Type<Signal>, option?: {
+}, Insight, Filter extends FilterType, Signal, _CapitalizedT extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc, _Sort = SortOf<Filter>, _SignalAction = GetActionObject<Signal>>(constant: ConstantModel<T, Input, Full, Light, Insight, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc>, filterRef: Type<Filter>, sigRef: Type<Signal>, option?: {
     overwrite?: {
         [key: string]: any;
     };
-}) => DbGraphQL<T, Input, Full, Light, Insight, Filter, LightWeightFetch<GetQueryMutationOf<_SignalAction & DefaultSignal<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _DocInput, _QueryOfDoc, _Sort>, Full>, Full, Light>, _SignalAction, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _Doc, _DocInput, _QueryOfDoc, _Sort>;
-export declare const makeDefault: <T>(target: Type<T>, option?: {
-    isChild?: boolean;
-    overwrite?: any;
-}) => DefaultOf<T>;
-export declare const makePurify: <I>(target: Type<I>, option?: {
-    overwrite?: any;
-}) => PurifyFunc<I>;
-export declare const makeCrystalize: <M>(target: Type<M>, option?: {
-    overwrite?: any;
-    partial?: string[];
-}) => CrystalizeFunc<M>;
-export declare const makeFragment: (target: Type, option?: {
-    overwrite?: any;
-    excludeSelf?: boolean;
-    partial?: string[];
-}) => string;
-export declare const getGqlStr: (modelRef: Type, gqlMeta: GqlMeta, argMetas: ArgMeta[], returnRef: Type, partial?: string[]) => string;
-export declare const serializeArg: (argMeta: ArgMeta, value: any) => object[] | null;
-export declare const deserializeArg: (argMeta: ArgMeta, value: any) => object[] | null;
+}) => DbGraphQL<T, Input, Full, Light, Insight, Filter, LightWeightFetch<GetQueryMutationOf<_SignalAction & DefaultSignal<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _PurifiedInput, _QueryOfDoc, _Sort>, Full>, Full, Light>, _SignalAction, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _Doc, _DocInput, _QueryOfDoc, _Sort>;
+export declare const query: <Query = any>(fetchClient: Client, query: string, variables?: AnyVariables, option?: FetchPolicy) => Promise<NonNullable<Query> | undefined>;
+export declare const mutate: <Mutation = any>(fetchClient: Client, mutation: string, variables?: AnyVariables, option?: FetchPolicy) => Promise<NonNullable<Mutation> | undefined>;
 export declare const fetchOf: <Signal, _SignalAction = GetActionObject<Signal>>(sigRef: Type<Signal>) => GetWsMessageOf<_SignalAction> & GetWsPubsubOf<_SignalAction> & GetQueryMutationOf<_SignalAction>;
 type CustomFetch<T> = Omit<T, "client" | "clone"> & {
     client: Client;
@@ -222,5 +186,5 @@ type CustomFetch<T> = Omit<T, "client" | "clone"> & {
         jwt: string | null;
     }) => CustomFetch<T>;
 };
-export declare const makeFetch: <Fetches extends object[]>(...fetches: [...Fetches]) => Prettify<CustomFetch<MergeAll<Fetches>>>;
+export declare const makeFetch: <Fetches extends object[]>(...fetches: Fetches) => Prettify<CustomFetch<MergeAll<Fetches>>>;
 export {};

package/src/graphql.d.ts

@@ -0,0 +1,9 @@
+import { Type } from "@akanjs/base";
+import { SerializedEndpoint } from ".";
+export declare const makeFragment: (modelRef: Type, option?: {
+    overwrite?: any;
+    excludeSelf?: boolean;
+    partial?: string[];
+}) => string;
+export declare const getGqlStr: (modelRef: Type, key: string, endpoint: SerializedEndpoint, returnRef: Type, partial?: string[]) => string;
+export declare function graphql(literals: string | readonly string[], ...args: any[]): string;

package/src/index.d.ts

@@ -6,3 +6,8 @@ export * from "./doc";
 export * from "./baseFetch";
 export * from "./base.signal";
 export * from "./fetch";
+export * from "./signalInfo";
+export * from "./apiInfo";
+export * from "./sliceInfo";
+export * from "./fetchInfo";
+export * from "./graphql";

package/src/internalApiInfo.d.ts

@@ -0,0 +1,74 @@
+import { JSON, PromiseOrObject, Type, UnType } from "@akanjs/base";
+import { ConstantFieldTypeInput, DocumentModel, FieldToValue, PlainTypeToFieldType } from "@akanjs/constant";
+import { GetInternalArg } from "./apiInfo";
+import { ArgType, InternalArgType, Job, SignalOption } from "./signalDecorators";
+type InternalApiType = "resolveField" | "interval" | "cron" | "timeout" | "init" | "destroy" | "process";
+interface InternalApiArgProps<Nullable extends boolean = false> {
+    nullable?: Nullable;
+}
+export declare class InternalApiInfo<ReqType extends InternalApiType, Srvs extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, Args extends any[] = [], InternalArgs extends any[] = [], Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Parent extends DocumentModel<any> = DocumentModel<any>, Nullable extends boolean = false> {
+    #private;
+    readonly type: ReqType;
+    readonly args: {
+        type: Extract<ArgType, "Msg">;
+        name: string;
+        argRef: any;
+        option?: InternalApiArgProps<boolean>;
+    }[];
+    readonly internalArgs: {
+        type: InternalArgType;
+        option?: InternalApiArgProps<boolean>;
+    }[];
+    readonly returnRef: Returns;
+    readonly signalOption: SignalOption<Returns, Nullable>;
+    execFn: ((...args: [...Args, ...InternalArgs]) => any) | null;
+    constructor(type: ReqType, returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>);
+    msg<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, Nullable extends boolean = false, _FieldToValue = FieldToValue<Arg>>(name: string, argRef: Arg, option?: InternalApiArgProps<Nullable>): InternalApiInfo<ReqType, Srvs, [...Args, arg: _FieldToValue | (Nullable extends true ? undefined : never)], InternalArgs, Returns, Parent, Nullable>;
+    with<ArgType extends InternalArgType, Nullable extends boolean = false>(argType: ArgType, option?: InternalApiArgProps<Nullable>): InternalApiInfo<ReqType, Srvs, Args, [...InternalArgs, arg: ArgType extends "Job" ? Job : ArgType extends "Parent" ? Parent : GetInternalArg<ArgType> | (Nullable extends true ? null : never)], Returns, Parent, Nullable>;
+    exec(query: (this: {
+        [K in keyof Srvs as K extends string ? Uncapitalize<K> : never]: Srvs[K];
+    }, ...args: [...Args, ...InternalArgs]) => ReqType extends "process" | "resolveField" ? PromiseOrObject<DocumentModel<FieldToValue<Returns>> | (Nullable extends true ? null : never)> : PromiseOrObject<void>): this;
+    applyApiMeta(sigRef: Type, key: string): void;
+}
+export declare const makeInternalApiBuilder: <Srvs extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, Parent extends DocumentModel<any> = DocumentModel<any>>() => {
+    resolveField: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: Pick<SignalOption<Returns, Nullable>, "nullable">) => InternalApiInfo<"resolveField", Srvs, [], [], Returns, Parent, Nullable>;
+    interval: <Nullable_2 extends boolean = false>(scheduleTime: number, signalOption?: SignalOption<typeof JSON, Nullable_2>) => InternalApiInfo<"interval", Srvs, [], [], typeof JSON, Parent, Nullable_2>;
+    cron: <Nullable_2 extends boolean = false>(scheduleCron: string, signalOption?: SignalOption<typeof JSON, Nullable_2>) => InternalApiInfo<"cron", Srvs, [], [], typeof JSON, Parent, Nullable_2>;
+    timeout: <Nullable_2 extends boolean = false>(timeout: number, signalOption?: SignalOption<typeof JSON, Nullable_2>) => InternalApiInfo<"timeout", Srvs, [], [], typeof JSON, Parent, Nullable_2>;
+    initialize: <Nullable_2 extends boolean = false>(signalOption?: SignalOption<typeof JSON, Nullable_2>) => InternalApiInfo<"init", Srvs, [], [], typeof JSON, Parent, Nullable_2>;
+    destroy: <Nullable_2 extends boolean = false>(signalOption?: SignalOption<typeof JSON, Nullable_2>) => InternalApiInfo<"destroy", Srvs, [], [], typeof JSON, Parent, Nullable_2>;
+    process: <Returns extends ConstantFieldTypeInput, Nullable_1 extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable_1>) => InternalApiInfo<"process", Srvs, [], [], Returns, Parent, Nullable_1>;
+};
+export type BuildInternalApiSignal<SigBuilder extends InternalApiBuilder<any>, _ApiMap = ReturnType<SigBuilder>> = {
+    [K in keyof _ApiMap as _ApiMap[K] extends InternalApiInfo<"process", any, any, any, any, any, any> ? K : never]: _ApiMap[K] extends InternalApiInfo<infer ReqType, any, infer Args, any, infer Returns, any, infer Nullable> ? (...args: Args) => ReqType extends "process" ? Promise<(FieldToValue<Returns> | (Nullable extends true ? null : never)) & {
+        __Returns__: "Done";
+    }> : never : never;
+};
+export type InternalApiBuilder<Srvs extends {
+    [key: string]: Type;
+} = {
+    [key: string]: Type;
+}, Parent extends DocumentModel<any> = DocumentModel<any>, _ThisSrvs extends {
+    [key: string]: any;
+} = {
+    [K in keyof Srvs as K extends string ? Uncapitalize<K> : never]: UnType<Srvs[K]>;
+}> = (builder: {
+    resolveField: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: Pick<SignalOption<Returns, Nullable>, "nullable">) => InternalApiInfo<"resolveField", _ThisSrvs, [], [], Returns, Parent, Nullable>;
+    interval: <Nullable extends boolean = false>(scheduleTime: number, signalOption?: SignalOption<typeof JSON, Nullable>) => InternalApiInfo<"interval", _ThisSrvs, [], [], typeof JSON, Parent, Nullable>;
+    cron: <Nullable extends boolean = false>(scheduleCron: string, signalOption?: SignalOption<typeof JSON, Nullable>) => InternalApiInfo<"cron", _ThisSrvs, [], [], typeof JSON, Parent, Nullable>;
+    timeout: <Nullable extends boolean = false>(timeout: number, signalOption?: SignalOption<typeof JSON, Nullable>) => InternalApiInfo<"timeout", _ThisSrvs, [], [], typeof JSON, Parent, Nullable>;
+    initialize: <Nullable extends boolean = false>(signalOption?: SignalOption<typeof JSON, Nullable>) => InternalApiInfo<"init", _ThisSrvs, [], [], typeof JSON, Parent, Nullable>;
+    destroy: <Nullable extends boolean = false>(signalOption?: SignalOption<typeof JSON, Nullable>) => InternalApiInfo<"destroy", _ThisSrvs, [], [], typeof JSON, Parent, Nullable>;
+    process: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>) => InternalApiInfo<"process", _ThisSrvs, [], [], Returns, Parent, Nullable>;
+}) => {
+    [key: string]: InternalApiInfo<any, any, any, any, any, any, any>;
+};
+export {};

package/src/signalDecorators.d.ts

@@ -1,15 +1,21 @@
 import "reflect-metadata";
-import { BaseObject, Dayjs, Enum, Environment, SingleFieldType, Type } from "@akanjs/base";
-import { ConstantModel, DocumentModel, FilterType, QueryOf, ReturnType, SortOf } from "@akanjs/constant";
+import { BaseObject, Dayjs, Enum, Environment, type MergeAllActionTypes, SingleFieldType, Type, UnType } from "@akanjs/base";
+import { ConstantModel, DocumentModel, GqlReturn, PurifiedModel, QueryOf } from "@akanjs/constant";
+import type { Doc, FilterType, SortOf } from "@akanjs/document";
+import type { ServiceModule } from "@akanjs/service";
 import type { Job as BullJob } from "bull";
 import type { Request as ExpressRequest, Response as ExpressResponse } from "express";
 import type { Socket } from "socket.io";
+import { BuildSliceSignal, SliceApiBuilder } from ".";
+import { type ApiBuilder, type BuildApiSignal } from "./apiInfo";
+import { BuildInternalApiSignal, InternalApiBuilder } from "./internalApiInfo";
 export declare const ssoTypes: readonly ["github", "google", "facebook", "apple", "naver", "kakao"];
 export type SSOType = (typeof ssoTypes)[number];
 export declare class SignalStorage {
 }
 export declare const getAllSignalRefs: () => Type[];
 export declare const getSignalRefsOnStorage: (refName: string) => Type[];
+export declare const setSignalRefOnStorage: (refName: string, signalRef: Type) => void;
 export type Resolve<T> = T;
 export declare const resolve: <T>(data: any) => Resolve<T>;
 export declare const emit: <T>(data: any) => Resolve<T> & {
@@ -32,8 +38,8 @@ interface TimerOption {
     lock?: boolean;
     enabled?: boolean;
 }
-export interface SignalOption<Response = any> extends InitOption, TimerOption {
-    nullable?: boolean;
+export interface SignalOption<Response = any, Nullable extends boolean = false, _Key = keyof UnType<Response>> extends InitOption, TimerOption {
+    nullable?: Nullable;
     name?: string;
     default?: boolean;
     path?: string;
@@ -41,7 +47,7 @@ export interface SignalOption<Response = any> extends InitOption, TimerOption {
     sso?: SSOType;
     serverMode?: "federation" | "batch" | "all";
     timeout?: number;
-    partial?: (keyof Response)[] | readonly (keyof Response)[];
+    partial?: _Key[] | readonly _Key[];
     cache?: number;
     scheduleType?: "init" | "destroy" | "cron" | "interval" | "timeout";
     scheduleCron?: string;
@@ -50,14 +56,14 @@ export interface SignalOption<Response = any> extends InitOption, TimerOption {
     enabled?: boolean;
 }
 export interface ResolveFieldMeta {
-    returns: ReturnType;
+    returns: GqlReturn;
     argsOption: ArgsOption;
     key: string;
     descriptor: PropertyDescriptor;
 }
 export declare const signalTypes: readonly ["graphql", "restapi"];
 export type SignalType = (typeof signalTypes)[number];
-export declare const endpointTypes: readonly ["Query", "Mutation", "Message", "Pubsub", "Process", "Schedule"];
+export declare const endpointTypes: readonly ["Query", "Mutation", "Message", "Pubsub", "Process", "Schedule", "ResolveField"];
 export type EndpointType = (typeof endpointTypes)[number];
 export declare const guardTypes: readonly ["Public", "None", "User", "Admin", "SuperAdmin", "Every", "Owner"];
 export type GuardType = (typeof guardTypes)[number];
@@ -69,7 +75,7 @@ export declare const internalArgTypes: readonly ["Account", "Me", "Self", "UserI
 export type InternalArgType = (typeof internalArgTypes)[number];
 export interface GqlMeta {
     returns: (of?: any) => Type;
-    signalOption: SignalOption;
+    signalOption: SignalOption<any, any, any>;
     key: string;
     descriptor: PropertyDescriptor;
     guards: GuardType[];
@@ -78,11 +84,11 @@ export interface GqlMeta {
 export interface ArgsOption {
     nullable?: boolean;
     example?: string | number | boolean | Dayjs;
-    enum?: Enum<string | number>;
+    enum?: Enum;
 }
 export interface ArgMeta {
     name: string;
-    returns: ReturnType;
+    returns: GqlReturn;
     argsOption: ArgsOption;
     key: string;
     idx: number;
@@ -102,17 +108,14 @@ export interface SliceMeta {
     argLength: number;
     defaultArgs: any[];
 }
+export declare const getDefaultArg: (argRef: Type | Type[]) => object;
 export interface SignalMeta {
     refName: string;
     slices: SliceMeta[];
     returns?: (of?: any) => Type;
     prefix?: string;
+    enabled: boolean;
 }
-interface SignalDecoratorInput {
-    name: string;
-    prefix?: string;
-}
-export declare function Signal(returnsOrObj: (() => Type) | SignalDecoratorInput): (target: Type) => void;
 export declare const createArgMetaDecorator: (type: InternalArgType) => (option?: {
     nullable?: boolean;
 }) => (prototype: object, key: string, idx: number) => void;
@@ -212,7 +215,7 @@ export declare const Job: (option?: {
 export type Job = {
     __InternalArg__: "Job";
 } & BullJob;
-type Guard = <Response extends SingleFieldType>(returns: ReturnType<Response>, signalOption?: SignalOption<UnType<Response>>, guards?: GuardType[]) => MethodDecorator;
+type Guard = <Response extends SingleFieldType>(returns: GqlReturn<Response>, signalOption?: SignalOption<UnType<Response>>, guards?: GuardType[]) => MethodDecorator;
 export declare const Query: {
     Public: Guard;
     Every: Guard;
@@ -261,20 +264,57 @@ export declare const Schedule: {
     Timeout: (timeout: number, options?: TimerOption) => MethodDecorator;
     Destroy: (options?: InitOption) => MethodDecorator;
 };
-export declare function ResolveField(returns: ReturnType, argsOption?: ArgsOption): (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare function ResolveField(returns: GqlReturn, argsOption?: ArgsOption): (target: any, key: string, descriptor: PropertyDescriptor) => void;
 export declare const Arg: {
-    Body: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
-    Param: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
-    Query: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
-    Upload: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
-    Msg: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
-    Room: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Body: (name: string, returns: GqlReturn, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Param: (name: string, returns: GqlReturn, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Query: (name: string, returns: GqlReturn, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Upload: (name: string, returns: GqlReturn, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Msg: (name: string, returns: GqlReturn, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Room: (name: string, returns: GqlReturn, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
 };
 export declare function Parent(): (prototype: object, key: string, idx: number) => void;
-export declare function LogSignal<Srv>(srv: Srv): Type<{ [K in keyof Srv as K extends string ? Uncapitalize<K> : never]: Srv[K]; }>;
-type UnType<Class> = Class extends Type<infer T> ? T : never;
-export type DefaultSignal<T extends string, Input, Full, Light, Insight, Filter extends FilterType, _CapitalizedT extends string = Capitalize<T>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<DocumentModel<Full>>, _Sort = SortOf<Filter>> = DefaultSignalWithQuerySort<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _DocInput, _QueryOfDoc, _Sort>;
-type DefaultSignalWithQuerySort<T extends string, Input, Full, Light, Insight, Filter, _CapitalizedT extends string = Capitalize<T>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<DocumentModel<Full>>, _Sort = SortOf<Filter>> = {
+interface SigOptionV2 {
+    guards?: {
+        get: GuardType;
+        cru: GuardType;
+    };
+    prefix?: string;
+}
+type ExtendedGqlReturn<Return, Input, Full, Light, Insight> = Full extends Return ? Full : Full[] extends Return ? Full[] : Light extends Return ? Light : Light[] extends Return ? Light[] : Insight extends Return ? Insight : Return;
+type ExtendSignals<Input, Full, Light, Insight, LibSignals extends Type[], _Endpoints = MergeAllActionTypes<LibSignals>> = {
+    [K in keyof _Endpoints as _Endpoints[K] extends (...args: any) => any ? K : never]: _Endpoints[K] extends (...args: infer Args) => Promise<infer Return & {
+        __Returns__?: infer Rts;
+    }> ? (...args: Args) => Promise<ExtendedGqlReturn<Return, Input, Full, Light, Insight> & (Rts extends unknown ? unknown : {
+        __Returns__: Rts;
+    })> : _Endpoints[K] extends (...args: infer Args) => infer Return & {
+        __Returns__?: infer Rts;
+    } ? (...args: Args) => ExtendedGqlReturn<Return, Input, Full, Light, Insight> & (Rts extends unknown ? unknown : {
+        __Returns__: Rts;
+    }) : never;
+};
+export interface SrvOption<T extends string, Srv extends {
+    [key: string]: Type;
+}, Input = never, Full = never, Light = never, Insight = never> {
+    ref: T;
+    srv: Srv;
+    cnst?: ConstantModel<T, Input, Full, Light, Insight>;
+}
+export declare function internal<Srv extends {
+    [key: string]: any;
+}, Full, InternalBuilder extends InternalApiBuilder<Srv, Doc<Full>>, LibInternals extends Type[]>(srv: ServiceModule<string, Srv, any, Full, any, any>, internalBuilder: InternalBuilder, ...libInternals: LibInternals): Type<BuildInternalApiSignal<InternalBuilder> & ExtendSignals<any, Full, any, any, LibInternals>>;
+export declare function slice<T extends string, Input, Full extends BaseObject & {
+    status: string;
+}, Light extends BaseObject, Insight extends {
+    count: number;
+}, Srv extends {
+    [key: string]: any;
+}, SliceBuilder extends SliceApiBuilder<Full, Light, Insight, Srv>, LibSlices extends Type[]>(srv: ServiceModule<T, Srv, Input, Full, Light, Insight>, option: SigOptionV2, sliceBuilder: SliceBuilder, ...libSlices: LibSlices): Type<BuildSliceSignal<T, SliceBuilder, Full, Light, Insight> & ExtendSignals<Input, Full, Light, Insight, LibSlices>>;
+export declare function endpoint<Input, Full, Light, Insight, Srv extends {
+    [key: string]: any;
+}, Builder extends ApiBuilder<Srv>, LibSignals extends Type[]>(srv: ServiceModule<string, Srv, Input, Full, Light, Insight>, builder: Builder, ...libSignals: LibSignals): Type<BuildApiSignal<Builder> & ExtendSignals<Input, Full, Light, Insight, LibSignals>>;
+export declare const mergeSignals: <Endpoint, Internal, Slice = unknown>(signalRef: Type<Endpoint>, internalRef: Type<Internal>, sliceRef?: Type<Slice>) => Type<Endpoint & Internal & Slice>;
+export type DefaultSignal<T extends string, Input, Full, Light, Insight, Filter extends FilterType, _CapitalizedT extends string = Capitalize<T>, _PurifiedInput = PurifiedModel<Input>, _QueryOfDoc = QueryOf<DocumentModel<Full>>, _Sort = SortOf<Filter>> = {
     [K in T]: (id: string) => Promise<Full>;
 } & {
     [K in `light${_CapitalizedT}`]: (id: string) => Promise<Light>;
@@ -283,32 +323,21 @@ type DefaultSignalWithQuerySort<T extends string, Input, Full, Light, Insight, F
 } & {
     [K in `${T}Insight`]: (query: _QueryOfDoc) => Promise<Insight>;
 } & {
-    [K in `${T}Exists`]: (query: _QueryOfDoc) => Promise<boolean>;
-} & {
-    [K in `create${_CapitalizedT}`]: (data: _DocInput, account: Account) => Promise<Full>;
+    [K in `create${_CapitalizedT}`]: (data: _PurifiedInput, account: Account) => Promise<Full>;
 } & {
-    [K in `update${_CapitalizedT}`]: (id: string, data: _DocInput, account: Account) => Promise<Full>;
+    [K in `update${_CapitalizedT}`]: (id: string, data: _PurifiedInput, account: Account) => Promise<Full>;
 } & {
     [K in `remove${_CapitalizedT}`]: (id: string, account: Account) => Promise<Full>;
 };
-export declare function DbSignal<Srv>(constant: ConstantModel<string, any, BaseObject & {
-    status: string;
-}, BaseObject, {
-    count: number;
-}, any>, srv: Srv, option: {
-    guards: {
-        get: Guard;
-        cru: Guard;
-    };
-    omit?: ("get" | "list" | "insight" | "exist" | "create" | "update" | "remove")[];
-}): Type<{ [K in keyof Srv as K extends string ? Uncapitalize<K> : never]: Srv[K]; }>;
 export declare const getSigMeta: (sigRef: Type) => SignalMeta;
+export declare const setSigMeta: (sigRef: Type, sigMeta: SignalMeta) => void;
 export declare const getGqlMeta: (sigRef: Type, key: string) => GqlMeta;
 export declare const getGqlMetaMapOnPrototype: (prototype: object) => Map<string, GqlMeta>;
 export declare const getGqlMetas: (sigRef: Type) => GqlMeta[];
 export declare const setGqlMetaMapOnPrototype: (prototype: object, gqlMetaMap: Map<string, GqlMeta>) => void;
 export declare const getArgMetas: (sigRef: Type, key: string) => [ArgMeta[], InternalArgMeta[]];
 export declare const setArgMetas: (sigRef: Type, key: string, argMetas: ArgMeta[], internalArgMetas: InternalArgMeta[]) => void;
+export declare const getResolveFieldMetaMapOnPrototype: (prototype: object) => Map<string, ResolveFieldMeta>;
 export declare const getResolveFieldMetas: (sigRef: Type) => ResolveFieldMeta[];
 export declare const getControllerPrefix: (sigMeta: SignalMeta) => string | undefined;
 export declare const getControllerPath: (gqlMeta: GqlMeta, paramArgMetas: ArgMeta[]) => string;

package/src/signalInfo.d.ts

@@ -0,0 +1,78 @@
+import { GqlScalarName, Type } from "@akanjs/base";
+import { ArgsOption, ArgType, SignalOption, SliceMeta } from "./signalDecorators";
+export declare const signalInfo: {
+    database: Map<string, Type>;
+    service: Map<string, Type>;
+    serializedSignals: SerializedSignal[];
+    setDatabase(refName: string, signal: Type): void;
+    getDatabase(refName: string): Type | undefined;
+    setRefNameTemp(sigRef: Type, refName: string): void;
+    getRefNameTemp(sigRef: Type): string;
+    setPrefixTemp(sigRef: Type, prefix: string): void;
+    getPrefixTemp(sigRef: Type): string | undefined;
+    setHandlerKey(execFn: (...args: any) => any, key: string): void;
+    getHandlerKey(execFn: (...args: any) => any): string;
+    setService(refName: string, signal: Type): void;
+    getService(refName: string): Type | undefined;
+    registerSignals<Signals extends Type[]>(...signals: Signals): Signals;
+    serialize(sigRef: Type): SerializedSignal;
+    initialize(): object;
+    buildFetch(signals?: SerializedSignal[], cnstInfo?: {
+        database: Map<string, import("@akanjs/constant").ConstantModel<any, any, any, any, any, any, import("@akanjs/constant").DefaultOf<any>, import("@akanjs/constant").DefaultOf<any>, import("@akanjs/base").GetStateObject<any>, import("@akanjs/base").GetStateObject<any>, import("@akanjs/constant").DefaultOf<any>, any, any, any, import("mongoose").FilterQuery<any>>>;
+        scalar: Map<string, import("@akanjs/constant").ScalarConstantModel<any, any, any, any, any>>;
+        modelRefNameMap: Map<Type, string>;
+        getRefName<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
+            allowEmpty?: AllowEmpty;
+        }): AllowEmpty extends true ? string | undefined : string;
+        getModelType<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
+            allowEmpty?: AllowEmpty;
+        }): AllowEmpty extends true ? import("@akanjs/constant").ModelType | undefined : import("@akanjs/constant").ModelType;
+        setModelType(modelRef: Type, modelType: import("@akanjs/constant").ModelType): void;
+        isObject(modelRef: Type): boolean;
+        isFull(modelRef: Type): boolean;
+        isLight(modelRef: Type): boolean;
+        isInsight(modelRef: Type): boolean;
+        isFilter(modelRef: Type): boolean;
+        isScalar(modelRef: Type): boolean;
+        setDatabase(refName: string, cnst: import("@akanjs/constant").ConstantModel<any, any, any, any, any, any>): void;
+        getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+            allowEmpty?: AllowEmpty;
+        }): AllowEmpty extends true ? import("@akanjs/constant").ConstantModel<any, any, any, any, any, any> | undefined : import("@akanjs/constant").ConstantModel<any, any, any, any, any, any>;
+        setScalar(refName: string, cnst: import("@akanjs/constant").ScalarConstantModel<any, any, any, any, any>): void;
+        getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+            allowEmpty?: AllowEmpty;
+        }): AllowEmpty extends true ? import("@akanjs/constant").ScalarConstantModel<any, any, any, any, any> | undefined : import("@akanjs/constant").ScalarConstantModel<any, any, any, any, any>;
+        getModelRef(refName: string, modelType: "input" | "full" | "light" | "insight" | "scalar"): Type | import("@akanjs/base").GqlScalar;
+    }): object;
+    registerClient: (cnst: any) => Promise<{
+        fetch: typeof fetch;
+        signals: SerializedSignal[];
+    }>;
+};
+export interface SerializedReturns {
+    refName: Exclude<GqlScalarName, "Map" | "Upload"> | (string & {});
+    modelType: "input" | "full" | "light" | "insight" | "scalar";
+    arrDepth: number;
+}
+export interface SerializedArg {
+    type: ArgType;
+    refName: Exclude<GqlScalarName, "Map"> | (string & {});
+    modelType: "input" | "insight" | "scalar";
+    name: string;
+    argsOption: ArgsOption;
+    arrDepth: number;
+}
+export interface SerializedEndpoint {
+    type: "query" | "mutation" | "pubsub" | "message";
+    signalOption?: SignalOption<any, any, any>;
+    returns: SerializedReturns;
+    args: SerializedArg[];
+}
+export interface SerializedSignal {
+    refName: string;
+    slices: SliceMeta[];
+    prefix?: string;
+    endpoint: {
+        [key: string]: SerializedEndpoint;
+    };
+}

package/src/sliceInfo.d.ts

@@ -0,0 +1,68 @@
+import { BaseObject, PromiseOrObject, Type, UnType } from "@akanjs/base";
+import { ConstantFieldTypeInput, DocumentModel, FieldToValue, ParamFieldType, PlainTypeToFieldType, PurifiedModel, QueryOf } from "@akanjs/constant";
+import { ApiArgProps } from "./apiInfo";
+import { Access, Account, ArgType, GuardType, InternalArgType, Job, Me, Req, Res, Self, SignalOption, UserIp, Ws } from "./signalDecorators";
+export declare class SliceInfo<Full extends BaseObject, Light extends BaseObject, Insight extends {
+    count: number;
+}, Srvs extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, Args extends any[] = [], InternalArgs extends any[] = [], ServerArgs extends any[] = []> {
+    readonly full: Type<Full>;
+    readonly light: Type<Light>;
+    readonly insight: Type<Insight>;
+    readonly args: {
+        type: ArgType;
+        name: string;
+        argRef: ConstantFieldTypeInput;
+        option?: ApiArgProps<boolean>;
+    }[];
+    readonly internalArgs: {
+        type: InternalArgType;
+        option?: ApiArgProps<boolean>;
+    }[];
+    readonly signalOption: SignalOption;
+    readonly guards: GuardType[];
+    execFn: ((...args: [...ServerArgs, ...InternalArgs]) => QueryOf<DocumentModel<Full>>) | null;
+    constructor(full: Type<Full>, light: Type<Light>, insight: Type<Insight>, signalOptionOrGuard?: SignalOption | GuardType, ...guards: GuardType[]);
+    param<Arg extends ParamFieldType, _ClientArg = FieldToValue<Arg>, _ServerArg = DocumentModel<_ClientArg>>(name: string, argRef: Arg, option?: Omit<ApiArgProps, "nullable">): SliceInfo<Full, Light, Insight, Srvs, [...Args, arg: _ClientArg], InternalArgs, [...ServerArgs, arg: _ServerArg]>;
+    body<ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: string, argRef: Arg, option?: ApiArgProps): SliceInfo<Full, Light, Insight, Srvs, [...Args, arg: _ClientArg], InternalArgs, [...ServerArgs, arg: _ServerArg]>;
+    search<ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: string, argRef: Arg, option?: Omit<ApiArgProps, "nullable">): SliceInfo<Full, Light, Insight, Srvs, [...Args, arg: _ClientArg | null], InternalArgs, [...ServerArgs, arg: _ServerArg | undefined]>;
+    with<ArgType extends InternalArgType>(argType: Exclude<ArgType, "Parent">, option?: ApiArgProps): SliceInfo<Full, Light, Insight, Srvs, Args, [...InternalArgs, arg: ArgType extends "Account" ? Account : ArgType extends "Me" ? Me : ArgType extends "Self" ? Self : ArgType extends "UserIp" ? UserIp : ArgType extends "Access" ? Access : ArgType extends "Req" ? Req : ArgType extends "Res" ? Res : ArgType extends "Ws" ? Ws : ArgType extends "Job" ? Job : never], ServerArgs>;
+    exec(query: (this: {
+        [K in keyof Srvs as K extends string ? Uncapitalize<K> : never]: Srvs[K];
+    }, ...args: [...ServerArgs, ...InternalArgs]) => PromiseOrObject<QueryOf<DocumentModel<Full>>>): this;
+    applySliceMeta(refName: string, sigRef: Type, key: string): void;
+}
+export type BuildSliceSignal<T extends string, SliceBuilder extends SliceApiBuilder<any, any, any>, Full extends BaseObject = BaseObject, Light extends BaseObject = BaseObject, Insight extends {
+    count: number;
+} = {
+    count: number;
+}, _Query extends QueryOf<DocumentModel<Full>> = QueryOf<DocumentModel<Full>>, _ApiMap = ReturnType<SliceBuilder>> = {
+    [K in `${T}List`]: (query: _Query | null, skip: number | null, limit: number | null, sort: string | null) => Promise<Full[]>;
+} & {
+    [K in `${T}Insight`]: (query: _Query) => Promise<Insight>;
+} & {
+    [K in keyof _ApiMap as `${T}List${Capitalize<K & string>}`]: _ApiMap[K] extends SliceInfo<infer Full, any, infer Insight, any, infer Args, any, any> ? (...args: [...Args, skip: number | null, limit: number | null, sort: string | null]) => Promise<Full[]> : never;
+} & {
+    [K in keyof _ApiMap as `${T}Insight${Capitalize<K & string>}`]: _ApiMap[K] extends SliceInfo<any, any, infer Insight, any, infer Args, any, any> ? (...args: Args) => Promise<Insight> : never;
+};
+export declare const sliceInit: <Full extends BaseObject, Light extends BaseObject, Insight extends {
+    count: number;
+}, Srvs extends {
+    [key: string]: any;
+}>(full: Type<Full>, light: Type<Light>, insight: Type<Insight>) => (signalOptionOrGuard?: SignalOption | GuardType, ...guards: GuardType[]) => SliceInfo<Full, Light, Insight, Srvs, [], [], []>;
+export type SliceApiBuilder<Full extends BaseObject, Light extends BaseObject, Insight extends {
+    count: number;
+}, Srvs extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, _ThisSrvs extends {
+    [key: string]: any;
+} = {
+    [K in keyof Srvs as K extends string ? Uncapitalize<K> : never]: UnType<Srvs[K]>;
+}> = (init: (signalOptionOrGuard?: SignalOption | GuardType, ...guards: GuardType[]) => SliceInfo<Full, Light, Insight, _ThisSrvs>) => {
+    [key: string]: SliceInfo<any, any, any, any, any, any>;
+};