@warp-drive/legacy 5.8.0-alpha.30 → 5.8.0-alpha.34

package/dist/unpkg/prod-deprecated/declarations/compat/-private.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from "@warp-drive/core";
+import type { CompatStore } from "../compat.js";
+/**
+* Utilities - often temporary - for maintaining backwards compatibility with
+* older parts of WarpDrive.
+*
+@module
+*/
+export { SnapshotRecordArray } from "./legacy-network-handler/snapshot-record-array.js";
+export { SaveOp } from "./legacy-network-handler/fetch-manager.js";
+export { FetchManager } from "./legacy-network-handler/fetch-manager.js";
+export { Snapshot } from "./legacy-network-handler/snapshot.js";
+export declare function upgradeStore(store: Store): asserts store is CompatStore;

package/dist/unpkg/prod-deprecated/declarations/compat/builders/find-all.d.ts

@@ -0,0 +1,35 @@
+import type { StoreRequestInput } from "@warp-drive/core";
+import type { FindAllOptions } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type FindAllRequestInput<
+	T extends string = string,
+	RT = unknown[]
+> = StoreRequestInput & {
+	op: "findAll";
+	data: {
+		type: T;
+		options: FindAllBuilderOptions;
+	};
+	[RequestSignature]?: RT;
+};
+type FindAllBuilderOptions = FindAllOptions;
+/**
+This function builds a request config to perform a `findAll` request for the given type.
+When passed to `store.request`, this config will result in the same behavior as a `store.findAll` request.
+Additionally, it takes the same options as `store.findAll`.
+
+All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of WarpDrive.
+
+@deprecated
+@public
+@param type the name of the resource
+@param query a query to be used by the adapter
+@param options optional, may include `adapterOptions` hash which will be passed to adapter.findAll
+@return request config
+*/
+export declare function findAllBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, options?: FindAllBuilderOptions): FindAllRequestInput<TypeFromInstance<T>, T[]>;
+export declare function findAllBuilder(type: string, options?: FindAllBuilderOptions): FindAllRequestInput;
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/builders/find-record.d.ts

@@ -0,0 +1,56 @@
+import type { StoreRequestInput } from "@warp-drive/core";
+import type { FindRecordOptions } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { ResourceIdentifierObject } from "@warp-drive/core/types/spec/json-api-raw";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type FindRecordRequestInput<
+	T extends string = string,
+	RT = unknown
+> = StoreRequestInput & {
+	op: "findRecord";
+	data: {
+		record: ResourceIdentifierObject<T>;
+		options: FindRecordBuilderOptions;
+	};
+	[RequestSignature]?: RT;
+};
+type FindRecordBuilderOptions = Omit<FindRecordOptions, "preload">;
+/**
+This function builds a request config to find the record for a given identifier or type and id combination.
+When passed to `store.request`, this config will result in the same behavior as a `store.findRecord` request.
+Additionally, it takes the same options as `store.findRecord`, with the exception of `preload` (which is unsupported).
+
+**Example 1**
+
+```ts
+import { findRecord } from '@warp-drive/legacy/compat/builders';
+const { content: post } = await store.request<Post>(findRecord<Post>('post', '1'));
+```
+
+**Example 2**
+
+`findRecord` can be called with a single identifier argument instead of the combination
+of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
+the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
+
+```ts
+import { findRecord } from '@warp-drive/legacy/compat/builders';
+const { content: post } = await store.request<Post>(findRecord<Post>({ type: 'post', id }));
+```
+
+All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Warp Drive.
+
+@deprecated
+@public
+@param resource - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
+@param id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
+@param options - if the first param is a string this will be the optional options for the request. See examples for available options.
+@return request config
+*/
+export declare function findRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, id: string, options?: FindRecordBuilderOptions): FindRecordRequestInput<TypeFromInstance<T>, T>;
+export declare function findRecordBuilder(type: string, id: string, options?: FindRecordBuilderOptions): FindRecordRequestInput;
+export declare function findRecordBuilder<T extends TypedRecordInstance>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, options?: FindRecordBuilderOptions): FindRecordRequestInput<TypeFromInstance<T>, T>;
+export declare function findRecordBuilder(resource: ResourceIdentifierObject, options?: FindRecordBuilderOptions): FindRecordRequestInput;
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/builders/query.d.ts

