akanjs 2.2.4 → 2.2.6

package/types/document/databaseRegistry.d.ts

@@ -0,0 +1,36 @@
+import type { ConstantCls } from "akanjs/constant";
+import type { DatabaseCls, ExtractSort, FilterCls, FilterInstance } from ".";
+import type { ModelCls } from "./loaderInfo.d.ts";
+export interface DatabaseModel<T extends string = string, Input = any, Doc = any, Model = any, Obj = any, Insight = any, Filter extends FilterInstance = any, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>> {
+    refName: T;
+    input: DatabaseCls<Input>;
+    doc: DatabaseCls<Doc>;
+    model: ModelCls<Model>;
+    filter: FilterCls<Filter>;
+    obj: ConstantCls<Obj>;
+    insight: ConstantCls<Insight>;
+    _Input: Input;
+    _Doc: Doc;
+    _Model: Model;
+    _Obj: Obj;
+    _Insight: Insight;
+    _Filter: Filter;
+    _Sort: _Sort;
+}
+export declare class DatabaseRegistry {
+    #private;
+    static isInput(modelRef: DatabaseCls): boolean;
+    static isDoc(modelRef: DatabaseCls): boolean;
+    static isModel(modelRef: DatabaseCls): boolean;
+    static isScalar(modelRef: DatabaseCls): boolean;
+    static setDatabase(refName: string, dbModel: DatabaseModel): DatabaseModel<string, any, any, any, any, any, any, string | number | symbol>;
+    static getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? DatabaseModel | undefined : DatabaseModel;
+    static setScalar(refName: string, Model: DatabaseCls): void;
+    static getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? DatabaseCls | undefined : DatabaseCls;
+    static buildModel<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>>(refName: T, input: DatabaseCls<Input>, doc: DatabaseCls<Doc>, model: ModelCls<Model>, obj: ConstantCls<Obj>, insight: ConstantCls<Insight>, filter: FilterCls<Filter>): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Sort>;
+    static buildScalar<T extends string, Model>(refName: T, Model: DatabaseCls<Model>): DatabaseCls<Model>;
+}

package/types/document/documentQuery.d.ts

