@ember-data-types/store 5.6.0-alpha.5 → 5.6.0-beta.1

package/unstable-preview-types/-types/q/schema-service.d.ts

@@ -1,334 +0,0 @@
-declare module '@ember-data/store/-types/q/schema-service' {
-  import type { StableRecordIdentifier } from '@warp-drive/core-types';
-  import type { RecordIdentifier } from '@warp-drive/core-types/identifier';
-  import type { ObjectValue } from '@warp-drive/core-types/json/raw';
-  import type { Derivation, HashFn, Transformation } from '@warp-drive/core-types/schema/concepts';
-  import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema } from '@warp-drive/core-types/schema/fields';
-  export type AttributesSchema = Record<string, LegacyAttributeField>;
-  export type RelationshipsSchema = Record<string, LegacyRelationshipField>;
-  interface ObjectWithStringTypeProperty {
-      type: string;
-  }
-  /**
-   * The SchemaService provides the ability to query for information about the structure
-   * of any resource type.
-   *
-   * Applications can provide any implementation of the SchemaService they please so long
-   * as it conforms to this interface.
-   *
-   * The design of the service means that schema information could be lazily populated,
-   * derived-on-demand, or progressively enhanced during the course of an application's runtime.
-   * The primary requirement is merely that any information the service needs to correctly
-   * respond to an inquest is available by the time it is asked.
-   *
-   * The `@ember-data/model` package provides an implementation of this service which
-   * makes use of your model classes as the source of information to respond to queries
-   * about resource schema. While this is useful, this may not be ideal for your application.
-   * For instance, Schema information could be sideloaded or pre-flighted for API calls,
-   * resulting in no need to bundle and ship potentially large and expensive JSON
-   * or large Javascript based Models to pull information from.
-   *
-   * To register a custom schema implementation, implement the store's `createSchemaService`
-   * hook to return an instance of your service.
-   *
-   * ```ts
-   * import Store from '@ember-data/store';
-   * import CustomSchemas from './custom-schemas';
-   *
-   * export default class extends Store {
-   *   createSchemaService() {
-   *     return new CustomSchemas();
-   *   }
-   * }
-   * ```
-   *
-   * At runtime, both the `Store` and the `CacheCapabilitiesManager` provide
-   * access to this service via the `schema` property.
-   *
-   * ```ts
-   * export default class extends Component {
-   *  @service store;
-   *
-   *  get fields() {
-   *    return this.store
-   *      .schema
-   *      .fields(this.args.dataType);
-   *  }
-   * }
-   * ```
-   *
-   * @class (Interface) SchemaService
-   * @public
-   */
-  export interface SchemaService {
-      /**
-       * DEPRECATED - use `hasResource` instead
-       *
-       * Queries whether the SchemaService recognizes `type` as a resource type
-       *
-       * @public
-       * @deprecated
-       * @param {String} type
-       * @return {Boolean}
-       */
-      doesTypeExist?(type: string): boolean;
-      /**
-       * Queries whether the SchemaService recognizes `type` as a resource type
-       *
-       * @public
-       * @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-       * @return {Boolean}
-       */
-      hasResource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): boolean;
-      /**
-       * Queries whether the SchemaService recognizes `type` as a resource trait
-       *
-       * @public
-       * @param {String} type
-       * @return {Boolean}
-       */
-      hasTrait(type: string): boolean;
-      /**
-       * Queries whether the given resource has the given trait
-       *
-       * @public
-       * @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-       * @param {String} trait
-       * @return {Boolean}
-       */
-      resourceHasTrait(resource: ObjectWithStringTypeProperty | StableRecordIdentifier, trait: string): boolean;
-      /**
-       * Queries for the fields of a given resource type or resource identity.
-       *
-       * Should error if the resource type is not recognized.
-       *
-       * @public
-       * @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-       * @return {Map<string, FieldSchema>}
-       */
-      fields(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Map<string, FieldSchema>;
-      /**
-       * Returns the transformation registered with the name provided
-       * by `field.type`. Validates that the field is a valid transformable.
-       *
-       * @public
-       * @param {TransformableField|ObjectWithStringTypeProperty} field
-       * @return {Transformation}
-       */
-      transformation(field: GenericField | ObjectField | ArrayField | ObjectWithStringTypeProperty): Transformation;
-      /**
-       * Returns the hash function registered with the name provided
-       * by `field.type`. Validates that the field is a valid HashField.
-       *
-       * @public
-       * @param {HashField|ObjectWithStringTypeProperty} field
-       * @return {HashFn}
-       */
-      hashFn(field: HashField | ObjectWithStringTypeProperty): HashFn;
-      /**
-       * Returns the derivation registered with the name provided
-       * by `field.type`. Validates that the field is a valid DerivedField.
-       *
-       * @public
-       * @param {DerivedField|ObjectWithStringTypeProperty} field
-       * @return {Derivation}
-       */
-      derivation(field: DerivedField | ObjectWithStringTypeProperty): Derivation;
-      /**
-       * Returns the schema for the provided resource type.
-       *
-       * @public
-       * @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-       * @return {ResourceSchema}
-       */
-      resource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Schema;
-      /**
-       * Enables registration of multiple Schemas at once.
-       *
-       * This can be useful for either pre-loading schema information
-       * or for registering schema information delivered by API calls
-       * or other sources just-in-time.
-       *
-       * @public
-       * @param {Schema[]} schemas
-       */
-      registerResources(schemas: Schema[]): void;
-      /**
-       * Enables registration of a single Schema representing either
-       * a resource in PolarisMode or LegacyMode or an ObjectSchema
-       * representing an embedded structure in other schemas.
-       *
-       * This can be useful for either pre-loading schema information
-       * or for registering schema information delivered by API calls
-       * or other sources just-in-time.
-       *
-       * @public
-       * @param {Schema} schema
-       */
-      registerResource(schema: Schema): void;
-      /**
-       * Enables registration of a transformation.
-       *
-       * The transformation can later be retrieved by the name
-       * attached to it's `[Type]` property.
-       *
-       * @public
-       * @param {Transformation} transform
-       */
-      registerTransformation(transform: Transformation): void;
-      /**
-       * Enables registration of a derivation.
-       *
-       * The derivation can later be retrieved by the name
-       * attached to it's `[Type]` property.
-       *
-       * @public
-       * @param {Derivation} derivation
-       */
-      registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
-      /**
-       * Enables registration of a hashing function
-       *
-       * The hashing function can later be retrieved by the name
-       * attached to it's `[Type]` property.
-       *
-       * @public
-       * @param {HashFn} hashfn
-       */
-      registerHashFn(hashFn: HashFn): void;
-      /**
-       * DEPRECATED - use `fields` instead
-       *
-       * Returns definitions for all properties of the specified resource
-       * that are considered "attributes". Generally these are properties
-       * that are not related to book-keeping state on the client and do
-       * not represent a linkage to another resource.
-       *
-       * The return value should be a dictionary of key:value pairs
-       * where the `key` is the attribute or property's name and `value`
-       * is an object with at least the property `name` which should also
-       * match `key`.
-       *
-       * Optionally, this object may also specify `type`, which should
-       * be a string reference to a `transform`, and `options` which
-       * should be dictionary in which any key:value pairs are permissable.
-       *
-       * For instance, when using `@ember-data/model`, the following attribute
-       * definition:
-       *
-       * ```ts
-       * class extends Model {
-       *   @attr('string', { defaultValue: 'hello' }) greeting;
-       *   @attr('date') birthday;
-       *   @attr firstName;
-       * }
-       * ```
-       *
-       * Would be returned as:
-       *
-       * ```js
-       * {
-       *   greeting: { name: 'greeting', type: 'string', options: { defaultValue: 'hello' } },
-       *   birthday: { name: 'birthday', type: 'date' },
-       *   firstName: { name: 'firstName' }
-       * }
-       * ```
-       *
-       * @public
-       * @deprecated
-       * @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
-       * @return {AttributesSchema}
-       */
-      attributesDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): AttributesSchema;
-      /**
-       * DEPRECATED - use `fields` instead
-       *
-       * Returns definitions for all properties of the specified resource
-       * that are considered "relationships". Generally these are properties
-       * that represent a linkage to another resource.
-       *
-       * The return value should be a dictionary of key:value pairs
-       * where the `key` is the relationship or property's name and `value`
-       * is an object with at least the following properties:
-       *
-       * - `name` which should also match the `key` used in the dictionary.
-       * - `kind` which should be either `belongsTo` or `hasMany`
-       * - `type` which should be the related resource's string "type"
-       * - `options` which should be a dictionary allowing any key but with
-       *    at least the below keys present.
-       *
-       * - `options.async` a boolean representing whether data for this relationship is
-       *      typically loaded on-demand.
-       * - `options.inverse` a string or null representing the field name / key of the
-       *       corresponding relationship on the inverse resource.
-       *
-       * Additionally the following options properties are optional. See [Polymorphic Relationships](https://rfcs.emberjs.com/id/0793-polymporphic-relations-without-inheritance)
-       *
-       * - `options.polymorphic` a boolean representing whether multiple resource types
-       *    can be used to satisfy this relationship.
-       * - `options.as` a string representing the abstract type that the concrete side of
-       *    a relationship must specify when fulfilling a polymorphic inverse.
-       *
-       * For example, the following Model using @ember-data/model would generate this relationships
-       * definition by default:
-       *
-       * ```js
-       * class User extends Model {
-       *   @belongsTo('user', { async: false, inverse: null }) bestFriend;
-       *   @hasMany('user', { async: true, inverse: 'friends' }) friends;
-       *   @hasMany('pet', { async: false, polymorphic: true, inverse: 'owner' }) pets;
-       * }
-       * ```
-       *
-       * Which would be returned as
-       *
-       * ```js
-       * {
-       *   bestFriend: {
-       *     name: 'bestFriend',
-       *     kind: 'belongsTo',
-       *     type: 'user',
-       *     options: {
-       *       async: false,
-       *       inverse: null
-       *     }
-       *   },
-       *   friends: {
-       *     name: 'friends',
-       *     kind: 'hasMany',
-       *     type: 'user',
-       *     options: {
-       *       async: true,
-       *       inverse: 'friends'
-       *     }
-       *   },
-       *   pets: {
-       *     name: 'pets',
-       *     kind: 'hasMany',
-       *     type: 'pet',
-       *     options: {
-       *       async: false,
-       *       polymorphic: true,
-       *       inverse: 'owner'
-       *     }
-       *   },
-       * }
-       * ```
-       *
-       * @public
-       * @deprecated
-       * @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
-       * @return {RelationshipsSchema}
-       */
-      relationshipsDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): RelationshipsSchema;
-      /**
-       * Returns all known resource types
-       *
-       * @public
-       * @return {String[]}
-       */
-      resourceTypes(): Readonly<string[]>;
-  }
-  export {};
-}
-//# sourceMappingURL=schema-service.d.ts.map

