@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/unpkg/prod-deprecated/model/migration-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-support.js","names":["recordIdentifierFor","Context","notifyInternalSignal","assertPrivateStore","getOrSetGlobal","Type","Errors","lookupLegacySupport","_destroyRecord","_reload","_save","belongsTo","changedAttributes","createSnapshot","deleteRecord","destroyRecord","hasMany","reload","rollbackAttributes","save","serialize","unloadRecord","RecordState","buildSchema","LegacyFields","LegacySupport","WeakMap","legacySupport","record","options","prop","state","get","set","suppressDeprecation","Boolean","currentState","adapterError","_constructor","isModel","name","type","modelName","recordState","dirtyType","errors","create","__record","isDirty","isDeleted","isEmpty","isError","isLoaded","isLoading","isNew","isSaving","isValid","withDefaults","schema","legacy","identity","kind","forEach","field","fields","push","defaultValue","objectExtensions","withRestoredDeprecatedModelRequestBehaviors","registerDerivations","registerDerivation","_registerMode","store","cacheKey","getBelongsTo","value","_join","setDirtyBelongsTo","getHasMany","support","manyArray","getManyArray","splice","length","notify","_manyArrayCache","hasPromise","_relationshipPromisesCache","signal","CAUTION_MEGA_DANGER_ZONE_registerExtension","features","isReloading","console","warn","_isReloading","v","DelegatingSchemaService","_preferred","_secondary","constructor","isDelegated","resource","hasResource","resourceTypes","Array","from","Set","concat","hasTrait","resourceHasTrait","trait","cacheFields","transformation","hashFn","derivation","registerResources","schemas","registerResource","registerTransformation","transform","registerHashFn","CAUTION_MEGA_DANGER_ZONE_hasExtension","ext","extension","CAUTION_MEGA_DANGER_ZONE_resourceExtensions","CAUTION_MEGA_DANGER_ZONE_objectExtensions","resolvedType","CAUTION_MEGA_DANGER_ZONE_arrayExtensions","mode","kinds","_kind","assertPrivate","service","prototype","attributesDefinitionFor","relationshipsDefinitionFor","doesTypeExist"],"sources":["../../../../src/model/migration-support.ts"],"sourcesContent":["/**\n * This module provides support for migrating away from @warp-drive/legacy/model\n * to ReactiveResource from @warp-drive/core/reactive.\n *\n * It includes:\n *\n * - A `withDefaults` function to assist in creating a schema in LegacyMode\n * - A `registerDerivations` function to register the derivations necessary to support LegacyMode\n * - A `DelegatingSchemaService` that can be used to provide a schema service that works with both\n *   @warp-drive/legacy/model and @warp-drive/core/reactive simultaneously for migration purposes.\n * - A `WithLegacy` type util that can be used to create a type that includes the legacy\n *   properties and methods of a record.\n *\n * Using LegacyMode features on a ReactiveResource *requires* the use of these derivations and schema\n * additions. LegacyMode is not intended to be a long-term solution, but rather a stepping stone\n * to assist in more rapidly adopting modern WarpDrive features.\n *\n * @module\n */\nimport { deprecate } from '@ember/debug';\n\nimport type { Store } from '@warp-drive/core';\nimport { recordIdentifierFor } from '@warp-drive/core';\nimport { ENABLE_LEGACY_SCHEMA_SERVICE } from '@warp-drive/core/build-config/deprecations';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from '@warp-drive/core/reactive';\nimport type { ExtensibleField } from '@warp-drive/core/reactive/-private';\nimport { Context } from '@warp-drive/core/reactive/-private';\nimport { notifyInternalSignal } from '@warp-drive/core/signals/-leaked';\nimport type { PrivateReactiveResourceArray } from '@warp-drive/core/store/-private';\nimport { assertPrivateStore } from '@warp-drive/core/store/-private';\nimport type { SchemaService } from '@warp-drive/core/types';\nimport { getOrSetGlobal } from '@warp-drive/core/types/-private';\nimport type { ChangedAttributesHash } from '@warp-drive/core/types/cache';\nimport type { ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { ObjectValue } from '@warp-drive/core/types/json/raw';\nimport type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { Derivation, HashFn, Transformation } from '@warp-drive/core/types/schema/concepts';\nimport type {\n  ArrayField,\n  CacheableFieldSchema,\n  DerivedField,\n  FieldSchema,\n  GenericField,\n  HashField,\n  IdentityField,\n  LegacyBelongsToField,\n  LegacyHasManyField,\n  LegacyResourceSchema,\n  ObjectField,\n  ObjectSchema,\n  ResourceSchema,\n} from '@warp-drive/core/types/schema/fields';\nimport { Type } from '@warp-drive/core/types/symbols';\nimport type { WithPartial } from '@warp-drive/core/types/utils';\n\nimport type { Snapshot } from '../compat/-private.ts';\nimport { Errors, lookupLegacySupport } from './-private.ts';\nimport type { MinimalLegacyRecord } from './-private/model-methods.ts';\nimport {\n  _destroyRecord,\n  _reload,\n  _save,\n  belongsTo,\n  changedAttributes,\n  createSnapshot,\n  deleteRecord,\n  destroyRecord,\n  hasMany,\n  reload,\n  rollbackAttributes,\n  save,\n  serialize,\n  unloadRecord,\n} from './-private/model-methods.ts';\nimport RecordState from './-private/record-state.ts';\nimport type BelongsToReference from './-private/references/belongs-to.ts';\nimport type HasManyReference from './-private/references/has-many.ts';\nimport { buildSchema } from './-private/schema-provider.ts';\nimport type { _MaybeBelongsToFields, MaybeHasManyFields } from './-private/type-utils.ts';\n\n/**\n * Adds the `Model`-style `belongsTo`/`hasMany` reference methods to a\n * {@link TypedRecordInstance}, for use when migrating a resource from\n * `Model` to a schema-based record while preserving these APIs.\n */\nexport type WithLegacyDerivations<T extends TypedRecordInstance> = T &\n  MinimalLegacyRecord & {\n    /**\n     * see {@link belongsTo}\n     */\n    belongsTo: typeof belongsTo;\n    /**\n     * see {@link hasMany}\n     */\n    hasMany: typeof hasMany;\n  };\n\ntype AttributesSchema = ReturnType<Exclude<SchemaService['attributesDefinitionFor'], undefined>>;\ntype RelationshipsSchema = ReturnType<Exclude<SchemaService['relationshipsDefinitionFor'], undefined>>;\n\ninterface LegacyModeRecord<T extends TypedRecordInstance> {\n  id: string | null;\n\n  serialize(options?: Record<string, unknown>): unknown;\n  destroyRecord(options?: Record<string, unknown>): Promise<this>;\n  unloadRecord(): void;\n  changedAttributes(): ChangedAttributesHash;\n  rollbackAttributes(): void;\n  _createSnapshot(): Snapshot<T>;\n  save(options?: Record<string, unknown>): Promise<this>;\n  reload(options?: Record<string, unknown>): Promise<T>;\n  belongsTo<K extends _MaybeBelongsToFields<T>>(prop: K): BelongsToReference<T, K>;\n  hasMany<K extends MaybeHasManyFields<T>>(prop: K): HasManyReference<T, K>;\n  deleteRecord(): void;\n\n  adapterError: unknown;\n  constructor: { modelName: TypeFromInstance<T> };\n  currentState: RecordState;\n  dirtyType: 'deleted' | 'created' | 'updated' | '';\n  errors: unknown;\n  hasDirtyAttributes: boolean;\n  isDeleted: boolean;\n  isEmpty: boolean;\n  isError: boolean;\n  isLoaded: boolean;\n  isLoading: boolean;\n  isDestroying: boolean;\n  isDestroyed: boolean;\n  isNew: boolean;\n  isSaving: boolean;\n  isValid: boolean;\n}\n\n// 'isDestroying', 'isDestroyed'\nconst LegacyFields = [\n  '_createSnapshot',\n  'adapterError',\n  'belongsTo',\n  'changedAttributes',\n  'constructor',\n  'currentState',\n  'deleteRecord',\n  'destroyRecord',\n  'dirtyType',\n  'errors',\n  'hasDirtyAttributes',\n  'hasMany',\n  'isDeleted',\n  'isEmpty',\n  'isError',\n  'isLoaded',\n  'isLoading',\n  'isNew',\n  'isSaving',\n  'isValid',\n  'reload',\n  'rollbackAttributes',\n  'save',\n  'serialize',\n  'unloadRecord',\n] as const;\n\n/**\n * A Type utility that enables quickly adding type information for the fields\n * defined by `import { withDefaults } from '@warp-drive/legacy/model/migration-support'`.\n *\n * Example:\n *\n * ```ts\n * import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';\n * import { Type } from '@warp-drive/core/types/symbols';\n * import type { HasMany } from '@@warp-drive/legacy/model';\n *\n * export const UserSchema = withDefaults({\n *   type: 'user',\n *   fields: [\n *     { name: 'firstName', kind: 'attribute' },\n *     { name: 'lastName', kind: 'attribute' },\n *     { name: 'age', kind: 'attribute' },\n *     { name: 'friends',\n *       kind: 'hasMany',\n *       type: 'user',\n *       options: { inverse: 'friends', async: false }\n *     },\n *     { name: 'bestFriend',\n *       kind: 'belongsTo',\n *       type: 'user',\n *       options: { inverse: null, async: false }\n *     },\n *   ],\n * });\n *\n * export type User = WithLegacy<{\n *   firstName: string;\n *   lastName: string;\n *   age: number;\n *   friends: HasMany<User>;\n *   bestFriend: User | null;\n *   [Type]: 'user';\n * }>\n * ```\n *\n */\nexport type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;\n\nconst LegacySupport = getOrSetGlobal('LegacySupport', new WeakMap<MinimalLegacyRecord, Record<string, unknown>>());\n\nfunction legacySupport(record: MinimalLegacyRecord, options: ObjectValue | null, prop: string): unknown {\n  let state = LegacySupport.get(record);\n  if (!state) {\n    state = {};\n    LegacySupport.set(record, state);\n  }\n  const suppressDeprecation = Boolean(options && options.suppressDeprecation);\n\n  switch (prop) {\n    case '_createSnapshot':\n      // FIXME should be deprecated too?\n      return createSnapshot;\n    case 'adapterError':\n      // FIXME should be deprecated too?\n      return record.currentState.adapterError;\n    case 'belongsTo':\n      return belongsTo;\n    case 'changedAttributes':\n      return changedAttributes;\n    case 'constructor':\n      return (state._constructor = state._constructor || {\n        isModel: true,\n        name: `Record<${recordIdentifierFor(record).type}>`,\n        modelName: recordIdentifierFor(record).type,\n      });\n    case 'currentState':\n      return (state.recordState = state.recordState || new RecordState(record));\n    case 'deleteRecord':\n      return deleteRecord;\n    case 'destroyRecord':\n      return suppressDeprecation ? _destroyRecord : destroyRecord;\n    case 'dirtyType':\n      return record.currentState.dirtyType;\n    case 'errors':\n      // FIXME should be deprecated too?\n      // @ts-expect-error\n      // oxlint-disable-next-line typescript/no-unsafe-call\n      return (state.errors = state.errors || Errors.create({ __record: record }));\n    case 'hasDirtyAttributes':\n      return record.currentState.isDirty;\n    case 'hasMany':\n      return hasMany;\n    case 'isDeleted':\n      return record.currentState.isDeleted;\n    case 'isEmpty':\n      return record.currentState.isEmpty;\n    case 'isError':\n      return record.currentState.isError;\n    case 'isLoaded':\n      return record.currentState.isLoaded;\n    case 'isLoading':\n      return record.currentState.isLoading;\n    case 'isNew':\n      return record.currentState.isNew;\n    case 'isSaving':\n      return record.currentState.isSaving;\n    case 'isValid':\n      return record.currentState.isValid;\n    case 'reload':\n      return suppressDeprecation ? _reload : reload;\n    case 'rollbackAttributes':\n      return rollbackAttributes;\n    case 'save':\n      return suppressDeprecation ? _save : save;\n    case 'serialize':\n      // FIXME should be deprecated too? (is somewhat deprecated via store.serializeRecord)\n      return serialize;\n    case 'unloadRecord':\n      return unloadRecord;\n    default:\n      assert(`${prop} is not a supported legacy field`, false);\n  }\n}\nlegacySupport[Type] = '@legacy';\n\n/**\n * A function which adds the necessary fields to a schema and marks it as\n * being in LegacyMode. This is used to support the legacy features of\n * @warp-drive/legacy/model while migrating to WarpDrive.\n *\n * Example:\n *\n * ```ts\n * import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';\n * import { Type } from '@warp-drive/core/types/symbols';\n * import type { HasMany } from '@warp-drive/legacy/model';\n *\n * export const UserSchema = withDefaults({\n *   type: 'user',\n *   fields: [\n *     { name: 'firstName', kind: 'attribute' },\n *     { name: 'lastName', kind: 'attribute' },\n *     { name: 'age', kind: 'attribute' },\n *     { name: 'friends',\n *       kind: 'hasMany',\n *       type: 'user',\n *       options: { inverse: 'friends', async: false }\n *     },\n *     { name: 'bestFriend',\n *       kind: 'belongsTo',\n *       type: 'user',\n *       options: { inverse: null, async: false }\n *     },\n *   ],\n * });\n *\n * export type User = WithLegacy<{\n *   firstName: string;\n *   lastName: string;\n *   age: number;\n *   friends: HasMany<User>;\n *   bestFriend: User | null;\n *   [Type]: 'user';\n * }>\n * ```\n *\n * Using this function require registering the derivations\n * it requires with the schema service.\n *\n * ```ts\n * import { registerDerivations } from '@warp-drive/legacy/model/migration-support';\n *\n * registerDerivations(schema);\n * ```\n *\n * @param schema The schema to add legacy support to.\n * @return The schema with legacy support added.\n * @public\n */\nexport function withDefaults(schema: WithPartial<LegacyResourceSchema, 'legacy' | 'identity'>): LegacyResourceSchema {\n  schema.legacy = true;\n  schema.identity = { kind: '@id', name: 'id' };\n\n  LegacyFields.forEach((field) => {\n    schema.fields.push({\n      type: '@legacy',\n      name: field,\n      kind: 'derived',\n    });\n  });\n  schema.fields.push({\n    name: '_isReloading',\n    kind: '@local',\n    type: 'boolean',\n    options: { defaultValue: false },\n  });\n  schema.fields.push({\n    name: 'isDestroying',\n    kind: '@local',\n    type: 'boolean',\n    options: { defaultValue: false },\n  });\n  schema.fields.push({\n    name: 'isDestroyed',\n    kind: '@local',\n    type: 'boolean',\n    options: { defaultValue: false },\n  });\n  schema.objectExtensions = schema.objectExtensions || [];\n  schema.objectExtensions.push('deprecated-model-behaviors');\n  return schema as LegacyResourceSchema;\n}\n\n/**\n * Adds the necessasary fields to the schema for supporting\n * the deprecated request methods on LegacyMode schemas.\n *\n * Use this instead of `withDefaults` to add the fields\n * and behaviors necessary to support Model-Like capabilities.\n *\n * ```ts\n * import { withRestoredDeprecatedModelRequestBehaviors } from '@warp-drive/legacy/model/migration-support';\n *\n * export const UserSchema = withRestoredDeprecatedModelRequestBehaviors({\n *   type: 'user',\n *   fields: [\n *     { name: 'firstName', kind: 'attribute' },\n *     { name: 'lastName', kind: 'attribute' },\n *   ]\n * });\n * ```\n */\nexport function withRestoredDeprecatedModelRequestBehaviors(\n  schema: WithPartial<LegacyResourceSchema, 'legacy' | 'identity'>\n): LegacyResourceSchema {\n  schema.legacy = true;\n  schema.identity = { kind: '@id', name: 'id' };\n\n  LegacyFields.forEach((field) => {\n    schema.fields.push({\n      type: '@legacy',\n      name: field,\n      kind: 'derived',\n      options: { suppressDeprecation: true },\n    });\n  });\n  schema.fields.push({\n    name: 'isReloading',\n    kind: '@local',\n    type: 'boolean',\n    options: { defaultValue: false },\n  });\n  schema.fields.push({\n    name: 'isDestroying',\n    kind: '@local',\n    type: 'boolean',\n    options: { defaultValue: false },\n  });\n  schema.fields.push({\n    name: 'isDestroyed',\n    kind: '@local',\n    type: 'boolean',\n    options: { defaultValue: false },\n  });\n  return schema as LegacyResourceSchema;\n}\n\n/**\n * A function which registers the necessary derivations to support\n * the LegacyMode features of @warp-drive/legacy/model while migrating to WarpDrive.\n *\n * This must be called in order to use the fields added by {@link withDefaults} or\n * {@link withRestoredDeprecatedModelRequestBehaviors}.\n *\n * @param schema The schema service to register the derivations with.\n * @public\n */\nexport function registerDerivations(schema: SchemaService): void {\n  schema.registerDerivation(legacySupport);\n  // @ts-expect-error\n  // oxlint-disable-next-line typescript/no-unsafe-call\n  schema._registerMode('@legacy', {\n    belongsTo: {\n      get(store: Store, record: object, cacheKey: ResourceKey, field: LegacyBelongsToField) {\n        // FIXME field.name here should likely be field.sourceKey || field.name\n        return lookupLegacySupport(record as unknown as MinimalLegacyRecord).getBelongsTo(field.name);\n      },\n      set(store: Store, record: object, cacheKey: ResourceKey, field: LegacyBelongsToField, value: unknown) {\n        assertPrivateStore(store);\n        store._join(() => {\n          // FIXME field.name here should likely be field.sourceKey || field.name\n          lookupLegacySupport(record as unknown as MinimalLegacyRecord).setDirtyBelongsTo(field.name, value);\n        });\n      },\n    },\n    hasMany: {\n      get(store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField) {\n        // FIXME field.name here should likely be field.sourceKey || field.name\n        return lookupLegacySupport(record as unknown as MinimalLegacyRecord).getHasMany(field.name);\n      },\n      set(store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField, value: unknown[]) {\n        assertPrivateStore(store);\n        store._join(() => {\n          const support = lookupLegacySupport(record as unknown as MinimalLegacyRecord);\n          // FIXME field.name here should likely be field.sourceKey || field.name\n          const manyArray = support.getManyArray(field.name);\n\n          manyArray.splice(0, manyArray.length, ...value);\n        });\n      },\n      notify(store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField): boolean {\n        const support = lookupLegacySupport(record as unknown as MinimalLegacyRecord);\n        // FIXME field.name here should likely be field.sourceKey || field.name\n        const manyArray = support && support._manyArrayCache[field.name];\n        const hasPromise = support && (support._relationshipPromisesCache[field.name] as Promise<unknown> | undefined);\n\n        if (manyArray && hasPromise) {\n          // do nothing, we will notify the ManyArray directly\n          // once the fetch has completed.\n          return false;\n        }\n\n        if (manyArray) {\n          notifyInternalSignal((manyArray as unknown as PrivateReactiveResourceArray)[Context].signal);\n\n          return true;\n        }\n\n        return false;\n      },\n    },\n  });\n\n  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension!({\n    name: 'deprecated-model-behaviors',\n    kind: 'object',\n    features: {\n      // oxlint-disable-next-line typescript/no-unsafe-assignment\n      get isReloading() {\n        deprecate(\n          `record.isReloading is deprecated, please use store.request and either <Request> or getRequuestState to keep track of the request state instead.`,\n          false,\n          {\n            id: 'warp-drive:deprecate-legacy-request-methods',\n            until: '6.0',\n            for: '@warp-drive/core',\n            url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',\n            since: {\n              enabled: '5.7',\n              available: '5.7',\n            },\n          }\n        );\n        // @ts-expect-error\n        // oxlint-disable-next-line typescript/no-unsafe-return\n        return this._isReloading;\n      },\n      // oxlint-disable-next-line typescript/no-unsafe-assignment\n      set isReloading(v) {\n        // @ts-expect-error\n        // oxlint-disable-next-line typescript/no-unsafe-assignment\n        this._isReloading = v;\n      },\n    },\n  });\n}\n\n/**\n * A class which provides a schema service that delegates between\n * a primary schema service and one that supports legacy model\n * classes as its schema source.\n *\n * When the primary schema service has a schema for the given\n * resource, it will be used. Otherwise, the fallback schema\n * service will be used.\n *\n * This can be used when incrementally migrating from Models to\n * ReactiveResources by enabling unmigrated Models to continue to\n * provide their own schema information to the application.\n *\n * ```ts\n * import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';\n * import { SchemaService } from '@warp-drive/core/reactive';\n *\n * class AppStore extends Store {\n *   createSchemaService() {\n *     const schema = new SchemaService();\n *     return new DelegatingSchemaService(this, schema);\n *   }\n * }\n * ```\n *\n * All calls to register resources, derivations, transformations, hash functions\n * etc. will be delegated to the primary schema service.\n *\n * @class DelegatingSchemaService\n * @public\n */\nexport interface DelegatingSchemaService {\n  /**\n   * Delegates to whichever of the primary/fallback schema services has a\n   * schema for the resource, preferring the primary. See {@link DelegatingSchemaService.isDelegated | isDelegated}.\n   */\n  attributesDefinitionFor?(resource: ResourceKey | { type: string }): AttributesSchema;\n  /**\n   * Delegates to whichever of the primary/fallback schema services has a\n   * schema for the resource, preferring the primary. See {@link DelegatingSchemaService.isDelegated | isDelegated}.\n   */\n  relationshipsDefinitionFor?(resource: ResourceKey | { type: string }): RelationshipsSchema;\n  /**\n   * Whether either the primary or fallback schema service has a schema\n   * for the given type.\n   */\n  doesTypeExist?(type: string): boolean;\n}\n/**\n * See the {@link DelegatingSchemaService | class documentation above} for usage.\n */\nexport class DelegatingSchemaService implements SchemaService {\n  /** @internal */\n  _preferred!: SchemaService;\n  /** @internal */\n  _secondary!: SchemaService;\n\n  constructor(store: Store, schema: SchemaService) {\n    this._preferred = schema;\n    this._secondary = buildSchema(store);\n  }\n\n  /**\n   * Whether the given resource's schema is being served by the fallback\n   * (legacy Model-derived) schema service rather than the primary one.\n   */\n  isDelegated(resource: ResourceKey | { type: string }): boolean {\n    return !this._preferred.hasResource(resource) && this._secondary.hasResource(resource);\n  }\n\n  resourceTypes(): Readonly<string[]> {\n    return Array.from(new Set(this._preferred.resourceTypes().concat(this._secondary.resourceTypes())));\n  }\n\n  hasResource(resource: ResourceKey | { type: string }): boolean {\n    return this._preferred.hasResource(resource) || this._secondary.hasResource(resource);\n  }\n  hasTrait(type: string): boolean {\n    if (this._preferred.hasResource({ type })) {\n      return this._preferred.hasTrait(type);\n    }\n    return this._secondary.hasTrait(type);\n  }\n  resourceHasTrait(resource: ResourceKey | { type: string }, trait: string): boolean {\n    if (this._preferred.hasResource(resource)) {\n      return this._preferred.resourceHasTrait(resource, trait);\n    }\n    return this._secondary.resourceHasTrait(resource, trait);\n  }\n  fields(resource: ResourceKey | { type: string }): Map<string, FieldSchema> {\n    if (this._preferred.hasResource(resource)) {\n      return this._preferred.fields(resource);\n    }\n    return this._secondary.fields(resource);\n  }\n  cacheFields?(resource: { type: string }): Map<string, Exclude<CacheableFieldSchema, IdentityField>> {\n    if (this._preferred.hasResource?.(resource)) {\n      // @ts-expect-error\n      return this._preferred.cacheFields?.(resource);\n    }\n\n    // @ts-expect-error\n    return this._secondary.cacheFields?.(resource);\n  }\n  transformation(field: GenericField | ObjectField | ArrayField | { type: string }): Transformation {\n    return this._preferred.transformation(field);\n  }\n  hashFn(field: HashField | { type: string }): HashFn {\n    return this._preferred.hashFn(field);\n  }\n  derivation(field: DerivedField | { type: string }): Derivation {\n    return this._preferred.derivation(field);\n  }\n  resource(resource: ResourceKey | { type: string }): ResourceSchema | ObjectSchema {\n    if (this._preferred.hasResource(resource)) {\n      return this._preferred.resource(resource);\n    }\n    return this._secondary.resource(resource);\n  }\n  registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void {\n    this._preferred.registerResources(schemas);\n  }\n  registerResource(schema: ResourceSchema | ObjectSchema): void {\n    this._preferred.registerResource(schema);\n  }\n  registerTransformation(transform: Transformation): void {\n    this._preferred.registerTransformation(transform);\n  }\n  registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void {\n    this._preferred.registerDerivation(derivation);\n  }\n  registerHashFn(hashFn: HashFn): void {\n    this._preferred.registerHashFn(hashFn);\n  }\n\n  CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: { kind: 'object' | 'array'; name: string }): boolean {\n    return this._preferred.CAUTION_MEGA_DANGER_ZONE_hasExtension!(ext);\n  }\n\n  CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void {\n    this._preferred.CAUTION_MEGA_DANGER_ZONE_registerExtension!(extension);\n  }\n\n  CAUTION_MEGA_DANGER_ZONE_resourceExtensions(\n    resource: ResourceKey | { type: string }\n  ): null | ProcessedExtension['features'] {\n    return this._preferred.CAUTION_MEGA_DANGER_ZONE_resourceExtensions!(resource);\n  }\n\n  CAUTION_MEGA_DANGER_ZONE_objectExtensions(\n    field: ExtensibleField,\n    resolvedType: string | null\n  ): null | ProcessedExtension['features'] {\n    return this._preferred.CAUTION_MEGA_DANGER_ZONE_objectExtensions!(field, resolvedType);\n  }\n\n  CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension['features'] {\n    return this._preferred.CAUTION_MEGA_DANGER_ZONE_arrayExtensions!(field);\n  }\n\n  /**\n   * This is an internal method used to register behaviors for legacy mode.\n   * It is not intended for public use.\n   *\n   * We do think a generalized `kind` registration system would be useful,\n   * but we have not yet designed it.\n   *\n   * See https://github.com/warp-drive-data/warp-drive/issues/9534\n   *\n   * @internal\n   */\n  _registerMode(mode: string, kinds: unknown): void {\n    // @ts-expect-error\n    // oxlint-disable-next-line typescript/no-unsafe-call\n    this._preferred._registerMode(mode, kinds);\n  }\n\n  /**\n   * This is an internal method used to enable legacy behaviors for legacy mode.\n   * It is not intended for public use.\n   *\n   * We do think a generalized `kind` registration system would be useful,\n   * but we have not yet designed it.\n   *\n   * See https://github.com/warp-drive-data/warp-drive/issues/9534\n   *\n   * @internal\n   */\n  _kind(mode: string, kind: 'belongsTo' | 'hasMany'): () => unknown {\n    // @ts-expect-error\n    // oxlint-disable-next-line typescript/no-unsafe-call\n    return this._preferred._kind(mode, kind) as () => unknown;\n  }\n}\n\n/**\n * @internal\n */\nexport interface PrivateDelegatingSchemaService extends DelegatingSchemaService {\n  _preferred: SchemaService;\n  _secondary: SchemaService;\n}\nfunction assertPrivate(service: DelegatingSchemaService): asserts service is PrivateDelegatingSchemaService {}\n\nif (ENABLE_LEGACY_SCHEMA_SERVICE) {\n  DelegatingSchemaService.prototype.attributesDefinitionFor = function (resource: ResourceKey | { type: string }) {\n    assertPrivate(this);\n    if (this._preferred.hasResource(resource)) {\n      return this._preferred.attributesDefinitionFor!(resource);\n    }\n\n    return this._secondary.attributesDefinitionFor!(resource);\n  };\n  DelegatingSchemaService.prototype.relationshipsDefinitionFor = function (resource: ResourceKey | { type: string }) {\n    assertPrivate(this);\n    if (this._preferred.hasResource(resource)) {\n      return this._preferred.relationshipsDefinitionFor!(resource);\n    }\n\n    return this._secondary.relationshipsDefinitionFor!(resource);\n  };\n  DelegatingSchemaService.prototype.doesTypeExist = function (type: string) {\n    assertPrivate(this);\n    return this._preferred.doesTypeExist?.(type) || this._secondary.doesTypeExist?.(type) || false;\n  };\n}\n"],"mappings":"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"}

package/dist/unpkg/prod-deprecated/model-aiVrr1fz.js

@@ -0,0 +1,604 @@
+import { n as normalizeModelName, t as isElementDescriptor } from "./util-CQQdHX3n.js";
+import { r as lookupLegacySupport } from "./errors-9LXqpfRd.js";
+import { n as getModelFactory } from "./schema-provider-DyfSd9Cv.js";
+import { recordIdentifierFor } from "@warp-drive/core";
+import { getOwner, setOwner } from "@ember/application";
+import { StoreMap, assertPrivateStore, setRecordIdentifier } from "@warp-drive/core/store/-private";
+import { computed } from "@ember/object";
+import { RecordStore } from "@warp-drive/core/types/symbols";
+import { dasherize, singularize } from "@warp-drive/utilities/string";
+
+//#region src/model/-private/attr.ts
+/**
+* Options provided to the attr decorator are
+* supplied to the associated transform. Any
+* key-value pair is valid; however, it is highly
+* recommended to only use statically defined values
+* that could be serialized to JSON.
+*
+* If no transform is provided, the only valid
+* option is `defaultValue`.
+*
+* Examples:
+*
+* ```ts
+* class User extends Model {
+*  @attr('string', { defaultValue: 'Anonymous' }) name;
+*  @attr('date', { defaultValue: () => new Date() }) createdAt;
+*  @attr({ defaultValue: () => ({}) }) preferences;
+*  @attr('boolean') hasVerifiedEmail;
+*  @attr address;
+* }
+*
+* @class NOTATHING
+*/
+function _attr(type, options) {
+	if (typeof type === "object") {
+		options = type;
+		type = void 0;
+	} else options = options || {};
+	const meta = {
+		type,
+		kind: "attribute",
+		isAttribute: true,
+		options,
+		sourceKey: options.sourceKey,
+		key: null
+	};
+	return computed({
+		get(key) {
+			if (this.isDestroyed || this.isDestroying) return;
+			return this[RecordStore].cache.getAttr(recordIdentifierFor(this), meta.sourceKey ?? key);
+		},
+		set(key, value) {
+			const identifier = recordIdentifierFor(this);
+			const cache = this[RecordStore].cache;
+			const cacheKey = meta.sourceKey ?? key;
+			if (cache.getAttr(identifier, cacheKey) !== value) {
+				cache.setAttr(identifier, cacheKey, value);
+				if (!this.isValid) {
+					const { errors } = this;
+					if (errors.get(key)) {
+						errors.remove(key);
+						this.currentState.cleanErrorRequests();
+					}
+				}
+			}
+			return value;
+		}
+	}).meta(meta);
+}
+/**
+* The return type of `void` is a lie to appease TypeScript. The actual return type
+* is a descriptor, but typescript incorrectly insists that decorator functions return
+* `void` or `any`.
+*
+*/
+/**
+`attr` defines an attribute on a {@link Model}.
+By default, attributes are passed through as-is, however you can specify an
+optional type to have the value automatically transformed.
+WarpDrive ships with four basic transform types: `string`, `number`,
+`boolean` and `date`. You can define your own transforms by subclassing
+{@link Transform}.
+
+Note that you cannot use `attr` to define an attribute of `id`.
+
+`attr` takes an optional hash as a second parameter, currently
+supported options are:
+
+- `defaultValue`: Pass a string or a function to be called to set the attribute
+to a default value if and only if the key is absent from the payload response.
+
+Example
+
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class UserModel extends Model {
+@attr('string') username;
+@attr('string') email;
+@attr('boolean', { defaultValue: false }) verified;
+}
+```
+
+Default value can also be a function. This is useful it you want to return
+a new object for each attribute.
+
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class UserModel extends Model {
+@attr('string') username;
+@attr('string') email;
+
+@attr({
+defaultValue() {
+return {};
+}
+})
+settings;
+}
+```
+
+The `options` hash is passed as second argument to a transforms'
+`serialize` and `deserialize` method. This allows to configure a
+transformation and adapt the corresponding value, based on the config:
+
+```js [app/models/post.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class PostModel extends Model {
+@attr('text', {
+uppercase: true
+})
+text;
+}
+```
+
+```js [app/transforms/text.js]
+export default class TextTransform {
+serialize(value, options) {
+if (options.uppercase) {
+return value.toUpperCase();
+}
+
+return value;
+}
+
+deserialize(value) {
+return value;
+}
+
+static create() {
+return new this();
+}
+}
+```
+
+@public
+@param type the attribute type
+@param options a hash of options
+*/
+function attr(type, options, desc) {
+	const args = [
+		type,
+		options,
+		desc
+	];
+	return isElementDescriptor(args) ? _attr()(...args) : _attr(type, options);
+}
+
+//#endregion
+//#region src/model/-private/belongs-to.ts
+function _belongsTo(type, options) {
+	const meta = {
+		type: normalizeModelName(type),
+		options,
+		kind: "belongsTo",
+		name: "<Unknown BelongsTo>",
+		sourceKey: options.sourceKey
+	};
+	return computed({
+		get(key) {
+			if (this.isDestroying || this.isDestroyed) return null;
+			return lookupLegacySupport(this).getBelongsTo(key);
+		},
+		set(key, value) {
+			if (this.isDestroying || this.isDestroyed) return null;
+			const support = lookupLegacySupport(this);
+			assertPrivateStore(this[RecordStore]);
+			this[RecordStore]._join(() => {
+				support.setDirtyBelongsTo(key, value);
+			});
+			return support.getBelongsTo(key);
+		}
+	}).meta(meta);
+}
+/**
+`belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
+relationships on a {@link Model}.
+
+`belongsTo` takes a configuration hash as a second parameter, currently
+supported options are:
+
+- `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.
+- `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+- `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+- `as`: (*optional*) A string used to declare the abstract type "this" record satisfies for polymorphism.
+
+### Examples
+
+To declare a **one-to-many** (or many-to-many) relationship, use
+`belongsTo` in combination with `hasMany`:
+
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@belongsTo('post', { async: false, inverse: 'comments' }) post;
+}
+
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'post' }) comments;
+}
+```
+
+To declare a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:
+
+```js
+// app/models/author.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Author extends Model {
+@belongsTo('address', { async: true, inverse: 'owner' }) address;
+}
+
+// app/models/address.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Address extends Model {
+@belongsTo('author', { async: true, inverse: 'address' }) owner;
+}
+```
+
+To declare a **one-to-one** relationship without managed inverses, use `belongsTo` for both sides
+with `null` as the inverse:
+
+```js
+// app/models/author.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Author extends Model {
+@belongsTo('address', { async: true, inverse: null }) address;
+}
+
+// app/models/address.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Address extends Model {
+@belongsTo('author', { async: true, inverse: null }) owner;
+}
+```
+
+To declare a one-to-none relationship between two models, use
+`belongsTo` with inverse set to `null` on just one side::
+
+```js
+// app/models/person.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Person extends Model {
+@belongsTo('person', { async: false, inverse: null }) bestFriend;
+}
+```
+
+#### Sync vs Async Relationships
+
+WarpDrive fulfills relationships using resource data available in
+the cache.
+
+Sync relationships point directly to the known related resources.
+
+When a relationship is declared as async, if any of the known related
+resources have not been loaded, they will be fetched. The property
+on the record when accessed provides a promise that resolves once
+all resources are loaded.
+
+Async relationships may take advantage of links. On access, if the related
+link has not been loaded, or if any known resources are not available in
+the cache, the fresh state will be fetched using the link.
+
+In contrast to async relationship, accessing a sync relationship
+will error on access when any of the known related resources have
+not been loaded.
+
+If you are using `links` with sync relationships, you have to use
+the BelongsTo reference API to fetch or refresh related resources
+that aren't loaded. For instance, for a `bestFriend` relationship:
+
+```js
+person.belongsTo('bestFriend').reload();
+```
+
+#### Polymorphic Relationships
+
+To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+option set to `true`:
+
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+}
+```
+
+`'commentable'` here is referred to as the "abstract type" for the polymorphic
+relationship.
+
+Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+inverse relationships declaring itself as satisfying the abstract type.
+
+Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
+for this relationship.
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+}
+```
+
+Note: every Model that declares an inverse to a polymorphic relationship must
+declare itself exactly the same. This is because polymorphism is based on structural
+traits.
+
+Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+must be declared as polymorphic, and the `as` option must be used to declare the abstract
+type each record satisfies on both sides.
+
+@public
+@param type the name of the related resource
+@param options a hash of options
+*/
+function belongsTo(type, options) {
+	return _belongsTo(type, options);
+}
+
+//#endregion
+//#region src/model/-private/has-many.ts
+function normalizeType(type) {
+	return singularize(dasherize(type));
+}
+function _hasMany(type, options) {
+	const meta = {
+		type: normalizeType(type),
+		options,
+		kind: "hasMany",
+		name: "<Unknown BelongsTo>",
+		sourceKey: options.sourceKey
+	};
+	return computed({
+		get(key) {
+			if (this.isDestroying || this.isDestroyed) return [];
+			return lookupLegacySupport(this).getHasMany(key);
+		},
+		set(key, records) {
+			const support = lookupLegacySupport(this);
+			const manyArray = support.getManyArray(key);
+			assertPrivateStore(this[RecordStore]);
+			this[RecordStore]._join(() => {
+				manyArray.splice(0, manyArray.length, ...records);
+			});
+			return support.getHasMany(key);
+		}
+	}).meta(meta);
+}
+/**
+`hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None
+relationships on a {@link Model}.
+
+`hasMany` takes a configuration hash as a second parameter, currently
+supported options are:
+
+- `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.
+- `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+- `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+- `as`: (*optional*) A string used to declare the abstract type "this" record satisfies for polymorphism.
+
+### Examples
+
+To declare a **many-to-one** (or one-to-many) relationship, use
+`belongsTo` in combination with `hasMany`:
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'post' }) comments;
+}
+
+
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@belongsTo('post', { async: false, inverse: 'comments' }) post;
+}
+```
+
+To declare a **many-to-many** relationship with managed inverses, use `hasMany` for both sides:
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('tag', { async: true, inverse: 'posts' }) tags;
+}
+
+// app/models/tag.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Tag extends Model {
+@hasMany('post', { async: true, inverse: 'tags' }) posts;
+}
+```
+
+To declare a **many-to-many** relationship without managed inverses, use `hasMany` for both sides
+with `null` as the inverse:
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('tag', { async: true, inverse: null }) tags;
+}
+
+// app/models/tag.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Tag extends Model {
+@hasMany('post', { async: true, inverse: null }) posts;
+}
+```
+
+To declare a many-to-none relationship between two models, use
+`hasMany` with inverse set to `null` on just one side::
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('category', { async: true, inverse: null }) categories;
+}
+```
+
+#### Sync vs Async Relationships
+
+WarpDrive fulfills relationships using resource data available in
+the cache.
+
+Sync relationships point directly to the known related resources.
+
+When a relationship is declared as async, if any of the known related
+resources have not been loaded, they will be fetched. The property
+on the record when accessed provides a promise that resolves once
+all resources are loaded.
+
+Async relationships may take advantage of links. On access, if the related
+link has not been loaded, or if any known resources are not available in
+the cache, the fresh state will be fetched using the link.
+
+In contrast to async relationship, accessing a sync relationship
+will error on access when any of the known related resources have
+not been loaded.
+
+If you are using `links` with sync relationships, you have to use
+the HasMany reference API to fetch or refresh related resources
+that aren't loaded. For instance, for a `comments` relationship:
+
+```js
+post.hasMany('comments').reload();
+```
+
+#### Polymorphic Relationships
+
+To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+option set to `true`:
+
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+}
+```
+
+`'commentable'` here is referred to as the "abstract type" for the polymorphic
+relationship.
+
+Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+inverse relationships declaring itself as satisfying the abstract type.
+
+Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
+for this relationship.
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+}
+```
+
+Note: every Model that declares an inverse to a polymorphic relationship must
+declare itself exactly the same. This is because polymorphism is based on structural
+traits.
+
+Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+must be declared as polymorphic, and the `as` option must be used to declare the abstract
+type each record satisfies on both sides.
+
+@public
+@param type the name of the related resource
+@param options a hash of options
+*/
+function hasMany(type, options) {
+	return _hasMany(type, options);
+}
+
+//#endregion
+//#region src/model/-private/hooks.ts
+/**
+* The `instantiateRecord` hook implementation for use with `Model`. Pass
+* this to your store's `instantiateRecord` method when configuring the
+* store to use `Model` for schema/record instantiation.
+*
+* @public
+*/
+function instantiateRecord(identifier, createRecordArgs) {
+	const type = identifier.type;
+	const createOptions = {
+		_createProps: createRecordArgs ?? {},
+		_secretInit: {
+			identifier,
+			store: this,
+			cb: secretInit
+		}
+	};
+	setOwner(createOptions, getOwner(this));
+	return getModelFactory(this, type).class.create(createOptions);
+}
+/**
+* The `teardownRecord` hook implementation for use with `Model`. Pass this
+* to your store's `teardownRecord` method when configuring the store to
+* use `Model` for schema/record instantiation.
+*
+* @public
+*/
+function teardownRecord(record) {
+	record.destroy();
+}
+/**
+* The `modelFor` implementation for use with `Model`, exposed on the store
+* as `store.modelFor(type)` when the store is configured to use `Model`.
+* Returns the `Model` subclass registered for the given type, if any.
+*
+* @public
+*/
+/**
+* Overload accepting a raw type string instead of a typed record instance.
+*
+* @public
+*/
+function modelFor(modelName) {
+	assertPrivateStore(this);
+	const type = normalizeModelName(modelName);
+	const maybeFactory = getModelFactory(this, type);
+	const klass = maybeFactory && maybeFactory.class ? maybeFactory.class : null;
+	if (!(!klass || !klass.isModel || this._forceShim)) return klass;
+}
+function secretInit(record, identifier, store) {
+	setRecordIdentifier(record, identifier);
+	StoreMap.set(record, store);
+}
+
+//#endregion
+export { belongsTo as a, hasMany as i, modelFor as n, attr as o, teardownRecord as r, instantiateRecord as t };
+//# sourceMappingURL=model-aiVrr1fz.js.map