mobx-keystone 2.0.0 → 2.2.0

package/src/types/utility/typesMap.ts

@@ -41,18 +41,14 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
             return getValue(storedKey)
           }
         case "getOrInsert":
-          return (key: TKeyRuntime, defaultValue: TValueRuntime) => {
-            const storedKey = keyAdapter.toStored(key)
-            if (!target.has(storedKey)) {
-              target.set(storedKey, valueAdapter.toStored(defaultValue))
-            }
-            return getValue(storedKey)
-          }
         case "getOrInsertComputed":
-          return (key: TKeyRuntime, callback: (key: TKeyRuntime) => TValueRuntime) => {
+          return (key: TKeyRuntime, valueOrCallback: unknown) => {
             const storedKey = keyAdapter.toStored(key)
             if (!target.has(storedKey)) {
-              const value = callback(key)
+              const value =
+                prop === "getOrInsert"
+                  ? (valueOrCallback as TValueRuntime)
+                  : (valueOrCallback as (key: TKeyRuntime) => TValueRuntime)(key)
               target.set(storedKey, valueAdapter.toStored(value))
             }
             return getValue(storedKey)
@@ -114,10 +110,18 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   }) as unknown as Map<TKeyRuntime, TValueRuntime>
 }
 
-function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
-  valueAdapter: RuntimeAdapter<TStoredValue, TRuntimeValue>
-): ModelPropTransform<Record<string, TStoredValue>, Map<string, TRuntimeValue>> {
-  const storedByRuntime = new WeakMap<Map<string, TRuntimeValue>, Record<string, TStoredValue>>()
+function makeMapTransform<
+  TStored extends object,
+  TKeyStored,
+  TKeyRuntime,
+  TValueStored,
+  TValueRuntime,
+>(
+  keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
+  valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>,
+  toStored: (runtimeMap: Map<TKeyRuntime, TValueRuntime>) => TStored
+): ModelPropTransform<TStored, Map<TKeyRuntime, TValueRuntime>> {
+  const storedByRuntime = new WeakMap<Map<TKeyRuntime, TValueRuntime>, TStored>()
 
   return {
     transform({ originalValue, cachedTransformedValue }) {
@@ -125,63 +129,51 @@ function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
         return cachedTransformedValue
       }
 
-      const runtimeMap = makeMapProxy(asMap(originalValue), identityRuntimeAdapter, valueAdapter)
+      const runtimeMap = makeMapProxy(
+        asMap(originalValue as any) as Map<TKeyStored, TValueStored>,
+        keyAdapter,
+        valueAdapter
+      )
 
       storedByRuntime.set(runtimeMap, originalValue)
       return runtimeMap
     },
 
     untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
+      return storedByRuntime.get(transformedValue) ?? toStored(transformedValue)
+    },
+  }
+}
 
