akanjs 0.0.1 → 2.0.0-beta.0

package/document/database.ts

@@ -0,0 +1,168 @@
+import type { Dayjs, MergedValues, PromiseOrObject } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type { DocumentModel, QueryOf } from "akanjs/constant";
+import type { CacheAdaptor } from "akanjs/service";
+import type DataLoader from "dataloader";
+import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
+import type { CRUDEventType, Mdl, SaveEventType } from "./into";
+import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
+
+export interface RedisSetOptions {
+  expireAt?: Dayjs;
+}
+
+export class CacheDatabase<T = unknown> {
+  private logger: Logger;
+  constructor(
+    private readonly refName: string,
+    private readonly cache: CacheAdaptor,
+  ) {
+    this.logger = new Logger(`${refName}Cache`);
+  }
+  async set(topic: string, key: string, value: string | number | Buffer, option: RedisSetOptions = {}) {
+    await this.cache.set(this.refName, `${topic}:${key}`, value, option);
+  }
+  async get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined> {
+    return await this.cache.get<T>(this.refName, `${topic}:${key}`);
+  }
+  async delete(topic: string, key: string) {
+    await this.cache.delete(this.refName, `${topic}:${key}`);
+  }
+}
+type QueryMethodOfKey<
+  CapitalizedK extends string,
+  Doc,
+  Insight,
+  _Args extends any[],
+  _ListArgs extends any[],
+  _FindArgs extends any[],
+  _QueryOfDoc = QueryOf<Doc>,
+> = {
+  [K in `list${CapitalizedK}`]: (...args: _ListArgs) => Promise<Doc[]>;
+} & {
+  [K in `listIds${CapitalizedK}`]: (...args: _ListArgs) => Promise<string[]>;
+} & {
+  [K in `find${CapitalizedK}`]: (...args: _FindArgs) => Promise<Doc | null>;
+} & {
+  [K in `findId${CapitalizedK}`]: (...args: _FindArgs) => Promise<string | null>;
+} & {
+  [K in `pick${CapitalizedK}`]: (...args: _FindArgs) => Promise<Doc>;
+} & {
+  [K in `pickId${CapitalizedK}`]: (...args: _FindArgs) => Promise<string>;
+} & {
+  [K in `exists${CapitalizedK}`]: (...args: _Args) => Promise<string | null>;
+} & {
+  [K in `count${CapitalizedK}`]: (...args: _Args) => Promise<number>;
+} & {
+  [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
+} & {
+  [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
+};
+
+export type QueryMethodPart<
+  Query,
+  Sort,
+  Obj,
+  Doc,
+  Insight,
+  _FindQueryOption = FindQueryOption<Sort, Obj>,
+  _ListQueryOption = ListQueryOption<Sort, Obj>,
+  _QueryOfDoc = QueryOf<Doc>,
+> = MergedValues<{
+  [K in keyof Query]: K extends string
+    ? Query[K] extends (...args: infer Args) => any
+      ? QueryMethodOfKey<
+          Capitalize<K>,
+          Doc,
+          Insight,
+          Args,
+          [...Args, queryOption?: _ListQueryOption],
+          [...Args, queryOption?: _FindQueryOption]
+        >
+      : never
+    : never;
+}>;
+type DatabaseModelWithQuerySort<
+  T extends string,
+  Input,
+  Doc,
+  Obj,
+  Insight,
+  Query,
+  Sort,
+  _CapitalizedRefName extends string = Capitalize<T>,
+  _QueryOfDoc = QueryOf<Doc>,
+  _DataInput = DataInputOf<Input, DocumentModel<Obj>>,
+  _FindQueryOption = FindQueryOption<Sort, Obj>,
+  _ListQueryOption = ListQueryOption<Sort, Obj>,
+> = {
+  logger: Logger;
+  __model: Mdl<Doc, Obj>;
+  __cache: CacheDatabase<T>;
+  __loader: DataLoader<string, Doc, string>;
+  __get: (id: string) => Promise<Doc>;
+  __load: (id?: string) => Promise<Doc | null>;
+  __loadMany: (ids: string[]) => Promise<Doc[]>;
+  __create: (data: _DataInput) => Promise<Doc>;
+  __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
+  __remove: (id: string) => Promise<Doc>;
+  __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
+  __listIds(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
+  __find(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;
+  __findId(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string | null>;
+  __pick(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc>;
+  __pickId(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string>;
+  __exists(query: _QueryOfDoc): Promise<string | null>;
+  __count(query: _QueryOfDoc): Promise<number>;
+  __insight(query: _QueryOfDoc): Promise<Insight>;
+  clone(data: _DataInput & { id: string }): Promise<Doc>;
+  listenPre: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+  listenPost: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+} & {
+  [key in _CapitalizedRefName]: Mdl<Doc, Obj>;
+} & {
+  [key in `${T}Loader`]: DataLoader<string, Doc, string>;
+} & {
+  [key in `${T}Cache`]: CacheDatabase<T>;
+} & {
+  [K in `get${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & {
+  [K in `load${_CapitalizedRefName}`]: (id?: string) => Promise<Doc | null>;
+} & {
+  [K in `load${_CapitalizedRefName}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+  [K in `create${_CapitalizedRefName}`]: (data: _DataInput) => Promise<Doc>;
+} & {
+  [K in `update${_CapitalizedRefName}`]: (id: string, data: _DataInput) => Promise<Doc>;
+} & {
+  [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>;
+
+export type DatabaseInstance<
+  T extends string = string,
+  Input = any,
+  Doc = any,
+  Obj = any,
+  Insight = any,
+  Filter extends FilterInstance = FilterInstance,
+  _CapitalizedRefName extends string = Capitalize<T>,
+  _QueryOfDoc = QueryOf<Doc>,
+  _Query = ExtractQuery<Filter>,
+  _Sort = ExtractSort<Filter>,
+  _DataInput = DataInputOf<Input, DocumentModel<Obj>>,
+  _FindQueryOption = FindQueryOption<_Sort, Obj>,
+  _ListQueryOption = ListQueryOption<_Sort, Obj>,
+> = DatabaseModelWithQuerySort<
+  T,
+  Input,
+  Doc,
+  Obj,
+  Insight,
+  _Query,
+  _Sort,
+  _CapitalizedRefName,
+  _QueryOfDoc,
+  _DataInput,
+  _FindQueryOption,
+  _ListQueryOption
+>;

package/document/databaseRegistry.ts

@@ -0,0 +1,113 @@
+import type { ConstantCls } from "akanjs/constant";
+import type { DatabaseCls, ExtractSort, FilterCls, FilterInstance } from ".";
+import type { ModelCls } from "./loaderInfo";
+
+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 class DatabaseRegistry {
+  static #database = new Map<string, DatabaseModel>();
+  static #scalar = new Map<string, DatabaseCls>();
+  static #modelSets = {
+    input: new Set<DatabaseCls>(),
+    doc: new Set<DatabaseCls>(),
+    model: new Set<DatabaseCls>(),
+    filter: new Set<DatabaseCls>(),
+    scalar: new Set<DatabaseCls>(),
+  };
+  static isInput(modelRef: DatabaseCls) {
+    return DatabaseRegistry.#modelSets.input.has(modelRef);
+  }
+  static isDoc(modelRef: DatabaseCls) {
+    return DatabaseRegistry.#modelSets.doc.has(modelRef);
+  }
+  static isModel(modelRef: DatabaseCls) {
+    return DatabaseRegistry.#modelSets.model.has(modelRef);
+  }
+  static isScalar(modelRef: DatabaseCls) {
+    return DatabaseRegistry.#modelSets.scalar.has(modelRef);
+  }
+  static setDatabase(refName: string, dbModel: DatabaseModel) {
+    if (!DatabaseRegistry.#database.has(refName)) DatabaseRegistry.#database.set(refName, dbModel);
+    return dbModel;
+  }
+  static getDatabase<AllowEmpty extends boolean = false>(
+    refName: string,
+    { allowEmpty }: { allowEmpty?: AllowEmpty } = {},
+  ): AllowEmpty extends true ? DatabaseModel | undefined : DatabaseModel {
+    const info = DatabaseRegistry.#database.get(refName);
+    if (!info && !allowEmpty) throw new Error(`No database document model info for ${refName}`);
+    return info as AllowEmpty extends true ? DatabaseModel | undefined : DatabaseModel;
+  }
+  static setScalar(refName: string, Model: DatabaseCls) {
+    if (DatabaseRegistry.#scalar.has(refName)) return;
+    DatabaseRegistry.#scalar.set(refName, Model);
+  }
+  static getScalar<AllowEmpty extends boolean = false>(
+    refName: string,
+    { allowEmpty }: { allowEmpty?: AllowEmpty } = {},
+  ): AllowEmpty extends true ? DatabaseCls | undefined : DatabaseCls {
+    const model = DatabaseRegistry.#scalar.get(refName);
+    if (!model && !allowEmpty) throw new Error(`No scalar model for ${refName}`);
+    return model as 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> {
+    const dbInfo = {
+      refName,
+      input,
+      doc,
+      model,
+      obj,
+      insight,
+      filter,
+      _Sort: null as unknown as _Sort,
+    } as DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Sort>;
+    DatabaseRegistry.setDatabase(refName, dbInfo);
+    return dbInfo;
+  }
+
+  static buildScalar<T extends string, Model>(refName: T, Model: DatabaseCls<Model>): DatabaseCls<Model> {
+    DatabaseRegistry.setScalar(refName, Model);
+    return Model;
+  }
+}

package/document/documentQuery.ts

@@ -0,0 +1,143 @@
+import { type Dayjs, dayjs } from "akanjs/base";
+
+export type DocumentId = string & { readonly __brand: "DocumentId" };
+
+const documentIdProcessRandom = crypto.getRandomValues(new Uint8Array(5));
+let documentIdCounter = crypto.getRandomValues(new Uint8Array(3)).reduce((count, byte) => (count << 8) + byte, 0);
+
+const hex = (bytes: Uint8Array) => [...bytes].reduce((acc, byte) => acc + byte.toString(16).padStart(2, "0"), "");
+
+export const createDocumentId = (now = Date.now()): DocumentId => {
+  const timestampHex = Math.floor(now / 1000)
+    .toString(16)
+    .padStart(8, "0");
+  const processHex = hex(documentIdProcessRandom);
+  documentIdCounter = (documentIdCounter + 1) & 0xffffff;
+  const counterHex = documentIdCounter.toString(16).padStart(6, "0");
+  return `${timestampHex}${processHex}${counterHex}` as DocumentId;
+};
+
+export const isDocumentId = (value: unknown): value is DocumentId =>
+  typeof value === "string" && /^[0-9a-f]{24}$/i.test(value);
+
+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[];
+}
+
+const op = (op: DocumentQueryOperator, value?: unknown): DocumentQueryNode => ({ kind: "op", op, value });
+
+export const createDocumentQueryHelper = () => ({
+  all: (...queries: (DocumentQuery | null | undefined | false)[]): DocumentQueryNode => ({
+    kind: "all",
+    queries: queries.filter(Boolean) as DocumentQuery[],
+  }),
+  any: (...queries: (DocumentQuery | null | undefined | false)[]): DocumentQueryNode => ({
+    kind: "any",
+    queries: queries.filter(Boolean) as DocumentQuery[],
+  }),
+  not: (query: DocumentQuery): DocumentQueryNode => ({ kind: "not", query }),
+  eq: (value: unknown) => op("eq", value),
+  ne: (value: unknown) => op("ne", value),
+  oneOf: (values: readonly unknown[]) => op("oneOf", [...values]),
+  notOneOf: (values: readonly unknown[]) => op("notOneOf", [...values]),
+  gt: (value: unknown) => op("gt", value),
+  gte: (value: unknown) => op("gte", value),
+  lt: (value: unknown) => op("lt", value),
+  lte: (value: unknown) => op("lte", value),
+  between: (from: unknown, to: unknown) => op("between", [from, to]),
+  exists: (path: string) => ({ [path]: op("exists") }),
+  missing: (path: string) => ({ [path]: op("missing") }),
+  empty: (path: string) => ({ [path]: op("empty") }),
+  has: (value: unknown) => op("has", value),
+  contains: (value: unknown) => op("contains", value),
+  raw: (sql: string, params: unknown[] = []): DocumentQueryNode => ({ kind: "raw", sql, params }),
+  when: (condition: unknown, query: DocumentQuery): DocumentQuery => (condition ? query : {}),
+});
+
+export type DocumentQueryHelper = ReturnType<typeof createDocumentQueryHelper>;
+
+export const documentQueryHelper = createDocumentQueryHelper();
+
+export const encodeDocumentValue = (value: unknown): unknown => {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  if (dayjs.isDayjs(value)) return value.valueOf();
+  if (value instanceof Date) return value.getTime();
+  if (Array.isArray(value)) return value.map(encodeDocumentValue);
+  if (typeof value === "object") return JSON.stringify(sanitizeJson(value));
+  return value;
+};
+
+export const sanitizeJson = (value: unknown): unknown => {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  if (dayjs.isDayjs(value)) return value.valueOf();
+  if (value instanceof Date) return value.getTime();
+  if (value instanceof Map)
+    return Object.fromEntries([...value.entries()].map(([key, val]) => [key, sanitizeJson(val)]));
+  if (Array.isArray(value)) return value.map(sanitizeJson).filter((item) => item !== undefined);
+  if (typeof value !== "object") return value;
+  const entries = Object.entries(value as Record<string, unknown>).flatMap(([key, val]) => {
+    if (["__proto__", "constructor", "prototype"].includes(key)) {
+      throw new Error(`Unsafe JSON key: ${key}`);
+    }
+    const sanitized = sanitizeJson(val);
+    return sanitized === undefined ? [] : [[key, sanitized] as const];
+  });
+  return Object.fromEntries(entries);
+};

package/document/documentSchema.ts

@@ -0,0 +1,91 @@
+import type { PromiseOrObject } from "akanjs/base";
+import type { DocumentQuery, DocumentQueryHelper } from "./documentQuery";
+import { documentQueryHelper } from "./documentQuery";
+import type { CRUDEventType, SaveEventType } from "./into";
+
+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 type DocumentSaveHook<Doc = unknown> = (
+  this: Doc,
+  next?: () => void,
+  type?: CRUDEventType,
+) => PromiseOrObject<void>;
+
+export class DocumentSchema<Doc = unknown> {
+  readonly preHooks = new Map<SaveEventType, DocumentSaveHook<Doc>[]>();
+  readonly postHooks = new Map<SaveEventType, DocumentSaveHook<Doc>[]>();
+  readonly indexes: DocumentIndexDescriptor[] = [];
+
+  pre<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>) {
+    const hooks = this.preHooks.get(type) ?? [];
+    hooks.push(hook as unknown as DocumentSaveHook<Doc>);
+    this.preHooks.set(type, hooks);
+    return this;
+  }
+
+  post<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>) {
+    const hooks = this.postHooks.get(type) ?? [];
+    hooks.push(hook as unknown as DocumentSaveHook<Doc>);
+    this.postHooks.set(type, hooks);
+    return this;
+  }
+
+  hook(type: DocumentHookName, hook: DocumentSaveHook<Doc>) {
+    const [, phase, event] = /^(before|after)(.+)$/.exec(type) ?? [];
+    if (!phase || !event) throw new Error(`Invalid document hook: ${type}`);
+    const saveType = `${event.charAt(0).toLowerCase()}${event.slice(1)}` as SaveEventType;
+    return phase === "before" ? this.pre(saveType, hook) : this.post(saveType, hook);
+  }
+
+  index(fields: DocumentIndexDescriptor["fields"], options: Omit<DocumentIndexDescriptor, "fields"> = {}) {
+    this.indexes.push({ ...options, fields });
+    return this;
+  }
+
+  text(...fields: string[]) {
+    this.indexes.push({
+      text: true,
+      fields: Object.fromEntries(fields.map((field) => [field, "text" as const])),
+    });
+    return this;
+  }
+
+  createIndex(name: string) {
+    const schema = this;
+    const descriptor: DocumentIndexDescriptor = { name, fields: {} };
+    const api = {
+      path(path: string, order: 1 | -1 = 1) {
+        descriptor.fields[path] = order;
+        return api;
+      },
+      text(path: string) {
+        descriptor.fields[path] = "text";
+        descriptor.text = true;
+        return api;
+      },
+      unique() {
+        descriptor.unique = true;
+        return api;
+      },
+      where(where: DocumentQuery | ((q: DocumentQueryHelper) => DocumentQuery)) {
+        descriptor.where = typeof where === "function" ? where(documentQueryHelper) : where;
+        return api;
+      },
+      done() {
+        schema.indexes.push(descriptor);
+        return schema;
+      },
+    };
+    return api;
+  }
+}
+
+export type SchemaOf<Mdl = unknown, Doc = unknown> = DocumentSchema<Doc> & { readonly __model?: Mdl };