akanjs 2.1.0-rc.7 → 2.1.0-rc.9

package/document/filterMeta.ts

@@ -93,6 +93,11 @@ export const getFilterSortByKey = (modelRef: FilterCls, key: string) => {
   return filterMeta.sort[key];
 };
 
+export const fillMissingFilterArgs = (filterInfo: FilterInfo, args: unknown[]) => {
+  if (args.length >= filterInfo.args.length) return args;
+  return [...args, ...Array(filterInfo.args.length - args.length).fill(undefined)];
+};
+
 export type BaseFilterSortKey = "latest" | "oldest";
 export type BaseFilterQueryKey = "any";
 export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;

package/fetch/client/fetchClient.ts

@@ -19,6 +19,16 @@ import { WsClient } from "./wsClient";
 type FetchHandler = (...args: unknown[]) => PromiseOrObject<unknown>;
 type UnknownRecord = Record<string, unknown>;
 
+const isNullableArg = (arg: SerializedArg) => arg.nullable ?? arg.type === "search";
+
+const normalizeQueryArgs = (queryArgs: unknown[], args: SerializedArg[]) => {
+  let length = Math.min(queryArgs.length, args.length);
+  while (length > 0 && isNullableArg(args[length - 1]) && queryArgs[length - 1] == null) length--;
+  return queryArgs.slice(0, length);
+};
+
+const expandQueryArgs = (queryArgs: unknown[], args: SerializedArg[]) => args.map((_, idx) => queryArgs[idx]);
+
 export type FetchProxy<
   FetchType = unknown,
   SliceMetaObj extends Record<string, SliceMeta> = Record<never, never>,
