akanjs 2.3.11-rc.0 → 2.3.11-rc.2

package/document/documentQuery.ts

@@ -53,21 +53,67 @@ export type DocumentQueryValue =
   | 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 type DocumentUpdateOperator =
+  | "set"
+  | "unset"
+  | "inc"
+  | "mul"
+  | "min"
+  | "max"
+  | "push"
+  | "pull"
+  | "addToSet"
+  | "setOnInsert";
+
+export interface DocumentUpdateNode {
+  kind: "update";
+  op: DocumentUpdateOperator;
+  value?: unknown;
 }
 
+export type DocumentUpdateValue =
+  | DocumentUpdateNode
+  | DocumentPrimitive
+  | DocumentPrimitive[]
+  | Record<string, unknown>
+  | undefined;
+
+export type DocumentUpdate<T = any> = {
+  [K in DocumentPath<T>]?: DocumentUpdateValue;
+};
+
 export interface DocumentUpdateOptions {
   upsert?: boolean;
 }
 
+const updateOp = (op: DocumentUpdateOperator, value?: unknown): DocumentUpdateNode => ({ kind: "update", op, value });
+
+export const createDocumentUpdateHelper = () => ({
+  set: (value: unknown) => updateOp("set", value),
+  unset: () => updateOp("unset"),
+  inc: (by = 1) => updateOp("inc", by),
+  mul: (by: number) => updateOp("mul", by),
+  min: (value: unknown) => updateOp("min", value),
+  max: (value: unknown) => updateOp("max", value),
+  push: (value: unknown) => updateOp("push", value),
+  pull: (value: unknown) => updateOp("pull", value),
+  addToSet: (value: unknown) => updateOp("addToSet", value),
+  setOnInsert: (value: unknown) => updateOp("setOnInsert", value),
+});
+
+export type DocumentUpdateHelper = ReturnType<typeof createDocumentUpdateHelper>;
+
+export const documentUpdateHelper = createDocumentUpdateHelper();
+
+export type DocumentUpdateBuilder<T = any> = (helper: DocumentUpdateHelper) => DocumentUpdate<T>;
+export type DocumentUpdateInput<T = any> = DocumentUpdate<T> | DocumentUpdateBuilder<T>;
+
+export const resolveDocumentUpdate = <T>(update: DocumentUpdateInput<T>): DocumentUpdate<T> =>
+  typeof update === "function" ? update(documentUpdateHelper) : update;
+
+export const isDocumentUpdateNode = (value: unknown): value is DocumentUpdateNode =>
+  !!value && typeof value === "object" && (value as { kind?: unknown }).kind === "update";
+
 export type DocumentQuery<T = any> =
   | DocumentQueryNode
   | {

package/document/into.ts

@@ -4,7 +4,7 @@ import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { FilterCls, FilterQueryOf, FilterSortOf, SchemaOf } from ".";
 import type { CacheDatabase, QueryMethodPart } from "./database";
 import type { DataLoader } from "./dataLoader";
-import type { DocumentUpdate, DocumentUpdateOptions } from "./documentQuery";
+import type { DocumentQuery, DocumentUpdateInput, DocumentUpdateOptions } from "./documentQuery";
 import { type LoaderBuilder, type ModelCls, makeLoaderBuilder } from "./loaderInfo";
 import type { DocumentProjection } from "./types";
 
@@ -15,7 +15,7 @@ interface DefaultMdlStats<
   TDocument,
   TSchema,
   _Partial extends Partial<TSchema> = Partial<TSchema>,
-  _FilterQuery extends QueryOf<TSchema> = QueryOf<TSchema>,
+  _FilterQuery extends DocumentQuery<TSchema> = DocumentQuery<TSchema>,
   _Projection = DocumentProjection<TSchema>,
 > {
   pickOneAndWrite: (query: _FilterQuery, rawData: _Partial) => Promise<TDocument>;
@@ -47,10 +47,10 @@ export interface UpdateResult {
   modifiedCount: number;
   upsertedId?: string | null;
 }
-export interface BulkWriteOperation<Raw, _RawDoc = DocumentModel<Raw>, _RawQuery = QueryOf<_RawDoc>> {
+export interface BulkWriteOperation<Raw, _RawDoc = DocumentModel<Raw>, _RawQuery = DocumentQuery<_RawDoc>> {
   updateOne: {
     filter: _RawQuery;
-    update: DocumentUpdate;
+    update: DocumentUpdateInput<_RawDoc>;
     upsert?: boolean;
   };
 }
@@ -69,7 +69,7 @@ export type Mdl<
   Doc,
   Raw,
   _RawDoc = DocumentModel<Raw>,
-  _RawQuery = QueryOf<_RawDoc>,
+  _RawQuery extends DocumentQuery<_RawDoc> = DocumentQuery<_RawDoc>,
   _Projection extends DocumentProjection<Raw> = DocumentProjection<Raw>,
 > = DefaultMdlStats<Doc, _RawDoc, Partial<_RawDoc>, _RawQuery, _Projection> & {
   refName: string;
@@ -79,8 +79,12 @@ export type Mdl<
   findById(id: string | undefined, projection?: _Projection): Promise<Doc | null>;
   countDocuments(query: _RawQuery): Promise<number>;
   exists(query: _RawQuery): Promise<string | null>;
-  updateOne(query: _RawQuery, update: DocumentUpdate, options?: DocumentUpdateOptions): Promise<UpdateResult>;
-  updateMany(query: _RawQuery, update: DocumentUpdate): Promise<UpdateResult>;
+  updateOne(
+    query: _RawQuery,
+    update: DocumentUpdateInput<_RawDoc>,
+    options?: DocumentUpdateOptions,
+  ): Promise<UpdateResult>;
+  updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>): Promise<UpdateResult>;
   deleteMany(query: _RawQuery): Promise<UpdateResult>;
   bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.3.11-rc.0",
+  "version": "2.3.11-rc.2",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/resolver/database.resolver.ts

@@ -9,6 +9,7 @@ import {
   type DataInputOf,
   DataLoader,
   DocumentSchema,
+  type DocumentUpdateInput,
   documentQueryHelper,
   type FindQueryOption,
   fillMissingFilterArgs,
@@ -219,12 +220,12 @@ export class DatabaseResolver {
           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 }) =>
+          updateOne: (query: QueryOf<any>, update: DocumentUpdateInput, options?: { upsert?: boolean }) =>
             store.updateOneByQuery(query, update, options),
-          updateMany: (query: QueryOf<any>, update: Record<string, unknown>) => store.updateManyByQuery(query, update),
+          updateMany: (query: QueryOf<any>, update: DocumentUpdateInput) => store.updateManyByQuery(query, update),
           deleteMany: (query: QueryOf<any>) => store.deleteManyByQuery(query),
           bulkWrite: (
-            operations: { updateOne: { filter: QueryOf<any>; update: Record<string, unknown>; upsert?: boolean } }[],
+            operations: { updateOne: { filter: QueryOf<any>; update: DocumentUpdateInput; upsert?: boolean } }[],
           ) => store.bulkWrite(operations),
           listenPre: (type: SaveEventType, listener: (doc: any, type: CRUDEventType) => PromiseOrObject<void>) =>
             schema.pre(type, function (this: any, _next, crudType) {