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

package/declarations/model/-private/has-many.d.ts

@@ -1,162 +0,0 @@
-import type { TypeFromInstance } from "@warp-drive/core/types/record";
-import type { NoNull, RelationshipDecorator, RelationshipOptions } from "./belongs-to.js";
-/**
-`hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None
-relationships on a {@link Model}.
-
-`hasMany` takes a configuration hash as a second parameter, currently
-supported options are:
-
-- `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.
-- `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
-- `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
-- `as`: (*optional*) A string used to declare the abstract type "this" record satisfies for polymorphism.
-
-### Examples
-
-To declare a **many-to-one** (or one-to-many) relationship, use
-`belongsTo` in combination with `hasMany`:
-
-```js
-// app/models/post.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Post extends Model {
-@hasMany('comment', { async: false, inverse: 'post' }) comments;
-}
-
-
-// app/models/comment.js
-import { Model, belongsTo } from '@warp-drive/legacy/model';
-
-export default class Comment extends Model {
-@belongsTo('post', { async: false, inverse: 'comments' }) post;
-}
-```
-
-To declare a **many-to-many** relationship with managed inverses, use `hasMany` for both sides:
-
-```js
-// app/models/post.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Post extends Model {
-@hasMany('tag', { async: true, inverse: 'posts' }) tags;
-}
-
-// app/models/tag.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Tag extends Model {
-@hasMany('post', { async: true, inverse: 'tags' }) posts;
-}
-```
-
-To declare a **many-to-many** relationship without managed inverses, use `hasMany` for both sides
-with `null` as the inverse:
-
-```js
-// app/models/post.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Post extends Model {
-@hasMany('tag', { async: true, inverse: null }) tags;
-}
-
-// app/models/tag.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Tag extends Model {
-@hasMany('post', { async: true, inverse: null }) posts;
-}
-```
-
-To declare a many-to-none relationship between two models, use
-`hasMany` with inverse set to `null` on just one side::
-
-```js
-// app/models/post.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Post extends Model {
-@hasMany('category', { async: true, inverse: null }) categories;
-}
-```
-
-#### Sync vs Async Relationships
-
-WarpDrive fulfills relationships using resource data available in
-the cache.
-
-Sync relationships point directly to the known related resources.
-
-When a relationship is declared as async, if any of the known related
-resources have not been loaded, they will be fetched. The property
-on the record when accessed provides a promise that resolves once
-all resources are loaded.
-
-Async relationships may take advantage of links. On access, if the related
-link has not been loaded, or if any known resources are not available in
-the cache, the fresh state will be fetched using the link.
-
-In contrast to async relationship, accessing a sync relationship
-will error on access when any of the known related resources have
-not been loaded.
-
-If you are using `links` with sync relationships, you have to use
-the HasMany reference API to fetch or refresh related resources
-that aren't loaded. For instance, for a `comments` relationship:
-
-```js
-post.hasMany('comments').reload();
-```
-
-#### Polymorphic Relationships
-
-To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
-option set to `true`:
-
-```js
-// app/models/comment.js
-import { Model, belongsTo } from '@warp-drive/legacy/model';
-
-export default class Comment extends Model {
-@belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
-}
-```
-
-`'commentable'` here is referred to as the "abstract type" for the polymorphic
-relationship.
-
-Polymorphic relationships with `inverse: null` will accept any type of record as their content.
-Polymorphic relationships with `inverse` set to a string will only accept records with a matching
-inverse relationships declaring itself as satisfying the abstract type.
-
-Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
-for this relationship.
-
-```js
-// app/models/post.js
-import { Model, hasMany } from '@warp-drive/legacy/model';
-
-export default class Post extends Model {
-@hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
-}
-```
-
-Note: every Model that declares an inverse to a polymorphic relationship must
-declare itself exactly the same. This is because polymorphism is based on structural
-traits.
-
-Polymorphic to polymorphic relationships are supported. Both sides of the relationship
-must be declared as polymorphic, and the `as` option must be used to declare the abstract
-type each record satisfies on both sides.
-
-@public
-@param type the name of the related resource
-@param options a hash of options
-*/
-export declare function hasMany(): never;
-export declare function hasMany(type: string): never;
-export declare function hasMany<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
-export declare function hasMany(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;

package/declarations/model/-private/hooks.d.ts

@@ -1,36 +0,0 @@
-import { type Store } from "@warp-drive/core/store/-private";
-import type { ResourceKey } from "@warp-drive/core/types/identifier";
-import type { TypeFromInstance } from "@warp-drive/core/types/record";
-import type { Model } from "./model.js";
-/**
-* The `instantiateRecord` hook implementation for use with `Model`. Pass
-* this to your store's `instantiateRecord` method when configuring the
-* store to use `Model` for schema/record instantiation.
-*
-* @public
-*/
-export declare function instantiateRecord(this: Store, identifier: ResourceKey, createRecordArgs?: {
-	[key: string]: unknown;
-}): Model;
-/**
-* The `teardownRecord` hook implementation for use with `Model`. Pass this
-* to your store's `teardownRecord` method when configuring the store to
-* use `Model` for schema/record instantiation.
-*
-* @public
-*/
-export declare function teardownRecord(record: Model): void;
-/**
-* The `modelFor` implementation for use with `Model`, exposed on the store
-* as `store.modelFor(type)` when the store is configured to use `Model`.
-* Returns the `Model` subclass registered for the given type, if any.
-*
-* @public
-*/
-export declare function modelFor<T>(type: TypeFromInstance<T>): typeof Model | void;
-/**
-* Overload accepting a raw type string instead of a typed record instance.
-*
-* @public
-*/
-export declare function modelFor(type: string): typeof Model | void;

package/declarations/model/-private/legacy-relationships-support.d.ts

@@ -1,47 +0,0 @@
-import type { Store } from "@warp-drive/core";
-import type { CollectionEdge, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { LegacyManyArray } from "@warp-drive/core/store/-private";
-import type { BaseFinderOptions, ResourceKey } from "@warp-drive/core/types";
-import type { CollectionRelationship } from "@warp-drive/core/types/cache/relationship";
-import type { LocalRelationshipOperation } from "@warp-drive/core/types/graph";
-import type { OpaqueRecordInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
-import type { CollectionResourceRelationship, InnerRelationshipDocument, SingleResourceRelationship } from "@warp-drive/core/types/spec/json-api-raw";
-import type { MinimalLegacyRecord } from "./model-methods.js";
-import type { BelongsToProxyCreateArgs } from "./promise-belongs-to.js";
-import { PromiseBelongsTo } from "./promise-belongs-to.js";
-import type { HasManyProxyCreateArgs } from "./promise-many-array.js";
-import { PromiseManyArray } from "./promise-many-array.js";
-import BelongsToReference from "./references/belongs-to.js";
-import HasManyReference from "./references/has-many.js";
-export declare const LEGACY_SUPPORT: Map<ResourceKey | MinimalLegacyRecord, LegacySupport>;
-export declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
-/**
-* @hideconstructor
-*/
-export declare class LegacySupport {
-	identifier: ResourceKey;
-	constructor(record: MinimalLegacyRecord, identifier: ResourceKey);
-	/** @private */
-	_syncArray(array: LegacyManyArray): void;
-	mutate(mutation: LocalRelationshipOperation): void;
-	_findBelongsTo(key: string, resource: SingleResourceRelationship, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
-	reloadBelongsTo(key: string, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
-	getBelongsTo(key: string, options?: BaseFinderOptions): PromiseBelongsTo | OpaqueRecordInstance | null;
-	setDirtyBelongsTo(key: string, value: OpaqueRecordInstance | null): void;
-	_getCurrentState<T>(identifier: ResourceKey, field: string): [ResourceKey<TypeFromInstanceOrString<T>>[], CollectionRelationship];
-	getManyArray<T>(key: string, definition?: UpgradedMeta): LegacyManyArray<T>;
-	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: LegacyManyArray, options?: BaseFinderOptions): Promise<LegacyManyArray>;
-	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<LegacyManyArray<T>> | PromiseManyArray<T>;
-	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | LegacyManyArray;
-	_updatePromiseProxyFor(kind: "hasMany", key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
-	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
-	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: {
-		promise: Promise<OpaqueRecordInstance | null>;
-	}): PromiseBelongsTo;
-	referenceFor(kind: "belongsTo", key: string): BelongsToReference;
-	referenceFor(kind: "hasMany", key: string): HasManyReference;
-	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: ResourceKey, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
-	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: ResourceKey, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<ResourceKey | null>;
-	destroy(): void;
-}
-export declare function areAllInverseRecordsLoaded(store: Store, resource: InnerRelationshipDocument): boolean;

package/declarations/model/-private/model-for-mixin.d.ts

@@ -1,3 +0,0 @@
-import type { Store } from "@warp-drive/core";
-import { type ModelFactory } from "./model.js";
-export default function modelForMixin(store: Store, normalizedModelName: string): ModelFactory | undefined;

package/declarations/model/-private/model-methods.d.ts

@@ -1,39 +0,0 @@
-import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import type { Snapshot } from "../../compat/-private.js";
-import type { Errors } from "./errors.js";
-import type RecordState from "./record-state.js";
-import type BelongsToReference from "./references/belongs-to.js";
-import type HasManyReference from "./references/has-many.js";
-import type { MaybeBelongsToFields, MaybeHasManyFields } from "./type-utils.js";
-export interface MinimalLegacyRecord {
-	errors: Errors;
-	currentState: RecordState;
-	isDestroyed: boolean;
-	isDestroying: boolean;
-	isReloading: boolean;
-	isValid: boolean;
-	deleteRecord(): void;
-	unloadRecord(): void;
-	save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
-	destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
-}
-export declare function rollbackAttributes<T extends MinimalLegacyRecord>(this: T): void;
-export declare function unloadRecord<T extends MinimalLegacyRecord>(this: T): void;
-export declare function belongsTo<
-	T extends MinimalLegacyRecord,
-	K extends MaybeBelongsToFields<T>
->(this: T, prop: K): BelongsToReference<T, K>;
-export declare function hasMany<
-	T extends MinimalLegacyRecord,
-	K extends MaybeHasManyFields<T>
->(this: T, prop: K): HasManyReference<T, K>;
-export declare function reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-export declare function _reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-export declare function changedAttributes<T extends MinimalLegacyRecord>(this: T): ChangedAttributesHash;
-export declare function serialize<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): unknown;
-export declare function deleteRecord<T extends MinimalLegacyRecord>(this: T): void;
-export declare function save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-export declare function _save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-export declare function destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-export declare function _destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-export declare function createSnapshot<T extends MinimalLegacyRecord>(this: T): Snapshot<T>;