enhance: types: symbol -> INVALID return value - more specific

Author: ntucker

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 { 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);
@@ -135,6 +136,10 @@ export default class MemoCache {
     }
     return value;
   }
+
+  isInvalid(data: any): data is typeof INVALID {
+    return data === INVALID;
+  }
 }
 
 type StateInterface = {

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) => {

website/src/components/Playground/editor-types/@data-client/core.d.ts

@@ -191,6 +191,8 @@ type NormalizeNullable<S> = S extends {
     [K: string]: any;
 } ? NormalizedNullableObject<S> : S;
 
+declare const INVALID: unique symbol;
+
 /** Maps a (ordered) list of dependencies to a value.
  *
  * Useful as a memoization cache for flat/normalized stores.
@@ -227,15 +229,16 @@ declare class MemoCache {
     protected queryKeys: Map<string, WeakDependencyMap<QueryPath>>;
     /** Compute denormalized form maintaining referential equality for same inputs */
     denormalize<S extends Schema>(schema: S | undefined, input: unknown, entities: any, args?: readonly any[]): {
-        data: DenormalizeNullable<S> | symbol;
+        data: DenormalizeNullable<S> | typeof INVALID;
         paths: EntityPath[];
     };
     /** Compute denormalized form maintaining referential equality for same inputs */
     query<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): {
-        data: DenormalizeNullable<S> | symbol;
+        data: DenormalizeNullable<S> | typeof INVALID;
         paths: EntityPath[];
     };
     buildQueryKey<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): NormalizeNullable<S>;
+    isInvalid(data: any): data is typeof INVALID;
 }
 type StateInterface = {
     entities: Record<string, Record<string, any> | undefined> | {
@@ -334,8 +337,6 @@ type UpdateFunction<SourceSchema extends Schema | undefined, DestSchema extends
 
 type FetchFunction<A extends readonly any[] = any, R = any> = (...args: A) => Promise<R>;
 
-declare const INVALID: unique symbol;
-
 declare class AbortOptimistic extends Error {
 }
 

website/src/components/Playground/editor-types/@data-client/normalizr.d.ts

@@ -225,7 +225,9 @@ interface NormalizeMeta {
     fetchedAt: number;
 }
 
-declare function denormalize<S extends Schema>(schema: S | undefined, input: any, entities: any, args?: readonly any[]): DenormalizeNullable<S> | symbol;
+declare const INVALID: unique symbol;
+
+declare function denormalize<S extends Schema>(schema: S | undefined, input: any, entities: any, args?: readonly any[]): DenormalizeNullable<S> | typeof INVALID;
 
 declare function isEntity(schema: Schema): schema is EntityInterface;
 
@@ -267,15 +269,16 @@ declare class MemoCache {
     protected queryKeys: Map<string, WeakDependencyMap<QueryPath>>;
     /** Compute denormalized form maintaining referential equality for same inputs */
     denormalize<S extends Schema>(schema: S | undefined, input: unknown, entities: any, args?: readonly any[]): {
-        data: DenormalizeNullable<S> | symbol;
+        data: DenormalizeNullable<S> | typeof INVALID;
         paths: EntityPath[];
     };
     /** Compute denormalized form maintaining referential equality for same inputs */
     query<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): {
-        data: DenormalizeNullable<S> | symbol;
+        data: DenormalizeNullable<S> | typeof INVALID;
         paths: EntityPath[];
     };
     buildQueryKey<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): NormalizeNullable<S>;
+    isInvalid(data: any): data is typeof INVALID;
 }
 type StateInterface = {
     entities: Record<string, Record<string, any> | undefined> | {
@@ -398,8 +401,6 @@ type ReadEndpoint<F extends FetchFunction = FetchFunction, S extends Schema | un
 
 type FetchFunction<A extends readonly any[] = any, R = any> = (...args: A) => Promise<R>;
 
-declare const INVALID: unique symbol;
-
 declare function validateQueryKey(queryKey: unknown): boolean;
 
 export { type AbstractInstanceType, type ArrayElement, type CheckLoop, type Denormalize, type DenormalizeNullable, type EndpointExtraOptions, type EndpointInterface, type EntityInterface, type EntityPath, type EntityTable, type ErrorTypes, ExpiryStatus, type ExpiryStatusInterface, type FetchFunction, type GetEntity, type GetIndex, INVALID, type INormalizeDelegate, type IQueryDelegate, type IndexInterface, type IndexParams, type InferReturn, MemoCache, type Mergeable, type MutateEndpoint, type NI, type NetworkError, type Normalize, type NormalizeNullable, type NormalizeReturnType, type NormalizedIndex, type NormalizedSchema, type OptimisticUpdateParams, type Queryable, type ReadEndpoint, type ResolveType, type Schema, type SchemaArgs, type SchemaClass, type SchemaSimple, type Serializable, type SnapshotInterface, type UnknownError, type UpdateFunction, type Visit, WeakDependencyMap, denormalize, isEntity, normalize, validateQueryKey };