enhance: Perform INVALID checks against the symbol itself

Author: ntucker

packages/core/src/controller/Controller.ts

@@ -17,6 +17,7 @@ import {
   isEntity,
   denormalize,
   validateQueryKey,
+  INVALID,
 } from '@data-client/normalizr';
 
 import AbortOptimistic from './AbortOptimistic.js';
@@ -563,7 +564,7 @@ export default class Controller<
     return {
       data,
       expiryStatus: this.getExpiryStatus(
-        typeof data === 'symbol',
+        data === INVALID,
         !!endpoint.invalidIfStale || isInvalid,
         meta,
       ),
@@ -590,7 +591,7 @@ export default class Controller<
       .map(ensurePojo) as SchemaArgs<S>;
 
     const { data } = this.memo.query(schema, args, state);
-    return typeof data === 'symbol' ? undefined : data;
+    return data === INVALID ? undefined : data;
   }
 
   /**
@@ -616,7 +617,7 @@ export default class Controller<
     const { data, paths } = this.memo.query(schema, args, state);
 
     return {
-      data: typeof data === 'symbol' ? undefined : data,
+      data: data === INVALID ? undefined : data,
       countRef: this.gcPolicy.createCountRef({ paths }),
     };
   }

packages/normalizr/README.md

@@ -214,7 +214,7 @@ function query(schema, args, state, key) {
     key,
   );
   const { data } = this.denormalize(schema, queryKey, state.entities, args);
-  return typeof data === 'symbol' ? undefined : (data as any);
+  return data === INVALID ? undefined : (data as any);
 }
 ```
 

packages/normalizr/src/denormalize/cache.ts

@@ -1,13 +1,14 @@
 import type { EntityInterface } from '../interface.js';
 import { EntityPath } from '../types.js';
+import type { INVALID } from './symbol.js';
 
 export default interface Cache {
   getEntity(
     pk: string,
     schema: EntityInterface,
     entity: any,
     computeValue: (localCacheKey: Map<string, any>) => void,
-  ): object | undefined | symbol;
+  ): object | undefined | typeof INVALID;
   getResults(
     input: any,
     cachable: boolean,

packages/normalizr/src/denormalize/denormalize.ts

@@ -4,13 +4,14 @@ import getUnvisit from './unvisit.js';
 import type { Schema } from '../interface.js';
 import { isImmutable } from '../schemas/ImmutableUtils.js';
 import type { DenormalizeNullable } from '../types.js';
+import type { INVALID } from './symbol.js';
 
 export function denormalize<S extends Schema>(
   schema: S | undefined,
   input: any,
   entities: any,
   args: readonly any[] = [],
-): DenormalizeNullable<S> | symbol {
+): DenormalizeNullable<S> | typeof INVALID {
   // undefined means don't do anything
   if (schema === undefined || input === undefined) {
     return input as any;

packages/normalizr/src/denormalize/localCache.ts

@@ -1,6 +1,7 @@
 import type Cache from './cache.js';
 import type { EntityInterface } from '../interface.js';
 import type { EntityPath } from '../types.js';
+import type { INVALID } from './symbol.js';
 
 export default class LocalCache implements Cache {
   private localCache = new Map<string, Map<string, any>>();
@@ -10,7 +11,7 @@ export default class LocalCache implements Cache {
     schema: EntityInterface,
     entity: any,
     computeValue: (localCacheKey: Map<string, any>) => void,
-  ): object | undefined | symbol {
+  ): object | undefined | typeof INVALID {
     const key = schema.key;
     if (!this.localCache.has(key)) {
       this.localCache.set(key, new Map<string, any>());

packages/normalizr/src/denormalize/unvisit.ts

@@ -18,7 +18,7 @@ const getUnvisitEntity = (
   return function unvisitEntity(
     schema: EntityInterface,
     entityOrId: Record<string, any> | string,
-  ): object | undefined | symbol {
+  ): object | undefined | typeof INVALID {
     const inputIsId = typeof entityOrId !== 'object';
     const entity =
       inputIsId ? getEntity({ key: schema.key, pk: entityOrId }) : entityOrId;
@@ -92,7 +92,7 @@ function unvisitEntityObject(
 
 function noCacheGetEntity(
   computeValue: (localCacheKey: Map<string, any>) => void,
-): object | undefined | symbol {
+): object | undefined | typeof INVALID {
   const localCacheKey = new Map<string, any>();
   computeValue(localCacheKey);
 

packages/normalizr/src/memo/MemoCache.ts

@@ -21,6 +21,7 @@ import {
 } from './Delegate.js';
 import { EndpointsCache, EntityCache } from './types.js';
 import { QueryPath } from './types.js';
+import type { INVALID } from '../denormalize/symbol.js';
 
 //TODO: make immutable distinction occur when initilizing MemoCache
 
@@ -40,7 +41,7 @@ export default class MemoCache {
     entities: any,
     args: readonly any[] = [],
   ): {
-    data: DenormalizeNullable<S> | symbol;
+    data: DenormalizeNullable<S> | typeof INVALID;
     paths: EntityPath[];
   } {
     // we already vary based on input, so we don't need endpointKey? TODO: verify
@@ -72,7 +73,7 @@ export default class MemoCache {
     // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
     argsKey: string = JSON.stringify(args),
   ): {
-    data: DenormalizeNullable<S> | symbol;
+    data: DenormalizeNullable<S> | typeof INVALID;
     paths: EntityPath[];
   } {
     const input = this.buildQueryKey(schema, args, state, argsKey);

packages/normalizr/src/memo/globalCache.ts

@@ -2,6 +2,7 @@ import { EndpointsCache, EntityCache } from './types.js';
 import WeakDependencyMap, { type Dep } from './WeakDependencyMap.js';
 import type Cache from '../denormalize/cache.js';
 import type { GetEntity } from '../denormalize/getEntities.js';
+import type { INVALID } from '../denormalize/symbol.js';
 import type { EntityInterface } from '../interface.js';
 import type { EntityPath } from '../types.js';
 
@@ -34,7 +35,7 @@ export default class GlobalCache implements Cache {
     schema: EntityInterface,
     entity: any,
     computeValue: (localCacheKey: Map<string, any>) => void,
-  ): object | undefined | symbol {
+  ): object | undefined | typeof INVALID {
     const key = schema.key;
     const { localCacheKey, cycleCacheKey } = this.getCacheKey(key);
 
@@ -140,7 +141,7 @@ export default class GlobalCache implements Cache {
 
 interface EntityCacheValue {
   dependencies: Dep<EntityPath>[];
-  value: object | symbol | undefined;
+  value: object | typeof INVALID | undefined;
 }
 
 const getEntityCaches = (entityCache: EntityCache) => {

packages/normalizr/src/schemas/Array.ts

@@ -1,3 +1,4 @@
+import { INVALID } from '../denormalize/symbol.js';
 import type { Visit } from '../interface.js';
 
 const validateSchema = definition => {
@@ -17,7 +18,7 @@ const validateSchema = definition => {
 const getValues = input =>
   Array.isArray(input) ? input : Object.keys(input).map(key => input[key]);
 
-const filterEmpty = item => item !== undefined && typeof item !== 'symbol';
+const filterEmpty = item => item !== undefined && item !== INVALID;
 
 export const normalize = (
   schema: any,

packages/normalizr/src/schemas/ImmutableUtils.ts

@@ -46,7 +46,7 @@ export function denormalizeImmutable(
     const stringKey = `${key}`;
 
     const item = unvisit(schema[stringKey], object.get(stringKey));
-    if (typeof item === 'symbol') {
+    if (item === INVALID) {
       deleted = true;
     }
     if (object.has(stringKey)) {