akanjs 3.0.0-alpha.70 → 3.0.0-alpha.71

package/constant/crystalize.ts

@@ -8,8 +8,10 @@ import {
 } from "akanjs/base";
 
 import type { FieldProps } from ".";
+import { ConstantRegistry } from "./constantRegistry";
 
 export type CrystalizeFunc<Model> = (self: GetStateObject<Model>, isChild?: boolean) => Model;
+export type Converter = (value: unknown) => unknown;
 
 /**
  * The relation instances one hydration pass has already built, by model class and then document id.
@@ -34,58 +36,76 @@ export const withSharedInstances = <T>(hydrate: () => T): T => {
   }
 };
 
-type ModelCls = Cls<{ set: (obj: object) => object }>;
+type ModelCls = new (obj?: object) => object;
 
 const relationIdOf = (value: object): string | null => {
   const id = (value as { id?: unknown }).id;
   return typeof id === "string" && id ? id : null;
 };
 
-const crystalizeModel = (field: FieldProps, value: object): object => {
-  const modelRef = field.modelRef as ModelCls;
+const modelConverterOf = (props: FieldProps): Converter => {
+  const modelRef = props.modelRef as unknown as ModelCls;
 
-  if (value instanceof modelRef) return value;
+  if (props.isScalar) return (value) => (value instanceof modelRef ? value : new modelRef(value as object));
+  return (value) => {
+    if (value instanceof modelRef) return value;
 
-  const id = field.isScalar ? null : relationIdOf(value);
-  if (!sharedInstances || !id) return new modelRef().set(value);
-  const byId = sharedInstances.get(modelRef) ?? new Map<string, object>();
-  if (!sharedInstances.has(modelRef)) sharedInstances.set(modelRef, byId);
-  const shared = byId.get(id) ?? new modelRef().set(value);
-  byId.set(id, shared);
-  return shared;
+    const id = relationIdOf(value as object);
+    if (!sharedInstances || !id) return new modelRef(value as object);
+    const byId = sharedInstances.get(modelRef as unknown as Cls) ?? new Map<string, object>();
+    if (!sharedInstances.has(modelRef as unknown as Cls)) sharedInstances.set(modelRef as unknown as Cls, byId);
+    const shared = byId.get(id) ?? new modelRef(value as object);
+    byId.set(id, shared);
+    return shared;
+  };
 };
 
-export const crystalize = (field: FieldProps, value: unknown): unknown => {
-  if (value === undefined || value === null) return value as undefined | null;
-  if (field.isArray && Array.isArray(value))
-    return value.map((v: unknown) =>
-      crystalize({ ...field, isArray: field.arrDepth > 1, arrDepth: field.arrDepth - 1 }, v),
-    );
-  const crystalizeValue = PrimitiveRegistry.has(field.modelRef)
-    ? (value: unknown) => (field.modelRef as unknown as typeof PrimitiveScalar)._parse(value as never)
-    : (value: unknown) => value as object;
-  if (field.isMap) {
-    const mapValueField = {
-      ...field,
-      modelRef: field.of ?? field.modelRef,
-      isMap: false,
-      isClass: !!field.of && !PrimitiveRegistry.has(field.of),
-      isScalar: !!field.of && PrimitiveRegistry.has(field.of),
-      isArray: false,
-      arrDepth: 0,
-    };
+const mapConverterOf = (props: FieldProps): Converter => {
+  const of = props.of as Cls | undefined;
+  const valueConverter: Converter = of
+    ? singleConverterOf({
+        ...props,
+        modelRef: of as FieldProps["modelRef"],
+        isMap: false,
+        isClass: !PrimitiveRegistry.has(of),
+        isScalar: PrimitiveRegistry.has(of) || ConstantRegistry.isScalar(of),
+        isArray: false,
+        arrDepth: 0,
+      })
+    : (value) => value;
+  return (value) => {
     
     const entries = value instanceof Map ? [...value.entries()] : Object.entries(value as Record<string, unknown>);
     return new Map(
-      entries.map(([key, val]: [string, unknown]) => [
-        key,
-        field.of
-          ? applyFnToArrayObjects(val, (v: never) => crystalize(mapValueField, v))
-          : applyFnToArrayObjects(val, crystalizeValue),
-      ]),
+      entries.map(([key, val]: [string, unknown]) => [key, applyFnToArrayObjects(val, valueConverter as never)]),
     );
+  };
+};
+
+const singleConverterOf = (props: FieldProps): Converter => {
+  if (props.isMap) return mapConverterOf(props);
+  if (props.isClass) return modelConverterOf(props);
+  
+  if ((props.modelRef as unknown) === Date) return (value) => dayjs(value as Date);
+  if (PrimitiveRegistry.has(props.modelRef as Cls))
+    return (value) => (props.modelRef as unknown as typeof PrimitiveScalar)._parse(value as never);
+  return (value) => value;
+};
+
+const converters = new WeakMap<FieldProps, Converter>();
+
+/** The converter for one field, compiled once per `FieldProps` — which `getProps()` freezes and shares per field. */
+export const converterOf = (props: FieldProps): Converter => {
+  const cached = converters.get(props);
+  if (cached) return cached;
+  const single = singleConverterOf(props);
+  let convert: Converter = (value) => (value === null || value === undefined ? value : single(value));
+  for (let depth = props.arrDepth; depth > 0; depth--) {
+    const inner: Converter = convert;
+    convert = (value: unknown): unknown => (Array.isArray(value) ? value.map(inner) : inner(value));
   }
-  if (field.isClass) return crystalizeModel(field, value as object);
-  if (field.modelRef === Date) return dayjs(value as Date);
-  return crystalizeValue(value);
+  converters.set(props, convert);
+  return convert;
 };
