@warp-drive/core 5.6.0-alpha.5 → 5.6.0-beta.1

package/declarations/reactive/-private/schema.d.ts

@@ -0,0 +1,271 @@
+import type { Store } from "../../store/-private.js";
+import type { SchemaService as SchemaServiceInterface } from "../../types.js";
+import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ObjectValue, Value } from "../../types/json/raw.js";
+import type { Derivation, HashFn } from "../../types/schema/concepts.js";
+import { type ArrayField, type DerivedField, type FieldSchema, type GenericField, type HashField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema } from "../../types/schema/fields.js";
+import { Type } from "../../types/symbols.js";
+import type { WithPartial } from "../../types/utils.js";
+import type { ReactiveResource } from "./record.js";
+/**
+* Extensions allow providing non-schema driven behaviors to
+* reactive resources and arrays.
+*/
+export interface CAUTION_MEGA_DANGER_ZONE_Extension {
+	/**
+	* Whether this extension extends the behaviors of objects
+	* or of arrays.
+	*/
+	kind: "object" | "array";
+	/**
+	* The name of the extension, to be used when specifying
+	* either `objectExtensions` or `arrayExtensions`
+	*/
+	name: string;
+	/**
+	* An object with iterable keys whose values are the getters
+	* or methods to expose on the object or array.
+	*
+	* or
+	*
+	* A constructable such as a Function or Class whose prototype
+	* will be iterated with getOwnPropertyNames.
+	*/
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	features: Record<string | symbol, unknown> | Function;
+}
+export type ExtensionDef = {
+	kind: "method";
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	fn: Function;
+} | {
+	kind: "readonly-value";
+	value: unknown;
+} | {
+	kind: "mutable-value";
+	value: unknown;
+} | {
+	kind: "readonly-field";
+	get: () => unknown;
+} | {
+	kind: "mutable-field";
+	get: () => unknown;
+	set: (value: unknown) => void;
+} | {
+	kind: "writeonly-field";
+	set: (value: unknown) => void;
+};
+export interface ProcessedExtension {
+	kind: "object" | "array";
+	name: string;
+	features: Map<string | symbol, ExtensionDef>;
+}
+export interface ExtensibleField {
+	kind: "schema-object" | "schema-array" | "array" | "object" | "hasMany";
+	options?: {
+		objectExtensions?: string[];
+		arrayExtensions?: string[];
+	};
+}
+/**
+* Utility for constructing a ResourceSchema with the recommended
+* fields for the PolarisMode experience.
+*
+* Using this requires registering the PolarisMode derivations
+*
+* ```ts
+* import { registerDerivations } from '@warp-drive/schema-record';
+*
+* registerDerivations(schema);
+* ```
+*
+* @public
+* @param schema
+* @return {PolarisResourceSchema}
+*/
+export declare function withDefaults(schema: WithPartial<PolarisResourceSchema, "identity">): ResourceSchema;
+interface FromIdentityDerivation {
+	(record: ReactiveResource, options: {
+		key: "lid";
+	} | {
+		key: "type";
+	}, key: string): string;
+	(record: ReactiveResource, options: {
+		key: "id";
+	}, key: string): string | null;
+	(record: ReactiveResource, options: {
+		key: "^";
+	}, key: string): StableRecordIdentifier;
+	(record: ReactiveResource, options: null, key: string): asserts options;
+	(record: ReactiveResource, options: {
+		key: "id" | "lid" | "type" | "^";
+	} | null, key: string): StableRecordIdentifier | string | null;
+	[Type]: "@identity";
+}
+/**
+* A derivation that computes its value from the
+* record's identity.
+*
+* It can be used via a derived field definition like:
+*
+* ```ts
+* {
+*   kind: 'derived',
+*   name: 'id',
+*   type: '@identity',
+*   options: { key: 'id' }
+* }
+* ```
+*
+* Valid keys are `'id'`, `'lid'`, `'type'`, and `'^'`.
+*
+* `^` returns the entire identifier object.
+*
+* @public
+*/
+export declare const fromIdentity: FromIdentityDerivation;
+/**
+* Registers the default derivations for records that want
+* to use the PolarisMode defaults provided by
+*
+* ```ts
+* import { withDefaults } from '@warp-drive/schema-record';
+* ```
+*
+* @public
+* @param {SchemaService} schema
+*/
+export declare function registerDerivations(schema: SchemaServiceInterface): void;
+interface InternalSchema {
+	original: ResourceSchema | ObjectSchema;
+	traits: Set<string>;
+	fields: Map<string, FieldSchema>;
+	attributes: Record<string, LegacyAttributeField>;
+	relationships: Record<string, LegacyRelationshipField>;
+}
+export type Transformation<
+	T extends Value = Value,
+	PT = unknown
+> = {
+	serialize(value: PT, options: Record<string, unknown> | null, record: ReactiveResource): T;
+	hydrate(value: T | undefined, options: Record<string, unknown> | null, record: ReactiveResource): PT;
+	defaultValue?(options: Record<string, unknown> | null, identifier: StableRecordIdentifier): T;
+	[Type]: string;
+};
+interface KindFns {
+	belongsTo: {
+		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyBelongsToField) => unknown;
+		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyBelongsToField, value: unknown) => void;
+	};
+	hasMany: {
+		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyHasManyField) => unknown;
+		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField, value: unknown) => void;
+		notify: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField) => boolean;
+	};
+}
+export interface SchemaService {
+	doesTypeExist(type: string): boolean;
+	attributesDefinitionFor(identifier: {
+		type: string;
+	}): InternalSchema["attributes"];
+	relationshipsDefinitionFor(identifier: {
+		type: string;
+	}): InternalSchema["relationships"];
+}
+/**
+* A SchemaService designed to work with dynamically registered schemas.
+*
+* @class SchemaService
+* @public
+*/
+export declare class SchemaService implements SchemaServiceInterface {
+	/** @internal */
+	_schemas: Map<string, InternalSchema>;
+	/** @internal */
+	_transforms: Map<string, Transformation>;
+	/** @internal */
+	_hashFns: Map<string, HashFn>;
+	/** @internal */
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	_derivations: Map<string, Derivation<any, any, any>>;
+	/** @internal */
+	_traits: Set<string>;
+	/** @internal */
+	_modes: Map<string, KindFns>;
+	/** @internal */
+	_extensions: {
+		object: Map<string, ProcessedExtension>;
+		array: Map<string, ProcessedExtension>;
+	};
+	_cachedFieldExtensionsByField: {
+		object: Map<object, ProcessedExtension["features"] | null>;
+		array: Map<object, ProcessedExtension["features"] | null>;
+	};
+	constructor();
+	resourceTypes(): Readonly<string[]>;
+	hasTrait(type: string): boolean;
+	resourceHasTrait(resource: StableRecordIdentifier | {
+		type: string;
+	}, trait: string): boolean;
+	transformation(field: GenericField | ObjectField | ArrayField | {
+		type: string;
+	}): Transformation;
+	derivation(field: DerivedField | {
+		type: string;
+	}): Derivation;
+	hashFn(field: HashField | {
+		type: string;
+	}): HashFn;
+	resource(resource: StableRecordIdentifier | {
+		type: string;
+	}): ResourceSchema | ObjectSchema;
+	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
+	registerResource(schema: ResourceSchema | ObjectSchema): void;
+	registerTransformation<
+		T extends Value = string,
+		PT = unknown
+	>(transformation: Transformation<T, PT>): void;
+	registerDerivation<
+		R,
+		T,
+		FM extends ObjectValue | null
+	>(derivation: Derivation<R, T, FM>): void;
+	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
+		type: string;
+	}): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
+	/**
+	* This is an internal method used to register behaviors for legacy mode.
+	* It is not intended for public use.
+	*
+	* We do think a generalized `kind` registration system would be useful,
+	* but we have not yet designed it.
+	*
+	* See https://github.com/emberjs/data/issues/9534
+	*
+	* @internal
+	*/
+	_registerMode(mode: string, kinds: KindFns): void;
+	/**
+	* This is an internal method used to enable legacy behaviors for legacy mode.
+	* It is not intended for public use.
+	*
+	* We do think a generalized `kind` registration system would be useful,
+	* but we have not yet designed it.
+	*
+	* See https://github.com/emberjs/data/issues/9534
+	*
+	* @internal
+	*/
+	_kind<T extends keyof KindFns>(mode: string, kind: T): KindFns[T];
+	registerHashFn<T extends object>(hashFn: HashFn<T>): void;
+	fields({ type }: {
+		type: string;
+	}): InternalSchema["fields"];
+	hasResource(resource: {
+		type: string;
+	}): boolean;
+}
+export {};