+function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
+  valueAdapter: RuntimeAdapter<TStoredValue, TRuntimeValue>
+): ModelPropTransform<Record<string, TStoredValue>, Map<string, TRuntimeValue>> {
+  return makeMapTransform(
+    identityRuntimeAdapter as RuntimeAdapter<string, string>,
+    valueAdapter,
+    (runtimeMap) => {
       const result: Record<string, TStoredValue> = {}
-      transformedValue.forEach((value, key) => {
+      runtimeMap.forEach((value, key) => {
         const storedValue = valueAdapter.toStored(value)
         if (key === "__proto__") setProtoProp(result, storedValue)
         else result[key] = storedValue
       })
       return result
-    },
-  }
+    }
+  )
 }
 
 function makeArrayBackedMapTransform<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
   valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>
 ): ModelPropTransform<Array<[TKeyStored, TValueStored]>, Map<TKeyRuntime, TValueRuntime>> {
-  const storedByRuntime = new WeakMap<
-    Map<TKeyRuntime, TValueRuntime>,
-    Array<[TKeyStored, TValueStored]>
-  >()
-
-  return {
-    transform({ originalValue, cachedTransformedValue }) {
-      if (cachedTransformedValue) {
-        return cachedTransformedValue
-      }
-
-      const runtimeMap = makeMapProxy(asMap(originalValue), keyAdapter, valueAdapter)
-
-      storedByRuntime.set(runtimeMap, originalValue)
-      return runtimeMap
-    },
-
-    untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
-
-      const result: Array<[TKeyStored, TValueStored]> = []
-      transformedValue.forEach((value, key) => {
-        result.push([keyAdapter.toStored(key), valueAdapter.toStored(value)])
-      })
-      return result
-    },
-  }
+  return makeMapTransform(keyAdapter, valueAdapter, (runtimeMap) => {
+    const result: Array<[TKeyStored, TValueStored]> = []
+    runtimeMap.forEach((value, key) => {
+      result.push([keyAdapter.toStored(key), valueAdapter.toStored(value)])
+    })
+    return result
+  })
 }
 
 export function typesMapFromObject<TValueType extends AnyType>(

package/src/types/utility/typesRefinement.ts

@@ -62,6 +62,11 @@ export function typesRefinement<T extends AnyType>(
       return `${refinementName}<${baseTypeName}>`
     }
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [baseChecker],
+      ([processor]) => processor
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       baseChecker.baseType,
 
@@ -103,14 +108,8 @@ export function typesRefinement<T extends AnyType>(
       // we cannot check refinement here since it checks data instances, not snapshots
       (sn) => baseChecker.snapshotType(sn),
 
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      ),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      )
+      processorPlan,
+      processorPlan
     )
 
     return thisTc

package/src/types/utility/typesSkipCheck.ts

@@ -42,20 +42,19 @@ export function typesSkipCheck<T extends AnyType>(baseType: T): T {
       return `skipCheck<${baseTypeName}>`
     }
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [baseChecker],
+      ([processor]) => processor
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       baseChecker.baseType,
       (_data, _path, _typeCheckedValue) => null, // always passes validation
       getTypeName,
       typeInfoGen,
       (sn) => baseChecker.snapshotType(sn),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      ),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      )
+      processorPlan,
+      processorPlan
     )
     thisTc.skipCheck = true
 

package/src/types/utility/typesTag.ts

@@ -52,20 +52,19 @@ export function typesTag<T extends AnyType, A>(baseType: T, tag: A, typeName?: s
       return `${taggedName}<${baseTypeName}>`
     }
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [baseChecker],
+      ([processor]) => processor
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       baseChecker.baseType,
       (data, path, typeCheckedValue) => baseChecker.check(data, path, typeCheckedValue),
       getTypeName,
       typeInfoGen,
       (sn) => baseChecker.snapshotType(sn),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      ),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      )
+      processorPlan,
+      processorPlan
     )
 
     return thisTc

package/src/utils/ModelPool.ts

@@ -1,74 +1,113 @@
 import type { AnyModel } from "../model/BaseModel"
-import { getModelIdPropertyName } from "../model/getModelMetadata"
 import { modelIdKey, modelTypeKey } from "../model/metadata"
-import { getSnapshotModelType, isModel } from "../model/utils"
-import type { ModelClass } from "../modelShared/BaseModelShared"
-import { getModelInfoForName } from "../modelShared/modelInfo"
+import { isModel } from "../model/utils"
 import { dataToModelNode } from "../parent/core"
 import {
-  getDeepObjectChildren,
+  type DeepObjectChildrenExtensionAccessor,
+  type PinnedDeepObjectChildrenExtensionData,
   registerDeepObjectChildrenExtension,
 } from "../parent/coreObjectChildren"
+import { getOrCreate } from "./mapUtils"
 
 type ModelsById = Map<string, AnyModel>
 type ModelsByTypeAndId = Map<string, ModelsById>
 