package/unstable-preview-types/-types/q/schema-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-service.d.ts","sourceRoot":"","sources":["../../../src/-types/q/schema-service.ts"],"names":[],"mappings":"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"}

package/unstable-preview-types/-types/q/store.d.ts

@@ -1,37 +0,0 @@
-declare module '@ember-data/store/-types/q/store' {
-  import type { Value } from '@warp-drive/core-types/json/raw';
-  import type { Includes, TypedRecordInstance } from '@warp-drive/core-types/record';
-  export interface BaseFinderOptions<T = unknown> {
-      reload?: boolean;
-      backgroundReload?: boolean;
-      include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
-      adapterOptions?: Record<string, unknown>;
-  }
-  export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
-      /**
-       * Data to preload into the store before the request is made.
-       * This feature is *highly* discouraged and has no corresponding
-       * feature when using builders and handlers.
-       *
-       * Excepting relationships: the data should be in the form of a
-       * JSON object where the keys are fields on the record and the value
-       * is the raw value to be added to the cache.
-       *
-       * Relationships can either be provided as string IDs from which
-       * an identifier will be built base upon the relationship's expected
-       * resource type, or be record instances from which the identifier
-       * will be extracted.
-       *
-       */
-      preload?: Record<string, Value>;
-  }
-  export type QueryOptions = {
-      [K in string | 'adapterOptions']?: K extends 'adapterOptions' ? Record<string, unknown> : unknown;
-  };
-  export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
-  export type LegacyResourceQuery<T = unknown> = {
-      include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
-      [key: string]: Value | undefined;
-  };
-}
-//# sourceMappingURL=store.d.ts.map

package/unstable-preview-types/-types/q/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/-types/q/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEnF,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,SAAS,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AACD,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAC1E;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,YAAY,GAAG;KACxB,CAAC,IAAI,MAAM,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;CAClG,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,mBAAmB,CAAC,CAAC,GAAG,OAAO,IAAI;IAC7C,OAAO,CAAC,EAAE,CAAC,SAAS,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5E,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;CAClC,CAAC"}

package/unstable-preview-types/configure.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;;;;;GAMG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,8CAA8C,CAAC"}

package/unstable-preview-types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmLG;AACH,OAAO,EACL,KAAK,IAAI,OAAO,EAChB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,mBAAmB,EACnB,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,gBAAgB,GACjB,MAAM,0CAA0C,CAAC;AAElD,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC"}

package/unstable-preview-types/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,GACf,MAAM,kBAAkB,CAAC"}