@@ -411,14 +421,18 @@ export class FetchClient {
     const listFn = this.handler[names.list] as (...args: unknown[]) => Promise<unknown[]>;
     const insightFn = this.handler[names.insight] as (...args: unknown[]) => Promise<unknown>;
     const initFn = async (...argData: unknown[]) => {
-      const queryArgs = Array.from({ length: argLength }, (_, idx) => argData[idx]);
+      const queryArgs = normalizeQueryArgs(
+        Array.from({ length: Math.min(argData.length, argLength) }, (_, idx) => argData[idx]),
+        slice.args,
+      );
+      const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
       const option = (argData[argLength] ?? {}) as { page?: number; limit?: number; sort?: string; insight?: boolean };
       const { page = 1, limit = 20, sort = "latest", insight: fetchInsight = true } = option;
       const skip = (page - 1) * limit;
 
       const [modelObjList, modelObjInsight] = (await Promise.all([
-        listFn(...queryArgs, skip, limit, sort, { ...option, crystalize: false }),
-        fetchInsight ? insightFn(...queryArgs, { ...option, crystalize: false }) : null,
+        listFn(...fetchQueryArgs, skip, limit, sort, { ...option, crystalize: false }),
+        fetchInsight ? insightFn(...fetchQueryArgs, { ...option, crystalize: false }) : null,
       ])) as unknown as [BaseObject[], BaseInsight];
       const modelList = new DataList(modelObjList.map((modelObj) => new cnst.light(modelObj)));
       const modelInsight = new cnst.insight(modelObjInsight);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.1.0-rc.7",
+  "version": "2.1.0-rc.9",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/resolver/database.resolver.ts

@@ -11,6 +11,7 @@ import {
   DocumentSchema,
   documentQueryHelper,
   type FindQueryOption,
+  fillMissingFilterArgs,
   getFilterInfoByKey,
   getFilterMeta,
   getFilterSortByKey,
@@ -338,7 +339,8 @@ export class DatabaseResolver {
       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 queryArgs = fillMissingFilterArgs(filterInfo, hasQueryOption ? args.slice(0, -1) : args);
+      const query = queryFn(...queryArgs, documentQueryHelper);
       const queryOption = hasQueryOption ? lastArg : {};
       return { query, queryOption };
     };
@@ -371,18 +373,19 @@ export class DatabaseResolver {
           return (this as unknown as DatabaseInstance).__pickId(query, queryOption);
         },
         [`exists${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...args, documentQueryHelper);
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
           return (this as unknown as DatabaseInstance).__exists(query);
         },
         [`count${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...args, documentQueryHelper);
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
           return (this as unknown as DatabaseInstance).__count(query);
         },
         [`insight${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...args, documentQueryHelper);
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
           return (this as unknown as DatabaseInstance).__insight(query);
         },
-        [`query${capitalize(queryKey)}`]: (...args: any) => queryFn(...args, documentQueryHelper),
+        [`query${capitalize(queryKey)}`]: (...args: any) =>
+          queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper),
       });
     });
     applyMixins(DatabaseModelInstance, [database.model]);

package/server/resolver/service.resolver.ts

@@ -8,6 +8,7 @@ import {
   type Doc,
   documentQueryHelper,
   type FindQueryOption,
+  fillMissingFilterArgs,
   getFilterInfoByKey,
   getFilterMeta,
   type ListQueryOption,
@@ -116,9 +117,11 @@ export class ServiceResolver {
           typeof lastArg.skip === "number" ||
           typeof lastArg.limit === "number" ||
           typeof lastArg.sort === "string");
-      const queryFn = getFilterInfoByKey(database.filter, queryKey).queryFn;
+      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 queryArgs = fillMissingFilterArgs(filterInfo, hasQueryOption ? args.slice(0, -1) : args);
+      const query = queryFn(...queryArgs, documentQueryHelper);
       const queryOption = hasQueryOption ? lastArg : {};
       return { query, queryOption };
     };
@@ -167,7 +170,7 @@ export class ServiceResolver {
           return this.__insight(query);
         },
         [`query${capitalize(queryKey)}`]: function (this: DatabaseService, ...args: any) {
-          return queryFn(...args, documentQueryHelper);
+          return queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
         },
       });
     });

package/service/predefinedAdaptor/database.adaptor.ts

@@ -1003,7 +1003,8 @@ export class SqliteDocumentStore {
     const store = this;
     const original = JSON.parse(JSON.stringify(sanitizeJson(originalData) ?? {})) as Record<string, unknown>;
     const isNew = !originalData.id;
-    const doc = Object.assign(Object.create(this.database.doc.prototype), data);
+    const hydratedData = isNew ? this.prepareDocument(data) : data;
+    const doc = Object.assign(Object.create(this.database.doc.prototype), hydratedData);
     Object.defineProperties(doc, {
       set: {
         value(patch: DocumentRecord) {

package/store/action.ts

@@ -25,6 +25,17 @@ type SliceActionKey =
   | "setQueryArgsOfModel"
   | "setSortOfModel";
 
+const isNullableSliceArg = (arg: SerializedSlice["args"][number]) => arg.nullable ?? arg.type === "search";
+
+const normalizeQueryArgs = (queryArgs: unknown[], sliceArgs: SerializedSlice["args"]) => {
+  let length = Math.min(queryArgs.length, sliceArgs.length);
+  while (length > 0 && isNullableSliceArg(sliceArgs[length - 1]) && queryArgs[length - 1] == null) length--;
+  return queryArgs.slice(0, length);
+};
+
+const expandQueryArgs = (queryArgs: unknown[], sliceArgs: SerializedSlice["args"]) =>
+  sliceArgs.map((_, idx) => queryArgs[idx]);
+
 export interface CreateOption<Full extends { id: string }> {
   idx?: number;
   path?: string;
@@ -852,10 +863,13 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const refreshArgLength = Math.min(args.length, slice.args.length);
         const currentState = this.get() as { [key: string]: any };
         const existingQueryArgs = currentState[namesOfSlice.queryArgsOfModel] as object[];
-        const queryArgs = [
-          ...new Array(refreshArgLength).fill(null).map((_, i) => args[i] as object),
-          ...existingQueryArgs.slice(refreshArgLength, slice.args.length),
-        ];
+        const queryArgs = normalizeQueryArgs(
+          [
+            ...new Array(refreshArgLength).fill(null).map((_, i) => args[i] as object),
+            ...existingQueryArgs.slice(refreshArgLength, slice.args.length),
+          ],
+          slice.args,
+        );
         const {
           default: defaultFromInitForm,
           insight,
@@ -881,15 +895,16 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         )
           return; 
         else this.set({ [namesOfSlice.modelListLoading]: true });
+        const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
         const [modelDataList, modelInsight] = await Promise.all([
           (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-            ...queryArgs,
+            ...fetchQueryArgs,
             (page - 1) * limit,
             limit,
             sort,
             { ...fetchPolicy, onError: initForm.onError },
           ),
-          (fetch[namesOfSlice.modelInsight] as (...args: any[]) => Promise<Insight & BaseInsight>)(...queryArgs, {
+          (fetch[namesOfSlice.modelInsight] as (...args: any[]) => Promise<Insight & BaseInsight>)(...fetchQueryArgs, {
             ...fetchPolicy,
             onError: initForm.onError,
           }),
@@ -934,8 +949,9 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (pageOfModel === page) return;
         this.set({ [namesOfSlice.modelListLoading]: true });
+        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
         const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-          ...queryArgsOfModel,
+          ...fetchQueryArgs,
           (page - 1) * limitOfModel,
           limitOfModel,
           sortOfModel,
@@ -957,8 +973,9 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (pageOfModel === page) return;
         const addFront = page < pageOfModel;
+        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
         const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-          ...queryArgsOfModel,
+          ...fetchQueryArgs,
           (page - 1) * limitOfModel,
           limitOfModel,
           sortOfModel,
@@ -979,8 +996,9 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         if (limitOfModel === limit) return;
         const skip = (pageOfModel - 1) * limitOfModel;
         const page = Math.max(Math.floor((skip - 1) / limit) + 1, 1);
+        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
         const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-          ...queryArgsOfModel,
+          ...fetchQueryArgs,
           (page - 1) * limit,
           limit,
           sortOfModel,
@@ -1004,9 +1022,12 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const currentState = this.get() as { [key: string]: any };
         const options = (isSetQueryAsFunction ? args[1] : args[slice.args.length]) as FetchPolicy | undefined;
         const queryArgsOfModel = currentState[namesOfSlice.queryArgsOfModel] as object[];
-        const queryArgs = isSetQueryAsFunction
-          ? (args[0] as (...prevQueryArgs: object[]) => object[])(...queryArgsOfModel)
-          : new Array(slice.args.length).fill(null).map((_, i) => args[i] as object);
+        const queryArgs = normalizeQueryArgs(
+          isSetQueryAsFunction
+            ? (args[0] as (...prevQueryArgs: object[]) => object[])(...queryArgsOfModel)
+            : new Array(slice.args.length).fill(null).map((_, i) => args[i] as object),
+          slice.args,
+        );
         const limitOfModel = currentState[namesOfSlice.limitOfModel] as number;
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (isQueryEqual(queryArgsOfModel, queryArgs)) {
@@ -1014,16 +1035,17 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
           return; 
         }
         this.set({ [namesOfSlice.modelListLoading]: true });
+        const fetchQueryArgs = expandQueryArgs(queryArgs, slice.args);
         const [modelDataList, modelInsight] = await Promise.all([
           (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-            ...queryArgs,
+            ...fetchQueryArgs,
             0,
             limitOfModel,
             sortOfModel,
             options,
           ),
           (fetch[namesOfSlice.modelInsight] as (...args: any[]) => Promise<Insight & BaseInsight>)(
-            ...queryArgs,
+            ...fetchQueryArgs,
             options,
           ),
         ]);
@@ -1045,8 +1067,9 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
         const sortOfModel = currentState[namesOfSlice.sortOfModel] as Sort;
         if (sortOfModel === sort) return; 
         this.set({ [namesOfSlice.modelListLoading]: true });
+        const fetchQueryArgs = expandQueryArgs(queryArgsOfModel, slice.args);
         const modelDataList = await (fetch[namesOfSlice.modelList] as (...args: any[]) => Promise<Light[]>)(
-          ...queryArgsOfModel,
+          ...fetchQueryArgs,
           0,
           limitOfModel,
           sort,

package/store/state.ts

@@ -1,6 +1,6 @@
-import { DataList, PRIMITIVE_DEFAULT_VALUE, PrimitiveRegistry, type SLICE_META } from "akanjs/base";
+import { DataList, type SLICE_META } from "akanjs/base";
 import { capitalize } from "akanjs/common";
-import { type ConstantCls, ConstantRegistry, type DefaultOf } from "akanjs/constant";
+import { ConstantRegistry, type DefaultOf } from "akanjs/constant";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
 import type { SerializedSlice, SliceCls, SliceInfoArgs } from "akanjs/signal";
 import type { Submit } from "./types";
@@ -180,16 +180,7 @@ export const createSliceState = (refName: string, slice: { [key: string]: Serial
     sortOfModel: `sortOf${className}`,
   };
   const sliceState: Record<string, unknown> = {};
-  Object.entries(slice).forEach(([suffix, serializedSlice]) => {
-    const defaultArgs = serializedSlice.args.map((arg) => {
-      if (arg.modelType) {
-        const modelRef = ConstantRegistry.getModelRef(arg.refName, arg.modelType) as ConstantCls;
-        return modelRef.getDefault();
-      } else {
-        const modelRef = PrimitiveRegistry.get(arg.refName);
-        return modelRef[PRIMITIVE_DEFAULT_VALUE];
-      }
-    });
+  Object.entries(slice).forEach(([suffix]) => {
     const sliceName = `${refName}${capitalize(suffix)}`;
     const SliceName = capitalize(sliceName);
     const namesOfSlice: { [key in SliceStateKey]: string } = {
@@ -217,7 +208,7 @@ export const createSliceState = (refName: string, slice: { [key: string]: Serial
       [namesOfSlice.lastPageOfModel]: 1,
       [namesOfSlice.pageOfModel]: 1,
       [namesOfSlice.limitOfModel]: 20,
-      [namesOfSlice.queryArgsOfModel]: defaultArgs,
+      [namesOfSlice.queryArgsOfModel]: [],
       [namesOfSlice.sortOfModel]: "latest",
     };
     Object.assign(sliceState, singleSliceState);

package/types/document/filterMeta.d.ts

@@ -18,6 +18,7 @@ export declare const setFilterMeta: (filterRef: Cls<unknown, {
 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;