+interface DeepChildrenModels {
+  readonly byTypeAndId: ModelsByTypeAndId
+  /** Id each model is indexed under, since ids can change later. */
+  readonly indexedIds: Map<AnyModel, string>
+  /** Whether some model was shadowed by another one with the same type and id. */
+  hasDuplicates: boolean
+}
+
+/**
+ * A view of the models under a node, as they were when the pool was created.
+ * Must be released once no longer used.
+ */
 export class ModelPool {
-  private pool: ReadonlyMap<string, ReadonlyMap<string, AnyModel>>
+  private readonly pool: ReadonlyMap<string, ReadonlyMap<string, AnyModel>>
+  private readonly pinned: PinnedDeepObjectChildrenExtensionData<DeepChildrenModels>
 
   constructor(root: object) {
     // make sure we don't use the sub-data $ object
     root = dataToModelNode(root)
 
-    this.pool = getDeepChildrenModels(getDeepObjectChildren(root))
+    this.pinned = getDeepChildrenModels().pin(root)
+    this.pool = this.pinned.data.byTypeAndId
   }
 
-  findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
-    return modelId !== undefined ? this.pool.get(modelType)?.get(modelId) : undefined
+  release(): void {
+    this.pinned.release()
   }
 
-  findModelForSnapshot(sn: any): AnyModel | undefined {
-    const modelType = getSnapshotModelType(sn)
-    if (modelType === undefined) {
-      return undefined
-    }
-
-    const modelInfo = getModelInfoForName(modelType)!
-    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-
-    return modelIdPropertyName !== undefined
-      ? this.findModelByTypeAndId(modelType, (sn as any)[modelIdPropertyName])
-      : undefined
+  findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
+    return modelId !== undefined ? this.pool.get(modelType)?.get(modelId) : undefined
   }
 }
 
-type GetDeepChildrenModels = (data: ReturnType<typeof getDeepObjectChildren>) => ModelsByTypeAndId
+let deepChildrenModels: DeepObjectChildrenExtensionAccessor<DeepChildrenModels> | undefined
 