@@ -0,0 +1,105 @@
+import { type Dayjs } from "akanjs/base";
+export type DocumentId = string & {
+    readonly __brand: "DocumentId";
+};
+export declare const createDocumentId: (now?: number) => DocumentId;
+export declare const isDocumentId: (value: unknown) => value is DocumentId;
+export type DocumentPrimitive = string | number | boolean | null | Dayjs | Date;
+export type DocumentPath<T = any> = Extract<keyof T, string> | (string & {});
+export type DocumentQueryNode = {
+    kind: "all";
+    queries: DocumentQuery[];
+} | {
+    kind: "any";
+    queries: DocumentQuery[];
+} | {
+    kind: "not";
+    query: DocumentQuery;
+} | {
+    kind: "op";
+    op: DocumentQueryOperator;
+    value?: unknown;
+} | {
+    kind: "raw";
+    sql: string;
+    params: unknown[];
+};
+export type DocumentQueryOperator = "eq" | "ne" | "oneOf" | "notOneOf" | "gt" | "gte" | "lt" | "lte" | "between" | "exists" | "missing" | "empty" | "has" | "contains";
+export type DocumentQueryValue = DocumentPrimitive | DocumentPrimitive[] | DocumentQueryNode | undefined | Record<string, unknown>;
+export interface DocumentUpdate {
+    [key: string]: unknown;
+    set?: Record<string, unknown>;
+    unset?: Record<string, unknown> | string[];
+    addToSet?: Record<string, unknown>;
+    pull?: Record<string, unknown>;
+    push?: Record<string, unknown>;
+    inc?: Record<string, number>;
+    setOnInsert?: Record<string, unknown>;
+}
+export interface DocumentUpdateOptions {
+    upsert?: boolean;
+}
+export type DocumentQuery<T = any> = DocumentQueryNode | {
+    [K in DocumentPath<T>]?: DocumentQueryValue;
+};
+export interface SqlFragment {
+    sql: string;
+    params: unknown[];
+}
+export declare const createDocumentQueryHelper: () => {
+    all: (...queries: (DocumentQuery | null | undefined | false)[]) => DocumentQueryNode;
+    any: (...queries: (DocumentQuery | null | undefined | false)[]) => DocumentQueryNode;
+    not: (query: DocumentQuery) => DocumentQueryNode;
+    eq: (value: unknown) => DocumentQueryNode;
+    ne: (value: unknown) => DocumentQueryNode;
+    oneOf: (values: readonly unknown[]) => DocumentQueryNode;
+    notOneOf: (values: readonly unknown[]) => DocumentQueryNode;
+    gt: (value: unknown) => DocumentQueryNode;
+    gte: (value: unknown) => DocumentQueryNode;
+    lt: (value: unknown) => DocumentQueryNode;
+    lte: (value: unknown) => DocumentQueryNode;
+    between: (from: unknown, to: unknown) => DocumentQueryNode;
+    exists: (path: string) => {
+        [x: string]: DocumentQueryNode;
+    };
+    missing: (path: string) => {
+        [x: string]: DocumentQueryNode;
+    };
+    empty: (path: string) => {
+        [x: string]: DocumentQueryNode;
+    };
+    has: (value: unknown) => DocumentQueryNode;
+    contains: (value: unknown) => DocumentQueryNode;
+    raw: (sql: string, params?: unknown[]) => DocumentQueryNode;
+    when: (condition: unknown, query: DocumentQuery) => DocumentQuery;
+};
+export type DocumentQueryHelper = ReturnType<typeof createDocumentQueryHelper>;
+export declare const documentQueryHelper: {
+    all: (...queries: (DocumentQuery | null | undefined | false)[]) => DocumentQueryNode;
+    any: (...queries: (DocumentQuery | null | undefined | false)[]) => DocumentQueryNode;
+    not: (query: DocumentQuery) => DocumentQueryNode;
+    eq: (value: unknown) => DocumentQueryNode;
+    ne: (value: unknown) => DocumentQueryNode;
+    oneOf: (values: readonly unknown[]) => DocumentQueryNode;
+    notOneOf: (values: readonly unknown[]) => DocumentQueryNode;
+    gt: (value: unknown) => DocumentQueryNode;
+    gte: (value: unknown) => DocumentQueryNode;
+    lt: (value: unknown) => DocumentQueryNode;
+    lte: (value: unknown) => DocumentQueryNode;
+    between: (from: unknown, to: unknown) => DocumentQueryNode;
+    exists: (path: string) => {
+        [x: string]: DocumentQueryNode;
+    };
+    missing: (path: string) => {
+        [x: string]: DocumentQueryNode;
+    };
+    empty: (path: string) => {
+        [x: string]: DocumentQueryNode;
+    };
+    has: (value: unknown) => DocumentQueryNode;
+    contains: (value: unknown) => DocumentQueryNode;
+    raw: (sql: string, params?: unknown[]) => DocumentQueryNode;
+    when: (condition: unknown, query: DocumentQuery) => DocumentQuery;
+};
+export declare const encodeDocumentValue: (value: unknown) => unknown;
+export declare const sanitizeJson: (value: unknown) => unknown;

package/types/document/documentSchema.d.ts

@@ -0,0 +1,33 @@
+import type { PromiseOrObject } from "akanjs/base";
+import type { DocumentQuery, DocumentQueryHelper } from "./documentQuery.d.ts";
+import type { CRUDEventType, SaveEventType } from "./into.d.ts";
+export type DocumentHookName = `before${Capitalize<SaveEventType>}` | `after${Capitalize<SaveEventType>}`;
+export interface DocumentIndexDescriptor {
+    name?: string;
+    fields: Record<string, 1 | -1 | "text" | boolean>;
+    unique?: boolean;
+    text?: boolean;
+    where?: DocumentQuery;
+}
+export interface DocumentIndexBuilder<Schema> {
+    path(path: string, order?: 1 | -1): DocumentIndexBuilder<Schema>;
+    text(path: string): DocumentIndexBuilder<Schema>;
+    unique(): DocumentIndexBuilder<Schema>;
+    where(where: DocumentQuery | ((q: DocumentQueryHelper) => DocumentQuery)): DocumentIndexBuilder<Schema>;
+    done(): Schema;
+}
+export type DocumentSaveHook<Doc = unknown> = (this: Doc, next?: () => void, type?: CRUDEventType) => PromiseOrObject<void>;
+export declare class DocumentSchema<Doc = unknown> {
+    readonly preHooks: Map<SaveEventType, DocumentSaveHook<Doc>[]>;
+    readonly postHooks: Map<SaveEventType, DocumentSaveHook<Doc>[]>;
+    readonly indexes: DocumentIndexDescriptor[];
+    pre<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>): this;
+    post<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>): this;
+    hook(type: DocumentHookName, hook: DocumentSaveHook<Doc>): this;
+    index(fields: DocumentIndexDescriptor["fields"], options?: Omit<DocumentIndexDescriptor, "fields">): this;
+    text(...fields: string[]): this;
+    createIndex(name: string): DocumentIndexBuilder<this>;
+}
+export type SchemaOf<Mdl = unknown, Doc = unknown> = DocumentSchema<Doc> & {
+    readonly __model?: Mdl;
+};