@@ -0,0 +1,66 @@
+import type { StoreRequestInput } from "@warp-drive/core";
+import type { LegacyResourceQuery, QueryOptions } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type QueryRequestInput<
+	T extends string = string,
+	RT = unknown[]
+> = StoreRequestInput & {
+	op: "query";
+	data: {
+		type: T;
+		query: LegacyResourceQuery;
+		options: QueryBuilderOptions;
+	};
+	[RequestSignature]?: RT;
+};
+type QueryBuilderOptions = QueryOptions;
+/**
+This function builds a request config for a given type and query object.
+When passed to `store.request`, this config will result in the same behavior as a `store.query` request.
+Additionally, it takes the same options as `store.query`.
+
+All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of WarpDrive.
+
+@deprecated
+@public
+@param type the name of the resource
+@param query a query to be used by the adapter
+@param options optional, may include `adapterOptions` hash which will be passed to adapter.query
+@return request config
+*/
+export declare function queryBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRequestInput<TypeFromInstance<T>, T[]>;
+export declare function queryBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRequestInput;
+type QueryRecordRequestInput<
+	T extends string = string,
+	RT = unknown
+> = StoreRequestInput & {
+	op: "queryRecord";
+	data: {
+		type: T;
+		query: LegacyResourceQuery;
+		options: QueryBuilderOptions;
+	};
+	[RequestSignature]?: RT;
+};
+/**
+This function builds a request config for a given type and query object.
+When passed to `store.request`, this config will result in the same behavior as a `store.queryRecord` request.
+Additionally, it takes the same options as `store.queryRecord`.
+
+All `@warp-drive/legacy/compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of WarpDrive.
+
+@deprecated
+@public
+@param type the name of the resource
+@param query a query to be used by the adapter
+@param options optional, may include `adapterOptions` hash which will be passed to adapter.query
+@return request config
+*/
+export declare function queryRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput<TypeFromInstance<T>, T | null>;
+export declare function queryRecordBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput;
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/builders/save-record.d.ts

@@ -0,0 +1,34 @@
+import { type StoreRequestInput } from "@warp-drive/core";
+import type { ResourceKey } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type SaveRecordRequestInput<
+	T extends string = string,
+	RT = unknown
+> = StoreRequestInput & {
+	op: "createRecord" | "deleteRecord" | "updateRecord";
+	data: {
+		record: ResourceKey<T>;
+		options: SaveRecordBuilderOptions;
+	};
+	records: [ResourceKey<T>];
+	[RequestSignature]?: RT;
+};
+type SaveRecordBuilderOptions = Record<string, unknown>;
+/**
+This function builds a request config for saving the given record (e.g. creating, updating, or deleting the record).
+When passed to `store.request`, this config will result in the same behavior as a legacy `store.saveRecord` request.
+Additionally, it takes the same options as `store.saveRecord`.
+
+All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+
+@deprecated
+@public
+@param {Object} record a record to save
+@param {SaveRecordBuilderOptions} options optional, may include `adapterOptions` hash which will be passed to adapter.saveRecord
+@return {SaveRecordRequestInput} request config
+*/
+export declare function saveRecordBuilder<T extends TypedRecordInstance>(record: T, options?: Record<string, unknown>): SaveRecordRequestInput<TypeFromInstance<T>, T>;
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/builders/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceIdentifierObject } from "@warp-drive/core/types/spec/json-api-raw";
+export declare function isMaybeIdentifier(maybeIdentifier: string | ResourceIdentifierObject): maybeIdentifier is ResourceIdentifierObject;
+export declare function normalizeModelName(type: string): string;

package/dist/unpkg/prod-deprecated/declarations/compat/builders.d.ts

@@ -0,0 +1,14 @@
+/**
+Builders for migrating from `store` methods to `store.request`.
+
+These builders enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+
+@module
+@deprecated
+*/
+export { findAllBuilder as findAll } from "./builders/find-all.js";
+export { findRecordBuilder as findRecord } from "./builders/find-record.js";
+export { queryBuilder as query, queryRecordBuilder as queryRecord } from "./builders/query.js";
+export { saveRecordBuilder as saveRecord } from "./builders/save-record.js";

package/dist/unpkg/prod-deprecated/declarations/compat/extensions.d.ts