+
+export const crystalize = (field: FieldProps, value: unknown): unknown => converterOf(field)(value);

package/constant/dateSlot.ts

@@ -0,0 +1,62 @@
+import { type Dayjs, dayjs } from "akanjs/base";
+
+/**
+ * A Date field stores a native `Date` under a per-key symbol and builds the `Dayjs` its type promises on first
+ * read, memoized by that `Date`. A dayjs instance is ~300 bytes and eight getter calls at construction; a `Date`
+ * is 40 bytes. A listing carries every row's dates and reads a handful of them, so this is most of what a
+ * hydrated list used to cost — see `crystalize`.
+ *
+ * The slot is a function of the key, not the class (`Symbol.for`): `applyMixins` copies a light model's accessors
+ * onto the full model's prototype, so an accessor and the `set()` that fills its slot must agree on the slot
+ * whichever class defined either one.
+ */
+const slotByKey = new Map<string, symbol>();
+export const dateSlotOf = (key: string): symbol => {
+  const cached = slotByKey.get(key);
+  if (cached) return cached;
+  const slot = Symbol.for(`akan.date.${key}`);
+  slotByKey.set(key, slot);
+  return slot;
+};
+
+const dayjsByDate = new WeakMap<Date, Dayjs>();
+const lazyDayjsOf = (date: Date): Dayjs => {
+  const cached = dayjsByDate.get(date);
+  if (cached) return cached;
+  const value = dayjs(date);
+  dayjsByDate.set(date, value);
+  return value;
+};
+
+/** A caller's own `Date` is copied: the slot must not alias an object the caller can still mutate. */
+export const toDateValue = (value: unknown): Date | null | undefined => {
+  if (value === null || value === undefined) return value;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (dayjs.isDayjs(value)) return value.toDate();
+  return new Date(value as string | number);
+};
+
+type DateSlotHolder = Record<symbol, Date | null | undefined>;
+
+/**
+ * Enumerable so `for...in` — `plainFieldsOf`, `immerify`, `deepObjectify` — still sees the field. immer calls a
+ * prototype setter with the draft as `this`, so a write through the accessor stays copy-on-write, and the getter
+ * writes nothing, so a read never marks a draft modified.
+ */
+export const dateAccessorOf = (key: string): PropertyDescriptor => {
+  const slot = dateSlotOf(key);
+  return {
+    enumerable: true,
+    configurable: true,
+    get(this: DateSlotHolder) {
+      const date = this[slot];
+      return date === null || date === undefined ? date : lazyDayjsOf(date);
+    },
+    set(this: DateSlotHolder, value: unknown) {
+      this[slot] = toDateValue(value);
+    },
+  };
+};
+
+export const isDateSlotField = (props: { modelRef: unknown; isArray: boolean; isMap: boolean }): boolean =>
+  props.modelRef === Date && !props.isArray && !props.isMap;