package/types/document/filterMeta.d.ts

@@ -0,0 +1,84 @@
+import type { Cls, MergeAllDoubleKeyOfObjects, MergeAllKeyOfTypes } from "akanjs/base";
+import { FILTER_META } from "akanjs/base";
+import type { BaseObject, ConstantFieldTypeInput, DocumentModel, FieldToValue, PlainTypeToFieldType, QueryOf, Serialized } from "akanjs/constant";
+import type { DocumentQuery, DocumentQueryHelper } from "./documentQuery.d.ts";
+import type { ConstantFilterMeta } from "./types.d.ts";
+export declare const isFilterModel: (filterRef: Cls<unknown, {
+    [FILTER_META]?: ConstantFilterMeta;
+}>) => boolean;
+export declare const getFilterMeta: <AllowEmpty extends boolean = false>(filterRef: Cls<unknown, {
+    [FILTER_META]?: ConstantFilterMeta;
+}> | FilterCls, { allowEmpty }?: {
+    allowEmpty?: AllowEmpty;
+}) => AllowEmpty extends true ? ConstantFilterMeta | undefined : ConstantFilterMeta;
+export declare const setFilterMeta: (filterRef: Cls<unknown, {
+    [FILTER_META]?: ConstantFilterMeta;
+    sortField: Set<string>;
+}>, filterMeta: ConstantFilterMeta, ...libFilterMetas: ConstantFilterMeta[]) => void;
+export declare const getFilterInfoByKey: <ArgNames extends string[] = [], Args extends any[] = any[], Model = any>(modelRef: FilterCls, key: string) => FilterInfo<ArgNames, Args, Model>;
+export declare const setFilterInfoByKey: <ArgNames extends string[] = [], Args extends any[] = any[], Model = any>(modelRef: Cls<Model>, key: string, filterInfo: FilterInfo<ArgNames, Args, Model>) => void;
+export declare const getFilterSortByKey: (modelRef: FilterCls, key: string) => unknown;
+export declare const fillMissingFilterArgs: (filterInfo: FilterInfo, args: unknown[]) => any[];
+export type BaseFilterSortKey = "latest" | "oldest";
+export type BaseFilterQueryKey = "any";
+export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;
+export type FilterInstance<Query extends {
+    [key: string]: FilterInfo;
+} = {}, Sort extends {
+    [key: string]: unknown;
+} = {}> = {
+    query: Query;
+    sort: Sort;
+};
+interface BaseQuery<Model> {
+    any: FilterInfo<[], [], Model>;
+}
+interface BaseSort {
+    latest: {
+        createdAt: -1;
+    };
+    oldest: {
+        createdAt: 1;
+    };
+}
+export type ExtractQuery<Filter extends FilterInstance> = {
+    [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<any, infer Args> ? (...args: Args) => QueryOf<any> : never;
+};
+export type ExtractSort<Filter extends FilterInstance> = keyof Filter["sort"];
+export interface FilterCls<Filter extends FilterInstance = any> extends Cls<{
+    [key: string]: any;
+}> {
+    [FILTER_META]: Filter;
+    sortField: Set<string>;
+}
+export declare const from: <Full extends BaseObject, BuildFilter extends (filter: () => FilterInfo<[], [], Full>) => FilterInstance, LibFilters extends FilterCls[], _Filter extends ReturnType<BuildFilter>>(modelRef: Cls<Full>, buildFilter: BuildFilter, ...libFilterRefs: LibFilters) => Cls<{
+    query: BaseQuery<Full> & MergeAllDoubleKeyOfObjects<LibFilters, typeof FILTER_META, "query"> & _Filter["query"];
+    sort: BaseSort & MergeAllKeyOfTypes<LibFilters, "sort"> & _Filter["sort"];
+}, {
+    [FILTER_META]: {
+        query: BaseQuery<Full> & MergeAllDoubleKeyOfObjects<LibFilters, typeof FILTER_META, "query"> & _Filter["query"];
+        sort: BaseSort & MergeAllKeyOfTypes<LibFilters, "sort"> & _Filter["sort"];
+    };
+    sortField: Set<string>;
+}>;
+interface ArgProps<Value = unknown> {
+    nullable?: boolean;
+    ref?: string;
+    default?: Value;
+    renderOption?: (arg: never) => string;
+}
+export declare class FilterInfo<ArgNames extends string[] = any, Args extends any[] = any, Model = any> {
+    readonly argNames: ArgNames;
+    readonly args: {
+        name: string;
+        argRef: ConstantFieldTypeInput;
+        option?: ArgProps;
+    }[];
+    queryFn: ((...args: [...Args, q: DocumentQueryHelper]) => DocumentQuery<Model>) | null;
+    constructor();
+    arg<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, ArgName extends string = "unknown", _FieldToValue = DocumentModel<FieldToValue<Arg>>>(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">): FilterInfo<[...ArgNames, ArgName], [...Args, arg: _FieldToValue], Model>;
+    opt<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, ArgName extends string = "unknown", _FieldToValue = DocumentModel<FieldToValue<Arg>>>(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">): FilterInfo<[...ArgNames, ArgName], [...Args, opt?: _FieldToValue | null], Model>;
+    query(query: (...args: [...Args, q: DocumentQueryHelper]) => DocumentQuery<Serialized<DocumentModel<Model>>>): this;
+}
+export declare const filter: () => FilterInfo<[], [], any>;
+export {};

package/types/document/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./by.d.ts";
+export * from "./database.d.ts";
+export * from "./databaseRegistry.d.ts";
+export * from "./dataLoader.d.ts";
+export * from "./documentQuery.d.ts";
+export * from "./documentSchema.d.ts";
+export * from "./filterMeta.d.ts";
+export * from "./into.d.ts";
+export * from "./loaderInfo.d.ts";
+export * from "./schema.d.ts";
+export * from "./types.d.ts";

package/types/document/into.d.ts

@@ -0,0 +1,65 @@
+import { type Cls, type MergeAllActionTypes, type PromiseOrObject } from "akanjs/base";
+import type { ConstantModel, DocumentModel, FieldObject, QueryOf } from "akanjs/constant";
+import type { ExtractQuery, ExtractSort, FilterCls, FilterInstance } from ".";
+import type { DatabaseInstance } from "./database.d.ts";
+import type { DocumentUpdate, DocumentUpdateOptions } from "./documentQuery.d.ts";
+import { type LoaderBuilder, type ModelCls } from "./loaderInfo.d.ts";
+export type CRUDEventType = "create" | "update" | "remove";
+export type SaveEventType = "save" | CRUDEventType;
+interface DefaultMdlStats<TDocument, TSchema, _Partial extends Partial<TSchema> = Partial<TSchema>, _FilterQuery extends QueryOf<TSchema> = QueryOf<TSchema>, _Projection extends Partial<Record<keyof TSchema, boolean>> = Partial<Record<keyof TSchema, boolean>>> {
+    pickOneAndWrite: (query: _FilterQuery, rawData: _Partial) => Promise<TDocument>;
+    pickAndWrite: (docId: string, rawData: _Partial) => Promise<TDocument>;
+    pickOne: (query: _FilterQuery, projection?: _Projection) => Promise<TDocument>;
+    pickById: (docId: string | undefined, projection?: _Projection) => Promise<TDocument>;
+    sample: (query: _FilterQuery, size?: number) => Promise<TDocument[]>;
+    sampleOne: (query: _FilterQuery) => Promise<TDocument | null>;
+    preSaveListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    postSaveListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    preCreateListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    postCreateListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    preUpdateListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    postUpdateListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    preRemoveListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    postRemoveListenerSet: Set<(doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>>;
+    listenPre: (eventType: SaveEventType, listener: (doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+    listenPost: (eventType: SaveEventType, listener: (doc: TDocument, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+}
+export interface UpdateResult {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    upsertedId?: string | null;
+}
+export interface BulkWriteOperation<Raw> {
+    updateOne: {
+        filter: QueryOf<DocumentModel<Raw>>;
+        update: DocumentUpdate;
+        upsert?: boolean;
+    };
+}
+type FindManyChain<Doc> = Promise<Doc[]> & {
+    sort(sort: Record<string, 1 | -1>): FindManyChain<Doc>;
+    skip(skip: number): FindManyChain<Doc>;
+    limit(limit: number): FindManyChain<Doc>;
+    select(projection?: unknown): FindManyChain<Doc>;
+};
+type FindOneChain<Doc> = Promise<Doc | null> & {
+    sort(sort: Record<string, 1 | -1>): FindOneChain<Doc>;
+    skip(skip: number): FindOneChain<Doc>;
+    select(projection?: unknown): FindOneChain<Doc>;
+};
+export type Mdl<Doc, Raw> = DefaultMdlStats<Doc, DocumentModel<Raw>> & {
+    refName: string;
+    new (data: Partial<DocumentModel<Raw>>): Doc;
+    find(query: QueryOf<DocumentModel<Raw>>, projection?: Partial<Record<keyof Raw, boolean>>): FindManyChain<Doc>;
+    findOne(query: QueryOf<DocumentModel<Raw>>, projection?: Partial<Record<keyof Raw, boolean>>): FindOneChain<Doc>;
+    findById(id: string | undefined, projection?: Partial<Record<keyof Raw, boolean>>): Promise<Doc | null>;
+    countDocuments(query: QueryOf<DocumentModel<Raw>>): Promise<number>;
+    exists(query: QueryOf<DocumentModel<Raw>>): Promise<string | null>;
+    updateOne(query: QueryOf<DocumentModel<Raw>>, update: DocumentUpdate, options?: DocumentUpdateOptions): Promise<UpdateResult>;
+    updateMany(query: QueryOf<DocumentModel<Raw>>, update: DocumentUpdate): Promise<UpdateResult>;
+    deleteMany(query: QueryOf<DocumentModel<Raw>>): Promise<UpdateResult>;
+    bulkWrite(operations: BulkWriteOperation<Raw>[]): Promise<UpdateResult>;
+};
+export declare const into: <Doc, Filter extends FilterInstance, T extends string, Input, Obj, Full, Light, Insight, FullFieldObj extends FieldObject, AddDbModels extends ModelCls[], _CapitalizedRefName extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc, _Query = ExtractQuery<Filter>, _Sort = ExtractSort<Filter>, _DatabaseModel = DatabaseInstance<T, _DocInput, Doc, Full, Insight, Filter, _CapitalizedRefName, _QueryOfDoc, _Query, _Sort>, _LoaderBuilder extends LoaderBuilder<_Doc> = LoaderBuilder<_Doc>>(docRef: Cls<Doc>, filterRef: FilterCls<Filter>, cnst: ConstantModel<T, Input, Obj, Full, Light, Insight, FullFieldObj, _CapitalizedRefName, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc>, loaderBuilder: _LoaderBuilder, ...addMdls: [...AddDbModels]) => ModelCls<MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel, ReturnType<_LoaderBuilder>>;
+export {};

package/types/document/loaderInfo.d.ts

@@ -0,0 +1,35 @@
+import { type Cls, LOADER_META } from "akanjs/base";
+import type { QueryOf } from "akanjs/constant";
+import type { Loader, SchemaOf } from ".";
+type LoaderType = "field" | "arrayField" | "query";
+export type ModelCls<Statics = {}, LoaderMap extends {
+    [key: string]: LoaderInfo;
+} = {}> = Cls<Statics & ExtractLoaderInfoObject<LoaderMap>, {
+    [LOADER_META]: LoaderMap;
+    _onSchema: (schema: SchemaOf<any, any>) => void;
+    _libsOnSchema: (schema: SchemaOf<any, any>) => void;
+}>;
+export declare class LoaderInfo<Doc = any, Key extends keyof Doc = keyof Doc, QueryArg = Doc[Key]> {
+    type: LoaderType;
+    field: Key | Key[];
+    defaultQuery: QueryOf<unknown>;
+    queryArg: QueryArg | undefined;
+    constructor(type: LoaderType, field: Key | Key[], defaultQuery?: QueryOf<unknown>);
+}
+export declare const makeLoaderBuilder: <Doc>() => {
+    byField: <Key extends keyof Doc & string>(fieldName: Key, defaultQuery?: QueryOf<unknown>) => LoaderInfo<Doc, Key, Doc[Key]>;
+    byArrayField: <Key extends keyof Doc & string>(fieldName: Key, defaultQuery?: QueryOf<unknown>) => LoaderInfo<Doc, Key, Doc[Key]>;
+    byQuery: <Key extends keyof Doc & string>(queryKeys: readonly Key[], defaultQuery?: QueryOf<unknown>) => LoaderInfo<Doc, Key, Pick<Doc, Key>>;
+};
+export type LoaderBuilder<Doc = any> = (builder: ReturnType<typeof makeLoaderBuilder<Doc>>) => {
+    [key: string]: LoaderInfo<Doc, any, any>;
+};
+export type ExtractLoaderInfoObject<LoaderInfoMap extends {
+    [key: string]: LoaderInfo;
+}> = {
+    [K in keyof LoaderInfoMap]: LoaderInfoMap[K] extends LoaderInfo<infer Doc, any, infer QueryArg> ? Loader<QueryArg, Doc> : never;
+};
+export declare const getLoaderInfos: (modelRef: ModelCls) => {
+    [key: string]: LoaderInfo;
+};
+export {};

package/types/document/schema.d.ts

@@ -0,0 +1,5 @@
+import { DocumentSchema } from "./documentSchema.d.ts";
+export declare const getDefaultSchemaOptions: <TSchema, TDocument>() => DocumentSchema<TDocument>;
+export declare const convertAggregateMatch: (query: unknown) => {
+    [k: string]: unknown;
+};

package/types/document/types.d.ts

@@ -0,0 +1,36 @@
+import type { EnumInstance, GetStateObject } from "akanjs/base";
+import type { FilterInfo } from ".";
+export type DataInputOf<Input = any, Obj = any> = {
+    [K in keyof Input as Input[K] extends (...args: any[]) => any ? never : K]: Input[K] extends any[] ? Input[K] | undefined : Input[K];
+} & Partial<Obj>;
+export type GetDocObject<D> = GetStateObject<Omit<D, "set" | "save" | "refresh">>;
+export interface ConstantFilterMeta {
+    query: {
+        [key: string]: FilterInfo;
+    };
+    sort: Record<string, unknown>;
+}
+export interface FilterKeyProps {
+    type?: "database";
+}
+export interface FilterArgProps {
+    nullable?: boolean;
+    ref?: string;
+    default?: string | number | boolean | object | null | (() => string | number | boolean | object | null);
+    renderOption?: (value: never) => string;
+    enum?: EnumInstance;
+}
+export interface ListQueryOption<Sort = never, Obj = any> {
+    skip?: number | null;
+    limit?: number | null;
+    sort?: Sort | null;
+    sample?: number;
+    select?: Partial<Record<keyof Obj, boolean>>;
+}
+export interface FindQueryOption<Sort = never, Obj = any> {
+    skip?: number | null;
+    sort?: Sort | null;
+    sample?: boolean;
+    select?: Partial<Record<keyof Obj, boolean>>;
+}
+export type { SchemaOf } from "./documentSchema.d.ts";

package/types/document.d.ts

@@ -0,0 +1 @@
+export * from "./document/index.d.ts";

package/types/fetch/client/fetchClient.d.ts

@@ -0,0 +1,78 @@
+import { type PromiseOrObject } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type { DatabaseSignal, SerializedArg, SerializedEndpoint, SerializedSignal, SerializedSlice, ServiceSignal } from "akanjs/signal";
+import type { ClientSignal, MergeAllFetchTypes, SliceMeta } from "../fetchType.d.ts";
+import type { GetSliceMetaObjFromDatabaseSignals } from "../types.d.ts";
+import { type ErrorConstructor, HttpClient } from "./httpClient.d.ts";
+import { WsClient } from "./wsClient.d.ts";
+type FetchHandler = (...args: unknown[]) => PromiseOrObject<unknown>;
+export type FetchProxy<FetchType = unknown, SliceMetaObj extends Record<string, SliceMeta> = Record<never, never>> = typeof global.fetch & FetchClient & FetchType & {
+    slice: SliceMetaObj;
+    instance: FetchClient;
+    _FetchType: FetchType;
+};
+type ClientSignalMap<SigType extends {
+    fetch: any;
+}> = {
+    [K in keyof SigType as SigType[K] extends DatabaseSignal<any, any, any, any> ? K : never]: SigType[K] extends DatabaseSignal<any, any, infer SlceCls, any> ? ClientSignal<SlceCls["baseName"], SlceCls, SlceCls["srv"]["cnst"]> : never;
+};
+/** Runtime fetch client that registers serialized Akan signals as HTTP/WebSocket methods. */
+export declare class FetchClient {
+    #private;
+    private ErrorCls?;
+    readonly logger: Logger;
+    readonly origin: string;
+    readonly http: HttpClient;
+    readonly ws: WsClient;
+    readonly handler: Record<string, FetchHandler>;
+    readonly slice: Record<string, SliceMeta>;
+    readonly sortKeyMap: Map<string, string[]>;
+    serializedSignal: {
+        [key: string]: SerializedSignal;
+    };
+    jwt: string | null;
+    constructor(origin: string, handler?: Record<string, FetchHandler>, serializedSignal?: {
+        [key: string]: SerializedSignal;
+    }, ErrorCls?: ErrorConstructor | undefined);
+    setErrorConstructor(ErrorCls?: ErrorConstructor): void;
+    applySignal(serializedSignal: {
+        [key: string]: SerializedSignal;
+    }): this;
+    connect(): void;
+    disconnect(): void;
+    clone({ origin, connect, jwt }?: {
+        origin?: string;
+        connect?: boolean;
+        jwt?: string;
+    }): FetchProxy<unknown, Record<never, never>>;
+    setJwt(jwt: string | null): void;
+    static paginationArgs: SerializedArg[];
+    static makeHttpUrl(key: string, endpoint: SerializedEndpoint, prefix: string | undefined, argMap: Map<string, unknown>): string;
+    static getBaseEndpoint(refName: string, signal: SerializedSignal): {
+        [key: string]: SerializedEndpoint;
+    };
+    static getEndpointFromSlice(refName: string, suffix: string, slice: SerializedSlice): {
+        [key: string]: SerializedEndpoint;
+    };
+    static classifyHttpArgs(args: SerializedArg[]): {
+        paramArgs: SerializedArg[];
+        searchArgs: SerializedArg[];
+        bodyArgs: SerializedArg[];
+        uploadArgs: SerializedArg[];
+    };
+    static from<Signals extends (FetchProxy<any, any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>)[]>(...signals: Signals): FetchProxy<MergeAllFetchTypes<Signals>, GetSliceMetaObjFromDatabaseSignals<Signals>>;
+    static build<SigType extends {
+        fetch: any;
+    }>(constant: object, serializedSignal: {
+        [key: string]: SerializedSignal;
+    }, { origin, connect, base, Err, }?: {
+        origin?: string;
+        connect?: boolean;
+        base?: FetchProxy;
+        Err?: ErrorConstructor;
+    }): {
+        sig: ClientSignalMap<SigType>;
+        fetch: SigType["fetch"];
+    };
+}
+export {};

package/types/fetch/client/httpClient.d.ts

@@ -0,0 +1,39 @@
+import type { SerializedArg } from "akanjs/signal";
+export interface ErrorResponsePayload {
+    error: string;
+    statusCode?: number;
+    data?: Record<string, unknown>;
+    details?: unknown;
+    path?: string;
+    timestamp?: string;
+}
+export interface RestoredError extends Error {
+    error?: string;
+    statusCode?: number;
+    data?: unknown;
+    details?: unknown;
+    path?: string;
+    timestamp?: string;
+}
+export interface ErrorConstructor {
+    fromJSON: (payload: ErrorResponsePayload) => RestoredError;
+}
+interface FetchOptions {
+    headers?: Record<string, string>;
+    baseUrl?: string;
+}
+export declare class HttpClient {
+    #private;
+    private ErrorCls?;
+    readonly baseUrl: string;
+    constructor(baseUrl: string, ErrorCls?: ErrorConstructor | undefined);
+    setErrorConstructor(ErrorCls?: ErrorConstructor): void;
+    get<Returns = unknown>(url: string, options?: FetchOptions): Promise<Returns>;
+    put<Returns = unknown>(url: string, data: FormData | Record<string, unknown>, options?: FetchOptions): Promise<Returns>;
+    post<Returns = unknown>(url: string, data: FormData | Record<string, unknown>, options?: FetchOptions): Promise<Returns>;
+    delete<Returns = unknown>(url: string, options?: FetchOptions): Promise<Returns>;
+    static makePath(key: string, paramArgs: SerializedArg[], prefix?: string): string;
+    static makeUrl(path: string, searchArgs: SerializedArg[], argMap: Map<string, unknown>): string;
+    static makeBody(bodyArgs: SerializedArg[], uploadArgs: SerializedArg[], argMap: Map<string, unknown>): Record<string, unknown> | FormData;
+}
+export {};

package/types/fetch/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./fetchClient.d.ts";
+export * from "./httpClient.d.ts";
+export * from "./wsClient.d.ts";

package/types/fetch/client/wsClient.d.ts

@@ -0,0 +1,37 @@
+import { Logger } from "akanjs/common";
+import type { ErrorConstructor } from "./httpClient.d.ts";
+export interface WsClientReconnectOptions {
+    enabled?: boolean;
+    interval?: number;
+    maxAttempts?: number;
+}
+type WsRequestPayload = unknown | unknown[];
+export declare class WsClient {
+    #private;
+    private ErrorCls?;
+    static makeRoomId(key: string, args: unknown[]): string;
+    readonly logger: Logger;
+    readonly url: string;
+    connected: boolean;
+    constructor(url: string, ErrorCls?: ErrorConstructor | undefined);
+    setErrorConstructor(ErrorCls?: ErrorConstructor): void;
+    connect(): void;
+    destroy(): void;
+    on<Data = unknown>(key: string, callback: (data: Data) => void): this;
+    once<Data = unknown>(key: string, callback: (data: Data) => void): this;
+    off<Data = unknown>(key: string, callback: (data: Data) => void): this;
+    removeAllListeners(key: string): this;
+    hasListeners(key: string): boolean;
+    emit(key: string, data: WsRequestPayload): this;
+    subscribe(option: {
+        key: string;
+        data: unknown[];
+        handleEvent: (data: unknown) => void;
+    }): this | undefined;
+    unsubscribe(option: {
+        key: string;
+        data: unknown[];
+        handleEvent: (data: unknown) => void;
+    }): void;
+}
+export {};

package/types/fetch/client.d.ts

@@ -0,0 +1 @@
+export * from "./client/index.d.ts";

package/types/fetch/fetchType/appliedReturn.type.d.ts

@@ -0,0 +1,67 @@
+import type { DataList, GetStateObject, PromiseOrObject } from "akanjs/base";
+import type { ExtractSort, FilterInstance } from "akanjs/document";
+/** Metadata that identifies a generated slice list/insight request. */
+export type SliceMeta = {
+    refName: string;
+    sliceName: string;
+    argLength: number;
+};
+export type ServerInit<RefName extends string, Light, Insight = any, QueryArgs = any, Filter extends FilterInstance = any, _CapitalizedRefName extends string = Capitalize<RefName>, _LightObj = GetStateObject<Light>, _InsightObj = GetStateObject<Insight>, _Sort = ExtractSort<Filter>> = SliceMeta & {
+    [K in `${RefName}ObjList`]: _LightObj[];
+} & {
+    [K in `${RefName}ObjInsight`]: _InsightObj;
+} & {
+    [K in `pageOf${_CapitalizedRefName}`]: number;
+} & {
+    [K in `lastPageOf${_CapitalizedRefName}`]: number;
+} & {
+    [K in `limitOf${_CapitalizedRefName}`]: number;
+} & {
+    [K in `queryArgsOf${_CapitalizedRefName}`]: QueryArgs;
+} & {
+    [K in `sortOf${_CapitalizedRefName}`]: _Sort;
+} & {
+    [K in `${RefName}InitAt`]: Date;
+};
+/** Client/server-friendly return type for initialized list and insight data. */
+export type ClientInit<RefName extends string, Light, Insight = any, QueryArgs = any, Filter extends FilterInstance = any, _CapitalizedRefName extends string = Capitalize<RefName>, _LightObj = GetStateObject<Light>, _InsightObj = GetStateObject<Insight>, _Sort = ExtractSort<Filter>> = PromiseOrObject<ServerInit<RefName, Light, Insight, QueryArgs, Filter, _CapitalizedRefName, _LightObj, _InsightObj, _Sort>>;
+export type ServerView<RefName extends string, Model> = {
+    refName: RefName;
+} & {
+    [K in `${RefName}Obj`]: GetStateObject<Model>;
+} & {
+    [K in `${RefName}ViewAt`]: Date;
+};
+/** Client/server-friendly return type for a single model view payload. */
+export type ClientView<RefName extends string, Model> = PromiseOrObject<ServerView<RefName, Model>>;
+export type ServerEdit<RefName extends string, Model> = {
+    refName: RefName;
+} & {
+    [K in `${RefName}Obj`]: GetStateObject<Model>;
+} & {
+    [K in `${RefName}ViewAt`]: Date;
+};
+export type ClientEdit<RefName extends string, Model> = PromiseOrObject<ServerEdit<RefName, Model>>;
+export type ViewReturn<RefName extends string, Full> = {
+    [K in RefName]: Full;
+} & {
+    [K in `${RefName}View`]: ServerView<RefName, Full>;
+};
+export type EditReturn<RefName extends string, Full> = {
+    [K in RefName]: Full;
+} & {
+    [K in `${RefName}Edit`]: ServerEdit<RefName, Full>;
+};
+export type InitReturn<RefName extends string, Suffix extends string, Light, Insight, Args, Filter extends FilterInstance, _CapitalizedRefName extends string = Capitalize<RefName>, _CapitalizedSuffix extends string = Capitalize<Suffix>, _Light extends {
+    id: string;
+} = Light extends {
+    id: string;
+} ? Light : {
+    id: string;
+}, _LightObj = GetStateObject<_Light>, _InsightObj = GetStateObject<Insight>, _Sort = ExtractSort<Filter>> = {
+    [K in `${RefName}Init${_CapitalizedSuffix}`]: ServerInit<RefName, Light, Insight, Args, Filter, _CapitalizedRefName, _LightObj, _InsightObj, _Sort>;
+} & {
+    [K in `${RefName}List${_CapitalizedSuffix}`]: DataList<_Light>;
+} & {
+    [K in `${RefName}Insight${_CapitalizedSuffix}`]: Insight;
+};