package/declarations/reactive/-private/symbols.d.ts

@@ -0,0 +1,36 @@
+// Great, got your attention with that warning didn't we?
+// Good. Here's the deal: typescript treats symbols as unique types.
+// If by accident a module creating a symbol is processed more than
+// once, the symbol will be different in each processing. This will
+// cause a type error.
+// It could also cause a runtime error if the symbol is used innapropriately.
+// However, this case is extremely hard to hit and would require other things
+// to go wrong first.
+//
+// So, why do the warning? And why do we lie about the types of the symbols?
+//
+// Because we intentionally create multiple copies of them within the types
+// at build time. This is because we rollup our d.ts files in order to give
+// our consumers a better experience.
+//
+// However, no tool today supports rolling up d.ts files with multiple entry
+// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor
+// which creates a fully unique stand-alone types file per-entry-point. Thus
+// every entry point that uses one of these symbols somewhere will have accidentally
+// created a new symbol type.
+//
+// This cast allows us to rollup these types using this tool while not encountering
+// the unique symbol type issue.
+//
+// Note that none of these symbols are part of the public API, these are used for
+// debugging DX and as a safe way to provide an intimate contract on public objects.
+export declare const SOURCE: "___(unique) Symbol(SOURCE)";
+export declare const MUTATE: "___(unique) Symbol(MUTATE)";
+export declare const Destroy: "___(unique) Symbol(Destroy)";
+export declare const Identifier: "___(unique) Symbol(Identifier)";
+export declare const Editable: "___(unique) Symbol(Editable)";
+export declare const Parent: "___(unique) Symbol(Parent)";
+export declare const Checkout: "___(unique) Symbol(Checkout)";
+export declare const Legacy: "___(unique) Symbol(Legacy)";
+export declare const EmbeddedPath: "___(unique) Symbol(EmbeddedPath)";
+export declare const EmbeddedField: "___(unique) Symbol(EmbeddedField)";