package/constant/getDefault.ts

@@ -2,11 +2,11 @@ import { DEFAULT_VALUE, FIELD_META, type PrimitiveScalar } from "akanjs/base";
 import type { FieldObject } from ".";
 import type { DefaultOf } from "./types";
 
-interface DefaultPlan {
+export interface DefaultPlan {
   /** Fields whose default is a value that can be shared: a primitive, `null`, or the field's own literal. */
   shared: Record<string, unknown>;
   /** Fields that have to be produced per call — a thunk, a fresh array, or a nested scalar record. */
-  perCall: [key: string, make: () => unknown][];
+  perCall: Map<string, () => unknown>;
 }
 
 const planCache = new WeakMap<FieldObject, DefaultPlan>();
@@ -17,28 +17,33 @@ const planCache = new WeakMap<FieldObject, DefaultPlan>();
  * sharing one. Only values that were already shared before this cache existed live in `shared`.
  */
 export const getDefault = <T>(fieldObj: FieldObject): DefaultOf<T> => {
-  let plan = planCache.get(fieldObj);
-  if (!plan) {
-    plan = buildPlan(fieldObj);
-    planCache.set(fieldObj, plan);
-  }
+  const plan = defaultPlanOf(fieldObj);
   const result: Record<string, unknown> = { ...plan.shared };
   for (const [key, make] of plan.perCall) result[key] = make();
   return result as DefaultOf<T>;
 };
 
+/** The per-field default rules, split as above; `HydrationPlan` reads them per field so a present value skips its thunk. */
+export const defaultPlanOf = (fieldObj: FieldObject): DefaultPlan => {
+  const cached = planCache.get(fieldObj);
+  if (cached) return cached;
+  const plan = buildPlan(fieldObj);
+  planCache.set(fieldObj, plan);
+  return plan;
+};
+
 const buildPlan = (fieldObj: FieldObject): DefaultPlan => {
   const shared: Record<string, unknown> = {};
-  const perCall: [string, () => unknown][] = [];
+  const perCall = new Map<string, () => unknown>();
   for (const [key, field] of Object.entries(fieldObj)) {
     if (field.fieldType === "hidden" || field.fieldType === "secret") shared[key] = null;
     else if (field.default !== undefined && field.default !== null) {
-      if (typeof field.default === "function") perCall.push([key, field.default as () => unknown]);
+      if (typeof field.default === "function") perCall.set(key, field.default as () => unknown);
       else shared[key] = field.default as object;
-    } else if (field.isArray) perCall.push([key, () => []]);
+    } else if (field.isArray) perCall.set(key, () => []);
     else if (field.nullable) shared[key] = null;
     else if (field.isClass) {
-      if (field.isScalar) perCall.push([key, () => getDefault(field.modelRef[FIELD_META])]);
+      if (field.isScalar) perCall.set(key, () => getDefault(field.modelRef[FIELD_META]));
       else shared[key] = null;
     } else shared[key] = (field.modelRef as unknown as typeof PrimitiveScalar)[DEFAULT_VALUE];
   }

package/constant/hydrationPlan.ts

@@ -0,0 +1,72 @@
+import { FIELD_META } from "akanjs/base";
+
+import { type Converter, converterOf } from "./crystalize";
+import { dateSlotOf, isDateSlotField, toDateValue } from "./dateSlot";
+import type { FieldObject } from "./fieldInfo";
+import { defaultPlanOf } from "./getDefault";
+
+interface PlanEntry {
+  key: string;
+  /** The own property the value lands on: the key itself, or a Date field's slot symbol. */
+  target: string | symbol;
+  convert: Converter;
+  makeDefault: () => unknown;
+}
+type PlanTarget = Record<string | symbol, unknown>;
+interface PlanOwner {
+  [FIELD_META]: FieldObject;
+}
+
+/**
+ * One hydration plan per model class, compiled from `FIELD_META` on the first instance. Reading the field map,
+ * resolving `getProps()` and dispatching on the field kind used to happen per field per instance, and was most of
+ * what a listing paid after the dayjs objects — a plan turns a row into a plain loop over precomputed converters.
+ *
+ * Cached per class rather than per field map because `fullModelOf` extends a lib model's `FIELD_META` in place;
+ * `applyConstantStatics` resets the entry whenever it finishes wiring a class.
+ */
+export class HydrationPlan {
+  static #byClass = new WeakMap<object, HydrationPlan>();
+  static of(cls: PlanOwner): HydrationPlan {
+    const cached = HydrationPlan.#byClass.get(cls);
+    if (cached) return cached;
+    const plan = new HydrationPlan(cls[FIELD_META]);
+    HydrationPlan.#byClass.set(cls, plan);
+    return plan;
+  }
+  static reset(cls: object) {
+    HydrationPlan.#byClass.delete(cls);
+  }
+
+  #entries: PlanEntry[];
+  constructor(fieldObj: FieldObject) {
+    const defaults = defaultPlanOf(fieldObj);
+    this.#entries = Object.entries(fieldObj).map(([key, field]) => {
+      const props = field.getProps();
+      const isDateSlot = isDateSlotField(props);
+      const convert: Converter = isDateSlot ? toDateValue : converterOf(props);
+      const perCall = defaults.perCall.get(key);
+      const rawDefault = perCall ?? (() => defaults.shared[key]);
+
+      return { key, target: isDateSlot ? dateSlotOf(key) : key, convert, makeDefault: () => convert(rawDefault()) };
+    });
+  }
+
+  /** Fills every field: the value when the source carries one, the field's default otherwise. */
+  construct(instance: object, source?: Record<string, unknown> | null) {
+    const target = instance as PlanTarget;
+    for (const entry of this.#entries) {
+      const value = source === undefined || source === null ? undefined : source[entry.key];
+      target[entry.target] = value === undefined ? entry.makeDefault() : entry.convert(value);
+    }
+  }
+
+  /** Overwrites only the fields the source names; `in` rather than own keys, so another instance's accessors count. */
+  assign(instance: object, source: Record<string, unknown>) {
+    const target = instance as PlanTarget;
+    for (const entry of this.#entries) {
+      if (!(entry.key in source)) continue;
+      target[entry.target] = entry.convert(source[entry.key]);
+    }
+  }
+}

