@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

package/declarations/serializer/-private/transforms/boolean.d.ts

@@ -1,60 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface BooleanTransform {
-	/**
-	* see {@link TransformName}
-	*/
-	[TransformName]: "boolean";
-}
-/**
-The `BooleanTransform` class is used to serialize and deserialize
-boolean attributes on Ember Data record objects. This transform is
-used when `'boolean'` is passed as the type parameter to the
-{@link attr}function.
-
-Usage
-
-```js [app/models/user.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class UserModel extends Model {
-@attr('boolean') isAdmin;
-@attr('string') name;
-@attr('string') email;
-}
-```
-
-By default, the boolean transform only allows for values of `true` or
-`false`. You can opt into allowing `null` values for
-boolean attributes via `attr('boolean', { allowNull: true })`
-
-```js [app/models/user.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class UserModel extends Model {
-@attr('string') email;
-@attr('string') username;
-@attr('boolean', { allowNull: true }) wantsWeeklyEmail;
-}
-```
-
-@public
-*/
-export declare class BooleanTransform {
-	/**
-	* Converts a serialized (raw payload) value into a `boolean` (or `null`
-	* when `allowNull` is set and the value is nullish).
-	*/
-	deserialize(serialized: boolean | null | number | string, options?: {
-		allowNull?: boolean;
-	}): boolean | null;
-	/**
-	* Converts a `boolean` attribute value into its serialized (raw payload) form.
-	*/
-	serialize(deserialized: boolean | null, options?: {
-		allowNull?: boolean;
-	}): boolean | null;
-	/**
-	* Creates a new instance of this transform.
-	*/
-	static create(): BooleanTransform;
-}

package/declarations/serializer/-private/transforms/date.d.ts

@@ -1,42 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface DateTransform {
-	/**
-	* see {@link TransformName}
-	*/
-	[TransformName]: "date";
-}
-/**
-The `DateTransform` class is used to serialize and deserialize
-date attributes on Ember Data record objects. This transform is used
-when `'date'` is passed as the type parameter to the
-{@link attr} function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
-standard.
-
-```js [app/models/score.js]
-import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
-
-export default class ScoreModel extends Model {
-@attr('number') value;
-@belongsTo('player') player;
-@attr('date') date;
-}
-```
-
-@public
-*/
-export declare class DateTransform {
-	/**
-	* Converts a serialized (raw payload) `ISO 8601` string, epoch number,
-	* or nullish value into a `Date` (or `null`/`undefined`).
-	*/
-	deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
-	/**
-	* Converts a `Date` attribute value into an `ISO 8601` string, or `null`
-	* if the value is not a valid `Date`.
-	*/
-	serialize(date: Date, _options?: Record<string, unknown>): string | null;
-	/**
-	* Creates a new instance of this transform.
-	*/
-	static create(): DateTransform;
-}

package/declarations/serializer/-private/transforms/number.d.ts

@@ -1,42 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface NumberTransform {
-	/**
-	* see {@link TransformName}
-	*/
-	[TransformName]: "number";
-}
-/**
-The `NumberTransform` class is used to serialize and deserialize
-numeric attributes on Ember Data record objects. This transform is
-used when `number` is passed as the type parameter to the
-{@link attr} function.
-
-Usage
-
-```js [app/models/score.js]
-import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
-
-export default class ScoreModel extends Model {
-@attr('number') value;
-@belongsTo('player') player;
-@attr('date') date;
-}
-```
-
-@public
-*/
-export declare class NumberTransform {
-	/**
-	* Converts a serialized (raw payload) value into a `number`, or `null`
-	* if the value is empty, nullish, or not a valid number.
-	*/
-	deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
-	/**
-	* Converts a `number` attribute value into its serialized (raw payload) form.
-	*/
-	serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
-	/**
-	* Creates a new instance of this transform.
-	*/
-	static create(): NumberTransform;
-}

package/declarations/serializer/-private/transforms/string.d.ts

@@ -1,42 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface StringTransform {
-	/**
-	* see {@link TransformName}
-	*/
-	[TransformName]: "string";
-}
-/**
-The `StringTransform` class is used to serialize and deserialize
-string attributes on Ember Data record objects. This transform is
-used when `string` is passed as the type parameter to the
-{@link attr} function.
-
-Usage
-
-```js [app/models/user.js]
-import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
-
-export default class UserModel extends Model {
-@attr('boolean') isAdmin;
-@attr('string') name;
-@attr('string') email;
-}
-```
-
-@public
-*/
-export declare class StringTransform {
-	/**
-	* Converts a serialized (raw payload) value into a `string`, or `null`
-	* if the value is falsy (and not an empty string).
-	*/
-	deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
-	/**
-	* Converts a `string` attribute value into its serialized (raw payload) form.
-	*/
-	serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
-	/**
-	* Creates a new instance of this transform.
-	*/
-	static create(): StringTransform;
-}

