akanjs 0.0.1 → 2.0.0-beta.1

package/document/filterMeta.ts

@@ -0,0 +1,210 @@
+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";
+import type { ConstantFilterMeta } from "./types";
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+export const isFilterModel = (filterRef: Cls<unknown, { [FILTER_META]?: ConstantFilterMeta }>): boolean => {
+  return filterRef[FILTER_META] !== undefined;
+};
+export const getFilterMeta = <AllowEmpty extends boolean = false>(
+  filterRef: Cls<unknown, { [FILTER_META]?: ConstantFilterMeta }> | FilterCls,
+  { allowEmpty = false as AllowEmpty }: { allowEmpty?: AllowEmpty } = {},
+): AllowEmpty extends true ? ConstantFilterMeta | undefined : ConstantFilterMeta => {
+  const filterMeta = filterRef[FILTER_META];
+  if (!filterMeta && !allowEmpty) throw new Error("filterMeta is not defined");
+  return filterMeta as AllowEmpty extends true ? ConstantFilterMeta | undefined : ConstantFilterMeta;
+};
+export const setFilterMeta = (
+  filterRef: Cls<unknown, { [FILTER_META]?: ConstantFilterMeta; sortField: Set<string> }>,
+  filterMeta: ConstantFilterMeta,
+  ...libFilterMetas: ConstantFilterMeta[]
+) => {
+  const sortField = new Set(
+    Object.values(filterMeta.sort)
+      .filter(isObjectRecord)
+      .flatMap((sort) => Object.keys(sort)),
+  );
+  const existingFilterMeta = getFilterMeta(filterRef, { allowEmpty: true });
+  if (existingFilterMeta) {
+    Object.assign(existingFilterMeta, {
+      ...filterMeta,
+      query: Object.assign(
+        existingFilterMeta.query,
+        ...libFilterMetas.map((libFilterMeta) => libFilterMeta.query),
+        filterMeta.query,
+      ),
+      sort: Object.assign(
+        existingFilterMeta.sort,
+        ...libFilterMetas.map((libFilterMeta) => libFilterMeta.sort),
+        filterMeta.sort,
+      ),
+    });
+    sortField.forEach((field) => {
+      filterRef.sortField.add(field);
+    });
+  } else {
+    Object.assign(filterRef, {
+      [FILTER_META]: {
+        query: Object.assign({}, ...libFilterMetas.map((libFilterMeta) => libFilterMeta.query), filterMeta.query),
+        sort: Object.assign({}, ...libFilterMetas.map((libFilterMeta) => libFilterMeta.sort), filterMeta.sort),
+      },
+    });
+    sortField.forEach((field) => {
+      filterRef.sortField.add(field);
+    });
+  }
+};
+export const getFilterInfoByKey = <ArgNames extends string[] = [], Args extends any[] = any[], Model = any>(
+  modelRef: FilterCls,
+  key: string,
+): FilterInfo<ArgNames, Args, Model> => {
+  const filterMeta = getFilterMeta(
+    modelRef as Cls<unknown, { [FILTER_META]?: ConstantFilterMeta; sortField: Set<string> }>,
+  );
+  const queryMeta = filterMeta.query[key];
+  if (!queryMeta) throw new Error(`queryMeta is not defined for key: ${key}`);
+  return queryMeta;
+};
+export const setFilterInfoByKey = <ArgNames extends string[] = [], Args extends any[] = any[], Model = any>(
+  modelRef: Cls<Model>,
+  key: string,
+  filterInfo: FilterInfo<ArgNames, Args, Model>,
+) => {
+  const filterMeta = getFilterMeta(modelRef);
+  Object.assign(filterMeta.query, { [key]: filterInfo });
+};
+export const getFilterSortByKey = (modelRef: FilterCls, key: string) => {
+  const filterMeta = getFilterMeta(
+    modelRef as Cls<unknown, { [FILTER_META]?: ConstantFilterMeta; sortField: Set<string> }>,
+  );
+  return filterMeta.sort[key];
+};
+
+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 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
+) => {
+  class Base {
+    static sortField: Set<string> = new Set();
+  }
+  const querySort = buildFilter(filter);
+  setFilterMeta(
+    Base,
+    {
+      query: {
+        any: filter().query((_q) => ({ removedAt: { empty: true } })),
+        ...querySort.query,
+      },
+      sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, querySort.sort),
+    },
+    ...libFilterRefs.map((libFilterRef) => getFilterMeta(libFilterRef)),
+  );
+  return Base as unknown as 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 class FilterInfo<ArgNames extends string[] = any, Args extends any[] = any, Model = any> {
+  readonly argNames: ArgNames = [] as unknown as ArgNames;
+  readonly args: { name: string; argRef: ConstantFieldTypeInput; option?: ArgProps }[];
+  queryFn: ((...args: [...Args, q: DocumentQueryHelper]) => DocumentQuery<Model>) | null = null;
+
+  constructor() {
+    this.args = [];
+  }
+  arg<
+    ExplicitType,
+    Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+    ArgName extends string = "unknown",
+    _FieldToValue = DocumentModel<FieldToValue<Arg>>,
+  >(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">) {
+    if (this.queryFn) throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable) throw new Error("Last argument is nullable");
+    this.argNames.push(name);
+    this.args.push({ name, argRef, option });
+    return this as unknown as 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">) {
+    if (this.queryFn) throw new Error("Query function is already set");
+    this.argNames.push(name);
+    this.args.push({ name, argRef, option: { ...option, nullable: true } });
+    return this as unknown as FilterInfo<[...ArgNames, ArgName], [...Args, opt?: _FieldToValue | null], Model>;
+  }
+  query(query: (...args: [...Args, q: DocumentQueryHelper]) => DocumentQuery<Serialized<DocumentModel<Model>>>) {
+    if (this.queryFn) throw new Error("Query function is already set");
+    this.queryFn = query;
+    return this;
+  }
+}
+
+export const filter = () => new FilterInfo<[], [], any>();