package/constant/immerify.ts

@@ -1,16 +1,14 @@
 import { FIELD_META } from "akanjs/base";
+import { plainFieldsOf } from "akanjs/common";
 import { immerable } from "immer";
 import type { ConstantModelRef } from ".";
 
 export const immerify = <T extends object>(modelRef: ConstantModelRef, objOrArr: T): T => {
   if (Array.isArray(objOrArr)) return objOrArr.map((val) => immerify(modelRef, val as object)) as T;
-  const immeredObj = Object.assign({}, objOrArr, {
-    [immerable]: true,
-  }) as Record<string, unknown>;
-  const objRecord = objOrArr as Record<string, unknown>;
+  const immeredObj = Object.assign(plainFieldsOf(objOrArr), { [immerable]: true }) as Record<string, unknown>;
   Object.entries(modelRef[FIELD_META]).forEach(([key, field]) => {
-    if (field.isScalar && field.isClass && objRecord[key])
-      immeredObj[key] = immerify(field.modelRef, objRecord[key] as object);
+    if (field.isScalar && field.isClass && immeredObj[key])
+      immeredObj[key] = immerify(field.modelRef, immeredObj[key] as object);
   });
   return immeredObj as T;
 };

package/constant/index.ts

@@ -1,10 +1,12 @@
 export * from "./cascadePaths";
 export * from "./constantRegistry";
 export * from "./crystalize";