package/declarations/serializer/-private/transforms/transform.d.ts

@@ -1,118 +0,0 @@
-import EmberObject from "@ember/object";
-import type { LegacyAttributeField } from "@warp-drive/core/types/schema/fields";
-export interface Transform {
-	/**
-	When given a deserialized value from a record attribute this
-	method must return the serialized value.
-	
-	Example
-	
-	```javascript
-	serialize(deserialized, options) {
-	return deserialized ? null : Number(deserialized);
-	}
-	```
-	
-	@public
-	@param deserialized The deserialized value
-	@param options hash of options passed to `attr`
-	@return The serialized value
-	*/
-	serialize(value: unknown, options: LegacyAttributeField["options"]): unknown;
-	/**
-	When given a serialized value from a JSON object this method must
-	return the deserialized value for the record attribute.
-	
-	Example
-	
-	```javascript
-	deserialize(serialized, options) {
-	return empty(serialized) ? null : Number(serialized);
-	}
-	```
-	
-	@public
-	@param serialized The serialized value
-	@param options hash of options passed to `attr`
-	@return The deserialized value
-	*/
-	deserialize(value: unknown, options: LegacyAttributeField["options"]): unknown;
-}
-/**
-The `Transform` class is used to serialize and deserialize model
-attributes when they are saved or loaded from an
-adapter. Subclassing `Transform` is useful for creating custom
-attributes. All subclasses of `Transform` must implement a
-`serialize` and a `deserialize` method.
-
-Example
-
-```js [app/transforms/temperature.js]
-
-// Converts centigrade in the JSON to fahrenheit in the app
-export default class TemperatureTransform {
-deserialize(serialized, options) {
-return (serialized *  1.8) + 32;
-}
-
-serialize(deserialized, options) {
-return (deserialized - 32) / 1.8;
-}
-
-static create() {
-return new this();
-}
-}
-```
-
-Usage
-
-```js [app/models/requirement.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class RequirementModel extends Model {
-@attr('string') name;
-@attr('temperature') temperature;
-}
-```
-
-The options passed into the `attr` function when the attribute is
-declared on the model is also available in the transform.
-
-```js [app/models/post.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class PostModel extends Model {
-@attr('string') title;
-@attr('markdown', {
-markdown: {
-gfm: false,
-sanitize: true
-}
-})
-markdown;
-}
-```
-
-```js [app/transforms/markdown.js]
-export default class MarkdownTransform {
-serialize(deserialized, options) {
-return deserialized.raw;
-}
-
-deserialize(serialized, options) {
-let markdownOptions = options.markdown || {};
-
-return marked(serialized, markdownOptions);
-}
-
-static create() {
-return new this();
-}
-}
-```
-
-@class Transform
-@public
-*/
-export declare const Transform: typeof EmberObject;

package/declarations/serializer/-private/utils.d.ts