package/declarations/reactive/-private.d.ts

@@ -0,0 +1 @@
+export { Editable, Legacy } from "./-private/symbols.js";

package/declarations/reactive.d.ts

@@ -0,0 +1,4 @@
+export { instantiateRecord, teardownRecord } from "./reactive/-private/hooks.js";
+export { type CAUTION_MEGA_DANGER_ZONE_Extension, type ProcessedExtension, type ExtensionDef, type Transformation, SchemaService, withDefaults, fromIdentity, registerDerivations } from "./reactive/-private/schema.js";
+export { type ReactiveResource } from "./reactive/-private/record.js";
+export { Checkout } from "./reactive/-private/symbols.js";

package/declarations/request/-private/context.d.ts

@@ -1,42 +1,41 @@
-import type { StableDocumentIdentifier } from '../../types/identifier';
-import type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from '../../types/request';
-import type { DeferredStream, GodContext } from './types';
+import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from "../../types/request.js";
+import type { DeferredStream, GodContext } from "./types.js";
 export declare function upgradeHeaders(headers: Headers | ImmutableHeaders): ImmutableHeaders;
 export declare function cloneResponseProperties(response: Response): ResponseInfo;
 export declare class ContextOwner {
-    hasSetStream: boolean;
-    hasSetResponse: boolean;
-    hasSubscribers: boolean;
-    stream: DeferredStream;
-    response: ResponseInfo | null;
-    request: ImmutableRequestInfo;
-    enhancedRequest: ImmutableRequestInfo;
-    nextCalled: number;
-    god: GodContext;
-    controller: AbortController;
-    requestId: number;
-    isRoot: boolean;
-    constructor(request: RequestInfo, god: GodContext, isRoot?: boolean);
-    get hasRequestedStream(): boolean;
-    getResponse(): ResponseInfo | null;
-    getStream(): Promise<ReadableStream | null>;
-    abort(reason: DOMException): void;
-    setStream(stream: ReadableStream | Promise<ReadableStream | null> | null): void;
-    resolveStream(): void;
-    setResponse(response: ResponseInfo | Response | null): void;
+	hasSetStream: boolean;
+	hasSetResponse: boolean;
+	hasSubscribers: boolean;
+	stream: DeferredStream;
+	response: ResponseInfo | null;
+	request: ImmutableRequestInfo;
+	enhancedRequest: ImmutableRequestInfo;
+	nextCalled: number;
+	god: GodContext;
+	controller: AbortController;
+	requestId: number;
+	isRoot: boolean;
+	constructor(request: RequestInfo, god: GodContext, isRoot?: boolean);
+	get hasRequestedStream(): boolean;
+	getResponse(): ResponseInfo | null;
+	getStream(): Promise<ReadableStream | null>;
+	abort(reason: DOMException): void;
+	setStream(stream: ReadableStream | Promise<ReadableStream | null> | null): void;
+	resolveStream(): void;
+	setResponse(response: ResponseInfo | Response | null): void;
 }
 export declare class Context {
-    #private;
-    request: ImmutableRequestInfo;
-    id: number;
-    private _isCacheHandler;
-    private _finalized;
-    constructor(owner: ContextOwner, isCacheHandler: boolean);
-    setStream(stream: ReadableStream | Promise<ReadableStream | null>): void;
-    setResponse(response: ResponseInfo | Response | null): void;
-    setIdentifier(identifier: StableDocumentIdentifier): void;
-    get hasRequestedStream(): boolean;
-    _finalize(): void;
+	#private;
+	request: ImmutableRequestInfo;
+	id: number;
+	private _isCacheHandler;
+	private _finalized;
+	constructor(owner: ContextOwner, isCacheHandler: boolean);
+	setStream(stream: ReadableStream | Promise<ReadableStream | null>): void;
+	setResponse(response: ResponseInfo | Response | null): void;
+	setIdentifier(identifier: StableDocumentIdentifier): void;
+	get hasRequestedStream(): boolean;
+	_finalize(): void;
 }
 export type HandlerRequestContext = Context;