@@ -0,0 +1,59 @@
+import { type default as EmberObject } from "@ember/object";
+import type { CAUTION_MEGA_DANGER_ZONE_Extension } from "@warp-drive/core/reactive";
+declare const EmberObjectMethods: readonly ["addObserver", "cacheFor", "decrementProperty", "get", "getProperties", "incrementProperty", "notifyPropertyChange", "removeObserver", "set", "setProperties", "toggleProperty"];
+export declare const EmberObjectArrayExtension: CAUTION_MEGA_DANGER_ZONE_Extension;
+export declare const EmberObjectExtension: CAUTION_MEGA_DANGER_ZONE_Extension;
+declare const EmberArrayLikeFeatures: {
+	addObject<T>(this: T[], obj: T): T[];
+	addObjects<T>(this: T[], objs: T[]): T[];
+	popObject<T>(this: T[]): T | undefined;
+	pushObject<T>(this: T[], obj: T): T;
+	pushObjects<T>(this: T[], objs: T[]): T[];
+	shiftObject<T>(this: T[]): NonNullable<T>;
+	unshiftObject<T>(this: T[], obj: T): T;
+	unshiftObjects<T>(this: T[], objs: T[]): T[];
+	objectAt<T>(this: T[], index: number): T;
+	objectsAt<T>(this: T[], indices: number[]): T[];
+	removeAt<T>(this: T[], index: number): T[];
+	insertAt<T>(this: T[], index: number, obj: T): T[];
+	removeObject<T>(this: T[], obj: T): T[];
+	removeObjects<T>(this: T[], objs: T[]): T[];
+	toArray<T>(this: T[]): T[];
+	replace<T>(this: T[], idx: number, amt: number, objects?: T[]): void;
+	clear<T>(this: T[]): T[];
+	setObjects<T>(this: T[], objects: T[]): T[];
+	reverseObjects<T>(this: T[]): T[];
+	compact<T>(this: T[]): (T & {})[];
+	any<T>(this: T[], callback: Parameters<Array<T>["some"]>[0], target?: unknown): boolean;
+	isAny<T>(this: T[], prop: string, value: unknown): boolean;
+	isEvery<T>(this: T[], prop: string, value: unknown): boolean;
+	getEach<T>(this: T[], key: string): unknown[];
+	mapBy<T>(this: T[], key: string): unknown[];
+	findBy<T>(this: T[], key: string, value?: unknown): T | undefined;
+	filterBy<T>(this: T[], key: string, value?: unknown): T[];
+	sortBy<T>(this: T[], ...sortKeys: string[]): T[];
+	invoke<T>(this: T[], key: string, ...args: unknown[]): unknown[];
+	addArrayObserver<T>(this: T[]): void;
+	removeArrayObserver<T>(this: T[]): void;
+	arrayContentWillChange<T>(this: T[]): void;
+	arrayContentDidChange<T>(this: T[]): void;
+	reject<T>(this: T[], callback: Parameters<Array<T>["filter"]>[0], target?: unknown): T[];
+	rejectBy<T>(this: T[], key: string, value?: unknown): T[];
+	setEach<T>(this: T[], key: string, value: unknown): void;
+	uniq<T>(this: T[]): T[];
+	uniqBy<T>(this: T[], key: string): T[];
+	without<T>(this: T[], value: T): T[];
+	firstObject: unknown;
+	lastObject: unknown;
+};
+export declare const EmberArrayLikeExtension: CAUTION_MEGA_DANGER_ZONE_Extension;
+export type ArrayType<T> = T extends ReadonlyArray<infer U> ? U : never;
+export type WithEmberObject<T> = T & Pick<T & EmberObject, ArrayType<typeof EmberObjectMethods>>;
+export type WithArrayLike<T> = T extends Array<infer U> ? U & Omit<typeof EmberArrayLikeFeatures, "firstObject" | "lastObject"> & {
+	firstObject: T | undefined;
+	lastObject: T | undefined;
+} : T[] & Omit<typeof EmberArrayLikeFeatures, "firstObject" | "lastObject"> & {
+	firstObject: T | undefined;
+	lastObject: T | undefined;
+};
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/legacy-network-handler/fetch-manager.d.ts

