@warp-drive/legacy 5.10.0-alpha.12 → 5.10.0-alpha.13

package/dist/unpkg/prod-deprecated/json-BD1kRTfB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-BD1kRTfB.js","names":["coerceId","id","undefined","toString","String","inverseForRelationship","store","type","name","relationship","schema","fields","get","options","inverse","schemaExists","hasResource","inverseField","determineRelationshipType","knownSide","knownKind","kind","otherKind","getOwner","dasherize","singularize","Serializer","coerceId","determineRelationshipType","SOURCE_POINTER_REGEXP","SOURCE_POINTER_PRIMARY_REGEXP","PRIMARY_ATTRIBUTE_KEY","JSONSerializer","extend","primaryKey","mergedProperties","applyTransforms","typeClass","data","attributes","eachTransformedAttribute","key","type","undefined","transform","transformFor","transformMeta","get","deserialize","options","normalizeResponse","store","primaryModelClass","payload","id","requestType","normalizeFindRecordResponse","arguments","normalizeQueryRecordResponse","normalizeFindAllResponse","normalizeFindBelongsToResponse","normalizeFindHasManyResponse","normalizeFindManyResponse","normalizeQueryResponse","normalizeCreateRecordResponse","normalizeDeleteRecordResponse","normalizeUpdateRecordResponse","normalizeSingleResponse","normalizeArrayResponse","normalizeSaveResponse","_normalizeResponse","isSingle","documentHash","included","meta","extractMeta","normalize","ret","Array","length","i","l","item","concat","modelClass","resourceHash","normalizeUsingDeclaredMapping","links","extractId","modelName","extractAttributes","relationships","extractRelationships","lid","attributeKey","eachAttribute","keyForAttribute","extractRelationship","relationshipModelName","relationshipHash","isArray","modelFor","fields","has","modelNameFromPayloadKey","extractPolymorphicRelationship","relationshipOptions","eachRelationship","relationshipMeta","relationship","relationshipKey","keyForRelationship","kind","polymorphic","linkKey","keyForLink","related","normalizeRelationships","hash","payloadKey","attrs","normalizedKey","_getMappedKey","relationshipsByName","console","warn","mappedKey","_canSerialize","serialize","_mustSerialize","shouldSerializeHasMany","snapshot","relationshipType","json","includeId","attribute","serializeAttribute","serializeBelongsTo","serializeHasMany","serializeIntoHash","Object","assign","value","attr","schema","name","belongsToId","belongsTo","serializePolymorphicType","hasMany","ids","extractErrors","errors","extracted","forEach","error","source","pointer","match","search","push","detail","title","method","attributeType","skipAssertion","lookup"],"sources":["../../../src/serializer/-private/utils.ts","../../../src/serializer/json.ts"],"sourcesContent":["import type { Store } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type {\n  LegacyBelongsToField,\n  LegacyHasManyField,\n  LegacyRelationshipField,\n} from '@warp-drive/core/types/schema/fields';\n\ntype Coercable = string | number | boolean | null | undefined | symbol;\n\nexport function coerceId(id: Coercable): string | null {\n  if (id === null || id === undefined || id === '') {\n    return null;\n  } else if (typeof id === 'string') {\n    return id;\n  } else if (typeof id === 'symbol') {\n    return id.toString();\n  } else {\n    return String(id);\n  }\n}\n\n/**\n  Given the name of a relationship on a resource `type`, determines the\n  inverse relationship field (if any) using only the schema service.\n\n  Unlike `Model.inverseFor`, this does not require `type` to be backed by\n  a `Model` class, so it works for both `Model`-based and schema-only\n  (e.g. `withDefaults` migration-support) resources.\n\n  @private\n*/\nexport function inverseForRelationship(store: Store, type: string, name: string): LegacyRelationshipField | null {\n  const relationship = store.schema.fields({ type }).get(name) as LegacyBelongsToField | LegacyHasManyField | undefined;\n  assert(`No relationship named '${name}' on '${type}' exists.`, relationship);\n\n  const { options } = relationship;\n  assert(\n    `Expected the relationship ${name} on ${type} to define an inverse.`,\n    options.inverse === null || (typeof options.inverse === 'string' && options.inverse.length > 0)\n  );\n\n  if (options.inverse === null) {\n    return null;\n  }\n\n  const schemaExists = store.schema.hasResource(relationship);\n  assert(\n    `No associated schema found for '${relationship.type}' while calculating the inverse of ${name} on ${type}`,\n    schemaExists\n  );\n\n  if (!schemaExists) {\n    return null;\n  }\n\n  const inverseField = store.schema.fields(relationship).get(options.inverse);\n  assert(\n    `No inverse relationship found for '${name}' on '${type}'`,\n    inverseField && (inverseField.kind === 'belongsTo' || inverseField.kind === 'hasMany')\n  );\n\n  return inverseField ?? null;\n}\n\n/**\n  Given a relationship field on a resource `type`, determines the\n  cardinality of the relationship using only the schema service.\n\n  Unlike `Model.determineRelationshipType`, this does not require `type`\n  to be backed by a `Model` class, so it works for both `Model`-based and\n  schema-only (e.g. `withDefaults` migration-support) resources.\n\n  @private\n*/\nexport function determineRelationshipType(\n  store: Store,\n  type: string,\n  knownSide: LegacyBelongsToField | LegacyHasManyField\n): 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany' | 'oneToNone' | 'manyToNone' {\n  const knownKind = knownSide.kind;\n  const inverse = inverseForRelationship(store, type, knownSide.name);\n\n  if (!inverse) {\n    return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';\n  }\n\n  const otherKind = inverse.kind;\n\n  if (otherKind === 'belongsTo') {\n    return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';\n  } else {\n    return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';\n  }\n}\n","/* oxlint-disable typescript/no-unsafe-argument */\n/* oxlint-disable typescript/no-unsafe-call */\n/* oxlint-disable typescript/no-unsafe-return */\n/* oxlint-disable typescript/no-unsafe-member-access */\n/* oxlint-disable typescript/no-unsafe-assignment */\nimport { getOwner } from '@ember/application';\nimport { warn } from '@ember/debug';\n\n// oxlint-disable-next-line no-unused-vars\nimport type { RequestManager, Store } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\n// oxlint-disable-next-line no-unused-vars\nimport type { Handler } from '@warp-drive/core/request';\nimport type { ModelSchema } from '@warp-drive/core/types';\nimport type {\n  LegacyAttributeField,\n  LegacyBelongsToField,\n  LegacyHasManyField,\n} from '@warp-drive/core/types/schema/fields';\nimport { dasherize, singularize } from '@warp-drive/utilities/string';\n\nimport type { Snapshot } from '../compat/-private.ts';\nimport { Serializer } from '../serializer.ts';\nimport { coerceId, determineRelationshipType } from './-private/utils.ts';\nimport type { Transform } from './transform.ts';\n\nconst SOURCE_POINTER_REGEXP = /^\\/?data\\/(attributes|relationships)\\/(.*)/;\nconst SOURCE_POINTER_PRIMARY_REGEXP = /^\\/?data/;\nconst PRIMARY_ATTRIBUTE_KEY = 'base';\n\n/**\n * :::danger\n    ⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.\n    If starting a new app or thinking of implementing a new adapter, consider writing a\n    {@link Handler} instead to be used with the {@link RequestManager}\n  :::\n\n  In WarpDrive a Serializer is used to serialize and deserialize\n  records when they are transferred in and out of an external source.\n  This process involves normalizing property names, transforming\n  attribute values and serializing relationships.\n\n  By default, WarpDrive uses and recommends the `JSONAPISerializer`.\n\n  `JSONSerializer` is useful for simpler or legacy backends that may\n  not support the http://jsonapi.org/ spec.\n\n  For example, given the following `User` model and JSON payload:\n\n  ```js [app/models/user.js]\n  import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';\n\n  export default class UserModel extends Model {\n    @hasMany('user') friends;\n    @belongsTo('location') house;\n\n    @attr('string') name;\n  }\n  ```\n\n  ```js\n  {\n    id: 1,\n    name: 'Sebastian',\n    friends: [3, 4],\n    links: {\n      house: '/houses/lefkada'\n    }\n  }\n  ```\n\n  `JSONSerializer` will normalize the JSON payload to the {json:api} format that the\n  JSONAPICache uses to cache data in the Store.\n\n  You can customize how JSONSerializer processes its payload by passing options in\n  the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:\n\n    - To customize how a single record is normalized, use the `normalize` hook.\n    - To customize how `JSONSerializer` normalizes the whole server response, use the\n      `normalizeResponse` hook.\n    - To customize how `JSONSerializer` normalizes a specific response from the server,\n      use one of the many specific `normalizeResponse` hooks.\n    - To customize how `JSONSerializer` normalizes your id, attributes or relationships,\n      use the `extractId`, `extractAttributes` and `extractRelationships` hooks.\n\n  The `JSONSerializer` normalization process follows these steps:\n\n    1. `normalizeResponse`\n        - entry method to the serializer.\n    2. `normalizeCreateRecordResponse`\n        - a `normalizeResponse` for a specific operation is called.\n    3. `normalizeSingleResponse`|`normalizeArrayResponse`\n        - for methods like `createRecord` we expect a single record back, while for methods like `findAll` we expect multiple records back.\n    4. `normalize`\n        - `normalizeArrayResponse` iterates and calls `normalize` for each of its records while `normalizeSingle`\n          calls it once. This is the method you most likely want to subclass.\n    5. `extractId` | `extractAttributes` | `extractRelationships`\n        - `normalize` delegates to these methods to\n          turn the record payload into the JSON API format.\n\n  @class JSONSerializer\n  @public\n*/\n// oxlint-disable-next-line typescript/no-explicit-any\nconst JSONSerializer: any = Serializer.extend({\n  /**\n    The `primaryKey` is used when serializing and deserializing\n    data. WarpDrive always uses the `id` property to store the id of\n    the record. The external source may not always follow this\n    convention. In these cases it is useful to override the\n    `primaryKey` property to match the `primaryKey` of your external\n    store.\n\n    Example\n\n    ```js [app/serializers/application.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class ApplicationSerializer extends JSONSerializer {\n      primaryKey = '_id'\n    }\n    ```\n\n    @public\n    @default 'id'\n  */\n  primaryKey: 'id',\n\n  /**\n    The `attrs` object can be used to declare a simple mapping between\n    property names on `Model` records and payload keys in the\n    serialized JSON object representing the record. An object with the\n    property `key` can also be used to designate the attribute's key on\n    the response payload.\n\n    Example\n\n    ```js [app/models/person.js]\n    import Model, { attr } from '@warp-drive/legacy/model';\n\n    export default class PersonModel extends Model {\n      @attr('string') firstName;\n      @attr('string') lastName;\n      @attr('string') occupation;\n      @attr('boolean') admin;\n    }\n    ```\n\n    ```js [app/serializers/person.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PersonSerializer extends JSONSerializer {\n      attrs = {\n        admin: 'is_admin',\n        occupation: { key: 'career' }\n      }\n    }\n    ```\n\n    You can also remove attributes and relationships by setting the `serialize`\n    key to `false` in your mapping object.\n\n    Example\n\n    ```js [app/serializers/person.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PostSerializer extends JSONSerializer {\n      attrs = {\n        admin: { serialize: false },\n        occupation: { key: 'career' }\n      }\n    }\n    ```\n\n    When serialized:\n\n    ```js\n    {\n      \"firstName\": \"Harry\",\n      \"lastName\": \"Houdini\",\n      \"career\": \"magician\"\n    }\n    ```\n\n    Note that the `admin` is now not included in the payload.\n\n    Setting `serialize` to `true` enforces serialization for hasMany\n    relationships even if it's neither a many-to-many nor many-to-none\n    relationship.\n\n    @public\n  */\n  mergedProperties: ['attrs'],\n\n  /**\n   Given a subclass of `Model` and a JSON object this method will\n   iterate through each attribute of the `Model` and invoke the\n   `Transform#deserialize` method on the matching property of the\n   JSON object.  This method is typically called after the\n   serializer's `normalize` method.\n\n   @private\n  */\n  applyTransforms(typeClass: ModelSchema, data: object): object {\n    const attributes = typeClass.attributes;\n\n    typeClass.eachTransformedAttribute((key, type) => {\n      if (data[key] === undefined) {\n        return;\n      }\n\n      const transform = this.transformFor(type!);\n      const transformMeta = attributes.get(key);\n      data[key] = transform.deserialize(data[key], transformMeta!.options);\n    });\n\n    return data;\n  },\n\n  /**\n    The `normalizeResponse` method is used to normalize a payload from the\n    server to a JSON-API Document.\n\n    http://jsonapi.org/format/#document-structure\n\n    This method delegates to a more specific normalize method based on\n    the `requestType`.\n\n    To override this method with a custom one, make sure to call\n    `return super.normalizeResponse(store, primaryModelClass, payload, id, requestType)` with your\n    pre-processed data.\n\n    Here's an example of using `normalizeResponse` manually:\n\n    ```javascript\n    socket.on('message', function(message) {\n      let data = message.data;\n      let modelClass = store.modelFor(data.modelName);\n      let serializer = store.serializerFor(data.modelName);\n      let normalized = serializer.normalizeSingleResponse(store, modelClass, data, data.id);\n\n      store.push(normalized);\n    });\n    ```\n\n    @since 1.13.0\n    @public\n  */\n  normalizeResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: string | null,\n    requestType: string\n    // @ts-expect-error\n  ): object {\n    switch (requestType) {\n      case 'findRecord':\n        // @ts-expect-error\n        return this.normalizeFindRecordResponse(...arguments);\n      case 'queryRecord':\n        // @ts-expect-error\n        return this.normalizeQueryRecordResponse(...arguments);\n      case 'findAll':\n        // @ts-expect-error\n        return this.normalizeFindAllResponse(...arguments);\n      case 'findBelongsTo':\n        // @ts-expect-error\n        return this.normalizeFindBelongsToResponse(...arguments);\n      case 'findHasMany':\n        // @ts-expect-error\n        return this.normalizeFindHasManyResponse(...arguments);\n      case 'findMany':\n        // @ts-expect-error\n        return this.normalizeFindManyResponse(...arguments);\n      case 'query':\n        // @ts-expect-error\n        return this.normalizeQueryResponse(...arguments);\n      case 'createRecord':\n        // @ts-expect-error\n        return this.normalizeCreateRecordResponse(...arguments);\n      case 'deleteRecord':\n        // @ts-expect-error\n        return this.normalizeDeleteRecordResponse(...arguments);\n      case 'updateRecord':\n        // @ts-expect-error\n        return this.normalizeUpdateRecordResponse(...arguments);\n    }\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `findRecord`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeFindRecordResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: string,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSingleResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `queryRecord`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeQueryRecordResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSingleResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `findAll`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeFindAllResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeArrayResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `findBelongsTo`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeFindBelongsToResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSingleResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `findHasMany`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeFindHasManyResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeArrayResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `findMany`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeFindManyResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeArrayResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `query`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeQueryResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeArrayResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `createRecord`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeCreateRecordResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: unknown,\n    id: string,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSaveResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `deleteRecord`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeDeleteRecordResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: object,\n    id: string | null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSaveResponse(...arguments);\n  },\n\n  /**\n    Called by the default normalizeResponse implementation when the\n    type of request is `updateRecord`\n\n    @since 1.13.0\n    @public\n  */\n  normalizeUpdateRecordResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: object,\n    id: string | null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSaveResponse(...arguments);\n  },\n\n  /**\n    normalizeUpdateRecordResponse, normalizeCreateRecordResponse and\n    normalizeDeleteRecordResponse delegate to this method by default.\n\n    @since 1.13.0\n    @public\n  */\n  normalizeSaveResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: object,\n    id: string | null,\n    requestType: string\n  ): object {\n    // @ts-expect-error\n    return this.normalizeSingleResponse(...arguments);\n  },\n\n  /**\n    normalizeQueryResponse and normalizeFindRecordResponse delegate to this\n    method by default.\n\n    @since 1.13.0\n    @public\n  */\n  normalizeSingleResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: object,\n    id: string | null,\n    requestType: string\n  ): object {\n    return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, true);\n  },\n\n  /**\n    normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate\n    to this method by default.\n\n    @since 1.13.0\n    @public\n  */\n  normalizeArrayResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: object,\n    id: string | null,\n    requestType: string\n  ): object {\n    return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, false);\n  },\n\n  /**\n    @private\n  */\n  _normalizeResponse(\n    store: Store,\n    primaryModelClass: ModelSchema,\n    payload: object,\n    id: string | null,\n    requestType: string,\n    isSingle: boolean\n  ): object {\n    const documentHash = {\n      data: null,\n      included: [],\n    };\n\n    const meta = this.extractMeta(store, primaryModelClass, payload);\n    if (meta) {\n      assert(\n        'The `meta` returned from `extractMeta` has to be an object, not \"' + typeof meta + '\".',\n        typeof meta === 'object'\n      );\n      // @ts-expect-error untyped\n      documentHash.meta = meta;\n    }\n\n    if (isSingle) {\n      // @ts-expect-error untyped\n      const { data, included } = this.normalize(primaryModelClass, payload);\n      documentHash.data = data;\n      if (included) {\n        documentHash.included = included;\n      }\n    } else {\n      // @ts-expect-error untyped\n      const ret = new Array(payload.length);\n      // @ts-expect-error untyped\n      for (let i = 0, l = payload.length; i < l; i++) {\n        const item = payload[i];\n        // @ts-expect-error untyped\n        const { data, included } = this.normalize(primaryModelClass, item);\n        if (included) {\n          documentHash.included = documentHash.included.concat(included);\n        }\n        ret[i] = data;\n      }\n\n      // @ts-expect-error untyped\n      documentHash.data = ret;\n    }\n\n    return documentHash;\n  },\n\n  /**\n    Normalizes a part of the JSON payload returned by\n    the server. You should override this method, munge the hash\n    and call super if you have generic normalization to do.\n\n    It takes the type of the record that is being normalized\n    (as a Model class), the property where the hash was\n    originally found, and the hash to normalize.\n\n    You can use this method, for example, to normalize underscored keys to camelized\n    or other general-purpose normalizations.\n\n    Example\n\n    ```js [app/serializers/application.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n    import { underscore } from '<app-name>/utils/string-utils';\n    import { get } from '@ember/object';\n\n    export default class ApplicationSerializer extends JSONSerializer {\n      normalize(typeClass, hash) {\n        let fields = typeClass.fields;\n\n        fields.forEach(function(type, field) {\n          let payloadField = underscore(field);\n          if (field === payloadField) { return; }\n\n          hash[field] = hash[payloadField];\n          delete hash[payloadField];\n        });\n\n        return super.normalize(...arguments);\n      }\n    }\n    ```\n\n    @public\n  */\n  normalize(modelClass: ModelSchema, resourceHash: object): object {\n    let data = null;\n\n    if (resourceHash) {\n      this.normalizeUsingDeclaredMapping(modelClass, resourceHash);\n      // @ts-expect-error untyped\n      if (typeof resourceHash.links === 'object') {\n        // @ts-expect-error untyped\n        this.normalizeUsingDeclaredMapping(modelClass, resourceHash.links);\n      }\n\n      // @ts-expect-error untyped\n      data = {\n        id: this.extractId(modelClass, resourceHash),\n        type: modelClass.modelName,\n        attributes: this.extractAttributes(modelClass, resourceHash),\n        relationships: this.extractRelationships(modelClass, resourceHash),\n      };\n\n      // @ts-expect-error untyped\n      if (resourceHash.lid) {\n        // @ts-expect-error untyped\n        data.lid = resourceHash.lid;\n      }\n\n      // @ts-expect-error untyped\n      this.applyTransforms(modelClass, data.attributes);\n    }\n\n    return { data };\n  },\n\n  /**\n    Returns the resource's ID.\n\n    @public\n  */\n  extractId(modelClass: ModelSchema, resourceHash: object): string {\n    const primaryKey = this.primaryKey;\n    const id = resourceHash[primaryKey];\n    return coerceId(id) as string;\n  },\n\n  /**\n    Returns the resource's attributes formatted as a JSON-API \"attributes object\".\n\n    http://jsonapi.org/format/#document-resource-object-attributes\n\n    @public\n  */\n  extractAttributes(modelClass: ModelSchema, resourceHash: object): object {\n    let attributeKey;\n    const attributes = {};\n\n    modelClass.eachAttribute((key) => {\n      attributeKey = this.keyForAttribute(key, 'deserialize');\n      if (resourceHash[attributeKey] !== undefined) {\n        attributes[key] = resourceHash[attributeKey];\n      }\n    });\n\n    return attributes;\n  },\n\n  /**\n    Returns a relationship formatted as a JSON-API \"relationship object\".\n\n    http://jsonapi.org/format/#document-resource-object-relationships\n\n    @public\n  */\n  extractRelationship(relationshipModelName: string, relationshipHash: object): object | null {\n    if (!relationshipHash) {\n      return null;\n    }\n    /*\n      When `relationshipHash` is an object it usually means that the relationship\n      is polymorphic. It could however also be embedded resources that the\n      EmbeddedRecordsMixin has be able to process.\n    */\n    if (relationshipHash && typeof relationshipHash === 'object' && !Array.isArray(relationshipHash)) {\n      // @ts-expect-error untyped\n      if (relationshipHash.id) {\n        // @ts-expect-error untyped\n        relationshipHash.id = coerceId(relationshipHash.id);\n      }\n\n      // @ts-expect-error store is dynamically injected\n      const modelClass = this.store.modelFor(relationshipModelName);\n      // @ts-expect-error untyped\n      if (relationshipHash.type && !modelClass.fields.has('type')) {\n        // @ts-expect-error untyped\n        relationshipHash.type = this.modelNameFromPayloadKey(relationshipHash.type);\n      }\n\n      return relationshipHash;\n    }\n    return {\n      id: coerceId(relationshipHash as unknown as string | number | null),\n      type: dasherize(singularize(relationshipModelName)),\n    };\n  },\n\n  /**\n    Returns a polymorphic relationship formatted as a JSON-API \"relationship object\".\n\n    http://jsonapi.org/format/#document-resource-object-relationships\n\n    `relationshipOptions` is a hash which contains more information about the\n    polymorphic relationship which should be extracted:\n      - `resourceHash` complete hash of the resource the relationship should be\n        extracted from\n      - `relationshipKey` key under which the value for the relationship is\n        extracted from the resourceHash\n      - `relationshipMeta` meta information about the relationship\n\n    @public\n  */\n  extractPolymorphicRelationship(\n    relationshipModelName: string,\n    relationshipHash: object,\n    relationshipOptions?: object\n  ): object | null {\n    return this.extractRelationship(relationshipModelName, relationshipHash);\n  },\n\n  /**\n    Returns the resource's relationships formatted as a JSON-API \"relationships object\".\n\n    http://jsonapi.org/format/#document-resource-object-relationships\n\n    @public\n  */\n  extractRelationships(modelClass: ModelSchema, resourceHash: object): object {\n    const relationships = {};\n\n    modelClass.eachRelationship((key, relationshipMeta) => {\n      let relationship = null;\n      const relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');\n      if (resourceHash[relationshipKey] !== undefined) {\n        let data = null;\n        const relationshipHash = resourceHash[relationshipKey];\n        if (relationshipMeta.kind === 'belongsTo') {\n          if (relationshipMeta.options.polymorphic) {\n            // extracting a polymorphic belongsTo may need more information\n            // than the type and the hash (which might only be an id) for the\n            // relationship, hence we pass the key, resource and\n            // relationshipMeta too\n            // @ts-expect-error untyped\n            data = this.extractPolymorphicRelationship(relationshipMeta.type, relationshipHash, {\n              key,\n              resourceHash,\n              relationshipMeta,\n            });\n          } else {\n            // @ts-expect-error untyped\n            data = this.extractRelationship(relationshipMeta.type, relationshipHash);\n          }\n        } else if (relationshipMeta.kind === 'hasMany') {\n          if (relationshipHash) {\n            // @ts-expect-error untyped\n            data = new Array(relationshipHash.length);\n            if (relationshipMeta.options.polymorphic) {\n              for (let i = 0, l = relationshipHash.length; i < l; i++) {\n                const item = relationshipHash[i];\n                // @ts-expect-error untyped\n                data[i] = this.extractPolymorphicRelationship(relationshipMeta.type, item, {\n                  key,\n                  resourceHash,\n                  relationshipMeta,\n                });\n              }\n            } else {\n              for (let i = 0, l = relationshipHash.length; i < l; i++) {\n                const item = relationshipHash[i];\n                // @ts-expect-error untyped\n                data[i] = this.extractRelationship(relationshipMeta.type, item);\n              }\n            }\n          }\n        }\n        // @ts-expect-error untyped\n        relationship = { data };\n      }\n\n      const linkKey = this.keyForLink(key, relationshipMeta.kind);\n      // @ts-expect-error untyped\n      if (resourceHash.links && resourceHash.links[linkKey] !== undefined) {\n        // @ts-expect-error untyped\n        const related = resourceHash.links[linkKey];\n        // @ts-expect-error untyped\n        relationship = relationship || {};\n        // @ts-expect-error untyped\n        relationship.links = { related };\n      }\n\n      if (relationship) {\n        relationships[key] = relationship;\n      }\n    });\n\n    return relationships;\n  },\n\n  /**\n    Dasherizes the model name in the payload\n\n    @public\n    @return the model's modelName\n  */\n  modelNameFromPayloadKey(key: string): string {\n    return dasherize(singularize(key));\n  },\n\n  /**\n    @private\n  */\n  normalizeRelationships(typeClass: ModelSchema, hash: object): void {\n    let payloadKey;\n\n    if (this.keyForRelationship) {\n      typeClass.eachRelationship((key, relationship) => {\n        payloadKey = this.keyForRelationship(key, relationship.kind, 'deserialize');\n        if (key === payloadKey) {\n          return;\n        }\n        if (hash[payloadKey] === undefined) {\n          return;\n        }\n\n        hash[key] = hash[payloadKey];\n        delete hash[payloadKey];\n      });\n    }\n  },\n\n  /**\n    @private\n  */\n  normalizeUsingDeclaredMapping(modelClass: ModelSchema, hash: object): void {\n    // @ts-expect-error attrs is dynamically injected\n    const attrs = this.attrs;\n    let normalizedKey;\n    let payloadKey;\n\n    if (attrs) {\n      for (const key in attrs) {\n        normalizedKey = payloadKey = this._getMappedKey(key, modelClass);\n\n        if (hash[payloadKey] === undefined) {\n          continue;\n        }\n\n        if (modelClass.attributes.has(key)) {\n          normalizedKey = this.keyForAttribute(key, 'deserialize');\n        }\n\n        if (modelClass.relationshipsByName.has(key)) {\n          normalizedKey = this.keyForRelationship(key, modelClass, 'deserialize');\n        }\n\n        if (payloadKey !== normalizedKey) {\n          hash[normalizedKey] = hash[payloadKey];\n          delete hash[payloadKey];\n        }\n      }\n    }\n  },\n\n  /**\n    Looks up the property key that was set by the custom `attr` mapping\n    passed to the serializer.\n\n    @private\n  */\n  _getMappedKey(key: string, modelClass: ModelSchema): string {\n    warn(\n      'There is no attribute or relationship with the name `' +\n        key +\n        '` on `' +\n        modelClass.modelName +\n        '`. Check your serializers attrs hash.',\n      modelClass.attributes.has(key) || modelClass.relationshipsByName.has(key),\n      {\n        id: 'ds.serializer.no-mapped-attrs-key',\n      }\n    );\n    // @ts-expect-error attrs is dynamically injected\n    const attrs = this.attrs;\n    let mappedKey;\n    if (attrs && attrs[key]) {\n      mappedKey = attrs[key];\n      //We need to account for both the { title: 'post_title' } and\n      //{ title: { key: 'post_title' }} forms\n      if (mappedKey.key) {\n        mappedKey = mappedKey.key;\n      }\n      if (typeof mappedKey === 'string') {\n        key = mappedKey;\n      }\n    }\n\n    return key;\n  },\n\n  /**\n    Check attrs.key.serialize property to inform if the `key`\n    can be serialized\n\n    @private\n    @return true if the key can be serialized\n  */\n  _canSerialize(key: string): boolean {\n    // @ts-expect-error no idea what attrs is here\n    const attrs = this.attrs;\n\n    return !attrs || !attrs[key] || attrs[key].serialize !== false;\n  },\n\n  /**\n    When attrs.key.serialize is set to true then\n    it takes priority over the other checks and the related\n    attribute/relationship will be serialized\n\n    @private\n    @return true if the key must be serialized\n  */\n  _mustSerialize(key: string): boolean {\n    // @ts-expect-error no idea what attrs is here\n    const attrs = this.attrs;\n\n    return attrs && attrs[key] && attrs[key].serialize === true;\n  },\n\n  /**\n    Check if the given hasMany relationship should be serialized\n\n    By default only many-to-many and many-to-none relationships are serialized.\n    This could be configured per relationship by Serializer's `attrs` object.\n\n    @public\n    @return true if the hasMany relationship should be serialized\n  */\n  shouldSerializeHasMany(\n    snapshot: Snapshot,\n    key: string,\n    relationship: LegacyBelongsToField | LegacyHasManyField\n  ): boolean {\n    // @ts-expect-error store is dynamically injected\n    const relationshipType = determineRelationshipType(this.store, snapshot.modelName, relationship);\n    if (this._mustSerialize(key)) {\n      return true;\n    }\n    return this._canSerialize(key) && (relationshipType === 'manyToNone' || relationshipType === 'manyToMany');\n  },\n\n  // SERIALIZE\n  /**\n    Called when a record is saved in order to convert the\n    record into JSON.\n\n    By default, it creates a JSON object with a key for\n    each attribute and belongsTo relationship.\n\n    For example, consider this model:\n\n    ```js [app/models/comment.js]\n    import Model, { attr, belongsTo } from '@warp-drive/legacy/model';\n\n    export default class CommentModel extends Model {\n      @attr title;\n      @attr body;\n\n      @belongsTo('user') author;\n    }\n    ```\n\n    The default serialization would create a JSON object like:\n\n    ```javascript\n    {\n      \"title\": \"Rails is unagi\",\n      \"body\": \"Rails? Omakase? O_O\",\n      \"author\": 12\n    }\n    ```\n\n    By default, attributes are passed through as-is, unless\n    you specified an attribute type (`attr('date')`). If\n    you specify a transform, the JavaScript value will be\n    serialized when inserted into the JSON hash.\n\n    By default, belongs-to relationships are converted into\n    IDs when inserted into the JSON hash.\n\n    ## IDs\n\n    `serialize` takes an options hash with a single option:\n    `includeId`. If this option is `true`, `serialize` will,\n    by default include the ID in the JSON object it builds.\n\n    Whether `includeId` is `true` or `false` depends on the\n    adapter and the operation being performed, since it is the\n    adapter that invokes `serialize` and decides which options\n    to pass. For instance, `RESTAdapter` passes `includeId: true`\n    when serializing a record for `createRecord`, but not for\n    `updateRecord`, while `JSONAPIAdapter` passes `includeId: true`\n    for both `createRecord` and `updateRecord`. Refer to the\n    documentation for the adapter and serializer pairing you are\n    using for specifics.\n\n    ## Customization\n\n    Your server may expect a different JSON format than the\n    built-in serialization format.\n\n    In that case, you can implement `serialize` yourself and\n    return a JSON hash of your choosing.\n\n    ```js [app/serializers/post.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PostSerializer extends JSONSerializer {\n      serialize(snapshot, options) {\n        let json = {\n          POST_TTL: snapshot.attr('title'),\n          POST_BDY: snapshot.attr('body'),\n          POST_CMS: snapshot.hasMany('comments', { ids: true })\n        };\n\n        if (options.includeId) {\n          json.POST_ID_ = snapshot.id;\n        }\n\n        return json;\n      }\n    }\n    ```\n\n    ## Customizing an App-Wide Serializer\n\n    If you want to define a serializer for your entire\n    application, you'll probably want to use `eachAttribute`\n    and `eachRelationship` on the record.\n\n    ```js [app/serializers/application.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n    import { singularize } from '<app-name>/utils/string-utils';\n\n    export default class ApplicationSerializer extends JSONSerializer {\n      serialize(snapshot, options) {\n        let json = {};\n\n        snapshot.eachAttribute((name) => {\n          json[serverAttributeName(name)] = snapshot.attr(name);\n        });\n\n        snapshot.eachRelationship((name, relationship) => {\n          if (relationship.kind === 'hasMany') {\n            json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });\n          }\n        });\n\n        if (options.includeId) {\n          json.ID_ = snapshot.id;\n        }\n\n        return json;\n      }\n    }\n\n    function serverAttributeName(attribute) {\n      return attribute.underscore().toUpperCase();\n    }\n\n    function serverHasManyName(name) {\n      return serverAttributeName(singularize(name)) + \"_IDS\";\n    }\n    ```\n\n    This serializer will generate JSON that looks like this:\n\n    ```javascript\n    {\n      \"TITLE\": \"Rails is omakase\",\n      \"BODY\": \"Yep. Omakase.\",\n      \"COMMENT_IDS\": [ \"1\", \"2\", \"3\" ]\n    }\n    ```\n\n    ## Tweaking the Default JSON\n\n    If you just want to do some small tweaks on the default JSON,\n    you can call `super.serialize` first and make the tweaks on\n    the returned JSON.\n\n    ```js [app/serializers/post.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PostSerializer extends JSONSerializer {\n      serialize(snapshot, options) {\n        let json = super.serialize(...arguments);\n\n        json.subject = json.title;\n        delete json.title;\n\n        return json;\n      }\n    }\n    ```\n\n    @public\n  */\n  serialize(snapshot: Snapshot, options: object): object {\n    const json = {};\n\n    // @ts-expect-error super loose typing here right now\n    if (options && options.includeId) {\n      const id = snapshot.id;\n      if (id) {\n        json[this.primaryKey] = id;\n      }\n    }\n\n    snapshot.eachAttribute((key, attribute) => {\n      this.serializeAttribute(snapshot, json, key, attribute);\n    });\n\n    snapshot.eachRelationship((key, relationship) => {\n      if (relationship.kind === 'belongsTo') {\n        this.serializeBelongsTo(snapshot, json, relationship);\n      } else if (relationship.kind === 'hasMany') {\n        this.serializeHasMany(snapshot, json, relationship);\n      }\n    });\n\n    return json;\n  },\n\n  /**\n    You can use this method to customize how a serialized record is added to the complete\n    JSON hash to be sent to the server. By default the JSON Serializer does not namespace\n    the payload and just sends the raw serialized JSON object.\n    If your server expects namespaced keys, you should consider using the RESTSerializer.\n    Otherwise you can override this method to customize how the record is added to the hash.\n    The hash property should be modified by reference.\n\n    For example, your server may expect underscored root objects.\n\n    ```js [app/serializers/application.js]\n    import RESTSerializer from '@warp-drive/legacy/serializer/rest';\n    import { underscoren} from '<app-name>/utils/string-utils';\n\n    export default class ApplicationSerializer extends RESTSerializer {\n      serializeIntoHash(data, type, snapshot, options) {\n        let root = underscore(type.modelName);\n        data[root] = this.serialize(snapshot, options);\n      }\n    }\n    ```\n\n    @public\n  */\n  serializeIntoHash(hash: object, typeClass: ModelSchema, snapshot: Snapshot, options: object): void {\n    Object.assign(hash, this.serialize(snapshot, options));\n  },\n\n  /**\n    `serializeAttribute` can be used to customize how `attr`\n    properties are serialized\n\n    For example if you wanted to ensure all your attributes were always\n    serialized as properties on an `attributes` object you could\n    write:\n\n    ```js [app/serializers/application.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class ApplicationSerializer extends JSONSerializer {\n      serializeAttribute(snapshot, json, key, attributes) {\n        json.attributes = json.attributes || {};\n        super.serializeAttribute(snapshot, json.attributes, key, attributes);\n      }\n    }\n    ```\n\n    @public\n  */\n  serializeAttribute(snapshot: Snapshot, json: object, key: string, attribute: LegacyAttributeField): void {\n    if (this._canSerialize(key)) {\n      const type = attribute.type;\n      // @ts-expect-error we don't know what is on the snapshot\n      let value = snapshot.attr(key);\n      if (type) {\n        const transform = this.transformFor(type);\n        value = transform.serialize(value, attribute.options);\n      }\n\n      // if provided, use the mapping provided by `attrs` in\n      // the serializer\n      // @ts-expect-error store added dynamically\n      const schema = this.store.modelFor(snapshot.modelName);\n      let payloadKey = this._getMappedKey(key, schema);\n\n      if (payloadKey === key && this.keyForAttribute) {\n        payloadKey = this.keyForAttribute(key, 'serialize');\n      }\n\n      json[payloadKey] = value;\n    }\n  },\n\n  /**\n    `serializeBelongsTo` can be used to customize how `belongsTo`\n    properties are serialized.\n\n    Example\n\n    ```js [app/serializers/post.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PostSerializer extends JSONSerializer {\n      serializeBelongsTo(snapshot, json, relationship) {\n        let key = relationship.name;\n        let belongsTo = snapshot.belongsTo(key);\n\n        key = this.keyForRelationship ? this.keyForRelationship(key, \"belongsTo\", \"serialize\") : key;\n\n        json[key] = !belongsTo ? null : belongsTo.record.toJSON();\n      }\n    }\n    ```\n\n    @public\n  */\n  serializeBelongsTo(snapshot: Snapshot, json: object, relationship: LegacyHasManyField | LegacyBelongsToField): void {\n    const name = relationship.name;\n\n    if (this._canSerialize(name)) {\n      const belongsToId = snapshot.belongsTo(name, { id: true });\n\n      // if provided, use the mapping provided by `attrs` in\n      // the serializer\n      // @ts-expect-error store added dynamically\n      const schema = this.store.modelFor(snapshot.modelName);\n      let payloadKey = this._getMappedKey(name, schema);\n      if (payloadKey === name && this.keyForRelationship) {\n        payloadKey = this.keyForRelationship(name, 'belongsTo', 'serialize');\n      }\n\n      //Need to check whether the id is there for new&async records\n      if (!belongsToId) {\n        json[payloadKey] = null;\n      } else {\n        json[payloadKey] = belongsToId;\n      }\n\n      if (relationship.options.polymorphic) {\n        this.serializePolymorphicType(snapshot, json, relationship);\n      }\n    }\n  },\n\n  /**\n   `serializeHasMany` can be used to customize how `hasMany`\n   properties are serialized.\n\n   Example\n\n   ```js [app/serializers/post.js]\n   import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n   export default class PostSerializer extends JSONSerializer {\n     serializeHasMany(snapshot, json, relationship) {\n       let key = relationship.name;\n       if (key === 'comments') {\n         return;\n       } else {\n         super.serializeHasMany(...arguments);\n       }\n     }\n   }\n   ```\n\n    @public\n  */\n  serializeHasMany(snapshot: Snapshot, json: object, relationship: LegacyBelongsToField | LegacyHasManyField): void {\n    const name = relationship.name;\n\n    if (this.shouldSerializeHasMany(snapshot, name, relationship)) {\n      const hasMany = snapshot.hasMany(name, { ids: true });\n      if (hasMany !== undefined) {\n        // if provided, use the mapping provided by `attrs` in\n        // the serializer\n        // @ts-expect-error store added dynamically\n        const schema = this.store.modelFor(snapshot.modelName);\n        let payloadKey = this._getMappedKey(name, schema);\n        if (payloadKey === name && this.keyForRelationship) {\n          payloadKey = this.keyForRelationship(name, 'hasMany', 'serialize');\n        }\n\n        json[payloadKey] = hasMany;\n        // TODO support for polymorphic manyToNone and manyToMany relationships\n      }\n    }\n  },\n\n  /**\n    You can use this method to customize how polymorphic objects are\n    serialized. Objects are considered to be polymorphic if\n    `{ polymorphic: true }` is pass as the second argument to the\n    `belongsTo` function.\n\n    Example\n\n    ```js [app/serializers/comment.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class CommentSerializer extends JSONSerializer {\n      serializePolymorphicType(snapshot, json, relationship) {\n        let key = relationship.name;\n        let belongsTo = snapshot.belongsTo(key);\n\n        key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;\n\n        if (!belongsTo) {\n          json[key + '_type'] = null;\n        } else {\n          json[key + '_type'] = belongsTo.modelName;\n        }\n      }\n    }\n    ```\n\n    @public\n  */\n  serializePolymorphicType(\n    snapshot: Snapshot,\n    json: object,\n    relationship: LegacyBelongsToField | LegacyHasManyField\n  ): void {},\n\n  /**\n    `extractMeta` is used to deserialize any meta information in the\n    adapter payload. By default Ember Data expects meta information to\n    be located on the `meta` property of the payload object.\n\n    Example\n\n    ```js [app/serializers/post.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PostSerializer extends JSONSerializer {\n      extractMeta(store, typeClass, payload) {\n        if (payload && payload.hasOwnProperty('_pagination')) {\n          let meta = payload._pagination;\n          delete payload._pagination;\n          return meta;\n        }\n      }\n    }\n    ```\n\n    @public\n  */\n  extractMeta(store: Store, modelClass: ModelSchema, payload: object): object | undefined {\n    if (payload && payload['meta'] !== undefined) {\n      // @ts-expect-error\n      const meta = payload.meta;\n      // @ts-expect-error\n      delete payload.meta;\n      return meta;\n    }\n  },\n\n  /**\n    `extractErrors` is used to extract model errors when a call\n    to `Model#save` fails with an `InvalidError`. By default\n    Ember Data expects error information to be located on the `errors`\n    property of the payload object.\n\n    This serializer expects this `errors` object to be an Array similar\n    to the following, compliant with the https://jsonapi.org/format/#errors specification:\n\n    ```js\n    {\n      \"errors\": [\n        {\n          \"detail\": \"This username is already taken!\",\n          \"source\": {\n            \"pointer\": \"data/attributes/username\"\n          }\n        }, {\n          \"detail\": \"Doesn't look like a valid email.\",\n          \"source\": {\n            \"pointer\": \"data/attributes/email\"\n          }\n        }\n      ]\n    }\n    ```\n\n    The key `detail` provides a textual description of the problem.\n    Alternatively, the key `title` can be used for the same purpose.\n\n    The nested keys `source.pointer` detail which specific element\n    of the request data was invalid.\n\n    Note that JSON-API also allows for object-level errors to be placed\n    in an object with pointer `data`, signifying that the problem\n    cannot be traced to a specific attribute:\n\n    ```javascript\n    {\n      \"errors\": [\n        {\n          \"detail\": \"Some generic non property error message\",\n          \"source\": {\n            \"pointer\": \"data\"\n          }\n        }\n      ]\n    }\n    ```\n\n    When turn into a `Errors` object, you can read these errors\n    through the property `base`:\n\n    ```handlebars\n    {{#each @model.errors.base as |error|}}\n      <div class=\"error\">\n        {{error.message}}\n      </div>\n    {{/each}}\n    ```\n\n    Example of alternative implementation, overriding the default\n    behavior to deal with a different format of errors:\n\n    ```js [app/serializers/post.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n\n    export default class PostSerializer extends JSONSerializer {\n      extractErrors(store, typeClass, payload, id) {\n        if (payload && typeof payload === 'object' && payload._problems) {\n          payload = payload._problems;\n          this.normalizeErrors(typeClass, payload);\n        }\n        return payload;\n      }\n    }\n    ```\n\n    @public\n    @return json The deserialized errors\n  */\n  extractErrors(store: Store, typeClass: ModelSchema, payload: object, id: string | null): object {\n    // @ts-expect-error\n    if (payload && typeof payload === 'object' && payload.errors) {\n      // the default assumption is that errors is already in JSON:API format\n      const extracted = {};\n\n      // @ts-expect-error\n      payload.errors.forEach((error) => {\n        if (error.source && error.source.pointer) {\n          let key = error.source.pointer.match(SOURCE_POINTER_REGEXP);\n\n          if (key) {\n            key = key[2];\n          } else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) {\n            key = PRIMARY_ATTRIBUTE_KEY;\n          }\n\n          if (key) {\n            extracted[key] = extracted[key] || [];\n            extracted[key].push(error.detail || error.title);\n          }\n        }\n      });\n\n      // if the user has an attrs hash, convert keys using it\n      this.normalizeUsingDeclaredMapping(typeClass, extracted);\n\n      // for each attr and relationship, make sure that we use\n      // the normalized key\n      typeClass.eachAttribute((name) => {\n        const key = this.keyForAttribute(name, 'deserialize');\n        if (key !== name && extracted[key] !== undefined) {\n          extracted[name] = extracted[key];\n          delete extracted[key];\n        }\n      });\n\n      typeClass.eachRelationship((name) => {\n        const key = this.keyForRelationship(name, 'deserialize');\n        if (key !== name && extracted[key] !== undefined) {\n          extracted[name] = extracted[key];\n          delete extracted[key];\n        }\n      });\n\n      return extracted;\n    }\n\n    return payload;\n  },\n\n  /**\n    `keyForAttribute` can be used to define rules for how to convert an\n    attribute name in your model to a key in your JSON.\n\n    Example\n\n    ```js [app/serializers/application.js]\n    import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n    import { underscore } from '<app-name>/utils/string-utils';\n\n    export default class ApplicationSerializer extends JSONSerializer {\n      keyForAttribute(attr, method) {\n        return underscore(attr).toUpperCase();\n      }\n    }\n    ```\n\n    @public\n  */\n  keyForAttribute(key: string, method: string): string {\n    return key;\n  },\n\n  /**\n    `keyForRelationship` can be used to define a custom key when\n    serializing and deserializing relationship properties. By default\n    `JSONSerializer` does not provide an implementation of this method.\n\n    Example\n\n      ```js [app/serializers/post.js]\n      import { JSONSerializer } from '@warp-drive/legacy/serializer/json';\n      import { underscore } from '<app-name>/utils/string-utils';\n\n      export default class PostSerializer extends JSONSerializer {\n        keyForRelationship(key, relationship, method) {\n          return `rel_${underscore(key)}`;\n        }\n      }\n      ```\n\n    @public\n  */\n  keyForRelationship(key: string, typeClass: ModelSchema | string, method?: string): string {\n    return key;\n  },\n\n  /**\n   `keyForLink` can be used to define a custom key when deserializing link\n   properties.\n\n    @public\n  */\n  keyForLink(key: string, kind: 'belongsTo' | 'hasMany'): string {\n    return key;\n  },\n\n  // HELPERS\n\n  /**\n   @private\n  */\n  transformFor(attributeType: string, skipAssertion?: boolean): Transform {\n    const transform = getOwner(this)!.lookup(`transform:${attributeType}`) as Transform | undefined;\n\n    assert(`Unable to find the transform for \\`attr('${attributeType}')\\``, skipAssertion || !!transform);\n\n    return transform!;\n  },\n});\n\nexport { JSONSerializer };\n"],"mappings":"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"}