-//# sourceMappingURL=context.d.ts.map

package/declarations/request/-private/debug.d.ts

@@ -1,5 +1,4 @@
-import type { RequestInfo } from '../../types/request';
-import { Context } from './context';
+import type { RequestInfo } from "../../types/request.js";
+import { Context } from "./context.js";
 export declare function deepFreeze<T = unknown>(value: T): T;
 export declare function assertValidRequest(request: RequestInfo | Context, isTopLevel: boolean): asserts request is RequestInfo;
-//# sourceMappingURL=debug.d.ts.map

package/declarations/request/-private/fetch.d.ts

@@ -1,43 +1,31 @@
-/**
- * A basic Fetch Handler which converts a request into a
- * `fetch` call presuming the response to be `json`.
- *
- * ```ts
- * import Fetch from '@ember-data/request/fetch';
- *
- * manager.use([Fetch]);
- * ```
- *
- * @module
- */
-import { type Context } from './context';
+import { type Context } from "./context.js";
 interface FastbootRequest extends Request {
-    protocol: string;
-    host: string;
-}
-interface FastBoot {
-    require(moduleName: string): unknown;
-    isFastBoot: boolean;
-    request: FastbootRequest;
+	protocol: string;
+	host: string;
 }
-declare global {
-    const FastBoot: undefined | FastBoot;
+export interface FastBoot {
+	require(moduleName: string): unknown;
+	isFastBoot: boolean;
+	request: FastbootRequest;
 }
 /**
- * A basic handler which converts a request into a
- * `fetch` call presuming the response to be `json`.
- *
- * ```ts
- * import Fetch from '@ember-data/request/fetch';
- *
- * manager.use([Fetch]);
- * ```
- *
- * @class Fetch
- * @public
- */
+* ```ts
+* import { Fetch } from '@warp-drive/core';
+* ```
+*
+* A basic Fetch Handler which converts a request into a
+* `fetch` call presuming the response to be `json`.
+*
+* ```ts
+* import { RequestManager, Fetch } from '@warp-drive/core';
+*
+* const manager = new RequestManager()
+*   .use([Fetch]);
+* ```
+*
+* @public
+*/
 declare const Fetch: {
-    request<T>(context: Context): Promise<T>;
+	request<T>(context: Context): Promise<T>;
 };
 export { Fetch };
-//# sourceMappingURL=fetch.d.ts.map

package/declarations/request/-private/future.d.ts

@@ -1,8 +1,7 @@
-import { type StructuredDocument } from '../../types/request';
-import type { ContextOwner } from './context';
-import type { Deferred, DeferredFuture, Future } from './types';
+import { type StructuredDocument } from "../../types/request.js";
+import type { ContextOwner } from "./context.js";
+import type { Deferred, DeferredFuture, Future } from "./types.js";
 export declare function isFuture<T>(maybe: unknown): maybe is Future<T>;
 export declare function createDeferred<T>(): Deferred<T>;
 export declare function upgradePromise<T>(promise: Promise<StructuredDocument<T>>, future: Future<T>): Future<T>;
 export declare function createFuture<T>(owner: ContextOwner): DeferredFuture<T>;
-//# sourceMappingURL=future.d.ts.map