@@ -0,0 +1,55 @@
+import type { Store } from "@warp-drive/core";
+import { createDeferred } from "@warp-drive/core/request";
+import type { Request } from "@warp-drive/core/store/-private";
+import type { FindRecordOptions } from "@warp-drive/core/types";
+import type { PersistedResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
+import type { TypeFromInstance } from "@warp-drive/core/types/record";
+import type { ImmutableRequestInfo } from "@warp-drive/core/types/request";
+import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
+import { Snapshot } from "./snapshot.js";
+type Deferred<T> = ReturnType<typeof createDeferred<T>>;
+export declare const SaveOp: "___(unique) Symbol(SaveOp)";
+export type FetchMutationOptions = FindRecordOptions & {
+	[SaveOp]: "createRecord" | "deleteRecord" | "updateRecord";
+};
+interface PendingFetchItem {
+	identifier: PersistedResourceKey;
+	queryRequest: Request;
+	resolver: Deferred<any>;
+	options: FindRecordOptions;
+	trace?: unknown;
+	promise: Promise<PersistedResourceKey>;
+}
+/**
+* @private
+*/
+export declare class FetchManager {
+	constructor(store: Store);
+	createSnapshot<T>(identifier: ResourceKey<TypeFromInstance<T>>, options?: FindRecordOptions): Snapshot<T>;
+	createSnapshot(identifier: ResourceKey, options?: FindRecordOptions): Snapshot;
+	/**
+	This method is called by `record.save`, and gets passed a
+	resolver for the promise that `record.save` returns.
+	
+	It schedules saving to happen at the end of the run loop.
+	
+	@private
+	*/
+	scheduleSave(identifier: ResourceKey, options: FetchMutationOptions): Promise<null | SingleResourceDocument>;
+	scheduleFetch(identifier: PersistedResourceKey, options: FindRecordOptions, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
+	getPendingFetch(identifier: PersistedResourceKey, options: FindRecordOptions): Promise<PersistedResourceKey> | undefined;
+	flushAllPendingFetches(): void;
+	fetchDataIfNeededForIdentifier(identifier: PersistedResourceKey, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
+	destroy(): void;
+}
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateFetchManager extends FetchManager {
+	_pendingFetch: Map<string, Map<PersistedResourceKey, PendingFetchItem[]>>;
+}
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/legacy-network-handler/identifier-has-id.d.ts

@@ -0,0 +1,2 @@
+import type { PersistedResourceKey } from "@warp-drive/core/types/identifier";
+export declare function assertIdentifierHasId(identifier: unknown): asserts identifier is PersistedResourceKey;

package/dist/unpkg/prod-deprecated/declarations/compat/legacy-network-handler/legacy-data-fetch.d.ts

@@ -0,0 +1,11 @@
+import type { Store } from "@warp-drive/core";
+import type { BaseFinderOptions } from "@warp-drive/core/types";
+import type { PersistedResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
+import type { LegacyRelationshipField as RelationshipSchema } from "@warp-drive/core/types/schema/fields";
+import type { MinimumAdapterInterface } from "./minimum-adapter-interface.js";
+export declare function _findHasMany(adapter: MinimumAdapterInterface, store: Store, identifier: ResourceKey, link: string | null | {
+	href: string;
+}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<PersistedResourceKey[]>;
+export declare function _findBelongsTo(store: Store, identifier: ResourceKey, link: string | null | {
+	href: string;
+}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<PersistedResourceKey | null>;

package/dist/unpkg/prod-deprecated/declarations/compat/legacy-network-handler/legacy-data-utils.d.ts

@@ -0,0 +1,5 @@
+import type { AdapterPayload } from "./minimum-adapter-interface.js";
+type IteratorCB<T> = ((o: T, index: number) => T) | ((o: T) => T);
+export declare function iterateData<T>(data: T[] | T, fn: IteratorCB<T>): T | T[];
+export declare function payloadIsNotBlank<T>(adapterPayload: T | AdapterPayload): adapterPayload is AdapterPayload;
+export {};

package/dist/unpkg/prod-deprecated/declarations/compat/legacy-network-handler/legacy-network-handler.d.ts

@@ -0,0 +1,2 @@
+import type { Handler } from "@warp-drive/core/request";
+export declare const LegacyNetworkHandler: Handler;