use forward refs for shallow objects

Author: Varixo

packages/qwik-router/src/middleware/request-handler/index.ts

@@ -2,6 +2,7 @@ export { getErrorHtml, ServerError } from './error-handler';
 export { mergeHeadersCookies } from './cookie';
 export { AbortMessage, RedirectMessage } from './redirect-handler';
 export { requestHandler } from './request-handler';
+export { RequestEvShareQData } from './request-event';
 export { _TextEncoderStream_polyfill } from './polyfill';
 export type {
   CacheControl,

packages/qwik-router/src/middleware/request-handler/request-event.ts

@@ -39,6 +39,7 @@ export const RequestEvSharedActionId = '@actionId';
 export const RequestEvSharedActionFormData = '@actionFormData';
 export const RequestEvSharedNonce = '@nonce';
 export const RequestEvShareServerTiming = '@serverTiming';
+/** @internal */
 export const RequestEvShareQData = 'qData';
 
 export function createRequestEvent(

packages/qwik-router/src/middleware/request-handler/resolve-request-handlers.ts

@@ -245,7 +245,7 @@ export function loadersMiddleware(routeLoaders: LoaderInternal[]): RequestHandle
 
         // mark skipped loaders as null
         for (const skippedLoader of skippedLoaders) {
-          loaders[skippedLoader.__id] = _UNINITIALIZED;
+          loaders[skippedLoader.__id] = null;
         }
       } else {
         currentLoaders = routeLoaders;
@@ -583,10 +583,10 @@ export async function renderQData(requestEv: RequestEvent) {
   const loaders: Record<string, unknown> = {};
   for (const loaderId in allLoaders) {
     const loader = allLoaders[loaderId];
-    if (typeof loader === 'object' && loader !== null && SerializerSymbol in loader) {
-      (loader as any)[SerializerSymbol] = undefined;
-    }
-    if (loader !== _UNINITIALIZED) {
+    if (loader !== null) {
+      if (typeof loader === 'object' && SerializerSymbol in loader) {
+        (loader as any)[SerializerSymbol] = undefined;
+      }
       loaders[loaderId] = loader;
     }
   }

packages/qwik-router/src/middleware/request-handler/router.api.md

@@ -150,6 +150,11 @@ export interface RequestEventLoader<PLATFORM = QwikRouterPlatform> extends Reque
     resolveValue: ResolveValue;
 }
 
+// Warning: (ae-internal-missing-underscore) The name "RequestEvShareQData" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal (undocumented)
+export const RequestEvShareQData = "qData";
+
 // @public (undocumented)
 export type RequestHandler<PLATFORM = QwikRouterPlatform> = (ev: RequestEvent<PLATFORM>) => Promise<void> | void;
 

packages/qwik-router/src/static/worker-thread.ts

@@ -1,6 +1,6 @@
 import { _deserialize, _serialize, _verifySerializable } from '@qwik.dev/core/internal';
 import type { ServerRequestEvent } from '@qwik.dev/router/middleware/request-handler';
-import { requestHandler } from '@qwik.dev/router/middleware/request-handler';
+import { requestHandler, RequestEvShareQData } from '@qwik.dev/router/middleware/request-handler';
 import { WritableStream } from 'node:stream/web';
 import { pathToFileURL } from 'node:url';
 import type { QwikSerializer } from '../middleware/request-handler/types';
@@ -12,7 +12,6 @@ import type {
   StaticWorkerRenderResult,
   System,
 } from './types';
-import { RequestEvShareQData } from '../middleware/request-handler/request-event';
 
 export async function workerThread(sys: System) {
   const ssgOpts = sys.getOptions();

packages/qwik/src/core/reactive-primitives/impl/store.ts

@@ -1,7 +1,7 @@
 import { pad, qwikDebugToString } from '../../debug';
 import { assertTrue } from '../../shared/error/assert';
 import { tryGetInvokeContext } from '../../use/use-core';
-import { isSerializableObject } from '../../shared/utils/types';
+import { isObject, isSerializableObject } from '../../shared/utils/types';
 import type { Container } from '../../shared/types';
 import {
   addQrlToSerializationCtx,
@@ -124,8 +124,7 @@ export class StoreHandler implements ProxyHandler<StoreTarget> {
     const flags = this.$flags$;
     if (
       flags & StoreFlags.RECURSIVE &&
-      typeof value === 'object' &&
-      value !== null &&
+      isObject(value) &&
       !Object.isFrozen(value) &&
       !isStore(value) &&
       !Object.isFrozen(target)

packages/qwik/src/core/reactive-primitives/utils.ts

@@ -9,6 +9,7 @@ import type { Container, HostElement } from '../shared/types';
 import { ChoreType } from '../shared/util-chore-type';
 import { ELEMENT_PROPS, OnRenderProp } from '../shared/utils/markers';
 import { SerializerSymbol } from '../shared/utils/serialize-utils';
+import { isObject } from '../shared/utils/types';
 import type { ISsrNode, SSRContainer } from '../ssr/ssr-types';
 import { TaskFlags, isTask } from '../use/use-task';
 import { ComputedSignalImpl } from './impl/computed-signal-impl';
@@ -147,7 +148,5 @@ export const triggerEffects = (
 export const isSerializerObj = <T extends { [SerializerSymbol]: (obj: any) => any }, S>(
   obj: unknown
 ): obj is CustomSerializable<T, S> => {
-  return (
-    typeof obj === 'object' && obj !== null && typeof (obj as any)[SerializerSymbol] === 'function'
-  );
+  return isObject(obj) && typeof (obj as any)[SerializerSymbol] === 'function';
 };

packages/qwik/src/core/shared/error/error.ts

@@ -1,5 +1,6 @@
 import { logErrorAndStop } from '../utils/log';
 import { qDev } from '../utils/qdev';
+import { isObject } from '../utils/types';
 
 export const codeToText = (code: number, ...parts: any[]): string => {
   if (qDev) {
@@ -61,7 +62,7 @@ export const codeToText = (code: number, ...parts: any[]): string => {
     if (parts.length) {
       text = text.replaceAll(/{{(\d+)}}/g, (_, index) => {
         let v = parts[index];
-        if (v && typeof v === 'object' && v.constructor === Object) {
+        if (v && isObject(v) && v.constructor === Object) {
           v = JSON.stringify(v).slice(0, 50);
         }
         return v;

packages/qwik/src/core/shared/shared-serialization.ts

@@ -56,13 +56,14 @@ import { SignalImpl } from '../reactive-primitives/impl/signal-impl';
 import { ComputedSignalImpl } from '../reactive-primitives/impl/computed-signal-impl';
 import { WrappedSignalImpl } from '../reactive-primitives/impl/wrapped-signal-impl';
 import { SerializerSignalImpl } from '../reactive-primitives/impl/serializer-signal-impl';
+import { isObject } from './utils/types';
 
 const deserializedProxyMap = new WeakMap<object, unknown[]>();
 
 type DeserializerProxy<T extends object = object> = T & { [SERIALIZER_PROXY_UNWRAP]: object };
 
 export const isDeserializerProxy = (value: unknown): value is DeserializerProxy => {
-  return typeof value === 'object' && value !== null && SERIALIZER_PROXY_UNWRAP in value;
+  return isObject(value) && SERIALIZER_PROXY_UNWRAP in value;
 };
 
 export const SERIALIZER_PROXY_UNWRAP = Symbol('UNWRAP');
@@ -887,6 +888,7 @@ async function serialize(serializationContext: SerializationContext): Promise<vo
   let forwardRefsId = 0;
   const promises: Set<Promise<unknown>> = new Set();
   const preloadQrls = new Set<QRLInternal>();
+  const uninitializedRefs = new Map<unknown, number>();
   let parent: unknown = null;
   const isRootObject = () => depth === 0;
 
@@ -960,7 +962,7 @@ async function serialize(serializationContext: SerializationContext): Promise<vo
         output(TypeIds.Constant, Constants.Fragment);
       } else if (isQrl(value)) {
         outputRootRef(value, () => {
-          const qrl = qrlToString(serializationContext, value);
+          const qrl = qrlToString(serializationContext, value, uninitializedRefs);
           const type = preloadQrls.has(value) ? TypeIds.PreloadQRL : TypeIds.QRL;
           if (isRootObject()) {
             output(type, qrl);
@@ -1112,6 +1114,10 @@ async function serialize(serializationContext: SerializationContext): Promise<vo
           return new PromiseResult(TypeIds.SerializerSignal, resolved, resolvedValue, null, null);
         });
         output(TypeIds.ForwardRef, forwardRef);
+      } else if (result === _UNINITIALIZED && !uninitializedRefs.has(value)) {
+        const forwardRefId = forwardRefsId++;
+        uninitializedRefs.set(value, forwardRefId);
+        output(TypeIds.ForwardRef, forwardRefId);
       } else {
         depth--;
         writeValue(result);
@@ -1349,6 +1355,14 @@ async function serialize(serializationContext: SerializationContext): Promise<vo
       rootsLength = serializationContext.$roots$.length;
     }
 
+    if (uninitializedRefs.size) {
+      for (const [value, forwardRefId] of uninitializedRefs) {
+        $writer$.write(',');
+        forwardRefs[forwardRefId] = serializationContext.$roots$.length;
+        writeValue(value);
+      }
+    }
+
     if (forwardRefs.length) {
       $writer$.write(',');
       $writer$.write(TypeIds.ForwardRefs + ',');
@@ -1412,7 +1426,8 @@ function serializeWrappingFn(
 
 export function qrlToString(
   serializationContext: SerializationContext,
-  value: QRLInternal | SyncQRLInternal
+  value: QRLInternal | SyncQRLInternal,
+  uninitializedRefs?: Map<unknown, number>
 ) {
   let symbol = value.$symbol$;
   let chunk = value.$chunk$;
@@ -1464,8 +1479,17 @@ export function qrlToString(
       if (i > 0) {
         serializedReferences += ' ';
       }
+      const captureRef = value.$captureRef$[i];
+      if (
+        isObject(captureRef) &&
+        uninitializedRefs &&
+        uninitializedRefs.has(captureRef) &&
+        SerializerSymbol in captureRef
+      ) {
+        captureRef[SerializerSymbol] = undefined;
+      }
       // We refer by id so every capture needs to be a root
-      serializedReferences += serializationContext.$addRoot$(value.$captureRef$[i]);
+      serializedReferences += serializationContext.$addRoot$(captureRef);
     }
     qrlStringInline += `[${serializedReferences}]`;
   } else if (value.$capture$ && value.$capture$.length > 0) {
@@ -1692,7 +1716,7 @@ function shouldTrackObj(obj: unknown) {
   return (
     // THINK: Not sure if we need to keep track of functions (QRLs) Let's skip them for now.
     // and see if we have a test case which requires them.
-    (typeof obj === 'object' && obj !== null) ||
+    isObject(obj) ||
     /**
      * We track all strings greater than 1 character, because those take at least 6 bytes to encode
      * and even with 999 root objects it saves one byte per reference. Tracking more objects makes
@@ -1725,9 +1749,7 @@ function isResource<T = unknown>(value: object): value is ResourceReturnInternal
 
 const frameworkType = (obj: any) => {
   return (
-    (typeof obj === 'object' &&
-      obj !== null &&
-      (obj instanceof SignalImpl || obj instanceof Task || isJSXNode(obj))) ||
+    (isObject(obj) && (obj instanceof SignalImpl || obj instanceof Task || isJSXNode(obj))) ||
     isQrl(obj)
   );
 };
@@ -1913,8 +1935,8 @@ const circularProofJson = (obj: unknown, indent?: string | number) => {
   const seen = new WeakSet();
   return JSON.stringify(
     obj,
-    (key, value) => {
-      if (typeof value === 'object' && value !== null) {
+    (_, value) => {
+      if (isObject(value)) {
         if (seen.has(value)) {
           return `[Circular ${value.constructor.name}]`;
         }
@@ -1958,7 +1980,7 @@ export const dumpState = (
     if (key === undefined) {
       hasRaw = true;
       out.push(
-        `${RED}[raw${typeof value === 'object' && value ? ` ${value.constructor.name}` : ''}]${RESET} ${printRaw(value, `${prefix}  `)}`
+        `${RED}[raw${isObject(value) ? ` ${value.constructor.name}` : ''}]${RESET} ${printRaw(value, `${prefix}  `)}`
       );
     } else {
       if (key === TypeIds.Constant) {

packages/qwik/src/core/shared/shared-serialization.unit.ts

@@ -1,6 +1,6 @@
 import { $, componentQrl, noSerialize } from '@qwik.dev/core';
 import { describe, expect, it, vi } from 'vitest';
-import { _fnSignal, _wrapProp } from '../internal';
+import { _fnSignal, _UNINITIALIZED, _wrapProp } from '../internal';
 import { type SignalImpl } from '../reactive-primitives/impl/signal-impl';
 import {
   createComputedQrl,
@@ -25,7 +25,7 @@ import { EMPTY_ARRAY, EMPTY_OBJ } from './utils/flyweight';
 import { isQrl } from './qrl/qrl-utils';
 import { NoSerializeSymbol, SerializerSymbol } from './utils/serialize-utils';
 import { SubscriptionData } from '../reactive-primitives/subscription-data';
-import { StoreFlags } from '../reactive-primitives/types';
+import { StoreFlags, type CustomSerializable } from '../reactive-primitives/types';
 
 const DEBUG = false;
 
@@ -77,6 +77,47 @@ describe('shared-serialization', () => {
         (81 chars)"
       `);
     });
+    describe('UNINITIALIZED', () => {
+      it(title(TypeIds.Constant) + ' - UNINITIALIZED, not serialized object', async () => {
+        const uninitializedObject = {
+          shouldNot: 'serialize',
+        };
+        (uninitializedObject as unknown as CustomSerializable<any, any>)[SerializerSymbol] = () => {
+          return _UNINITIALIZED;
+        };
+        expect(await dump(uninitializedObject)).toMatchInlineSnapshot(`
+        "
+        0 ForwardRef 0
+        1 Constant _UNINITIALIZED
+        2 ForwardRefs [
+          1
+        ]
+        (15 chars)"
+      `);
+      });
+      it(title(TypeIds.Constant) + ' - UNINITIALIZED, serialized object', async () => {
+        const uninitializedObject = {
+          should: 'serialize',
+        };
+        (uninitializedObject as unknown as CustomSerializable<any, any>)[SerializerSymbol] = () => {
+          return _UNINITIALIZED;
+        };
+        const qrl = inlinedQrl(() => uninitializedObject.should, 'dump_qrl', [uninitializedObject]);
+        expect(await dump(uninitializedObject, qrl)).toMatchInlineSnapshot(`
+        "
+        0 ForwardRef 0
+        1 QRL "mock-chunk#dump_qrl[0]"
+        2 Object [
+          String "should"
+          String "serialize"
+        ]
+        3 ForwardRefs [
+          2
+        ]
+        (69 chars)"
+      `);
+      });
+    });
     it(title(TypeIds.Number), async () => {
       expect(await dump(123)).toMatchInlineSnapshot(`
         "
@@ -770,6 +811,39 @@ describe('shared-serialization', () => {
       expect(effect).toBeInstanceOf(SubscriptionData);
       expect(effect.data).toEqual({ $isConst$: true, $scopedStyleIdPrefix$: null });
     });
+
+    describe('UNINITIALIZED', () => {
+      it(title(TypeIds.Constant) + ' - UNINITIALIZED, not serialized object', async () => {
+        const uninitializedObject = {
+          shouldNot: 'serialize',
+        };
+        (uninitializedObject as unknown as CustomSerializable<any, any>)[SerializerSymbol] = () => {
+          return _UNINITIALIZED;
+        };
+
+        const objs = await serialize(uninitializedObject);
+        const effect = deserialize(objs)[0] as any;
+        expect(effect).toBe(_UNINITIALIZED);
+      });
+      it(title(TypeIds.Constant) + ' - UNINITIALIZED, serialized object', async () => {
+        const uninitializedObject = {
+          should: 'serialize',
+        };
+        (uninitializedObject as unknown as CustomSerializable<any, any>)[SerializerSymbol] = () => {
+          return _UNINITIALIZED;
+        };
+        const qrl = inlinedQrl(() => uninitializedObject.should, 'dump_qrl', [uninitializedObject]);
+        const objs = await serialize(uninitializedObject, qrl);
+        const state = deserialize(objs);
+        delete (uninitializedObject as any)[SerializerSymbol];
+        const deserializedObject = state[0];
+        expect(deserializedObject).toEqual(uninitializedObject);
+
+        const deserializedQrl = state[1] as QRLInternal;
+        expect(isQrl(deserializedQrl)).toBeTruthy();
+        expect(await (deserializedQrl.getFn() as any)()).toBe(uninitializedObject.should);
+      });
+    });
   });
 
   describe('special cases', () => {

packages/qwik/src/core/shared/utils/serialize-utils.ts

@@ -99,7 +99,7 @@ export const shouldSerialize = (obj: unknown): boolean => {
 };
 
 export const fastSkipSerialize = (obj: object): boolean => {
-  return typeof obj === 'object' && obj && (NoSerializeSymbol in obj || noSerializeSet.has(obj));
+  return obj && isObject(obj) && (NoSerializeSymbol in obj || noSerializeSet.has(obj));
 };
 
 /**

packages/qwik/src/core/shared/utils/types.ts

@@ -9,7 +9,7 @@ export const isSerializableObject = (v: unknown): v is Record<string, unknown> =
 };
 
 export const isObject = (v: unknown): v is object => {
-  return !!v && typeof v === 'object';
+  return typeof v === 'object' && v !== null;
 };
 
 export const isArray = (v: unknown): v is unknown[] => {

packages/qwik/src/core/use/use-core.ts

@@ -5,7 +5,7 @@ import type { QRLInternal } from '../shared/qrl/qrl-class';
 import type { QRL } from '../shared/qrl/qrl.public';
 import { ComputedEvent, RenderEvent, ResourceEvent, TaskEvent } from '../shared/utils/markers';
 import { seal } from '../shared/utils/qdev';
-import { isArray } from '../shared/utils/types';
+import { isArray, isObject } from '../shared/utils/types';
 import { setLocale } from './use-locale';
 import type { Container, HostElement } from '../shared/types';
 import { vnode_getNode, vnode_isElementVNode, vnode_isVNode, vnode_locate } from '../client/vnode';
@@ -159,7 +159,7 @@ export const newInvokeContext = (
 ): InvokeContext => {
   // ServerRequestEvent has .locale, but it's not always defined.
   const $locale$ =
-    locale || (typeof event === 'object' && event && 'locale' in event ? event.locale : undefined);
+    locale || (event && isObject(event) && 'locale' in event ? event.locale : undefined);
   const ctx: InvokeContext = {
     $url$: url,
     $i$: 0,