package/dist/unpkg/prod-deprecated/model-fragments-DSqu0ptR.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-fragments-DSqu0ptR.js","names":["cached","tracked","Context","g","i","n","FragmentArray","prototype","isDestroying","isDestroyed","hasDirtyAttributes","array","context","path","resourceKey","store","record","peekRecord","root","at","changedAttributes","addFragment","fragment","addObject","createFragment","pushObject","removeFragment","index","indexOf","splice","rollbackAttributes","FragmentArrayExtension","kind","name","features","cached","tracked","Context","g","i","n","Fragment","prototype","isDestroying","isDestroyed","hasDirtyAttributes","path","resourceKey","store","record","peekRecord","root","at","changedAttributes","isFragment","$type","field","type","rollbackAttributes","oldValue","cache","getRemoteAttr","setAttr","FragmentExtension","kind","name","features","FragmentArrayExtension","FragmentExtension","registerFragmentExtensions","schema","CAUTION_MEGA_DANGER_ZONE_registerExtension","initialize","application","store","lookup","console","warn","name"],"sources":["../../../src/model-fragments/utilities/with-array-defaults.ts","../../../src/model-fragments/utilities/with-fragment-defaults.ts","../../../src/model-fragments/utilities/with-fragment-array-defaults.ts","../../../src/model-fragments/utilities/with-legacy.ts","../../../src/model-fragments/extensions/fragment-array.ts","../../../src/model-fragments/extensions/fragment.ts","../../../src/model-fragments/instance-initializers/fragment-extensions.ts","../../../src/model-fragments/hooks/model-for.ts"],"sourcesContent":["/**\n * Used as a helper to setup the relevant parts of an array\n * schema and add extensions etc.\n *\n * @param arrayName The name of the array\n * @param primitiveType The primitive type of items in the array (optional)\n * @returns The schema for an array\n */\nexport function withArrayDefaults<ArrayName extends string, PrimitiveType extends string>(\n  arrayName: ArrayName,\n  primitiveType?: PrimitiveType\n): PrimitiveType extends undefined\n  ? {\n      /**\n       * This field is an `'array'` schema field.\n       */\n      kind: 'array';\n      /**\n       * The name of the array field.\n       */\n      name: ArrayName;\n      /**\n       * The array's item type, `'array'` since no `primitiveType` was given.\n       */\n      type: 'array';\n      /**\n       * The schema options for this array field.\n       */\n      options: {\n        /**\n         * The registered array-schema extensions to apply to this array.\n         */\n        arrayExtensions: string[];\n      };\n    }\n  : {\n      /**\n       * This field is an `'array'` schema field.\n       */\n      kind: 'array';\n      /**\n       * The name of the array field.\n       */\n      name: ArrayName;\n      /**\n       * The array's item type, derived from `primitiveType`.\n       */\n      type: `array:${PrimitiveType}`;\n      /**\n       * The schema options for this array field.\n       */\n      options: {\n        /**\n         * The registered array-schema extensions to apply to this array.\n         */\n        arrayExtensions: string[];\n      };\n    };\n\nexport function withArrayDefaults<ArrayName extends string, PrimitiveType extends string>(\n  arrayName: ArrayName,\n  primitiveType?: PrimitiveType\n) {\n  const type = primitiveType ? (`array:${primitiveType}` as const) : ('array' as const);\n  return {\n    kind: 'array' as const,\n    name: arrayName,\n    type,\n    options: {\n      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array'],\n    },\n  };\n}\n","/**\n * Used as a helper to setup the relevant parts of a fragment schema\n * and add extensions etc.\n *\n * @param fragmentType The type of the fragment\n * @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.\n * @returns The schema for a fragment\n */\nexport function withFragmentDefaults<FragmentType extends string, FragmentName extends string>(\n  fragmentType: FragmentType,\n  fragmentName?: FragmentName\n): {\n  /**\n   * This field is a `'schema-object'` field, a single fragment.\n   */\n  kind: 'schema-object';\n  /**\n   * The resource type of the fragment.\n   */\n  type: `fragment:${FragmentType}`;\n  /**\n   * The name of the fragment field.\n   */\n  name: FragmentType | FragmentName;\n  /**\n   * The schema options for this fragment field.\n   */\n  options: {\n    /**\n     * The registered object-schema extensions to apply to this fragment.\n     */\n    objectExtensions: string[];\n  };\n} {\n  return {\n    kind: 'schema-object' as const,\n    type: `fragment:${fragmentType}` as const,\n    name: fragmentName ?? fragmentType,\n    options: {\n      objectExtensions: ['ember-object', 'fragment'],\n    },\n  };\n}\n","import { pluralize, singularize } from '@warp-drive/utilities/string';\n\n/**\n * Used as a helper to setup the relevant parts of a fragment-array\n * schema and add extensions etc.\n *\n * @param fragmentArrayType The type of the fragment-array\n * @param fragmentArrayName The name of the fragment-array\n * @returns The schema for a fragment-array\n */\nexport function withFragmentArrayDefaults<FragmentArrayType extends string, FragmentArrayName extends string>(\n  fragmentArrayType: FragmentArrayType,\n  fragmentArrayName?: FragmentArrayName\n): {\n  /**\n   * This field is a `'schema-array'` field, an array of fragments.\n   */\n  kind: 'schema-array';\n  /**\n   * The resource type of the fragments contained in this array.\n   */\n  type: `fragment:${string}`;\n  /**\n   * The name of the fragment-array field.\n   */\n  name: string;\n  /**\n   * The schema options for this fragment-array field.\n   */\n  options: {\n    /**\n     * The registered array-schema extensions to apply to this array.\n     */\n    arrayExtensions: string[];\n    /**\n     * Whether the array defaults to a non-null empty array when unset.\n     */\n    defaultValue: boolean;\n  };\n} {\n  return {\n    kind: 'schema-array' as const,\n    type: `fragment:${singularize(fragmentArrayType)}` as const,\n    name: fragmentArrayName ?? pluralize(fragmentArrayType),\n    options: {\n      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array'],\n      defaultValue: true,\n    },\n  };\n}\n","import type { LegacyResourceSchema, ResourceSchema } from '@warp-drive/core/types/schema/fields';\nimport type { WithPartial } from '@warp-drive/core/types/utils';\n\nimport { withDefaults } from '../../model/migration-support';\n\n/**\n * Used as a helper to setup the relevant parts of a legacy resource schema\n * migrated from `Model`, applying the `ember-object` and `fragment` object\n * extensions and a default `@id` identity field.\n *\n * @param schema the partial legacy resource schema to complete\n * @returns the completed resource schema\n */\nexport function withLegacy(schema: WithPartial<LegacyResourceSchema, 'legacy' | 'identity'>): ResourceSchema {\n  return withDefaults({\n    ...schema,\n    identity: { kind: '@id', name: 'id' },\n    objectExtensions: ['ember-object', 'fragment'],\n  });\n}\n","import { cached, tracked } from '@glimmer/tracking';\n\nimport type { CAUTION_MEGA_DANGER_ZONE_Extension } from '@warp-drive/core/reactive';\nimport { Context, type ManagedArray } from '@warp-drive/core/reactive/-private';\n\nimport type Model from '../../model.ts';\nimport type { WithFragmentArray } from '../index.ts';\nimport type { Fragment } from './fragment.ts';\n\n/**\n * The features added to an array resource by {@link FragmentArrayExtension}, providing\n * a subset of the legacy `ModelFragments` fragment-array API for migrated resources.\n */\nexport class FragmentArray<T extends Fragment> {\n  // We might want to check the parent values once we move this code to warp-drive.\n  /**\n   * Whether this fragment array is in the process of being destroyed.\n   */\n  @tracked isDestroying = false;\n  /**\n   * Whether this fragment array has been destroyed.\n   */\n  @tracked isDestroyed = false;\n\n  /**\n   * Whether this fragment array (or any of its members) has uncommitted changes.\n   */\n  @cached\n  get hasDirtyAttributes(): boolean {\n    const array = this as unknown as ManagedArray;\n    const context = array[Context];\n    const { path, resourceKey, store } = context;\n    const record = store.peekRecord(resourceKey) as Model;\n\n    if (record.hasDirtyAttributes && path) {\n      const root = path.at(0) as string;\n      return root in record.changedAttributes();\n    }\n\n    return false;\n  }\n\n  /**\n   * Adds an existing fragment to this array, if one was given.\n   */\n  addFragment(fragment?: T): Fragment[] | undefined {\n    if (!fragment) {\n      return;\n    }\n\n    return (this as unknown as WithFragmentArray<T>).addObject(fragment);\n  }\n\n  /**\n   * Appends a new fragment to the end of this array, if one was given.\n   */\n  createFragment(fragment?: T): Fragment | undefined {\n    if (!fragment) {\n      return;\n    }\n\n    return (this as unknown as WithFragmentArray<T>).pushObject(fragment);\n  }\n\n  /**\n   * Removes the given fragment from this array, if present.\n   */\n  removeFragment(fragment?: T): void {\n    if (!fragment) {\n      return;\n    }\n\n    const index = (this as unknown as WithFragmentArray<T>).indexOf(fragment);\n\n    if (index !== -1) {\n      (this as unknown as WithFragmentArray<T>).splice(index, 1);\n    }\n  }\n\n  /**\n   * Reverts each member fragment's attribute back to its last known remote value.\n   */\n  rollbackAttributes(): void {\n    for (const fragment of this as unknown as WithFragmentArray<T>) {\n      // @ts-expect-error TODO: fix these types\n      fragment?.rollbackAttributes?.();\n    }\n  }\n}\n\n/**\n * A schema extension that adds the {@link FragmentArray} API to migrated\n * `ModelFragments` array resources.\n */\nexport const FragmentArrayExtension: {\n  /**\n   * This extension applies to `'array'` schemas.\n   */\n  kind: 'array';\n  /**\n   * The registered name of this extension.\n   */\n  name: 'fragment-array';\n  /**\n   * The features ({@link FragmentArray}) added by this extension.\n   */\n  features: typeof FragmentArray;\n} = {\n  kind: 'array' as const,\n  name: 'fragment-array' as const,\n  features: FragmentArray,\n} satisfies CAUTION_MEGA_DANGER_ZONE_Extension;\n\nexport default FragmentArrayExtension;\n","import { cached, tracked } from '@glimmer/tracking';\n\nimport type { CAUTION_MEGA_DANGER_ZONE_Extension } from '@warp-drive/core/reactive';\nimport type { PrivateReactiveResource } from '@warp-drive/core/reactive/-private';\nimport { Context } from '@warp-drive/core/reactive/-private';\nimport type { Value } from '@warp-drive/core/types/json/raw';\n\nimport type Model from '../../model.ts';\n\n/**\n * The features added to an object resource by {@link FragmentExtension}, providing\n * a subset of the legacy `ModelFragments` fragment API for migrated resources.\n */\nexport class Fragment {\n  // We might want to check the parent values once we move this code to warp-drive.\n  /**\n   * Whether this fragment is in the process of being destroyed.\n   */\n  @tracked isDestroying = false;\n  /**\n   * Whether this fragment has been destroyed.\n   */\n  @tracked isDestroyed = false;\n\n  /**\n   * Whether this fragment (or the attribute it is rooted at) has uncommitted changes.\n   */\n  @cached\n  get hasDirtyAttributes(): boolean {\n    const { path, resourceKey, store } = (this as unknown as PrivateReactiveResource)[Context];\n    const record = store.peekRecord(resourceKey) as Model;\n\n    if (record.hasDirtyAttributes && path) {\n      const root = path.at(0) as string;\n      return root in record.changedAttributes();\n    }\n\n    return false;\n  }\n\n  /**\n   * Always `true`. Used to distinguish fragments from other resources.\n   */\n  get isFragment() {\n    return true;\n  }\n\n  /**\n   * The resource type of this fragment, if known.\n   */\n  get $type(): string | null | undefined {\n    const { field } = (this as unknown as PrivateReactiveResource)[Context];\n    return field?.type;\n  }\n\n  /**\n   * Reverts this fragment's attribute back to its last known remote value.\n   */\n  rollbackAttributes(this: PrivateReactiveResource): void {\n    const { path, resourceKey, store } = this[Context];\n\n    if (path) {\n      const oldValue = store.cache.getRemoteAttr(resourceKey, path) as Value;\n      store.cache.setAttr(resourceKey, path, oldValue);\n    }\n  }\n}\n\n/**\n * A schema extension that adds the {@link Fragment} API to migrated\n * `ModelFragments` object resources.\n */\nexport const FragmentExtension: {\n  /**\n   * This extension applies to `'object'` schemas.\n   */\n  kind: 'object';\n  /**\n   * The registered name of this extension.\n   */\n  name: 'fragment';\n  /**\n   * The features ({@link Fragment}) added by this extension.\n   */\n  features: typeof Fragment;\n} = {\n  kind: 'object' as const,\n  name: 'fragment' as const,\n  features: Fragment,\n} satisfies CAUTION_MEGA_DANGER_ZONE_Extension;\n\nexport default FragmentExtension;\n","import type ApplicationInstance from '@ember/application/instance';\n\nimport type { Store } from '@warp-drive/core';\nimport type { SchemaService } from '@warp-drive/core/types';\n\nimport FragmentArrayExtension from '../extensions/fragment-array.ts';\nimport FragmentExtension from '../extensions/fragment.ts';\n\n/**\n * Registers the {@link FragmentExtension}/{@link FragmentArrayExtension} schema\n * extensions on the given `SchemaService`, enabling ModelFragments migration support.\n *\n * @public\n */\nexport function registerFragmentExtensions(schema: SchemaService): void {\n  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);\n  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);\n}\n\nexport function initialize(application: ApplicationInstance): void {\n  const store = application.lookup('service:store') as Store | undefined;\n\n  if (store) {\n    registerFragmentExtensions(store.schema);\n  } else {\n    // oxlint-disable-next-line no-console\n    console.warn(\n      'No store service was found, you will need to call `registerFragmentExtensions` manually in your app.'\n    );\n  }\n}\n\nexport default {\n  name: 'fragment-extensions',\n  // the cast is required for isolatedDeclarations to determine this default\n  // export's type without inference, even though it's a no-op for `tsc`'s checker\n  // oxlint-disable-next-line typescript/no-unnecessary-type-assertion\n  initialize: initialize as (application: ApplicationInstance) => void,\n};\n","import type { Store } from '@warp-drive/core';\nimport type { ModelSchema } from '@warp-drive/core/types';\nimport type { Value } from '@warp-drive/core/types/json/raw';\nimport type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { LegacyAttributeField, LegacyRelationshipField } from '@warp-drive/core/types/schema/fields';\n\ntype KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;\n\n// if modelFor turns out to be a bottleneck we should replace with a Map\n// and clear it during store teardown.\nconst AvailableShims = new WeakMap<Store, Record<string, ShimModelClass>>();\n\nexport function getShimClass<T>(\n  store: Store,\n  modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string\n): ShimModelClass<T> {\n  let shims = AvailableShims.get(store);\n\n  if (!shims) {\n    shims = Object.create(null) as Record<string, ShimModelClass>;\n    AvailableShims.set(store, shims);\n  }\n\n  let shim = shims[modelName];\n  if (shim === undefined) {\n    shim = shims[modelName] = new ShimModelClass<unknown>(store, modelName);\n  }\n\n  return shim;\n}\n\nconst AttributeKinds = ['field', 'attribute', 'object', 'array', 'schema-object', 'schema-array'] as const;\n\n// Mimics the static apis of @warp-drive/legacy/model\nexport class ShimModelClass<T = unknown> implements ModelSchema<T> {\n  declare __store: Store;\n  declare modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;\n  constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string) {\n    this.__store = store;\n    this.modelName = modelName;\n  }\n\n  get fields(): Map<KeyOrString<T>, 'attribute' | 'belongsTo' | 'hasMany'> {\n    const fields = new Map<KeyOrString<T>, 'attribute' | 'belongsTo' | 'hasMany'>();\n    const fieldSchemas = this.__store.schema.fields({ type: this.modelName });\n\n    fieldSchemas.forEach((schema, key) => {\n      // @ts-expect-error checking if a string is a valid string\n      if (AttributeKinds.includes(schema.kind)) {\n        fields.set(key as KeyOrString<T>, 'attribute');\n      } else if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {\n        fields.set(key as KeyOrString<T>, schema.kind);\n      }\n    });\n\n    return fields;\n  }\n\n  get attributes(): Map<KeyOrString<T>, LegacyAttributeField> {\n    const attrs = new Map<KeyOrString<T>, LegacyAttributeField>();\n    const fields = this.__store.schema.fields({ type: this.modelName });\n\n    fields.forEach((schema, key) => {\n      if (schema.kind === 'attribute') {\n        attrs.set(key as KeyOrString<T>, schema);\n        // @ts-expect-error checking if a string is a valid string\n      } else if (AttributeKinds.includes(schema.kind)) {\n        attrs.set(key as KeyOrString<T>, {\n          kind: 'attribute',\n          name: key,\n          type: null,\n          options: (schema.options ?? {}) as Record<string, Value>,\n        });\n      }\n    });\n\n    return attrs;\n  }\n\n  get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField> {\n    const rels = new Map<KeyOrString<T>, LegacyRelationshipField>();\n    const fields = this.__store.schema.fields({ type: this.modelName });\n\n    fields.forEach((schema, key) => {\n      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {\n        rels.set(key as KeyOrString<T>, schema);\n      }\n    });\n\n    return rels;\n  }\n\n  eachAttribute<K extends KeyOrString<T>>(\n    callback: (key: K, attribute: LegacyAttributeField) => void,\n    binding?: T\n  ): void {\n    this.attributes.forEach((schema, key) => {\n      callback.call(binding, key as K, schema);\n    });\n  }\n\n  eachRelationship<K extends KeyOrString<T>>(\n    callback: (key: K, relationship: LegacyRelationshipField) => void,\n    binding?: T\n  ): void {\n    this.__store.schema.fields({ type: this.modelName }).forEach((schema, key) => {\n      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {\n        callback.call(binding, key as K, schema);\n      }\n    });\n  }\n\n  eachTransformedAttribute<K extends KeyOrString<T>>(\n    callback: (key: K, type: string | null) => void,\n    binding?: T\n  ): void {\n    this.__store.schema.fields({ type: this.modelName }).forEach((schema, key) => {\n      if (schema.kind === 'attribute') {\n        const type = schema.type;\n        if (type) callback.call(binding, key as K, type);\n      }\n    });\n  }\n}\n\nexport function fragmentsModelFor<T extends TypedRecordInstance>(\n  this: Store,\n  modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string\n): ShimModelClass<T> {\n  return getShimClass(this, modelName);\n}\n\n/**\n * The `modelFor` fallback used to construct a `ShimModelClass` schema for a\n * type when ModelFragments support is enabled and no real `Model` subclass\n * is registered for that type.\n *\n * @public\n */\nexport const modelFor: typeof fragmentsModelFor = fragmentsModelFor;\n"],"mappings":";;;;;;;AA2DA,SAAgB,kBACd,WACA,eACA;CAEA,OAAO;EACL,MAAM;EACN,MAAM;EACN,MAJW,gBAAiB,SAAS,kBAA6B;EAKlE,SAAS,EACP,iBAAiB;GAAC;GAAgB;GAAoB;EAAgB,EACxE;CACF;AACF;;;;;;;;;;;;AChEA,SAAgB,qBACd,cACA,cAuBA;CACA,OAAO;EACL,MAAM;EACN,MAAM,YAAY;EAClB,MAAM,gBAAgB;EACtB,SAAS,EACP,kBAAkB,CAAC,gBAAgB,UAAU,EAC/C;CACF;AACF;;;;;;;;;;;;AChCA,SAAgB,0BACd,mBACA,mBA2BA;CACA,OAAO;EACL,MAAM;EACN,MAAM,YAAY,YAAY,iBAAiB;EAC/C,MAAM,qBAAqB,UAAU,iBAAiB;EACtD,SAAS;GACP,iBAAiB;IAAC;IAAgB;IAAoB;GAAgB;GACtE,cAAc;EAChB;CACF;AACF;;;;;;;;;;;;ACpCA,SAAgB,WAAW,QAAkF;CAC3G,OAAO,aAAa;EAClB,GAAG;EACH,UAAU;GAAE,MAAM;GAAO,MAAM;EAAK;EACpC,kBAAkB,CAAC,gBAAgB,UAAU;CAC/C,CAAC;AACH;;;;;;;;ACNA,IAAaM,gBAAb,MAA+C;CAAA;EAAAH,gBAAA,KAAAI,WAAA,gBAAA,CAK5CN,OAAO,GAAA,WAAA;GAAA,OAAgB;EAAK,CAAA;CAAA;CAAA,iBAAAG,4BAAA,MAAA,cAAA,GAAA,KAAA;;;;CAH7B;EAAAD,gBAAA,KAAAI,WAAA,eAAA,CAOCN,OAAO,GAAA,WAAA;GAAA,OAAe;EAAK,CAAA;CAAA;CAAA,gBAAAG,4BAAA,MAAA,aAAA,GAAA,KAAA;;;;;;;CAK5B,IACIM,qBAA8B;EAGhC,MAAM,EAAEG,MAAMC,aAAaC,UADXJ,KAAMT;EAEtB,MAAMc,SAASD,MAAME,WAAWH,WAAW;EAE3C,IAAIE,OAAON,sBAAsBG,MAE/B,OADaA,KAAKM,GAAG,CACdD,KAAQF,OAAOI,kBAAkB;EAG1C,OAAO;CACT;;;;CAEA;EAAAf,iBAAA,KAAAE,WAAA,sBAAA,CAfCP,MAAM,CAAA;CAAA;CAkBPqB,YAAYC,UAAsC;EAChD,IAAI,CAACA,UACH;EAGF,OAAQ,KAAyCC,UAAUD,QAAQ;CACrE;;;;CAKAE,eAAeF,UAAoC;EACjD,IAAI,CAACA,UACH;EAGF,OAAQ,KAAyCG,WAAWH,QAAQ;CACtE;;;;CAKAI,eAAeJ,UAAoB;EACjC,IAAI,CAACA,UACH;EAGF,MAAMK,QAAS,KAAyCC,QAAQN,QAAQ;EAExE,IAAIK,UAAU,IACX,KAAyCE,OAAOF,OAAO,CAAC;CAE7D;;;;CAKAG,qBAA2B;EACzB,KAAK,MAAMR,YAAY,MAErBA,UAAUQ,qBAAqB;CAEnC;AACF;;;;;AAMA,MAAaC,yBAaT;CACFC,MAAM;CACNC,MAAM;CACNC,UAAU5B;AACZ;;;;;;;;AClGA,IAAamC,WAAb,MAAsB;CAAA;EAAAH,gBAAA,KAAAI,WAAA,gBAAA,CAKnBN,OAAO,GAAA,WAAA;GAAA,OAAgB;EAAK,CAAA;CAAA;CAAA,iBAAAG,4BAAA,MAAA,cAAA,GAAA,KAAA;;;;CAH7B;EAAAD,gBAAA,KAAAI,WAAA,eAAA,CAOCN,OAAO,GAAA,WAAA;GAAA,OAAe;EAAK,CAAA;CAAA;CAAA,gBAAAG,4BAAA,MAAA,aAAA,GAAA,KAAA;;;;;;;CAK5B,IACIM,qBAA8B;EAChC,MAAM,EAAEC,MAAMC,aAAaC,UAAW,KAA4CX;EAClF,MAAMY,SAASD,MAAME,WAAWH,WAAW;EAE3C,IAAIE,OAAOJ,sBAAsBC,MAE/B,OADaA,KAAKM,GAAG,CACdD,KAAQF,OAAOI,kBAAkB;EAG1C,OAAO;CACT;;;;CAEA;EAAAb,iBAAA,KAAAE,WAAA,sBAAA,CAbCP,MAAM,CAAA;CAAA;CAgBP,IAAImB,aAAa;EACf,OAAO;CACT;;;;CAKA,IAAIC,QAAmC;EACrC,MAAM,EAAEC,UAAW,KAA4CnB;EAC/D,OAAOmB,OAAOC;CAChB;;;;CAKAC,qBAAwD;EACtD,MAAM,EAAEZ,MAAMC,aAAaC,UAAU,KAAKX;EAE1C,IAAIS,MAAM;GACR,MAAMa,WAAWX,MAAMY,MAAMC,cAAcd,aAAaD,IAAI;GAC5DE,MAAMY,MAAME,QAAQf,aAAaD,MAAMa,QAAQ;EACjD;CACF;AACF;;;;;AAMA,MAAaI,oBAaT;CACFC,MAAM;CACNC,MAAM;CACNC,UAAUzB;AACZ;;;;;;;;;;AC3EA,SAAgB4B,2BAA2BC,QAA6B;CACtEA,OAAOC,6CAA6CH,iBAAiB;CACrEE,OAAOC,6CAA6CJ,sBAAsB;AAC5E;;;;ACPA,MAAM,iCAAiB,IAAI,QAA+C;AAE1E,SAAgB,aACd,OACA,WACmB;CACnB,IAAI,QAAQ,eAAe,IAAI,KAAK;CAEpC,IAAI,CAAC,OAAO;EACV,QAAQ,OAAO,OAAO,IAAI;EAC1B,eAAe,IAAI,OAAO,KAAK;CACjC;CAEA,IAAI,OAAO,MAAM;CACjB,IAAI,SAAS,QACX,OAAO,MAAM,aAAa,IAAI,eAAwB,OAAO,SAAS;CAGxE,OAAO;AACT;AAEA,MAAM,iBAAiB;CAAC;CAAS;CAAa;CAAU;CAAS;CAAiB;AAAc;AAGhG,IAAa,iBAAb,MAAmE;CAGjE,YAAY,OAAc,WAAyE;EACjG,KAAK,UAAU;EACf,KAAK,YAAY;CACnB;CAEA,IAAI,SAAqE;EACvE,MAAM,yBAAS,IAAI,IAA2D;EAG9E,AAFqB,KAAK,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,UAAU,CAE5D,CAAC,CAAC,SAAS,QAAQ,QAAQ;GAEpC,IAAI,eAAe,SAAS,OAAO,IAAI,GACrC,OAAO,IAAI,KAAuB,WAAW;QACxC,IAAI,OAAO,SAAS,eAAe,OAAO,SAAS,WACxD,OAAO,IAAI,KAAuB,OAAO,IAAI;EAEjD,CAAC;EAED,OAAO;CACT;CAEA,IAAI,aAAwD;EAC1D,MAAM,wBAAQ,IAAI,IAA0C;EAG5D,AAFe,KAAK,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,UAAU,CAE5D,CAAC,CAAC,SAAS,QAAQ,QAAQ;GAC9B,IAAI,OAAO,SAAS,aAClB,MAAM,IAAI,KAAuB,MAAM;QAElC,IAAI,eAAe,SAAS,OAAO,IAAI,GAC5C,MAAM,IAAI,KAAuB;IAC/B,MAAM;IACN,MAAM;IACN,MAAM;IACN,SAAU,OAAO,WAAW,CAAC;GAC/B,CAAC;EAEL,CAAC;EAED,OAAO;CACT;CAEA,IAAI,sBAAoE;EACtE,MAAM,uBAAO,IAAI,IAA6C;EAG9D,AAFe,KAAK,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,UAAU,CAE5D,CAAC,CAAC,SAAS,QAAQ,QAAQ;GAC9B,IAAI,OAAO,SAAS,eAAe,OAAO,SAAS,WACjD,KAAK,IAAI,KAAuB,MAAM;EAE1C,CAAC;EAED,OAAO;CACT;CAEA,cACE,UACA,SACM;EACN,KAAK,WAAW,SAAS,QAAQ,QAAQ;GACvC,SAAS,KAAK,SAAS,KAAU,MAAM;EACzC,CAAC;CACH;CAEA,iBACE,UACA,SACM;EACN,KAAK,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,QAAQ,QAAQ;GAC5E,IAAI,OAAO,SAAS,eAAe,OAAO,SAAS,WACjD,SAAS,KAAK,SAAS,KAAU,MAAM;EAE3C,CAAC;CACH;CAEA,yBACE,UACA,SACM;EACN,KAAK,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,QAAQ,QAAQ;GAC5E,IAAI,OAAO,SAAS,aAAa;IAC/B,MAAM,OAAO,OAAO;IACpB,IAAI,MAAM,SAAS,KAAK,SAAS,KAAU,IAAI;GACjD;EACF,CAAC;CACH;AACF;AAEA,SAAgB,kBAEd,WACmB;CACnB,OAAO,aAAa,MAAM,SAAS;AACrC;;;;;;;;AASA,MAAa,WAAqC"}

package/dist/unpkg/prod-deprecated/model-qeqVBN2l.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-qeqVBN2l.js","names":["computed","recordIdentifierFor","RecordStore","isElementDescriptor","_attr","type","options","undefined","meta","kind","isAttribute","sourceKey","key","get","isDestroyed","isDestroying","cache","getAttr","set","value","identifier","cacheKey","currentValue","setAttr","isValid","errors","remove","currentState","cleanErrorRequests","attr","desc","args","computed","assertPrivateStore","RecordStore","lookupLegacySupport","isElementDescriptor","normalizeModelName","_belongsTo","type","options","meta","kind","name","sourceKey","get","key","isDestroying","isDestroyed","support","getBelongsTo","set","value","_join","setDirtyBelongsTo","belongsTo","computed","assertPrivateStore","RecordStore","dasherize","singularize","lookupLegacySupport","isElementDescriptor","normalizeType","type","result","console","warn","_hasMany","options","meta","kind","name","sourceKey","get","key","isDestroying","isDestroyed","getHasMany","set","records","support","manyArray","getManyArray","_join","splice","length","hasMany","getOwner","setOwner","assertPrivateStore","setRecordIdentifier","StoreMap","getModelFactory","normalizeModelName","recast","context","instantiateRecord","identifier","createRecordArgs","type","createOptions","_createProps","_secretInit","store","cb","secretInit","factory","class","create","teardownRecord","record","destroy","modelFor","modelName","maybeFactory","klass","ignoreType","isModel","_forceShim","set"],"sources":["../../../src/model/-private/attr.ts","../../../src/model/-private/belongs-to.ts","../../../src/model/-private/has-many.ts","../../../src/model/-private/hooks.ts"],"sourcesContent":["import { computed } from '@ember/object';\n\nimport { recordIdentifierFor } from '@warp-drive/core';\nimport { DEBUG } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { ArrayValue, ObjectValue, PrimitiveValue, Value } from '@warp-drive/core/types/json/raw';\nimport { RecordStore, type TransformName } from '@warp-drive/core/types/symbols';\n\n// oxlint-disable-next-line no-unused-vars\nimport type { Transform } from '../../serializer/transform.ts';\nimport type { Model } from './model.ts';\nimport type { DecoratorPropertyDescriptor } from './util.ts';\nimport { isElementDescriptor } from './util.ts';\n/**\n * Options provided to the attr decorator are\n * supplied to the associated transform. Any\n * key-value pair is valid; however, it is highly\n * recommended to only use statically defined values\n * that could be serialized to JSON.\n *\n * If no transform is provided, the only valid\n * option is `defaultValue`.\n *\n * Examples:\n *\n * ```ts\n * class User extends Model {\n *  @attr('string', { defaultValue: 'Anonymous' }) name;\n *  @attr('date', { defaultValue: () => new Date() }) createdAt;\n *  @attr({ defaultValue: () => ({}) }) preferences;\n *  @attr('boolean') hasVerifiedEmail;\n *  @attr address;\n * }\n *\n * @class NOTATHING\n */\nexport type AttrOptions<DV = PrimitiveValue | object | unknown[]> = {\n  /**\n   * The default value for this attribute.\n   *\n   * Default values can be provided as a value or a function that will be\n   * executed to generate the default value.\n   *\n   * Default values *should not* be stateful (object, arrays, etc.) as\n   * they will be shared across all instances of the record.\n   *\n   */\n  defaultValue?: DV extends PrimitiveValue ? DV : () => DV;\n\n  /**\n   * The name of the field as returned by the API and inserted into the\n   * cache if it differs from the name of the decorated property.\n   *\n   * For instance, if the API returns:\n   *\n   * ```ts\n   * {\n   *   attributes: {\n   *     'first-name': 'Chris'\n   *   }\n   * }\n   * ```\n   *\n   * But the app desires to use `record.firstName; // 'Chris'`, then the\n   * property should be named `firstName` and `sourceKey` should be set\n   * to `'first-name'`.\n   *\n   * This option is only needed when the value differs from the property name.\n   */\n  sourceKey?: string;\n};\n\nfunction _attr(type?: string | AttrOptions, options?: AttrOptions) {\n  if (typeof type === 'object') {\n    options = type;\n    type = undefined;\n  } else {\n    options = options || {};\n  }\n\n  const meta = {\n    type: type,\n    kind: 'attribute',\n    isAttribute: true,\n    options: options,\n    sourceKey: options.sourceKey,\n    key: null,\n  };\n\n  return computed({\n    get(this: Model, key: string) {\n      if (DEBUG) {\n        if (['currentState'].includes(key)) {\n          throw new Error(\n            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`\n          );\n        }\n      }\n      if (this.isDestroyed || this.isDestroying) {\n        return;\n      }\n      const cache = this[RecordStore].cache;\n      return cache.getAttr(recordIdentifierFor(this), meta.sourceKey ?? key);\n    },\n    set(this: Model, key: string, value: Value) {\n      if (DEBUG) {\n        if (['currentState'].includes(key)) {\n          throw new Error(\n            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`\n          );\n        }\n      }\n      const identifier = recordIdentifierFor(this);\n      assert(\n        `Attempted to set '${key}' on the deleted record ${identifier.type}:${identifier.id} (${identifier.lid})`,\n        !this.currentState.isDeleted\n      );\n      const cache = this[RecordStore].cache;\n      const cacheKey = meta.sourceKey ?? key;\n\n      const currentValue = cache.getAttr(identifier, cacheKey);\n      if (currentValue !== value) {\n        cache.setAttr(identifier, cacheKey, value);\n\n        if (!this.isValid) {\n          const { errors } = this;\n\n          if (errors.get(key)) {\n            errors.remove(key);\n            this.currentState.cleanErrorRequests();\n          }\n        }\n      }\n\n      return value;\n    },\n  }).meta(meta);\n}\n\n// NOTE: Usage of Explicit ANY\n// -------------------------------------------------------------------\n// any is required here because we are the maximal not the minimal\n// subset of options allowed. If we used unknown, object, or\n// Record<string, unknown> we would get type errors when we try to\n// assert against a more specific implementation with precise options.\n// -------------------------------------------------------------------\n\ntype LooseTransformInstance<V, Raw, Name extends string> = {\n  /**\n   * value type must match the return type of the deserialize method\n   *\n   */\n  // see note on Explicit ANY above\n  // oxlint-disable-next-line typescript/no-explicit-any\n  serialize: (value: V, options: any) => Raw;\n  /**\n   * defaultValue type must match the return type of the deserialize method\n   *\n   */\n  // see note on Explicit ANY above\n  // oxlint-disable-next-line typescript/no-explicit-any\n  deserialize: (value: Raw, options: any) => V;\n\n  [TransformName]: Name;\n};\nexport type TransformHasType = { [TransformName]: string };\n\nexport type TypedTransformInstance<V, T extends string> =\n  | LooseTransformInstance<V, string, T>\n  | LooseTransformInstance<V, number, T>\n  | LooseTransformInstance<V, boolean, T>\n  | LooseTransformInstance<V, null, T>\n  | LooseTransformInstance<V, ObjectValue, T>\n  | LooseTransformInstance<V, ArrayValue, T>\n  | LooseTransformInstance<V, string | null, T>\n  | LooseTransformInstance<V, number | null, T>\n  | LooseTransformInstance<V, boolean | null, T>\n  | LooseTransformInstance<V, ObjectValue | null, T>\n  | LooseTransformInstance<V, ArrayValue | null, T>;\n\n// see note on Explicit ANY above\n// oxlint-disable-next-line typescript/no-explicit-any\nexport type GetMaybeDeserializeValue<T> = T extends { deserialize: (...args: any[]) => unknown }\n  ? ReturnType<T['deserialize']>\n  : never;\n\nexport type TypeFromInstance<T> = T extends TransformHasType ? T[typeof TransformName] : never;\nexport type ExtractOptions<T extends TypedTransformInstance<GetMaybeDeserializeValue<T>, TypeFromInstance<T>>> =\n  Parameters<T['deserialize']>[1] & Parameters<T['serialize']>[1] & AttrOptions<ReturnType<T['deserialize']>>;\nexport type OptionsFromInstance<T> =\n  TypeFromInstance<T> extends never\n    ? never\n    : GetMaybeDeserializeValue<T> extends never\n      ? never\n      : T extends TypedTransformInstance<GetMaybeDeserializeValue<T>, TypeFromInstance<T>>\n        ? Parameters<T['deserialize']>[1] & Parameters<T['serialize']>[1] & AttrOptions<ReturnType<T['deserialize']>>\n        : never;\n\n/**\n * The return type of `void` is a lie to appease TypeScript. The actual return type\n * is a descriptor, but typescript incorrectly insists that decorator functions return\n * `void` or `any`.\n *\n */\nexport type DataDecorator = (target: object, key: string, desc?: DecoratorPropertyDescriptor) => void;\n\n/**\n  `attr` defines an attribute on a {@link Model}.\n  By default, attributes are passed through as-is, however you can specify an\n  optional type to have the value automatically transformed.\n  WarpDrive ships with four basic transform types: `string`, `number`,\n  `boolean` and `date`. You can define your own transforms by subclassing\n  {@link Transform}.\n\n  Note that you cannot use `attr` to define an attribute of `id`.\n\n  `attr` takes an optional hash as a second parameter, currently\n  supported options are:\n\n  - `defaultValue`: Pass a string or a function to be called to set the attribute\n  to a default value if and only if the key is absent from the payload response.\n\n  Example\n\n  ```js [app/models/user.js]\n  import { Model, attr } from '@warp-drive/legacy/model';\n\n  export default class UserModel extends Model {\n    @attr('string') username;\n    @attr('string') email;\n    @attr('boolean', { defaultValue: false }) verified;\n  }\n  ```\n\n  Default value can also be a function. This is useful it you want to return\n  a new object for each attribute.\n\n  ```js [app/models/user.js]\n  import { Model, attr } from '@warp-drive/legacy/model';\n\n  export default class UserModel extends Model {\n    @attr('string') username;\n    @attr('string') email;\n\n    @attr({\n      defaultValue() {\n        return {};\n      }\n    })\n    settings;\n  }\n  ```\n\n  The `options` hash is passed as second argument to a transforms'\n  `serialize` and `deserialize` method. This allows to configure a\n  transformation and adapt the corresponding value, based on the config:\n\n  ```js [app/models/post.js]\n  import { Model, attr } from '@warp-drive/legacy/model';\n\n  export default class PostModel extends Model {\n    @attr('text', {\n      uppercase: true\n    })\n    text;\n  }\n  ```\n\n  ```js [app/transforms/text.js]\n  export default class TextTransform {\n    serialize(value, options) {\n      if (options.uppercase) {\n        return value.toUpperCase();\n      }\n\n      return value;\n    }\n\n    deserialize(value) {\n      return value;\n    }\n\n    static create() {\n      return new this();\n    }\n  }\n  ```\n\n  @public\n  @param type the attribute type\n  @param options a hash of options\n*/\nexport function attr(): DataDecorator;\nexport function attr<T>(type: TypeFromInstance<T>): DataDecorator;\nexport function attr(type: string): DataDecorator;\nexport function attr(options: AttrOptions): DataDecorator;\nexport function attr<T>(type: TypeFromInstance<T>, options?: OptionsFromInstance<T>): DataDecorator;\nexport function attr(type: string, options?: AttrOptions & object): DataDecorator;\nexport function attr(target: object, key: string | symbol, desc?: PropertyDescriptor): void; // see note on DataDecorator for why void\nexport function attr(\n  type?: string | AttrOptions | object,\n  options?: (AttrOptions & object) | string | symbol,\n  desc?: PropertyDescriptor\n): DataDecorator | void {\n  const args = [type, options, desc];\n  // see note on DataDecorator for why void\n  return isElementDescriptor(args) ? (_attr()(...args) as void) : _attr(type, options as object);\n}\n","import { warn } from '@ember/debug';\nimport { computed } from '@ember/object';\n\nimport { DEBUG } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { assertPrivateStore } from '@warp-drive/core/store/-private';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport { RecordStore } from '@warp-drive/core/types/symbols';\n\nimport { lookupLegacySupport } from './legacy-relationships-support.ts';\nimport type { MinimalLegacyRecord } from './model-methods.ts';\n// oxlint-disable-next-line no-unused-vars\nimport type { Model } from './model.ts';\nimport { isElementDescriptor, normalizeModelName } from './util.ts';\n\nexport type IsUnknown<T> = unknown extends T ? true : false;\n\nexport type RelationshipOptions<T, Async extends boolean> = {\n  async: Async;\n  inverse: null | (IsUnknown<T> extends true ? string : keyof NoNull<T> & string);\n  polymorphic?: boolean;\n  as?: string;\n  linksMode?: true;\n  resetOnRemoteUpdate?: boolean;\n\n  /**\n   * The name of the field as returned by the API and inserted into the\n   * cache if it differs from the name of the decorated property.\n   *\n   * For instance, if the API returns:\n   *\n   * ```ts\n   * {\n   *   relationships: {\n   *     'best-friend': { data: { type: 'user', id: '1' } }\n   *   }\n   * }\n   * ```\n   *\n   * But the app desires to use `record.bestFriend`, then the property\n   * should be named `bestFriend` and `sourceKey` should be set to\n   * `'best-friend'`.\n   *\n   * This option is only needed when the value differs from the property name.\n   */\n  sourceKey?: string;\n};\n\nexport type NoNull<T> = Exclude<T, null>;\n// type BelongsToDecoratorObject<getT> = {\n//   get: () => getT;\n//   // set: (value: Awaited<getT>) => void;\n//   set: (value: getT) => void;\n//   // init: () => getT;\n// };\n// oxlint-disable-next-line no-unused-vars\nexport type RelationshipDecorator<T> = <This>(target: This, key: string, desc?: PropertyDescriptor) => void; // BelongsToDecoratorObject<getT>;\n\nfunction _belongsTo<T, Async extends boolean>(\n  type: string,\n  options: RelationshipOptions<T, Async>\n): RelationshipDecorator<T> {\n  assert(\n    `Expected options.async from @belongsTo('${type}', options) to be a boolean`,\n    options && typeof options.async === 'boolean'\n  );\n  assert(\n    `Expected options.inverse from @belongsTo('${type}', options) to be either null or the string type of the related resource.`,\n    options.inverse === null || (typeof options.inverse === 'string' && options.inverse.length > 0)\n  );\n\n  const meta = {\n    type: normalizeModelName(type),\n    options: options,\n    kind: 'belongsTo',\n    name: '<Unknown BelongsTo>',\n    sourceKey: options.sourceKey,\n  };\n\n  return computed({\n    get<R extends MinimalLegacyRecord>(this: R, key: string) {\n      // this is a legacy behavior we may not carry into a new model setup\n      // it's better to error on disconnected records so users find errors\n      // in their logic.\n      if (this.isDestroying || this.isDestroyed) {\n        return null;\n      }\n      const support = lookupLegacySupport(this);\n\n      if (DEBUG) {\n        if (['currentState'].includes(key)) {\n          throw new Error(\n            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`\n          );\n        }\n        if (Object.prototype.hasOwnProperty.call(options, 'serialize')) {\n          warn(\n            `You provided a serialize option on the \"${key}\" property in the \"${support.identifier.type}\" class, this belongs in the serializer. See Serializer and it's implementations https://api.emberjs.com/ember-data/release/classes/Serializer`,\n            false,\n            {\n              id: 'ds.model.serialize-option-in-belongs-to',\n            }\n          );\n        }\n\n        if (Object.prototype.hasOwnProperty.call(options, 'embedded')) {\n          warn(\n            `You provided an embedded option on the \"${key}\" property in the \"${support.identifier.type}\" class, this belongs in the serializer. See EmbeddedRecordsMixin https://api.emberjs.com/ember-data/release/classes/EmbeddedRecordsMixin`,\n            false,\n            {\n              id: 'ds.model.embedded-option-in-belongs-to',\n            }\n          );\n        }\n      }\n\n      return support.getBelongsTo(key);\n    },\n    set<R extends MinimalLegacyRecord>(this: R, key: string, value: unknown) {\n      assert(`Cannot set belongsTo relationship ${key} on a destroyed record`, !this.isDestroying && !this.isDestroyed);\n      if (this.isDestroying || this.isDestroyed) {\n        return null;\n      }\n      const support = lookupLegacySupport(this);\n      if (DEBUG) {\n        if (['currentState'].includes(key)) {\n          throw new Error(\n            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`\n          );\n        }\n      }\n      assertPrivateStore(this[RecordStore]);\n      this[RecordStore]._join(() => {\n        support.setDirtyBelongsTo(key, value);\n      });\n\n      return support.getBelongsTo(key);\n    },\n  }).meta(meta);\n}\n\n/**\n  `belongsTo` is used to define One-To-One and One-To-Many, and One-To-None\n  relationships on a {@link Model}.\n\n  `belongsTo` takes a configuration hash as a second parameter, currently\n  supported options are:\n\n  - `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.\n  - `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.\n  - `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic\n  - `as`: (*optional*) A string used to declare the abstract type \"this\" record satisfies for polymorphism.\n\n  ### Examples\n\n  To declare a **one-to-many** (or many-to-many) relationship, use\n  `belongsTo` in combination with `hasMany`:\n\n  ```js\n  // app/models/comment.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Comment extends Model {\n    @belongsTo('post', { async: false, inverse: 'comments' }) post;\n  }\n\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('comment', { async: false, inverse: 'post' }) comments;\n  }\n  ```\n\n  To declare a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:\n\n  ```js\n  // app/models/author.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Author extends Model {\n    @belongsTo('address', { async: true, inverse: 'owner' }) address;\n  }\n\n  // app/models/address.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Address extends Model {\n    @belongsTo('author', { async: true, inverse: 'address' }) owner;\n  }\n  ```\n\n  To declare a **one-to-one** relationship without managed inverses, use `belongsTo` for both sides\n  with `null` as the inverse:\n\n  ```js\n  // app/models/author.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Author extends Model {\n    @belongsTo('address', { async: true, inverse: null }) address;\n  }\n\n  // app/models/address.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Address extends Model {\n    @belongsTo('author', { async: true, inverse: null }) owner;\n  }\n  ```\n\n  To declare a one-to-none relationship between two models, use\n  `belongsTo` with inverse set to `null` on just one side::\n\n  ```js\n  // app/models/person.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Person extends Model {\n    @belongsTo('person', { async: false, inverse: null }) bestFriend;\n  }\n  ```\n\n  #### Sync vs Async Relationships\n\n  WarpDrive fulfills relationships using resource data available in\n  the cache.\n\n  Sync relationships point directly to the known related resources.\n\n  When a relationship is declared as async, if any of the known related\n  resources have not been loaded, they will be fetched. The property\n  on the record when accessed provides a promise that resolves once\n  all resources are loaded.\n\n  Async relationships may take advantage of links. On access, if the related\n  link has not been loaded, or if any known resources are not available in\n  the cache, the fresh state will be fetched using the link.\n\n  In contrast to async relationship, accessing a sync relationship\n  will error on access when any of the known related resources have\n  not been loaded.\n\n  If you are using `links` with sync relationships, you have to use\n  the BelongsTo reference API to fetch or refresh related resources\n  that aren't loaded. For instance, for a `bestFriend` relationship:\n\n  ```js\n  person.belongsTo('bestFriend').reload();\n  ```\n\n  #### Polymorphic Relationships\n\n  To declare a polymorphic relationship, use `hasMany` with the `polymorphic`\n  option set to `true`:\n\n  ```js\n  // app/models/comment.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Comment extends Model {\n    @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;\n  }\n  ```\n\n  `'commentable'` here is referred to as the \"abstract type\" for the polymorphic\n  relationship.\n\n  Polymorphic relationships with `inverse: null` will accept any type of record as their content.\n  Polymorphic relationships with `inverse` set to a string will only accept records with a matching\n  inverse relationships declaring itself as satisfying the abstract type.\n\n  Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'\n  for this relationship.\n\n  ```js\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;\n  }\n  ```\n\n  Note: every Model that declares an inverse to a polymorphic relationship must\n  declare itself exactly the same. This is because polymorphism is based on structural\n  traits.\n\n  Polymorphic to polymorphic relationships are supported. Both sides of the relationship\n  must be declared as polymorphic, and the `as` option must be used to declare the abstract\n  type each record satisfies on both sides.\n\n  @public\n  @param type the name of the related resource\n  @param options a hash of options\n*/\n\nexport function belongsTo(): never;\nexport function belongsTo(type: string): never;\nexport function belongsTo<T>(\n  type: TypeFromInstance<NoNull<T>>,\n  options: RelationshipOptions<T, boolean>\n): RelationshipDecorator<T>;\n// export function belongsTo<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(\n//   type: TypeFromInstance<NoNull<T>>,\n//   options: RelationshipOptions<T, true>\n// ): RelationshipDecorator<K>;\nexport function belongsTo(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;\nexport function belongsTo<T>(\n  type?: TypeFromInstance<NoNull<T>>,\n  options?: RelationshipOptions<T, boolean>\n): RelationshipDecorator<T> {\n  if (DEBUG) {\n    assert(\n      `belongsTo must be invoked with a type and options. Did you mean \\`@belongsTo(${type}, { async: false, inverse: null })\\`?`,\n      !isElementDescriptor(arguments as unknown as unknown[])\n    );\n  }\n  return _belongsTo(type!, options!);\n}\n","import { deprecate } from '@ember/debug';\nimport { computed } from '@ember/object';\n\nimport { DEPRECATE_NON_STRICT_TYPES } from '@warp-drive/core/build-config/deprecations';\nimport { DEBUG } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { assertPrivateStore } from '@warp-drive/core/store/-private';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport { RecordStore } from '@warp-drive/core/types/symbols';\nimport { dasherize, singularize } from '@warp-drive/utilities/string';\n\nimport type { NoNull, RelationshipDecorator, RelationshipOptions } from './belongs-to.ts';\nimport { lookupLegacySupport } from './legacy-relationships-support.ts';\nimport type { MinimalLegacyRecord } from './model-methods.ts';\n// oxlint-disable-next-line no-unused-vars\nimport type { Model } from './model.ts';\nimport { isElementDescriptor } from './util.ts';\n\nfunction normalizeType(type: string) {\n  if (DEPRECATE_NON_STRICT_TYPES) {\n    const result = singularize(dasherize(type));\n\n    deprecate(\n      `The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`,\n      result === type,\n      {\n        id: 'ember-data:deprecate-non-strict-types',\n        until: '6.0',\n        for: 'ember-data',\n        since: {\n          available: '4.13',\n          enabled: '5.3',\n        },\n      }\n    );\n\n    return result;\n  }\n\n  return type;\n}\n\nfunction _hasMany<T, Async extends boolean>(\n  type: string,\n  options: RelationshipOptions<T, Async>\n): RelationshipDecorator<T> {\n  assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');\n\n  // Metadata about relationships is stored on the meta of\n  // the relationship. This is used for introspection and\n  // serialization. Note that `key` is populated lazily\n  // the first time the CP is called.\n  const meta = {\n    type: normalizeType(type),\n    options,\n    kind: 'hasMany',\n    name: '<Unknown BelongsTo>',\n    sourceKey: options.sourceKey,\n  };\n\n  return computed({\n    get<R extends MinimalLegacyRecord>(this: R, key: string) {\n      if (DEBUG) {\n        if (['currentState'].includes(key)) {\n          throw new Error(\n            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`\n          );\n        }\n      }\n      if (this.isDestroying || this.isDestroyed) {\n        return [];\n      }\n      return lookupLegacySupport(this).getHasMany(key);\n    },\n    set<R extends MinimalLegacyRecord>(this: R, key: string, records: T[]) {\n      if (DEBUG) {\n        if (['currentState'].includes(key)) {\n          throw new Error(\n            `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`\n          );\n        }\n      }\n      const support = lookupLegacySupport(this);\n      const manyArray = support.getManyArray(key);\n      assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));\n\n      assertPrivateStore(this[RecordStore]);\n      this[RecordStore]._join(() => {\n        manyArray.splice(0, manyArray.length, ...records);\n      });\n\n      return support.getHasMany(key);\n    },\n  }).meta(meta);\n}\n\n/**\n  `hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None\n  relationships on a {@link Model}.\n\n  `hasMany` takes a configuration hash as a second parameter, currently\n  supported options are:\n\n  - `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.\n  - `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.\n  - `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic\n  - `as`: (*optional*) A string used to declare the abstract type \"this\" record satisfies for polymorphism.\n\n  ### Examples\n\n  To declare a **many-to-one** (or one-to-many) relationship, use\n  `belongsTo` in combination with `hasMany`:\n\n  ```js\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('comment', { async: false, inverse: 'post' }) comments;\n  }\n\n\n  // app/models/comment.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Comment extends Model {\n    @belongsTo('post', { async: false, inverse: 'comments' }) post;\n  }\n  ```\n\n  To declare a **many-to-many** relationship with managed inverses, use `hasMany` for both sides:\n\n  ```js\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('tag', { async: true, inverse: 'posts' }) tags;\n  }\n\n  // app/models/tag.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Tag extends Model {\n    @hasMany('post', { async: true, inverse: 'tags' }) posts;\n  }\n  ```\n\n  To declare a **many-to-many** relationship without managed inverses, use `hasMany` for both sides\n  with `null` as the inverse:\n\n  ```js\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('tag', { async: true, inverse: null }) tags;\n  }\n\n  // app/models/tag.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Tag extends Model {\n    @hasMany('post', { async: true, inverse: null }) posts;\n  }\n  ```\n\n  To declare a many-to-none relationship between two models, use\n  `hasMany` with inverse set to `null` on just one side::\n\n  ```js\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('category', { async: true, inverse: null }) categories;\n  }\n  ```\n\n  #### Sync vs Async Relationships\n\n  WarpDrive fulfills relationships using resource data available in\n  the cache.\n\n  Sync relationships point directly to the known related resources.\n\n  When a relationship is declared as async, if any of the known related\n  resources have not been loaded, they will be fetched. The property\n  on the record when accessed provides a promise that resolves once\n  all resources are loaded.\n\n  Async relationships may take advantage of links. On access, if the related\n  link has not been loaded, or if any known resources are not available in\n  the cache, the fresh state will be fetched using the link.\n\n  In contrast to async relationship, accessing a sync relationship\n  will error on access when any of the known related resources have\n  not been loaded.\n\n  If you are using `links` with sync relationships, you have to use\n  the HasMany reference API to fetch or refresh related resources\n  that aren't loaded. For instance, for a `comments` relationship:\n\n  ```js\n  post.hasMany('comments').reload();\n  ```\n\n  #### Polymorphic Relationships\n\n  To declare a polymorphic relationship, use `hasMany` with the `polymorphic`\n  option set to `true`:\n\n  ```js\n  // app/models/comment.js\n  import { Model, belongsTo } from '@warp-drive/legacy/model';\n\n  export default class Comment extends Model {\n    @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;\n  }\n  ```\n\n  `'commentable'` here is referred to as the \"abstract type\" for the polymorphic\n  relationship.\n\n  Polymorphic relationships with `inverse: null` will accept any type of record as their content.\n  Polymorphic relationships with `inverse` set to a string will only accept records with a matching\n  inverse relationships declaring itself as satisfying the abstract type.\n\n  Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'\n  for this relationship.\n\n  ```js\n  // app/models/post.js\n  import { Model, hasMany } from '@warp-drive/legacy/model';\n\n  export default class Post extends Model {\n    @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;\n  }\n  ```\n\n  Note: every Model that declares an inverse to a polymorphic relationship must\n  declare itself exactly the same. This is because polymorphism is based on structural\n  traits.\n\n  Polymorphic to polymorphic relationships are supported. Both sides of the relationship\n  must be declared as polymorphic, and the `as` option must be used to declare the abstract\n  type each record satisfies on both sides.\n\n  @public\n  @param type the name of the related resource\n  @param options a hash of options\n*/\nexport function hasMany(): never;\nexport function hasMany(type: string): never;\nexport function hasMany<T>(\n  type: TypeFromInstance<NoNull<T>>,\n  options: RelationshipOptions<T, boolean>\n): RelationshipDecorator<T>;\n// export function hasMany<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(\n//   type: TypeFromInstance<NoNull<T>>,\n//   options: RelationshipOptions<T, true>\n// ): RelationshipDecorator<K>;\nexport function hasMany(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;\nexport function hasMany<T>(\n  type?: TypeFromInstance<NoNull<T>>,\n  options?: RelationshipOptions<T, boolean>\n): RelationshipDecorator<T> {\n  if (DEBUG) {\n    assert(\n      `hasMany must be invoked with a type and options. Did you mean \\`@hasMany(${type}, { async: false, inverse: null })\\`?`,\n      !isElementDescriptor(arguments as unknown as unknown[])\n    );\n  }\n  return _hasMany(type!, options!);\n}\n","import { getOwner, setOwner } from '@ember/application';\n\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { assertPrivateStore, setRecordIdentifier, type Store, StoreMap } from '@warp-drive/core/store/-private';\nimport type { ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { TypeFromInstance, TypeFromInstanceOrString } from '@warp-drive/core/types/record';\n\nimport type { Model, ModelStore } from './model.ts';\nimport { getModelFactory } from './schema-provider.ts';\nimport { normalizeModelName } from './util.ts';\n\nfunction recast(context: Store): asserts context is ModelStore {}\n\n/**\n * The `instantiateRecord` hook implementation for use with `Model`. Pass\n * this to your store's `instantiateRecord` method when configuring the\n * store to use `Model` for schema/record instantiation.\n *\n * @public\n */\nexport function instantiateRecord(\n  this: Store,\n  identifier: ResourceKey,\n  createRecordArgs?: { [key: string]: unknown }\n): Model {\n  const type = identifier.type;\n\n  recast(this);\n\n  // TODO deprecate allowing unknown args setting\n  const createOptions = {\n    _createProps: createRecordArgs ?? {},\n    // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for\n    _secretInit: {\n      identifier,\n      store: this,\n      cb: secretInit,\n    },\n  };\n\n  // ensure that `getOwner(this)` works inside a model instance\n  setOwner(createOptions, getOwner(this)!);\n  const factory = getModelFactory(this, type);\n\n  assert(`No model was found for '${type}'`, factory);\n  return factory.class.create(createOptions);\n}\n\n/**\n * The `teardownRecord` hook implementation for use with `Model`. Pass this\n * to your store's `teardownRecord` method when configuring the store to\n * use `Model` for schema/record instantiation.\n *\n * @public\n */\nexport function teardownRecord(record: Model): void {\n  assert(\n    `expected to receive an instance of Model from @warp-drive/legacy/model. If using a custom model make sure you implement teardownRecord`,\n    'destroy' in record\n  );\n  record.destroy();\n}\n\n/**\n * The `modelFor` implementation for use with `Model`, exposed on the store\n * as `store.modelFor(type)` when the store is configured to use `Model`.\n * Returns the `Model` subclass registered for the given type, if any.\n *\n * @public\n */\nexport function modelFor<T>(type: TypeFromInstance<T>): typeof Model | void;\n/**\n * Overload accepting a raw type string instead of a typed record instance.\n *\n * @public\n */\nexport function modelFor(type: string): typeof Model | void;\nexport function modelFor<T>(this: Store, modelName: TypeFromInstanceOrString<T>): typeof Model | void {\n  assertPrivateStore(this);\n  assert(\n    `Attempted to call store.modelFor(), but the store instance has already been destroyed.`,\n    !this.isDestroyed && !this.isDestroying\n  );\n  assert(`You need to pass a model name to the store's modelFor method`, modelName);\n  assert(\n    `Please pass a proper model name to the store's modelFor method`,\n    typeof modelName === 'string' && modelName.length\n  );\n  recast(this);\n\n  const type = normalizeModelName(modelName);\n  const maybeFactory = getModelFactory(this, type);\n  const klass = maybeFactory && maybeFactory.class ? maybeFactory.class : null;\n\n  const ignoreType = !klass || !klass.isModel || this._forceShim;\n  if (!ignoreType) {\n    return klass;\n  }\n  assert(`No model was found for '${type}' and no schema handles the type`, this.schema.hasResource({ type }));\n}\n\nfunction secretInit(record: Model, identifier: ResourceKey, store: Store): void {\n  setRecordIdentifier(record, identifier);\n  StoreMap.set(record, store);\n}\n"],"mappings":"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"}