-let getDeepChildrenModels: GetDeepChildrenModels = (data) => {
-  // Register on first use to keep ModelPool out of the coreObjectChildren
-  // module-initialization cycle. The extension getter backfills its index from
-  // data.deep, so registering after a deep-children set already exists is safe.
-  const getRegisteredDeepChildrenModels = registerDeepObjectChildrenExtension<ModelsByTypeAndId>({
+// Registered on first use to keep ModelPool out of the coreObjectChildren
+// module-initialization cycle.
+function getDeepChildrenModels() {
+  deepChildrenModels ??= registerDeepObjectChildrenExtension<DeepChildrenModels>({
     initData() {
-      return new Map()
+      return {
+        byTypeAndId: new Map(),
+        indexedIds: new Map(),
+        hasDuplicates: false,
+      }
     },
 
-    addNode(node, extensionData) {
+    // last one wins when rebuilding
+    addNode(node, data) {
       if (isModel(node)) {
         const id = node[modelIdKey]
         if (id !== undefined) {
-          const modelType = node[modelTypeKey]
-          let modelsById = extensionData.get(modelType)
-          if (!modelsById) {
-            modelsById = new Map()
-            extensionData.set(modelType, modelsById)
+          const modelsById = getOrCreate(data.byTypeAndId, node[modelTypeKey], () => new Map())
+          const previous = modelsById.get(id)
+          if (previous) {
+            data.hasDuplicates = true
+            data.indexedIds.delete(previous)
           }
           modelsById.set(id, node)
+          data.indexedIds.set(node, id)
         }
       }
     },
-  })
 
-  getDeepChildrenModels = getRegisteredDeepChildrenModels
-  return getRegisteredDeepChildrenModels(data)
+    addNodeIncrementally(node, data) {
+      if (isModel(node)) {
+        const id = node[modelIdKey]
+        if (id !== undefined) {
+          const modelsById = getOrCreate(data.byTypeAndId, node[modelTypeKey], () => new Map())
+          if (modelsById.has(id)) {
+            // which duplicate wins depends on the deep children order
+            return false
+          }
+          modelsById.set(id, node)
+          data.indexedIds.set(node, id)
+        }
+      }
+      return true
+    },
+
+    removeNode(node, data) {
+      if (isModel(node)) {
+        if (data.hasDuplicates) {
+          // a shadowed duplicate might need to take its place
+          return false
+        }
+        const id = data.indexedIds.get(node)
+        if (id !== undefined) {
+          data.indexedIds.delete(node)
+          data.byTypeAndId.get(node[modelTypeKey])!.delete(id)
+        }
+      }
+      return true
+    },
+
+    dependsOnModelIds: true,
+  })
+  return deepChildrenModels
 }

package/src/utils/chunks.ts

@@ -0,0 +1,271 @@
+/**
+ * Target size of the chunks large collections are split in, so a change only
+ * needs to revisit one chunk instead of every item.
+ *
+ * @internal
+ */
+export const chunkSize = 128
+
+/**
+ * @internal
+ */
+export interface SequenceChunk<T> {
+  items: T[]
+}
+
+/**
+ * An ordered sequence split in chunks, which splices keep near `chunkSize`:
+ * chunks are split above twice that size and merged below a quarter of it.
+ * Subclasses decide what a chunk keeps track of through the hooks.
+ *
+ * @internal
+ */
+export abstract class ChunkedSequence<T, C extends SequenceChunk<T>> {
+  chunks: C[] = []
+
+  protected abstract createChunk(items: T[]): C
+
+  /**
+   * Called once items were removed from or inserted into a chunk, before
+   * resizing it. The items from `from` on changed their position in it.
+   */
+  protected abstract onSpliced(chunk: C, from: number): void
+
+  /**
+   * Called when a resize moves items to another chunk, starting at `from`.
+   * The chunk they come from was already passed to `onSpliced`.
+   */
+  protected abstract onItemsMoved(chunk: C, from: number): void
+
+  /** Called for each chunk after the spliced ones when a splice changes the length. */
+  protected onShifted(_chunk: C): void {}
+
+  /** Splits items in new chunks, appended to the current ones. */
+  protected appendChunks(items: readonly T[]): void {
+    for (let i = 0; i < items.length; i += chunkSize) {
+      this.chunks.push(this.createChunk(items.slice(i, i + chunkSize)))
+    }
+  }
+
+  /** Replaces every chunk with new ones for the items. */
+  protected reset(items: readonly T[]): void {
+    this.chunks = []
+    this.appendChunks(items)
+  }
+
+  /** Chunk containing the index, and the index within it. Appends go to the last chunk. */
+  locate(index: number): [number, number] {
+    const chunks = this.chunks
+    let c = 0
+    let local = index
+    while (c < chunks.length - 1 && local >= chunks[c].items.length) {
+      local -= chunks[c].items.length
+      c++
+    }
+    return [c, local]
+  }
+
+  /**
+   * Removes and inserts items, like `Array.prototype.splice`. `onRemoved` is
+   * called with each removed item, the chunk it was in and its index there.
+   */
+  protected splice(
+    index: number,
+    removedCount: number,
+    added: readonly T[],
+    onRemoved?: (item: T, chunk: C, local: number) => void
+  ): void {
+    const chunks = this.chunks
+    if (chunks.length === 0) {
+      if (added.length === 0) {
+        return
+      }
+      chunks.push(this.createChunk([]))
+    }
+
+    const [first, start] = this.locate(index)
+    let last = first
+    let remaining = removedCount
+    let local = start
+    for (let c = first; remaining > 0; c++) {
+      const chunk = chunks[c]
+      const count = Math.min(remaining, chunk.items.length - local)
+      const removed = chunk.items.splice(local, count)
+      if (onRemoved) {
+        for (let i = 0; i < removed.length; i++) {
+          onRemoved(removed[i], chunk, local + i)
+        }
+      }
+      remaining -= count
+      local = 0
+      last = c
+    }
+
+    const firstChunk = chunks[first]
+    if (added.length > 0) {
+      firstChunk.items = firstChunk.items
+        .slice(0, start)
+        .concat(added as T[], firstChunk.items.slice(start))
+    }
+
+    this.onSpliced(firstChunk, start + added.length)
+    for (let c = first + 1; c <= last; c++) {
+      this.onSpliced(chunks[c], 0)
+    }
+    if (added.length !== removedCount) {
+      for (let c = last + 1; c < chunks.length; c++) {
+        this.onShifted(chunks[c])
+      }
+    }
+
+    // backwards, so merging or splitting a chunk does not move the ones left to visit
+    for (let c = last; c >= first; c--) {
+      this.resize(c)
+    }
+  }
+
+  /** Splits, merges or drops a changed chunk to keep its size near the target. */
+  private resize(c: number) {
+    const chunks = this.chunks
+    const chunk = chunks[c]
+    const length = chunk.items.length
+
+    if (length > 2 * chunkSize) {
+      const pieceCount = Math.ceil(length / chunkSize)
+      const pieceSize = Math.ceil(length / pieceCount)
+      const pieces: C[] = []
+      for (let i = pieceSize; i < length; i += pieceSize) {
+        const piece = this.createChunk(chunk.items.slice(i, i + pieceSize))
+        this.onItemsMoved(piece, 0)
+        pieces.push(piece)
+      }
+      chunk.items = chunk.items.slice(0, pieceSize)
+      this.chunks = chunks.slice(0, c + 1).concat(pieces, chunks.slice(c + 1))
+    } else if (length < chunkSize / 4) {
+      const previous = chunks[c - 1] as C | undefined
+      const next = chunks[c + 1] as C | undefined
+      if (previous && previous.items.length + length <= 2 * chunkSize) {
+        const from = previous.items.length
+        previous.items = previous.items.concat(chunk.items)
+        this.onItemsMoved(previous, from)
+        chunks.splice(c, 1)
+      } else if (next && next.items.length + length <= 2 * chunkSize) {
+        next.items = chunk.items.concat(next.items)
+        this.onItemsMoved(next, 0)
+        chunks.splice(c, 1)
+      } else if (length === 0) {
+        chunks.splice(c, 1)
+      }
+    }
+  }
+}
+
+/**
+ * An unordered set split in chunks. Items are added to the last chunk, and a
+ * chunk left under a quarter of `chunkSize` by removals is merged into a
+ * neighbor (or dropped once empty). Subclasses decide what a chunk keeps track
+ * of through the hooks.
+ *
+ * @internal
+ */
+export abstract class ChunkedSet<T, C extends SequenceChunk<T>> {
+  chunks: C[] = []
+  /** Chunk of each item, only needed (and kept) once an item is looked up. */
+  private chunkOf: Map<T, C> | undefined
+
+  protected abstract createChunk(items: T[]): C
+
+  /** Called when items were added to or removed from a chunk. */
+  protected abstract onChunkChanged(chunk: C): void
+
+  /** Called when chunks were added or removed. */
+  protected abstract onChunksChanged(): void
+
+  /** Called for a chunk removed after its items were moved to another one. */
+  protected onChunkDropped(_chunk: C): void {}
+
+  /** Splits items in new chunks, appended to the current ones. */
+  protected appendChunks(items: readonly T[]): void {
+    for (let i = 0; i < items.length; i += chunkSize) {
+      this.chunks.push(this.createChunk(items.slice(i, i + chunkSize)))
+    }
+  }
+
+  /** Replaces every chunk with new ones for the items. */
+  protected reset(items: readonly T[]): void {
+    this.chunks = []
+    this.chunkOf = undefined
+    this.appendChunks(items)
+  }
+
+  add(item: T): void {
+    let chunk = this.chunks[this.chunks.length - 1] as C | undefined
+    if (chunk && chunk.items.length < chunkSize) {
+      chunk.items.push(item)
+      this.onChunkChanged(chunk)
+    } else {
+      chunk = this.createChunk([item])
+      this.chunks.push(chunk)
+      this.onChunksChanged()
+    }
+    this.chunkOf?.set(item, chunk)
+  }
+
+  /** Chunk containing the item, if any. */
+  getChunkOf(item: T): C | undefined {
+    return this.getChunkOfMap().get(item)
+  }
+
+  private getChunkOfMap(): Map<T, C> {
+    if (!this.chunkOf) {
+      this.chunkOf = new Map()
+      for (const chunk of this.chunks) {
+        for (const i of chunk.items) {
+          this.chunkOf.set(i, chunk)
+        }
+      }
+    }
+    return this.chunkOf
+  }
+
+  /** Returns false if the item was not in the set. */
+  delete(item: T): boolean {
+    const chunkOf = this.getChunkOfMap()
+    const chunk = chunkOf.get(item)
+    if (!chunk) {
+      return false
+    }
+    chunkOf.delete(item)
+    // (the order within a chunk does not matter, so the last item fills the gap)
+    const items = chunk.items
+    const last = items.pop()!
+    if (last !== item) {
+      items[items.lastIndexOf(item)] = last
+    }
+    this.onChunkChanged(chunk)
+    if (chunk.items.length >= chunkSize / 4) {
+      return true
+    }
+
+    // merge it into a neighbor, or drop it once empty
+    const chunks = this.chunks
+    const c = chunks.indexOf(chunk)
+    if (chunk.items.length > 0) {
+      const neighbor = [chunks[c - 1], chunks[c + 1]].find(
+        (n) => n && n.items.length + chunk.items.length <= 2 * chunkSize
+      )
+      if (!neighbor) {
+        return true
+      }
+      for (const i of chunk.items) {
+        chunkOf.set(i, neighbor)
+      }
+      neighbor.items = neighbor.items.concat(chunk.items)
+      this.onChunkChanged(neighbor)
+    }
+    chunks.splice(c, 1)
+    this.onChunkDropped(chunk)
+    this.onChunksChanged()
+    return true
+  }
+}

package/src/utils/decorators.ts

@@ -109,7 +109,7 @@ export function decorateWrapMethodOrField(
     const propertyKey: string = args[1]
     const baseDescriptor: PropertyDescriptor | undefined = args[2]
 
-    checkModelDecoratorTaget(decoratorName, target)
+    checkModelDecoratorTarget(decoratorName, target)
     checkDecoratorContext(decoratorName, propertyKey, false)
 
     const data = getActionNameAndContextOverride(target, propertyKey, true)
@@ -166,7 +166,7 @@ export function decorateWrapMethodOrField(
           inited = true
 
           const target = this
-          checkModelDecoratorTaget(decoratorName, target)
+          checkModelDecoratorTarget(decoratorName, target)
 
           // find the deepest proto that matches the value
           let proto = this
@@ -195,7 +195,7 @@ export function decorateWrapMethodOrField(
           const instance = this
 
           if (!data) {
-            checkModelDecoratorTaget(decoratorName, instance)
+            checkModelDecoratorTarget(decoratorName, instance)
             data = getActionNameAndContextOverride(instance, propertyKey, false)
           }
 
@@ -207,7 +207,7 @@ export function decorateWrapMethodOrField(
       }
 
       default:
-        throw failure(`@${decoratorName} can only be used on fields or methods}`)
+        throw failure(`@${decoratorName} can only be used on fields or methods`)
     }
   }
 }
@@ -270,7 +270,7 @@ function getActionNameAndContextOverride(
   }
 }
 
-function checkModelDecoratorTaget(decoratorName: string, target: any) {
+function checkModelDecoratorTarget(decoratorName: string, target: any) {
   if (!inDevMode) {
     return
   }