package/document/index.ts

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

package/document/into.ts

@@ -0,0 +1,169 @@
+import { type Cls, LOADER_META, type MergeAllActionTypes, type PromiseOrObject } from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import type { ConstantModel, DocumentModel, FieldObject, QueryOf } from "akanjs/constant";
+import type { ExtractQuery, ExtractSort, FilterCls, FilterInstance, SchemaOf } from ".";
+import type { DatabaseInstance } from "./database";
+import type { DocumentUpdate, DocumentUpdateOptions } from "./documentQuery";
+import { type LoaderBuilder, type ModelCls, makeLoaderBuilder } from "./loaderInfo";
+
+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 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>
+> => {
+  const loaderInfoMap = loaderBuilder(makeLoaderBuilder());
+  const libsOnSchemaFns = addMdls.map((mdl) => mdl._onSchema);
+  const DefaultModel = Object.assign(class DefaultModel {}, {
+    [LOADER_META]: Object.assign({}, ...addMdls.map((mdl) => mdl[LOADER_META]), loaderInfoMap),
+    _onSchema(schema: SchemaOf) {
+    },
+    _libsOnSchema(schema: SchemaOf) {
+      libsOnSchemaFns.map((libsOnSchema) => libsOnSchema(schema));
+    },
+  });
+  applyMixins(DefaultModel, addMdls);
+  addMdls.forEach((mdl) => {
+    Object.entries(Object.getOwnPropertyDescriptors(mdl)).forEach(([name, descriptor]) => {
+      if (["length", "name", "prototype"].includes(name)) return;
+      Object.defineProperty(DefaultModel, name, { ...descriptor, configurable: true });
+    });
+  });
+  return DefaultModel as unknown as ModelCls<
+    MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel,
+    ReturnType<_LoaderBuilder>
+  >;
+};

package/document/loaderInfo.ts

@@ -0,0 +1,50 @@
+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 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> = {}) {
+    this.type = type;
+    this.field = field;
+    this.defaultQuery = defaultQuery;
+  }
+}
+
+export const makeLoaderBuilder = <Doc>() => ({
+  byField: <Key extends keyof Doc & string>(fieldName: Key, defaultQuery: QueryOf<unknown> = {}) =>
+    new LoaderInfo<Doc, Key>("field", fieldName, defaultQuery),
+  byArrayField: <Key extends keyof Doc & string>(fieldName: Key, defaultQuery: QueryOf<unknown> = {}) =>
+    new LoaderInfo<Doc, Key>("arrayField", fieldName, defaultQuery),
+  byQuery: <Key extends keyof Doc & string>(queryKeys: readonly Key[], defaultQuery: QueryOf<unknown> = {}) =>
+    new LoaderInfo<Doc, Key, Pick<Doc, Key>>("query", queryKeys as Key[], defaultQuery),
+});
+
+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 const getLoaderInfos = (modelRef: ModelCls): { [key: string]: LoaderInfo } => {
+  const loaderInfos = modelRef[LOADER_META];
+  if (!loaderInfos) throw new Error(`No loader infos for modelRef: ${modelRef}`);
+  return loaderInfos;
+};

package/document/schema.ts

@@ -0,0 +1,24 @@
+import { dayjs } from "akanjs/base";
+import { isValidDate } from "akanjs/common";
+import { DocumentSchema } from "./documentSchema";
+
+export const getDefaultSchemaOptions = <TSchema, TDocument>() => new DocumentSchema<TDocument>();
+
+const convertOperatorValue = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map((v) => convertOperatorValue(v));
+  else if (!value) return value;
+  else if (isValidDate(value as Date)) return dayjs(value as Date).valueOf();
+  else if (typeof value !== "object") return value;
+  else if (value.constructor !== Object) return value;
+  else
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, value]) => [key, convertOperatorValue(value)]),
+    );
+};
+export const convertAggregateMatch = (query: unknown) => {
+  return Object.fromEntries(
+    Object.entries(query as Record<string, unknown>).map(([key, value]) => {
+      return [key, convertOperatorValue(value)];
+    }),
+  );
+};

package/document/types.ts

@@ -0,0 +1,41 @@
+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";