feat (internal): support legacy model behaviors in SchemaRecord legac…

…y mode (#9095)

* more progress

* more features

* all the things

* references

* more impls

* implement more tests

* add more tests

* make sure lifecycle flags work

* more tests

* more tests

* implement destroy as locals

* fix

* fix tests

* fix prod test

* fix prettier

config/eslint/qunit.cjs

@@ -15,7 +15,9 @@ function defaults(config = {}) {
         ],
       }),
       config?.rules,
-      {}
+      {
+        'qunit/no-ok-equality': 'off',
+      }
     ),
   };
 }

config/rollup/external.js

@@ -6,9 +6,30 @@ function external(manual = []) {
   const peers = Object.keys(pkg.peerDependencies || {});
   const all = new Set([...deps, ...peers, ...manual]);
 
-  const result = [...all.keys()];
   // console.log({ externals: result });
-  return result;
+  return function (id) {
+    if (all.has(id)) {
+      return true;
+    }
+
+    for (const dep of deps) {
+      if (id.startsWith(dep + '/')) {
+        return true;
+      }
+    }
+
+    for (const dep of peers) {
+      if (id.startsWith(dep + '/')) {
+        return true;
+      }
+    }
+
+    if (id.startsWith('@ember/') || id.startsWith('@ember-data/') || id.startsWith('@warp-drive/')) {
+      throw new Error(`Unexpected import: ${id}`);
+    }
+
+    return false;
+  };
 }
 
 module.exports = {

packages/core-types/rollup.config.mjs

@@ -19,7 +19,7 @@ export default {
   plugins: [
     // These are the modules that users should be able to import from your
     // addon. Anything not listed here may get optimized away.
-    addon.publicEntrypoints(['index.js', 'identifier.js', 'request.js']),
+    addon.publicEntrypoints(['index.js', 'identifier.js', 'request.js', 'symbols.js']),
 
     nodeResolve({ extensions: ['.ts'] }),
     babel({

packages/core-types/src/symbols.ts

@@ -0,0 +1 @@
+export const RecordStore = Symbol('Store');

packages/legacy-compat/rollup.config.mjs

@@ -14,7 +14,7 @@ export default {
   // You can augment this if you need to.
   output: addon.output(),
 
-  external: external(['@ember/debug', '@embroider/macros', '@ember-data/store/-private']),
+  external: external(['@ember/debug', '@ember/application', '@embroider/macros', '@ember-data/store/-private']),
 
   plugins: [
     // These are the modules that users should be able to import from your

packages/model/rollup.config.mjs

@@ -35,7 +35,7 @@ export default {
   plugins: [
     // These are the modules that users should be able to import from your
     // addon. Anything not listed here may get optimized away.
-    addon.publicEntrypoints(['index.js', '-private.js', 'hooks.js']),
+    addon.publicEntrypoints(['index.js', '-private.js', 'hooks.js', 'migration-support.js']),
 
     nodeResolve({ extensions: ['.ts', '.js'] }),
     babel({

packages/model/src/-private.ts

@@ -8,5 +8,5 @@ export { default as ManyArray } from './-private/many-array';
 export { default as PromiseBelongsTo } from './-private/promise-belongs-to';
 export { default as PromiseManyArray } from './-private/promise-many-array';
 
-// // Used by tests
-export { LEGACY_SUPPORT } from './-private/model';
+// // Used by tests, migration support
+export { lookupLegacySupport, LEGACY_SUPPORT } from './-private/legacy-relationships-support';

packages/model/src/-private/belongs-to.js

@@ -3,7 +3,7 @@ import { computed } from '@ember/object';
 
 import { DEBUG } from '@ember-data/env';
 
-import { lookupLegacySupport } from './model';
+import { lookupLegacySupport } from './legacy-relationships-support';
 import { computedMacroWithOptionalParams, normalizeModelName } from './util';
 
 /**

packages/model/src/-private/has-many.js

@@ -10,7 +10,7 @@ import { singularize } from 'ember-inflector';
 import { DEPRECATE_NON_STRICT_TYPES } from '@ember-data/deprecations';
 import { DEBUG } from '@ember-data/env';
 
-import { lookupLegacySupport } from './model';
+import { lookupLegacySupport } from './legacy-relationships-support';
 import { computedMacroWithOptionalParams } from './util';
 
 function normalizeType(type) {

packages/model/src/-private/legacy-relationships-support.ts

@@ -28,7 +28,7 @@ import type { LocalRelationshipOperation } from '@warp-drive/core-types/graph';
 import type { CollectionResourceRelationship, SingleResourceRelationship } from '@warp-drive/core-types/spec/raw';
 
 import RelatedCollection from './many-array';
-import type Model from './model';
+import type { MinimalLegacyRecord } from './model-methods';
 import type { BelongsToProxyCreateArgs, BelongsToProxyMeta } from './promise-belongs-to';
 import PromiseBelongsTo from './promise-belongs-to';
 import type { HasManyProxyCreateArgs } from './promise-many-array';
@@ -38,8 +38,25 @@ import HasManyReference from './references/has-many';
 
 type PromiseBelongsToFactory = { create(args: BelongsToProxyCreateArgs): PromiseBelongsTo };
 
+export const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport> = new Map();
+
+export function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport {
+  const identifier = recordIdentifierFor(record);
+  assert(`Expected a record`, identifier);
+  let support = LEGACY_SUPPORT.get(identifier);
+
+  if (!support) {
+    assert(`Memory Leak Detected`, !record.isDestroyed && !record.isDestroying);
+    support = new LegacySupport(record);
+    LEGACY_SUPPORT.set(identifier, support);
+    LEGACY_SUPPORT.set(record, support);
+  }
+
+  return support;
+}
+
 export class LegacySupport {
-  declare record: Model;
+  declare record: MinimalLegacyRecord;
   declare store: Store;
   declare graph: Graph;
   declare cache: Cache;
@@ -53,7 +70,7 @@ export class LegacySupport {
   declare isDestroying: boolean;
   declare isDestroyed: boolean;
 
-  constructor(record: Model) {
+  constructor(record: MinimalLegacyRecord) {
     this.record = record;
     this.store = storeFor(record)!;
     this.identifier = recordIdentifierFor(record);

packages/model/src/-private/model-methods.ts

@@ -0,0 +1,135 @@
+import { assert } from '@ember/debug';
+
+import { importSync } from '@embroider/macros';
+
+import { upgradeStore } from '@ember-data/legacy-compat/-private';
+import Store, { recordIdentifierFor } from '@ember-data/store';
+import { peekCache } from '@ember-data/store/-private';
+import { RecordStore } from '@warp-drive/core-types/symbols';
+
+import Errors from './errors';
+import { lookupLegacySupport } from './legacy-relationships-support';
+import RecordState from './record-state';
+
+export interface MinimalLegacyRecord {
+  errors: Errors;
+  ___recordState: RecordState;
+  currentState: RecordState;
+  isDestroyed: boolean;
+  isDestroying: boolean;
+  isReloading: boolean;
+  [RecordStore]: Store;
+
+  deleteRecord(): void;
+  unloadRecord(): void;
+  save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+  destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+}
+
+export function rollbackAttributes(this: MinimalLegacyRecord) {
+  const { currentState } = this;
+  const { isNew } = currentState;
+
+  this[RecordStore]._join(() => {
+    peekCache(this).rollbackAttrs(recordIdentifierFor(this));
+    this.errors.clear();
+    currentState.cleanErrorRequests();
+    if (isNew) {
+      this.unloadRecord();
+    }
+  });
+}
+
+export function unloadRecord(this: MinimalLegacyRecord) {
+  if (this.currentState.isNew && (this.isDestroyed || this.isDestroying)) {
+    return;
+  }
+  this[RecordStore].unloadRecord(this);
+}
+
+export function belongsTo(this: MinimalLegacyRecord, prop: string) {
+  return lookupLegacySupport(this).referenceFor('belongsTo', prop);
+}
+
+export function hasMany(this: MinimalLegacyRecord, prop: string) {
+  return lookupLegacySupport(this).referenceFor('hasMany', prop);
+}
+
+export function reload(this: MinimalLegacyRecord, options: Record<string, unknown> = {}) {
+  options.isReloading = true;
+  options.reload = true;
+
+  const identifier = recordIdentifierFor(this);
+  assert(`You cannot reload a record without an ID`, identifier.id);
+
+  this.isReloading = true;
+  const promise = this[RecordStore].request({
+    op: 'findRecord',
+    data: {
+      options,
+      record: identifier,
+    },
+    cacheOptions: { [Symbol.for('wd:skip-cache')]: true },
+  })
+    .then(() => this)
+    .finally(() => {
+      this.isReloading = false;
+    });
+
+  return promise;
+}
+
+export function changedAttributes(this: MinimalLegacyRecord) {
+  return peekCache(this).changedAttrs(recordIdentifierFor(this));
+}
+
+export function serialize(this: MinimalLegacyRecord, options?: Record<string, unknown>) {
+  upgradeStore(this[RecordStore]);
+  return this[RecordStore].serializeRecord(this, options);
+}
+
+export function deleteRecord(this: MinimalLegacyRecord) {
+  // ensure we've populated currentState prior to deleting a new record
+  if (this.currentState) {
+    this[RecordStore].deleteRecord(this);
+  }
+}
+
+export function save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T> {
+  let promise: Promise<T>;
+
+  if (this.currentState.isNew && this.currentState.isDeleted) {
+    promise = Promise.resolve(this);
+  } else {
+    this.errors.clear();
+    promise = this[RecordStore].saveRecord(this, options) as Promise<T>;
+  }
+
+  return promise;
+}
+
+export function destroyRecord(this: MinimalLegacyRecord, options?: Record<string, unknown>) {
+  const { isNew } = this.currentState;
+  this.deleteRecord();
+  if (isNew) {
+    return Promise.resolve(this);
+  }
+  return this.save(options).then((_) => {
+    this.unloadRecord();
+    return this;
+  });
+}
+
+export function createSnapshot(this: MinimalLegacyRecord) {
+  const store = this[RecordStore];
+
+  upgradeStore(store);
+  if (!store._fetchManager) {
+    const FetchManager = (
+      importSync('@ember-data/legacy-compat/-private') as typeof import('@ember-data/legacy-compat/-private')
+    ).FetchManager;
+    store._fetchManager = new FetchManager(store);
+  }
+
+  return store._fetchManager.createSnapshot(recordIdentifierFor(this));
+}