@warp-drive/core 5.7.0-alpha.3 → 5.7.0-alpha.31

package/declarations/store/-private/record-arrays/identifier-array.d.ts

@@ -1,147 +0,0 @@
-import type { BaseFinderOptions } from "../../../types.js";
-import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
-import type { TypeFromInstanceOrString } from "../../../types/record.js";
-import type { ImmutableRequestInfo } from "../../../types/request.js";
-import type { LegacyHasManyField, LinksModeHasManyField } from "../../../types/schema/fields.js";
-import type { Links, PaginationLinks } from "../../../types/spec/json-api-raw.js";
-import type { RecordArrayManager } from "../managers/record-array-manager.js";
-import type { WarpDriveSignal } from "../new-core-tmp/reactivity/internal.js";
-import { ARRAY_SIGNAL } from "../new-core-tmp/reactivity/internal.js";
-import type { Store } from "../store-service.js";
-import { NativeProxy } from "./native-proxy-type-fix.js";
-export declare const SOURCE: "___(unique) Symbol(#source)";
-export declare const MUTATE: "___(unique) Symbol(#update)";
-declare const IS_COLLECTION: "___(unique) Symbol(IS_COLLECTION)";
-export type IdentifierArrayCreateOptions<T = unknown> = {
-	identifiers: StableRecordIdentifier<TypeFromInstanceOrString<T>>[];
-	type?: TypeFromInstanceOrString<T>;
-	store: Store;
-	allowMutation: boolean;
-	manager: MinimumManager;
-	field?: LegacyHasManyField | LinksModeHasManyField;
-	links?: Links | PaginationLinks | null;
-	meta?: Record<string, unknown> | null;
-	identifier?: StableDocumentIdentifier | null;
-	[MUTATE]?(target: StableRecordIdentifier[], receiver: typeof NativeProxy<StableRecordIdentifier[], T[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal): unknown;
-};
-type PromiseTo<T> = Omit<Promise<T>, typeof Symbol.toStringTag>;
-type PromiseManyArray<T> = {
-	length: number;
-	content: IdentifierArray<T> | null;
-	promise: Promise<IdentifierArray<T>> | null;
-} & PromiseTo<IdentifierArray<T>>;
-export type MinimumManager = {
-	_syncArray: (array: IdentifierArray) => void;
-	mutate?(mutation: LocalRelationshipOperation): void;
-	reloadHasMany?<T>(key: string, options?: BaseFinderOptions): Promise<IdentifierArray<T>> | PromiseManyArray<T>;
-};
-/**
-A record array is an array that contains records of a certain type (or modelName).
-The record array materializes records as needed when they are retrieved for the first
-time. You should not create record arrays yourself. Instead, an instance of
-`RecordArray` or its subclasses will be returned by your application's store
-in response to queries.
-
-This class should not be imported and instantiated by consuming applications.
-
-@class RecordArray
-@public
-*/
-export interface IdentifierArray<T = unknown> extends Omit<Array<T>, "[]"> {
-	[IS_COLLECTION]: boolean;
-	[ARRAY_SIGNAL]: WarpDriveSignal;
-	[SOURCE]: StableRecordIdentifier[];
-}
-export declare class IdentifierArray<T = unknown> {
-	DEPRECATED_CLASS_NAME: string;
-	/**
-	The flag to signal a `RecordArray` is currently loading data.
-	Example
-	```javascript
-	let people = store.peekAll('person');
-	people.isUpdating; // false
-	people.update();
-	people.isUpdating; // true
-	```
-	@property isUpdating
-	@public
-	@type Boolean
-	*/
-	isUpdating: boolean;
-	isLoaded: boolean;
-	isDestroying: boolean;
-	isDestroyed: boolean;
-	_updatingPromise: Promise<IdentifierArray<T>> | null;
-	readonly identifier: StableDocumentIdentifier | null;
-	links: Links | PaginationLinks | null;
-	meta: Record<string, unknown> | null;
-	modelName?: TypeFromInstanceOrString<T>;
-	/**
-	The store that created this record array.
-	
-	@property store
-	@private
-	@type Store
-	*/
-	store: Store;
-	_manager: MinimumManager;
-	destroy(clear: boolean): void;
-	constructor(options: IdentifierArrayCreateOptions<T>);
-	/**
-	Used to get the latest version of all of the records in this array
-	from the adapter.
-	
-	Example
-	
-	```javascript
-	let people = store.peekAll('person');
-	people.isUpdating; // false
-	
-	people.update().then(function() {
-	people.isUpdating; // false
-	});
-	
-	people.isUpdating; // true
-	```
-	
-	@public
-	*/
-	update(): Promise<IdentifierArray<T>>;
-	/*
-	Update this Array and return a promise which resolves once the update
-	is finished.
-	*/
-	_update(): Promise<IdentifierArray<T>>;
-	// TODO deprecate
-	/**
-	Saves all of the records in the `RecordArray`.
-	
-	Example
-	
-	```javascript
-	let messages = store.peekAll('message');
-	messages.forEach(function(message) {
-	message.hasBeenSeen = true;
-	});
-	messages.save();
-	```
-	
-	@public
-	@return {Promise<IdentifierArray>} promise
-	*/
-	save(): Promise<IdentifierArray>;
-}
-export type CollectionCreateOptions = IdentifierArrayCreateOptions & {
-	manager: RecordArrayManager;
-	query: ImmutableRequestInfo | Record<string, unknown> | null;
-	isLoaded: boolean;
-};
-export declare class Collection<T = unknown> extends IdentifierArray<T> {
-	query: ImmutableRequestInfo | Record<string, unknown> | null;
-	_manager: RecordArrayManager;
-	constructor(options: CollectionCreateOptions);
-	_update(): Promise<Collection<T>>;
-	destroy(clear: boolean): void;
-}
-export {};

package/declarations/store/-private/record-arrays/many-array.d.ts

@@ -1,197 +0,0 @@
-import type { BaseFinderOptions, ModelSchema, StableRecordIdentifier } from "../../../types.js";
-import type { Cache } from "../../../types/cache.js";
-import type { TypedRecordInstance, TypeFromInstance, TypeFromInstanceOrString } from "../../../types/record.js";
-import type { LegacyHasManyField, LinksModeHasManyField } from "../../../types/schema/fields.js";
-import type { Links, PaginationLinks } from "../../../types/spec/json-api-raw.js";
-import type { CreateRecordProperties, Store } from "../store-service.js";
-import type { MinimumManager } from "./identifier-array.js";
-import { IdentifierArray } from "./identifier-array.js";
-export interface ManyArrayCreateArgs<T> {
-	identifiers: StableRecordIdentifier<TypeFromInstanceOrString<T>>[];
-	type: TypeFromInstanceOrString<T>;
-	store: Store;
-	allowMutation: boolean;
-	manager: MinimumManager;
-	field?: LegacyHasManyField | LinksModeHasManyField;
-	identifier: StableRecordIdentifier;
-	cache: Cache;
-	meta: Record<string, unknown> | null;
-	links: Links | PaginationLinks | null;
-	key: string;
-	isPolymorphic: boolean;
-	isAsync: boolean;
-	_inverseIsAsync: boolean;
-	isLoaded: boolean;
-}
-/**
-A `ManyArray` is a `MutableArray` that represents the contents of a has-many
-relationship.
-
-The `ManyArray` is instantiated lazily the first time the relationship is
-requested.
-
-This class is not intended to be directly instantiated by consuming applications.
-
-### Inverses
-
-Often, the relationships in Ember Data applications will have
-an inverse. For example, imagine the following models are
-defined:
-
-```js [app/models/post.js]
-import Model, { hasMany } from '@ember-data/model';
-
-export default class PostModel extends Model {
-@hasMany('comment') comments;
-}
-```
-
-```js [app/models/comment.js]
-import { Model, belongsTo } from '@warp-drive/legacy/model';
-
-export default class CommentModel extends Model {
-@belongsTo('post') post;
-}
-```
-
-If you created a new instance of `Post` and added
-a `Comment` record to its `comments` has-many
-relationship, you would expect the comment's `post`
-property to be set to the post that contained
-the has-many.
-
-We call the record to which a relationship belongs-to the
-relationship's _owner_.
-
-@class ManyArray
-@public
-*/
-export declare class RelatedCollection<T = unknown> extends IdentifierArray<T> {
-	isAsync: boolean;
-	/**
-	The loading state of this array
-	
-	@property isLoaded
-	@type {Boolean}
-	@public
-	*/
-	isLoaded: boolean;
-	/**
-	`true` if the relationship is polymorphic, `false` otherwise.
-	
-	@property isPolymorphic
-	@type {Boolean}
-	@private
-	*/
-	isPolymorphic: boolean;
-	_inverseIsAsync: boolean;
-	/**
-	Metadata associated with the request for async hasMany relationships.
-	
-	Example
-	
-	Given that the server returns the following JSON payload when fetching a
-	hasMany relationship:
-	
-	```js
-	{
-	"comments": [{
-	"id": 1,
-	"comment": "This is the first comment",
-	}, {
-	// ...
-	}],
-	
-	"meta": {
-	"page": 1,
-	"total": 5
-	}
-	}
-	```
-	
-	You can then access the meta data via the `meta` property:
-	
-	```js
-	let comments = await post.comments;
-	let meta = comments.meta;
-	
-	// meta.page => 1
-	// meta.total => 5
-	```
-	
-	@property meta
-	@type {Object | null}
-	@public
-	*/
-	meta: Record<string, unknown> | null;
-	/**
-	* Retrieve the links for this relationship
-	*
-	@property links
-	@type {Object | null}
-	@public
-	*/
-	links: Links | PaginationLinks | null;
-	identifier: StableRecordIdentifier;
-	cache: Cache;
-	_manager: MinimumManager;
-	store: Store;
-	key: string;
-	type: ModelSchema;
-	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
-	constructor(options: ManyArrayCreateArgs<T>);
-	notify(): void;
-	/**
-	Reloads all of the records in the manyArray. If the manyArray
-	holds a relationship that was originally fetched using a links url
-	WarpDrive will revisit the original links url to repopulate the
-	relationship.
-	
-	If the ManyArray holds the result of a `store.query()` reload will
-	re-run the original query.
-	
-	Example
-	
-	```javascript
-	let user = store.peekRecord('user', '1')
-	await login(user);
-	
-	let permissions = await user.permissions;
-	await permissions.reload();
-	```
-	
-	@public
-	*/
-	reload(options?: BaseFinderOptions): Promise<this>;
-	/**
-	Create a child record within the owner
-	
-	@public
-	@param {Object} hash
-	@return {Model} record
-	*/
-	createRecord(hash: CreateRecordProperties<T>): T;
-	/**
-	Saves all of the records in the `ManyArray`.
-	
-	Note: this API can only be used in legacy mode with a configured Adapter.
-	
-	Example
-	
-	```javascript
-	const { content: { data: inbox } } = await store.request(findRecord({ type: 'inbox', id: '1' }));
-	
-	let messages = await inbox.messages;
-	messages.forEach((message) => {
-	message.isRead = true;
-	});
-	messages.save();
-	```
-	
-	@public
-	@return {PromiseArray} promise
-	*/
-	save: () => Promise<IdentifierArray<T>>;
-	/** @internal */
-	destroy(): void;
-}

package/dist/handler-D2jjnIA-.js

@@ -1,339 +0,0 @@
-import { K as ReactiveDocument } from "./request-state-CejVJgdj.js";
-import { SkipCache, EnableHydration } from './types/request.js';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
-const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
-function calcShouldFetch(store, request, hasCachedValue, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
-}
-function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
-}
-function isMutation(request) {
-  return Boolean(request.op && MUTATION_OPS.has(request.op));
-}
-function isCacheAffecting(document) {
-  if (!isMutation(document.request)) {
-    return true;
-  }
-  // a mutation combined with a 204 has no cache impact when no known records were involved
-  // a createRecord with a 201 with an empty response and no known records should similarly
-  // have no cache impact
-
-  if (document.request.op === 'createRecord' && document.response?.status === 201) {
-    return document.content ? Object.keys(document.content).length > 0 : false;
-  }
-  return document.response?.status !== 204;
-}
-function isAggregateError(error) {
-  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
-}
-// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
-function cloneError(error) {
-  const isAggregate = isAggregateError(error);
-  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
-  cloned.stack = error.stack;
-  cloned.error = error.error;
-
-  // copy over enumerable properties
-  Object.assign(cloned, error);
-  return cloned;
-}
-function getPriority(identifier, deduped, priority) {
-  if (identifier) {
-    const existing = deduped.get(identifier);
-    if (existing) {
-      return existing.priority;
-    }
-  }
-  return priority;
-}
-
-/**
- * A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
- *
- * This handler will only run when a request has supplied a `store` instance. Requests
- * issued by the store via `store.request()` will automatically have the `store` instance
- * attached to the request.
- *
- * ```ts
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET'
- * });
- * ```
- *
- * When this handler elects to handle a request, it will return the raw `StructuredDocument`
- * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
- * return a `Document` instance that will automatically update the UI when the cache is updated
- * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
- *
- * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
- * means that if desired you can issue requests that utilize the cache without needing to also
- * utilize Record instances if desired.
- *
- * Said differently, you could elect to issue all requests via a RequestManager, without ever using
- * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
- * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
- * approach of WarpDrive allows for this flexibility.
- *
- * ```ts
- * import { EnableHydration } from '@warp-drive/core/types/request';
- *
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET',
- *   [EnableHydration]: true
- * });
- *
- */
-const CacheHandler = {
-  request(context, next) {
-    // if we have no cache or no cache-key skip cache handling
-    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
-    if (identifier) {
-      context.setIdentifier(identifier);
-    }
-
-    // used to dedupe existing requests that match
-    const DEDUPE = store.requestManager._deduped;
-    const activeRequest = identifier && DEDUPE.get(identifier);
-    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
-
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
-      if (activeRequest) {
-        activeRequest.priority = {
-          blocking: true
-        };
-        return activeRequest.promise;
-      }
-      let promise = fetchContentAndHydrate(next, context, identifier, {
-        blocking: true
-      });
-      if (identifier) {
-        promise = promise.finally(() => {
-          DEDUPE.delete(identifier);
-          store.notifications.notify(identifier, 'state');
-        });
-        DEDUPE.set(identifier, {
-          priority: {
-            blocking: true
-          },
-          promise
-        });
-        store.notifications.notify(identifier, 'state');
-      }
-      return promise;
-    }
-
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
-      let promise = activeRequest?.promise || fetchContentAndHydrate(next, context, identifier, {
-        blocking: false
-      });
-      if (identifier && !activeRequest) {
-        promise = promise.finally(() => {
-          DEDUPE.delete(identifier);
-          store.notifications.notify(identifier, 'state');
-        });
-        DEDUPE.set(identifier, {
-          priority: {
-            blocking: false
-          },
-          promise
-        });
-        store.notifications.notify(identifier, 'state');
-      }
-      store.requestManager._pending.set(context.id, promise);
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected a peeked request to be present`);
-      }
-    })(peeked) : {};
-    const shouldHydrate = context.request[EnableHydration] || false;
-    context.setResponse(peeked.response);
-    if ('error' in peeked) {
-      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        identifier
-      }, peeked.content) : peeked.content;
-      const newError = cloneError(peeked);
-      newError.content = content;
-      throw newError;
-    }
-    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-      shouldHydrate,
-      identifier
-    }, peeked.content) : peeked.content;
-    return result;
-  }
-};
-function maybeUpdateUiObjects(store, request, options, document) {
-  const {
-    identifier
-  } = options;
-  if (!document || !options.shouldHydrate) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`The CacheHandler expected response content but none was found`);
-      }
-    })(!options.shouldHydrate) : {};
-    return document ?? null;
-  }
-  if (identifier) {
-    return store._instanceCache.getDocument(identifier);
-  }
-
-  // if we don't have an identifier, we give the document
-  // its own local cache
-  return new ReactiveDocument(store, null, {
-    request,
-    document
-  });
-}
-function updateCacheForSuccess(store, request, options, document) {
-  let response = null;
-  if (isMutation(request)) {
-    const record = request.data?.record || request.records?.[0];
-    if (record) {
-      response = store.cache.didCommit(record, document);
-
-      // a mutation combined with a 204 has no cache impact when no known records were involved
-      // a createRecord with a 201 with an empty response and no known records should similarly
-      // have no cache impact
-    } else if (isCacheAffecting(document)) {
-      response = store.cache.put(document);
-    }
-  } else {
-    response = store.cache.put(document);
-  }
-  return maybeUpdateUiObjects(store, request, options, response);
-}
-function handleFetchSuccess(store, context, options, document) {
-  const {
-    request
-  } = context;
-  store.requestManager._pending.delete(context.id);
-  store._enableAsyncFlush = true;
-  let response;
-  store._join(() => {
-    response = updateCacheForSuccess(store, request, options, document);
-  });
-  store._enableAsyncFlush = null;
-  if (store.lifetimes?.didRequest) {
-    store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
-  }
-  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
-  if (finalPriority.blocking) {
-    return response;
-  } else {
-    store.notifications._flush();
-  }
-}
-function updateCacheForError(store, context, options, error) {
-  let response;
-  if (isMutation(context.request)) {
-    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
-    // currently we let the response remain undefiend.
-    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
-    const record = context.request.data?.record || context.request.records?.[0];
-    store.cache.commitWasRejected(record, errors);
-  } else {
-    response = store.cache.put(error);
-    return maybeUpdateUiObjects(store, context.request, options, response);
-  }
-}
-function handleFetchError(store, context, options, error) {
-  store.requestManager._pending.delete(context.id);
-  if (context.request.signal?.aborted) {
-    throw error;
-  }
-  store._enableAsyncFlush = true;
-  let response;
-  store._join(() => {
-    response = updateCacheForError(store, context, options, error);
-  });
-  store._enableAsyncFlush = null;
-  if (options.identifier && store.lifetimes?.didRequest) {
-    store.lifetimes.didRequest(context.request, error.response, options.identifier, store);
-  }
-  if (isMutation(context.request)) {
-    throw error;
-  }
-  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
-  if (finalPriority.blocking) {
-    const newError = cloneError(error);
-    newError.content = response;
-    throw newError;
-  } else {
-    store.notifications._flush();
-  }
-}
-function fetchContentAndHydrate(next, context, identifier, priority) {
-  const {
-    store
-  } = context.request;
-  const shouldHydrate = context.request[EnableHydration] || false;
-  const options = {
-    shouldHydrate,
-    identifier,
-    priority
-  };
-  let isMut = false;
-  if (isMutation(context.request)) {
-    isMut = true;
-    // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
-    const record = context.request.data?.record || context.request.records?.[0];
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected to receive a list of records included in the ${context.request.op} request`);
-      }
-    })(record || !shouldHydrate) : {};
-    if (record) {
-      store.cache.willCommit(record, context);
-    }
-  }
-  if (store.lifetimes?.willRequest) {
-    store.lifetimes.willRequest(context.request, identifier, store);
-  }
-  const promise = next(context.request).then(document => {
-    return handleFetchSuccess(store, context, options, document);
-  }, error => {
-    return handleFetchError(store, context, options, error);
-  });
-  if (!isMut) {
-    return promise;
-  }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a mutation`);
-    }
-  })(isMutation(context.request)) : {};
-
-  // for mutations we need to enqueue the promise with the requestStateService
-  // TODO should we enque a request per record in records?
-  const record = context.request.data?.record || context.request.records?.[0];
-  return store._requestCache._enqueue(promise, {
-    data: [{
-      op: 'saveRecord',
-      recordIdentifier: record,
-      options: undefined
-    }]
-  });
-}
-export { CacheHandler as C };