akanjs 0.0.1 → 2.0.0-beta.1

package/server/resolver/database.resolver.ts

@@ -0,0 +1,340 @@
+import type { PromiseOrObject } from "akanjs/base";
+import { applyMixins, capitalize } from "akanjs/common";
+import { type ConstantModel, DEFAULT_PAGE_SIZE, type QueryOf } from "akanjs/constant";
+import {
+  CacheDatabase,
+  type CRUDEventType,
+  type DatabaseInstance,
+  type DatabaseModel,
+  type DataInputOf,
+  DataLoader,
+  DocumentSchema,
+  documentQueryHelper,
+  type FindQueryOption,
+  getFilterInfoByKey,
+  getFilterMeta,
+  getFilterSortByKey,
+  getLoaderInfos,
+  type ListQueryOption,
+  type Mdl,
+  type SaveEventType,
+} from "akanjs/document";
+import {
+  type AdaptorCls,
+  adapt,
+  CacheAdaptorRole,
+  type DatabaseAdaptor,
+  DatabaseAdaptorRole,
+  type DocumentStore,
+} from "akanjs/service";
+
+export class DatabaseResolver {
+  static resolveDatabase(constant: ConstantModel, database: DatabaseModel): AdaptorCls<DatabaseInstance> {
+    const [modelName, className]: [string, string] = [database.refName, capitalize(database.refName)];
+    const getListQuery = (query?: QueryOf<any>, queryOption?: ListQueryOption) => {
+      const find = query ?? {};
+      const sort = getFilterSortByKey(database.filter, queryOption?.sort ?? "latest") as {
+        [key: string]: 1 | -1;
+      };
+      const skip = Number(queryOption?.skip ?? 0);
+      const limit = queryOption?.limit === null ? DEFAULT_PAGE_SIZE : Number(queryOption?.limit ?? 0);
+      const select = queryOption?.select;
+      const sample = queryOption?.sample;
+      return { find, sort, skip, limit, select, sample };
+    };
+    const getFindQuery = (query?: QueryOf<any>, queryOption?: FindQueryOption) => {
+      const find = query ?? {};
+      const sort = getFilterSortByKey(database.filter, queryOption?.sort ?? "latest") as {
+        [key: string]: 1 | -1;
+      };
+      const skip = Number(queryOption?.skip ?? 0);
+      const select = queryOption?.select;
+      const sample = queryOption?.sample ?? false;
+      return { find, sort, skip, select, sample };
+    };
+    const schema = new DocumentSchema();
+    database.model._onSchema(schema as any);
+    database.model._libsOnSchema(schema as any);
+
+    class DatabaseModelInstance extends adapt(`${modelName}Model`, ({ plug }) => ({
+      __database: plug(DatabaseAdaptorRole, (database) => database),
+      __cache: plug(CacheAdaptorRole, (cache) => new CacheDatabase(modelName, cache)),
+      [`${modelName}Cache` as never]: plug(CacheAdaptorRole, (cache) => new CacheDatabase(modelName, cache)),
+    })) {
+      declare readonly __database: DatabaseAdaptor;
+      __store!: DocumentStore;
+      __model!: Mdl<any, any>;
+      __loader!: DataLoader<string, any, string>;
+
+      override async onInit() {
+        this.__store = this.__database.getStore(constant, database, schema);
+        await this.__store.ensure();
+        this.__model = this.#createModelFacade() as unknown as Mdl<any, any>;
+        this.__loader = new DataLoader<string, any>(
+          async (ids) => await Promise.all(ids.map((id) => this.__store.findOne({ id }))),
+          { name: `${modelName}Loader`, cache: false },
+        );
+        Object.assign(this, {
+          [className]: this.__model,
+          [`${modelName}Loader`]: this.__loader,
+        });
+        Object.entries(getLoaderInfos(database.model)).forEach(([key, loaderInfo]) => {
+          Object.assign(this, {
+            [key]: new DataLoader<any, any>(async (keys) => {
+              return await Promise.all(
+                keys.map(async (key) => {
+                  const query =
+                    loaderInfo.type === "query"
+                      ? key
+                      : {
+                          [loaderInfo.field as string]:
+                            loaderInfo.type === "arrayField" ? documentQueryHelper.has(key) : key,
+                        };
+                  return await this.__store.findOne(documentQueryHelper.all(loaderInfo.defaultQuery, query));
+                }),
+              );
+            }),
+          });
+        });
+      }
+
+      #createModelFacade() {
+        const store = this.__store;
+        function Model(this: any, data: Record<string, unknown>) {
+          return store.hydrate(data);
+        }
+        const createFindManyChain = (
+          query: QueryOf<any>,
+          options: { sort?: any; skip?: number; limit?: number } = {},
+        ) => {
+          const chain: any = {
+            sort(sort: any) {
+              return createFindManyChain(query, { ...options, sort });
+            },
+            skip(skip: number) {
+              return createFindManyChain(query, { ...options, skip });
+            },
+            limit(limit: number) {
+              return createFindManyChain(query, { ...options, limit });
+            },
+            select() {
+              return createFindManyChain(query, options);
+            },
+            
+            then(resolve: (value: any[]) => void, reject: (reason: unknown) => void) {
+              return store.find(query, options).then(resolve, reject);
+            },
+            catch(reject: (reason: unknown) => void) {
+              return store.find(query, options).catch(reject);
+            },
+          };
+          return chain;
+        };
+        const createFindOneChain = (query: QueryOf<any>, options: { sort?: any; skip?: number } = {}) => {
+          const chain: any = {
+            sort(sort: any) {
+              return createFindOneChain(query, { ...options, sort });
+            },
+            skip(skip: number) {
+              return createFindOneChain(query, { ...options, skip });
+            },
+            select() {
+              return createFindOneChain(query, options);
+            },
+            
+            then(resolve: (value: any | null) => void, reject: (reason: unknown) => void) {
+              return store.findOne(query, options).then(resolve, reject);
+            },
+            catch(reject: (reason: unknown) => void) {
+              return store.findOne(query, options).catch(reject);
+            },
+          };
+          return chain;
+        };
+        return Object.assign(Model, {
+          refName: modelName,
+          pickOne: (query: QueryOf<any>, _projection?: any) => store.pickOne(query),
+          pickById: (id: string | undefined, _projection?: any) => {
+            if (!id) throw new Error("No Document ID");
+            return store.pickById(id);
+          },
+          exists: async (query: QueryOf<any>) => await store.exists(query),
+          sample: (query: QueryOf<any>, size = 1) => store.find(query, { sample: size, limit: size }),
+          sampleOne: (query: QueryOf<any>) => store.findOne(query, { sample: true }),
+          find: (query: QueryOf<any>) => createFindManyChain(query),
+          findOne: (query: QueryOf<any>) => createFindOneChain(query),
+          findById: (id: string | undefined) => (id ? store.findOne({ id }) : Promise.resolve(null)),
+          countDocuments: (query: QueryOf<any>) => store.count(query),
+          updateOne: (query: QueryOf<any>, update: Record<string, unknown>, options?: { upsert?: boolean }) =>
+            store.updateOneByQuery(query, update, options),
+          updateMany: (query: QueryOf<any>, update: Record<string, unknown>) => store.updateManyByQuery(query, update),
+          deleteMany: (query: QueryOf<any>) => store.deleteManyByQuery(query),
+          bulkWrite: (
+            operations: { updateOne: { filter: QueryOf<any>; update: Record<string, unknown>; upsert?: boolean } }[],
+          ) => store.bulkWrite(operations),
+          listenPre: (type: SaveEventType, listener: (doc: any, type: CRUDEventType) => PromiseOrObject<void>) =>
+            schema.pre(type, function (this: any, _next, crudType) {
+              return listener(this, crudType ?? "update");
+            }),
+          listenPost: (type: SaveEventType, listener: (doc: any, type: CRUDEventType) => PromiseOrObject<void>) =>
+            schema.post(type, function (this: any, _next, crudType) {
+              return listener(this, crudType ?? "update");
+            }),
+        });
+      }
+
+      async __list(query?: QueryOf<any>, queryOption?: ListQueryOption): Promise<any[]> {
+        const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
+        return await this.__store.find(find, { sort, skip, limit, sample });
+      }
+      async __listIds(query?: QueryOf<any>, queryOption?: ListQueryOption): Promise<string[]> {
+        const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
+        return await this.__store.findIds(find, { sort, skip, limit, sample });
+      }
+      async __find(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<any | null> {
+        const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+        return await this.__store.findOne(find, { sort, skip, sample });
+      }
+      async __findId(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<string | null> {
+        const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+        return await this.__store.findId(find, { sort, skip, sample });
+      }
+      async __pick(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<any> {
+        const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+        return await this.__store.pickOne(find, { sort, skip, sample });
+      }
+      async __pickId(query?: QueryOf<any>, queryOption?: FindQueryOption): Promise<string> {
+        const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+        const id = await this.__store.findId(find, { sort, skip, sample });
+        if (!id) throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
+        return id;
+      }
+      async __exists(query?: QueryOf<any>): Promise<string | null> {
+        return await this.__store.exists(query);
+      }
+      async __count(query?: QueryOf<any>): Promise<number> {
+        return await this.__store.count(query);
+      }
+      async __insight(query?: QueryOf<any>): Promise<any> {
+        return await this.__store.insight(query);
+      }
+      listenPre(type: SaveEventType, listener: (doc: any, type: CRUDEventType) => PromiseOrObject<void>) {
+        schema.pre(type, function (this: any, _next, crudType) {
+          return listener(this, crudType ?? "update");
+        });
+        return () => undefined;
+      }
+      listenPost(type: SaveEventType, listener: (doc: any, type: CRUDEventType) => PromiseOrObject<void>) {
+        schema.post(type, function (this: any, _next, crudType) {
+          return listener(this, crudType ?? "update");
+        });
+        return () => undefined;
+      }
+      async __get(id: string) {
+        const doc = await this.__loader.load(id);
+        if (!doc) throw new Error(`No Document (${database.refName}): ${id}`);
+        return doc;
+      }
+      async [`get${className}`](id: string) {
+        return this.__get(id);
+      }
+      async __load(id?: string) {
+        return (id ? await this.__loader.load(id) : null) as any | null;
+      }
+      async [`load${className}`](id?: string) {
+        return this.__load(id);
+      }
+      async __loadMany(ids: string[]) {
+        return await this.__loader.loadMany(ids);
+      }
+      async [`load${className}Many`](ids: string[]) {
+        return this.__loadMany(ids);
+      }
+      async clone(data: DataInputOf<any, any> & { id: string }) {
+        return await this.__store.clone(data);
+      }
+      async __create(data: DataInputOf<any, any>) {
+        return await this.__store.create(data);
+      }
+      async [`create${className}`](data: DataInputOf<any, any>) {
+        return this.__create(data);
+      }
+      async __update(id: string, data: DataInputOf<any, any>) {
+        return await this.__store.update(id, data);
+      }
+      async [`update${className}`](id: string, data: DataInputOf<any, any>) {
+        return this.__update(id, data);
+      }
+      async __remove(id: string) {
+        return await this.__store.remove(id);
+      }
+      async [`remove${className}`](id: string) {
+        return this.__remove(id);
+      }
+    }
+
+    const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
+      const lastArg = args.at(-1);
+      const hasQueryOption =
+        lastArg &&
+        typeof lastArg === "object" &&
+        (typeof lastArg.select === "object" ||
+          typeof lastArg.skip === "number" ||
+          typeof lastArg.limit === "number" ||
+          typeof lastArg.sort === "string");
+      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
+      const queryFn = filterInfo.queryFn;
+      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
+      const query = queryFn(...(hasQueryOption ? args.slice(0, -1) : args), documentQueryHelper);
+      const queryOption = hasQueryOption ? lastArg : {};
+      return { query, queryOption };
+    };
+    const filterMeta = getFilterMeta(database.filter);
+
+    Object.entries(filterMeta.query).forEach(([queryKey, filterInfo]) => {
+      const queryFn = filterInfo.queryFn;
+      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
+      Object.assign(DatabaseModelInstance.prototype, {
+        [`list${capitalize(queryKey)}`]: async function (...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return (this as unknown as DatabaseInstance).__list(query, queryOption);
+        },
+        [`listIds${capitalize(queryKey)}`]: async function (...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return (this as unknown as DatabaseInstance).__listIds(query, queryOption);
+        },
+        [`find${capitalize(queryKey)}`]: async function (...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return (this as unknown as DatabaseInstance).__find(query, queryOption);
+        },
+        [`findId${capitalize(queryKey)}`]: async function (...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return (this as unknown as DatabaseInstance).__findId(query, queryOption);
+        },
+        [`pick${capitalize(queryKey)}`]: async function (...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return (this as unknown as DatabaseInstance).__pick(query, queryOption);
+        },
+        [`pickId${capitalize(queryKey)}`]: async function (...args: any) {
+          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+          return (this as unknown as DatabaseInstance).__pickId(query, queryOption);
+        },
+        [`exists${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...args, documentQueryHelper);
+          return (this as unknown as DatabaseInstance).__exists(query);
+        },
+        [`count${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...args, documentQueryHelper);
+          return (this as unknown as DatabaseInstance).__count(query);
+        },
+        [`insight${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...args, documentQueryHelper);
+          return (this as unknown as DatabaseInstance).__insight(query);
+        },
+        [`query${capitalize(queryKey)}`]: (...args: any) => queryFn(...args, documentQueryHelper),
+      });
+    });
+    applyMixins(DatabaseModelInstance, [database.model]);
+    return DatabaseModelInstance as unknown as AdaptorCls<DatabaseInstance<any, any, any, any, any, any>>;
+  }
+}

package/server/resolver/index.ts

@@ -0,0 +1,3 @@
+export * from "./database.resolver";
+export * from "./service.resolver";
+export * from "./signal.resolver";

package/server/resolver/resolver.contract.fixture.ts

@@ -0,0 +1,222 @@
+import { ID, Int } from "akanjs/base";
+import { ConstantRegistry, via } from "akanjs/constant";
+import { by, type DatabaseCls, DatabaseRegistry, from, into, type ModelCls, type SchemaOf } from "akanjs/document";
+import { ServiceModel, serve } from "akanjs/service";
+import { endpoint } from "../../signal/endpoint";
+import { Public } from "../../signal/guards";
+import { internal } from "../../signal/internal";
+import { middleware } from "../../signal/middleware";
+import { serverSignal } from "../../signal/serverSignal";
+import type { SignalContext } from "../../signal/signalContext";
+import { slice } from "../../signal/slice";
+
+const ServerResolverTestNested = via((f) => ({
+  label: f(String),
+}));
+ConstantRegistry.buildScalar("serverResolverTestNested", ServerResolverTestNested, { ServerResolverTestNested });
+
+const ServerResolverTestInput = via((f) => ({
+  ownerId: f(ID),
+  category: f(String),
+  title: f(String),
+  count: f(Int, { default: 0 }),
+  tags: f([String]),
+  nested: f(ServerResolverTestNested),
+}));
+const ServerResolverTestObject = via(ServerResolverTestInput, (f) => ({
+  secret: f.secret(String),
+}));
+export const ServerResolverTestLight = via(ServerResolverTestObject, ["title", "category"] as const, () => ({}));
+const ServerResolverTestFull = via(ServerResolverTestObject, ServerResolverTestLight, (r) => ({
+  resolvedLabel: r(String),
+}));
+const ServerResolverTestInsight = via(ServerResolverTestFull, (f) => ({
+  total: f(Int, { default: 0, accumulate: { $sum: "$count" } }),
+}));
+export const serverResolverTestConstant = ConstantRegistry.buildModel(
+  "serverResolverTestItem",
+  ServerResolverTestInput,
+  ServerResolverTestObject,
+  ServerResolverTestFull,
+  ServerResolverTestLight,
+  ServerResolverTestInsight,
+  {
+    ServerResolverTestInput,
+    ServerResolverTestObject,
+    ServerResolverTestFull,
+    ServerResolverTestLight,
+    ServerResolverTestInsight,
+  },
+);
+
+class ServerResolverTestFilter extends from(ServerResolverTestFull, (filter) => ({
+  query: {
+    inCategory: filter()
+      .arg("category", String)
+      .opt("includeRemoved", Boolean)
+      .query((category, includeRemoved, q) => q.all({ category }, q.when(!includeRemoved, q.empty("removedAt")))),
+    byOwner: filter()
+      .arg("ownerId", ID, { ref: "user" })
+      .query((ownerId) => ({ ownerId })),
+  },
+  sort: {
+    titleAsc: { title: 1 },
+  },
+})) {}
+
+class ServerResolverTestDoc extends by(ServerResolverTestFull) {}
+
+export class ServerResolverTestModelMixin {
+  static schemaTouched = false;
+  static _onSchema(schema: SchemaOf) {
+    ServerResolverTestModelMixin.schemaTouched = true;
+    schema.index({ category: 1 });
+    schema.pre("create", () => {
+    });
+  }
+  static modelKind() {
+    return "resolver-contract";
+  }
+}
+
+class ServerResolverTestModel extends into(
+  ServerResolverTestDoc,
+  ServerResolverTestFilter,
+  serverResolverTestConstant,
+  (loader) => ({
+    byOwner: loader.byField("ownerId", { removedAt: { kind: "op", op: "empty" } }),
+    byTag: loader.byArrayField("tags"),
+    byOwnerCategory: loader.byQuery(["ownerId", "category"] as const),
+  }),
+  ServerResolverTestModelMixin as unknown as ModelCls,
+) {}
+
+export const serverResolverTestDatabase = DatabaseRegistry.buildModel(
+  "serverResolverTestItem",
+  ServerResolverTestInput as unknown as DatabaseCls<InstanceType<typeof ServerResolverTestInput>>,
+  ServerResolverTestDoc,
+  ServerResolverTestModel,
+  ServerResolverTestObject,
+  ServerResolverTestInsight,
+  ServerResolverTestFilter,
+);
+
+class ParentHookService extends serve(serverResolverTestDatabase, () => ({})) {
+  _preCreate(data: Record<string, unknown>) {
+    return { ...data, parentPreCreate: true };
+  }
+  _postCreate(doc: Record<string, unknown>) {
+    return { ...doc, parentPostCreate: true };
+  }
+}
+
+export class ServerResolverTestService extends serve(serverResolverTestDatabase, () => ({}), ParentHookService) {
+  _preCreate(data: Record<string, unknown>) {
+    return { ...data, childPreCreate: true };
+  }
+  _postCreate(doc: Record<string, unknown>) {
+    return { ...doc, childPostCreate: true };
+  }
+  queryInCategory(category: string) {
+    return { category };
+  }
+  categoryEcho(category: string) {
+    return category;
+  }
+}
+
+export const serverResolverTestServiceModel = ServiceModel.fromModel(
+  ServerResolverTestService,
+  serverResolverTestConstant,
+  serverResolverTestDatabase,
+);
+
+export let resolverOrder: string[] = [];
+export const resetResolverOrder = () => {
+  resolverOrder = [];
+};
+export const validId = "507f1f77bcf86cd799439011";
+
+export class ServerResolverTestMiddleware extends middleware("serverResolverTestMiddleware") {
+  override async use() {
+    return async (_context: SignalContext, next: () => Promise<unknown>) => {
+      resolverOrder.push("global-before");
+      const result = await next();
+      resolverOrder.push("global-after");
+      return result;
+    };
+  }
+}
+
+export class ServerResolverTestEndpoint extends endpoint(serverResolverTestServiceModel, (builder) => ({
+  getTitle: builder
+    .query(String, {
+      guards: [Public],
+      middlewares: [ServerResolverTestMiddleware],
+      globalPrefix: false,
+      prefix: false,
+    })
+    .param("id", ID)
+    .search("suffix", String)
+    .exec(function (id, suffix) {
+      resolverOrder.push(`query:${id}:${suffix}`);
+      return `${id}:${suffix}:${this.serverResolverTestItemService.categoryEcho("public")}`;
+    }),
+  updateTitle: builder
+    .mutation(ServerResolverTestLight)
+    .param("id", ID)
+    .body("data", ServerResolverTestInput)
+    .exec((id, data) => {
+      return { id, ...data, createdAt: new Date(0), updatedAt: new Date(0), removedAt: null, secret: "hidden" };
+    }),
+  roomFeed: builder
+    .pubsub(ServerResolverTestLight)
+    .room("roomId", ID)
+    .exec(() => {
+      resolverOrder.push("pubsub-subscribe");
+    }),
+  echoMessage: builder
+    .message(String)
+    .msg("text", String)
+    .exec((text) => `echo:${text}`),
+})) {}
+
+export class ServerResolverTestSlice extends slice(
+  serverResolverTestServiceModel,
+  { guards: { root: Public, get: Public, cru: Public } },
+  (init) => ({
+    inCategory: init()
+      .search("category", String)
+      .exec(function (category) {
+        return this.serverResolverTestItemService.queryInCategory(category ?? "all");
+      }),
+  }),
+) {}
+
+export class ServerResolverTestInternal extends internal(serverResolverTestServiceModel, (builder) => ({
+  processItem: builder
+    .process(Boolean)
+    .msg("itemId", ID)
+    .exec(() => true),
+  boot: builder.initialize().exec(() => {
+    resolverOrder.push("init");
+  }),
+  cleanup: builder.destroy().exec(() => {
+    resolverOrder.push("destroy");
+  }),
+})) {}
+
+export class ServerResolverTestServerSignal extends serverSignal(
+  ServerResolverTestEndpoint,
+  ServerResolverTestInternal,
+) {}
+
+export const makeEnv = () => ({
+  repoName: "akan",
+  serveDomain: "example.com",
+  appName: "serverResolver",
+  environment: "local",
+  operationMode: "local",
+  tunnelUsername: "root",
+  tunnelPassword: "akan",
+});