+export * from "./dateSlot";
 export * from "./deserialize";
 export * from "./fieldInfo";
 export * from "./fieldQueryMeta";
 export * from "./getDefault";
+export * from "./hydrationPlan";
 export * from "./immerify";
 export * from "./labelOf";
 export * from "./mask";

package/constant/via.ts

@@ -10,12 +10,13 @@ import {
   PURIFIED_VALUE,
   SERVER_VALUE,
 } from "akanjs/base";
-import { applyMixins } from "akanjs/common";
+import { applyMixins, plainFieldsOf } from "akanjs/common";
 import { immerable } from "immer";
 
-import { crystalize, getDefault } from ".";
+import { getDefault } from ".";
 import { CascadePaths } from "./cascadePaths";
 import { ConstantRegistry } from "./constantRegistry";
+import { dateAccessorOf, isDateSlotField } from "./dateSlot";
 import {
   ConstantField,
   type ExtractFieldInfoObject,
@@ -27,6 +28,7 @@ import {
   field,
   resolve,
 } from "./fieldInfo";
+import { HydrationPlan } from "./hydrationPlan";
 import { makePurify, type PurifiedModel, type PurifyFunc } from "./purify";
 import { TextFieldPaths } from "./textFieldPaths";
 import type { BaseInsight, BaseObject, ConstantType, DefaultOf, DefaultOfSchema, NonFunctionalKeys } from "./types";
@@ -201,22 +203,16 @@ const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "sca
     static enums: Set<EnumInstance> = new Set();
     [immerable] = true;
     constructor(obj?: Partial<unknown>) {
-      this.set({
-        ...(this.constructor as ConstantCls).getDefault(),
-        ...((obj ?? {}) as Partial<typeof this>),
-      });
+      HydrationPlan.of(this.constructor as ConstantCls).construct(this, obj as Record<string, unknown> | undefined);
     }
     set(obj: Partial<typeof this>) {
-      Object.entries(obj).forEach(([key, value]) => {
-        
-        if (!(this.constructor as ConstantCls)[FIELD_META][key] as unknown as object | undefined) return;
-        const field = (this.constructor as ConstantCls)[FIELD_META][key];
-        if (!field) throw new Error(`Field ${key} not found`);
-        const fieldProp = field.getProps();
-        (this as Record<string, unknown>)[key] = crystalize(fieldProp, value);
-      });
+      HydrationPlan.of(this.constructor as ConstantCls).assign(this, obj as Record<string, unknown>);
       return this;
     }
+    
+    toJSON() {
+      return plainFieldsOf(this);
+    }
   }
   return BaseConstant as unknown as ConstantCls;
 };
@@ -453,6 +449,10 @@ const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldO
   });
   model.text.collect(fieldMap);
   model.cascade.collect(fieldMap);
+
+  for (const [key, field] of Object.entries(model[FIELD_META]))
+    if (isDateSlotField(field.getProps())) Object.defineProperty(model.prototype, key, dateAccessorOf(key));
+  HydrationPlan.reset(model);
   return model as unknown as ConstantCls<Model>;
 };
 

package/fetch/client/fetchClient.ts

@@ -19,7 +19,12 @@ import type {
 } from "akanjs/signal";
 import { agentTurnConstant } from "../agentTurn";
 import type { ClientSignal, FetchClientType, FetchSignalInput, MergeAllFetchTypes, SliceMeta } from "../fetchType";