@@ -1,27 +0,0 @@
-import type { Store } from "@warp-drive/core";
-import type { LegacyBelongsToField, LegacyHasManyField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
-type Coercable = string | number | boolean | null | undefined | symbol;
-export declare function coerceId(id: Coercable): string | null;
-/**
-Given the name of a relationship on a resource `type`, determines the
-inverse relationship field (if any) using only the schema service.
-
-Unlike `Model.inverseFor`, this does not require `type` to be backed by
-a `Model` class, so it works for both `Model`-based and schema-only
-(e.g. `withDefaults` migration-support) resources.
-
-@private
-*/
-export declare function inverseForRelationship(store: Store, type: string, name: string): LegacyRelationshipField | null;
-/**
-Given a relationship field on a resource `type`, determines the
-cardinality of the relationship using only the schema service.
-
-Unlike `Model.determineRelationshipType`, this does not require `type`
-to be backed by a `Model` class, so it works for both `Model`-based and
-schema-only (e.g. `withDefaults` migration-support) resources.
-
-@private
-*/
-export declare function determineRelationshipType(store: Store, type: string, knownSide: LegacyBelongsToField | LegacyHasManyField): "oneToOne" | "oneToMany" | "manyToOne" | "manyToMany" | "oneToNone" | "manyToNone";
-export {};

package/declarations/serializer/rest.d.ts

@@ -1,51 +0,0 @@
-/**
-* :::danger
-⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
-If starting a new app or thinking of implementing a new adapter, consider writing a
-{@link Handler} instead to be used with the {@link RequestManager}
-:::
-
-Normally, applications will use the `RESTSerializer` by implementing
-the `normalize` method.
-
-This allows you to do whatever kind of munging you need and is
-especially useful if your server is inconsistent and you need to
-do munging differently for many different kinds of responses.
-
-See the `normalize` documentation for more information.
-
-## Across the Board Normalization
-
-There are also a number of hooks that you might find useful to define
-across-the-board rules for your payload. These rules will be useful
-if your server is consistent, or if you're building an adapter for
-an infrastructure service, like Firebase, and want to encode service
-conventions.
-
-For example, if all of your keys are underscored and all-caps, but
-otherwise consistent with the names you use in your models, you
-can implement across-the-board rules for how to convert an attribute
-name in your model to a key in your JSON.
-
-```js [app/serializers/application.js]
-import { RESTSerializer } from '@warp-drive/legacy/serializer/rest';
-import { underscore } from '<app-name>/utils/string-utils';
-
-export default class ApplicationSerializer extends RESTSerializer {
-keyForAttribute(attr, method) {
-return underscore(attr).toUpperCase();
-}
-}
-```
-
-You can also implement `keyForRelationship`, which takes the name
-of the relationship as the first parameter, the kind of
-relationship (`hasMany` or `belongsTo`) as the second parameter, and
-the method (`serialize` or `deserialize`) as the third parameter.
-
-@class RESTSerializer
-@public
-*/
-declare const RESTSerializer: any;
-export { EmbeddedRecordsMixin } from "./-private/embedded-records-mixin.js";
-export { RESTSerializer };

package/declarations/serializer/transform.d.ts

@@ -1,5 +0,0 @@
-export { Transform } from "./-private/transforms/transform.js";
-export { BooleanTransform } from "./-private/transforms/boolean.js";
-export { DateTransform } from "./-private/transforms/date.js";
-export { NumberTransform } from "./-private/transforms/number.js";
-export { StringTransform } from "./-private/transforms/string.js";

package/declarations/serializer.d.ts

@@ -1,252 +0,0 @@
-/**
-## Overview
-
-:::danger
-⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
-If starting a new app or thinking of implementing a new serializer, consider writing a
-{@link Handler} instead to be used with the {@link RequestManager}
-:::
-
-In order to properly manage and present your data, WarpDrive
-needs to understand the structure of data it receives.
-
-`Serializers` convert data between the server's API format and
-the format WarpDrive understands.
-
-Data received from an API response is **normalized** into
-[{json:api}](https://jsonapi.org/) (the format used internally
-by WarpDrive), while data sent to an API is **serialized**
-into the format the API expects.
-
-### Implementing a Serializer
-
-There are only two required serializer methods, one for
-normalizing data from the server API format into {json:api}, and
-another for serializing records via `Snapshots` into the expected
-server API format.
-
-To implement a serializer, export a class that conforms to the structure
-described by {@link MinimumSerializerInterface}
-from the `app/serializers/` directory. An example is below.
-
-```ts
-import EmberObject from '@ember/object';
-
-export default class ApplicationSerializer extends EmberObject {
-normalizeResponse(store, schema, rawPayload) {
-return rawPayload;
-}
-
-serialize(snapshot, options) {
-const serializedResource = {
-id: snapshot.id,
-type: snapshot.modelName,
-attributes: snapshot.attributes()
-};
-
-return serializedResource;
-}
-}
-```
-
-
-### Serializer Resolution
-
-`store.serializerFor(name)` will lookup serializers defined in
-`app/serializers/` and return an instance. If no serializer is found, an
-error will be thrown.
-
-`serializerFor` first attempts to find a serializer with an exact match on `name`,
-then falls back to checking for the presence of a serializer named `application`.
-
-```ts
-store.serializerFor('author');
-
-// lookup paths (in order) =>
-//   app/serializers/author.js
-//   app/serializers/application.js
-```
-
-Most requests in `@warp-drive/legacy` are made with respect to a particular `type` (or `modelName`)
-(e.g., "get me the full collection of **books**" or "get me the **employee** whose id is 37"). We
-refer to this as the **primary** resource `type`.
-
-Typically `serializerFor` will be used to find a serializer with a name matching that of the primary
-resource `type` for the request, falling back to the `application` serializer for those types that
-do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy
-for defining serializers. However, because APIs rarely format payloads per-type but rather
-per-API-version, this may not be a desired strategy.
-
-It is recommended that applications define only a single `application` adapter and serializer
-where possible.
-
-If you have multiple API formats and the per-type strategy is not viable, one strategy is to
-write an `application` adapter and serializer that make use of `options` to specify the desired
-format when making a request.
-
-### Using a Serializer
-
-Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.
-
-### Default Serializers
-
-For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**
-format the `@warp-drive/legacy/serializer` package contains implementations these applications can
-extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.
-
-Many applications will find writing their own serializer to be more performant and less
-complex than extending these classes even when their API format is very close to that expected
-by these serializers.
-
-It is recommended that apps write their own serializer to best suit the needs of their API and
-application.
-
-@module
-*/
-import EmberObject from "@ember/object";
-import type { Store } from "@warp-drive/core";
-import type { ModelSchema } from "@warp-drive/core/types";
-import type { EmptyResourceDocument, SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
-/**
-> ⚠️ CAUTION you likely want the docs for {@link MinimumSerializerInterface}
-> as extending this abstract class is unnecessary.
-
-`Serializer` is an abstract base class that you may override in your
-application to customize it for your backend. The minimum set of methods
-that you should implement is:
-
-* `normalizeResponse()`
-* `serialize()`
-
-And you can optionally override the following methods:
-
-* `normalize()`
-
-For an example implementation, see the included {@link JSONSerializer}.
-
-@class Serializer
-@public
-*/
-export declare class Serializer extends EmberObject {
-	/**
-	The `store` property is the application's `store` that contains
-	all records. It can be used to look up serializers for other model
-	types that may be nested inside the payload response.
-	
-	Example:
-	
-	```js
-	Serializer.extend({
-	extractRelationship(relationshipModelName, relationshipHash) {
-	let modelClass = this.store.modelFor(relationshipModelName);
-	let relationshipSerializer = this.store.serializerFor(relationshipModelName);
-	return relationshipSerializer.normalize(modelClass, relationshipHash);
-	}
-	});
-	```
-	
-	@public
-	*/
-	store: Store;
-	/**
-	The `normalizeResponse` method is used to normalize a payload from the
-	server to a JSON-API Document.
-	
-	http://jsonapi.org/format/#document-structure
-	
-	Example:
-	
-	```js
-	Serializer.extend({
-	normalizeResponse(store, primaryModelClass, payload, id, requestType) {
-	if (requestType === 'findRecord') {
-	return this.normalize(primaryModelClass, payload);
-	} else {
-	return payload.reduce(function(documentHash, item) {
-	let { data, included } = this.normalize(primaryModelClass, item);
-	documentHash.included.push(...included);
-	documentHash.data.push(data);
-	return documentHash;
-	}, { data: [], included: [] })
-	}
-	}
-	});
-	```
-	
-	@since 1.13.0
-	@public
-	@param {Store} store
-	@param {Model} primaryModelClass
-	@param {Object} payload
-	@param {String|Number} id
-	@param {String} requestType
-	@return {Object} JSON-API Document
-	*/
-	/**
-	The `serialize` method is used when a record is saved in order to convert
-	the record into the form that your external data source expects.
-	
-	`serialize` takes an optional `options` hash with a single option:
-	
-	- `includeId`: If this is `true`, `serialize` should include the ID
-	in the serialized object it builds.
-	
-	Example:
-	
-	```js
-	Serializer.extend({
-	serialize(snapshot, options) {
-	let json = {
-	id: snapshot.id
-	};
-	
-	snapshot.eachAttribute((key, attribute) => {
-	json[key] = snapshot.attr(key);
-	});
-	
-	snapshot.eachRelationship((key, relationship) => {
-	if (relationship.kind === 'belongsTo') {
-	json[key] = snapshot.belongsTo(key, { id: true });
-	} else if (relationship.kind === 'hasMany') {
-	json[key] = snapshot.hasMany(key, { ids: true });
-	}
-	});
-	
-	return json;
-	},
-	});
-	```
-	
-	@public
-	@param {Snapshot} snapshot
-	@param {Object} [options]
-	@return {Object}
-	*/
-	/**
-	The `normalize` method is used to convert a payload received from your
-	external data source into the normalized form `store.push()` expects. You
-	should override this method, munge the hash and return the normalized
-	payload.
-	
-	Example:
-	
-	```js
-	Serializer.extend({
-	normalize(modelClass, resourceHash) {
-	let data = {
-	id:            resourceHash.id,
-	type:          modelClass.modelName,
-	attributes:    resourceHash
-	};
-	return { data: data };
-	}
-	})
-	```
-	
-	@public
-	@param _typeClass - the model class the hash is being normalized for
-	@param hash - the raw payload hash to normalize
-	@return the normalized resource document
-	*/
-	normalize(_typeClass: ModelSchema, hash: Record<string, unknown>): SingleResourceDocument | EmptyResourceDocument;
-}