@warp-drive/legacy 5.8.0-alpha.9 → 5.8.0-beta.1

package/dist/unpkg/prod-deprecated/hooks-yId87yyG.js

@@ -0,0 +1,41 @@
+import { setOwner, getOwner } from '@ember/application';
+import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
+import { g as getModelFactory } from "./schema-provider-CjX55uSY.js";
+import { n as normalizeModelName } from "./util-B6cn-i93.js";
+function instantiateRecord(identifier, createRecordArgs) {
+  const type = identifier.type;
+
+  // TODO deprecate allowing unknown args setting
+  const createOptions = {
+    _createProps: createRecordArgs ?? {},
+    // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
+    _secretInit: {
+      identifier,
+      store: this,
+      cb: secretInit
+    }
+  };
+
+  // ensure that `getOwner(this)` works inside a model instance
+  setOwner(createOptions, getOwner(this));
+  const factory = getModelFactory(this, type);
+  return factory.class.create(createOptions);
+}
+function teardownRecord(record) {
+  record.destroy();
+}
+function modelFor(modelName) {
+  assertPrivateStore(this);
+  const type = normalizeModelName(modelName);
+  const maybeFactory = getModelFactory(this, type);
+  const klass = maybeFactory && maybeFactory.class ? maybeFactory.class : null;
+  const ignoreType = !klass || !klass.isModel || this._forceShim;
+  if (!ignoreType) {
+    return klass;
+  }
+}
+function secretInit(record, identifier, store) {
+  setRecordIdentifier(record, identifier);
+  StoreMap.set(record, store);
+}
+export { instantiateRecord as i, modelFor as m, teardownRecord as t };

package/dist/unpkg/prod-deprecated/index.js

@@ -0,0 +1,150 @@
+import { Store, RequestManager, Fetch, CacheHandler, recordIdentifierFor } from '@warp-drive/core';
+import { SchemaService, registerDerivations, instantiateRecord as instantiateRecord$1, teardownRecord as teardownRecord$1 } from '@warp-drive/core/reactive';
+import { DefaultCachePolicy } from '@warp-drive/core/store';
+import { LegacyNetworkHandler, adapterFor, serializerFor, pushPayload, normalize, serializeRecord, cleanup } from './compat.js';
+import { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension } from './compat/extensions.js';
+import '@ember/object';
+import '@warp-drive/core/types/symbols';
+import '@warp-drive/utilities/string';
+import '@warp-drive/core/store/-private';
+import "./errors-CdDaK81x.js";
+import "./schema-provider-CjX55uSY.js";
+import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-yId87yyG.js";
+import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
+import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-CqXsIKws.js";
+import { restoreDeprecatedStoreBehaviors } from './store.js';
+
+/**
+ * @module
+ * @mergeModuleWith <project>
+ */
+
+//export type ConfiguredStore<T = unknown> = typeof Store;
+
+/**
+ * Use the legacy store with the given options.
+ */
+
+function useLegacyStore(options, StoreKlass = Store) {
+  // we extend the store to ensure we don't leak our prototype overrides to other stores below.
+  class BaseKlass extends StoreKlass {}
+  class LegacyConfiguredStore extends BaseKlass {
+    requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...(options.handlers ?? []), Fetch].filter(Boolean)).useCache(CacheHandler);
+    lifetimes = options.policy ?? new DefaultCachePolicy({
+      apiCacheHardExpires: 15 * 60 * 1000,
+      // 15 minutes
+      apiCacheSoftExpires: 1 * 30 * 1000,
+      // 30 seconds
+      constraints: {
+        headers: {
+          'X-WarpDrive-Expires': true,
+          'Cache-Control': true,
+          Expires: true
+        }
+      }
+    });
+    createSchemaService() {
+      // prepare for PolarisMode
+      const schema = new SchemaService();
+      registerDerivations(schema);
+      if (options.schemas) schema.registerResources(options.schemas);
+      if (options.traits) {
+        for (const trait of options.traits) {
+          schema.registerTrait(trait);
+        }
+      }
+      if (options.derivations) {
+        for (const derivation of options.derivations) {
+          schema.registerDerivation(derivation);
+        }
+      }
+      if (options.transformations) {
+        for (const transformation of options.transformations) {
+          schema.registerTransformation(transformation);
+        }
+      }
+      if (options.hashFns) {
+        for (const hashFn of options.hashFns) {
+          schema.registerHashFn(hashFn);
+        }
+      }
+      if (options.CAUTION_MEGA_DANGER_ZONE_extensions) {
+        for (const extension of options.CAUTION_MEGA_DANGER_ZONE_extensions) {
+          schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
+        }
+      }
+
+      // Add support for LegacyMode ReactiveResource with Maximal coverage
+      // for upgrading from 4.x
+      registerDerivations$1(schema);
+      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberArrayLikeExtension);
+      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectArrayExtension);
+      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectExtension);
+
+      // add support for fragments
+      if (options.modelFragments) {
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+      }
+
+      // Add fallback for Models
+      return new DelegatingSchemaService(this, schema);
+    }
+    createCache(capabilities) {
+      // eslint-disable-next-line new-cap
+      return new options.cache(capabilities);
+    }
+    instantiateRecord(key, createArgs) {
+      if (this.schema.isDelegated(key)) {
+        return instantiateRecord.call(this, key, createArgs);
+      }
+      return instantiateRecord$1(this, key, createArgs);
+    }
+    teardownRecord(record) {
+      const key = recordIdentifierFor(record);
+      if (this.schema.isDelegated(key)) {
+        return teardownRecord.call(this, record);
+      }
+      return teardownRecord$1(record);
+    }
+    modelFor(type) {
+      assertType(this.schema);
+      const klass =
+      // prefer real models if present
+      modelFor.call(this, type) || (
+      // fallback to ShimModelClass specific to fragments if fragments support in use
+      options.modelFragments ? fragmentsModelFor.call(this, type) : false) ||
+      // fallback to ShimModelClass
+      super.modelFor(type);
+      return klass;
+    }
+    adapterFor(modelName, _allowMissing) {
+      // @ts-expect-error
+      return adapterFor.call(this, modelName, _allowMissing);
+    }
+    serializerFor(...args) {
+      return serializerFor.call(this, ...args);
+    }
+    pushPayload(...args) {
+      return pushPayload.call(this, ...args);
+    }
+    normalize(...args) {
+      return normalize.call(this, ...args);
+    }
+    serializeRecord(...args) {
+      return serializeRecord.call(this, ...args);
+    }
+    destroy() {
+      if (!options.linksMode) {
+        cleanup.call(this);
+      }
+      super.destroy();
+    }
+  }
+  if (options.legacyRequests) {
+    restoreDeprecatedStoreBehaviors(BaseKlass);
+  }
+  return LegacyConfiguredStore;
+}
+function assertType(schema, type) {}
+export { useLegacyStore };