-import { memoizeRequestQuery, cookies as requestCookies, headers as requestHeaders } from "../requestStorage";
+import {
+  getRequestStore,
+  memoizeRequestQuery,
+  cookies as requestCookies,
+  headers as requestHeaders,
+} from "../requestStorage";
 import type { GetSliceMetaObjFromDatabaseSignals } from "../types";
 import { type ErrorConstructor, HttpClient } from "./httpClient";
 import { WsClient } from "./wsClient";
@@ -311,8 +316,9 @@ export class FetchClient {
           const response = baseUrl
             ? await requestQuery()
             : await memoizeRequestQuery(FetchClient.#makeRequestQueryCacheKey(this.origin, url, headers), requestQuery);
-          const parsedReturn = parseReturn(FetchClient.#deepCopy(response), { crystalize: option?.crystalize ?? true });
-          return parsedReturn;
+
+          const payload = !baseUrl && getRequestStore() ? FetchClient.#deepCopy(response) : response;
+          return parseReturn(payload, { crystalize: option?.crystalize ?? true });
         };
         return queryFn;
       }
@@ -665,10 +671,6 @@ export class FetchClient {
         listFn(...fetchQueryArgs, skip, limit, sort, { ...option, crystalize: false }),
         fetchInsight ? insightFn(...fetchQueryArgs, { ...option, crystalize: false }) : null,
       ])) as unknown as [BaseObject[], BaseInsight];
-      const modelList = new DataList(
-        withSharedInstances(() => modelObjList.map((modelObj) => new cnst.light(modelObj))),
-      );
-      const modelInsight = new cnst.insight(modelObjInsight);
       const lastPage = modelObjInsight?.count
         ? Math.max(Math.floor((modelObjInsight.count - 1) / (limit || 20)) + 1, 1)
         : 1;
@@ -686,11 +688,27 @@ export class FetchClient {
         [`sortOf${capRefName}`]: sort,
         [`${refName}InitAt`]: new Date(),
       };
-      return {
-        [`${refName}Init${capSuffix}`]: serverInit,
-        [`${refName}List${capSuffix}`]: modelList,
-        [`${refName}Insight${capSuffix}`]: modelInsight,
-      };
+      
+      let modelList: DataList<BaseObject> | undefined;
+      let modelInsight: object | undefined;
+      return Object.defineProperties({ [`${refName}Init${capSuffix}`]: serverInit } as Record<string, unknown>, {
+        [`${refName}List${capSuffix}`]: {
+          enumerable: true,
+          get: () => {
+            modelList ??= new DataList(
+              withSharedInstances(() => modelObjList.map((modelObj) => new cnst.light(modelObj) as BaseObject)),
+            );
+            return modelList;
+          },
+        },
+        [`${refName}Insight${capSuffix}`]: {
+          enumerable: true,
+          get: () => {
+            modelInsight ??= new cnst.insight(modelObjInsight);
+            return modelInsight;
+          },
+        },
+      });
     });
     this.#setHandlerFactory(names.getInit, () => async (...args: unknown[]) => {
       const initFn = this.#requireHandler<(...args: unknown[]) => Promise<Record<string, unknown>>>(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.70",
+  "version": "3.0.0-alpha.71",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -180,6 +180,16 @@
       "types": "./types/server/lifecycle/portInUse.d.ts",
       "import": "./server/lifecycle/portInUse.ts",
       "default": "./server/lifecycle/portInUse.ts"
+    },
+    "./server/logging/logQuery": {
+      "types": "./types/server/logging/logQuery.d.ts",
+      "import": "./server/logging/logQuery.ts",
+      "default": "./server/logging/logQuery.ts"
+    },
+    "./server/logging/logTailClient": {
+      "types": "./types/server/logging/logTailClient.d.ts",
+      "import": "./server/logging/logTailClient.ts",
+      "default": "./server/logging/logTailClient.ts"
     }
   },
   "dependencies": {