Revert to non-proxy implementation of model fields

This is technically more correct in case a model is instantiated
outside of the store - making the magic field behaviour inherent in the
class.

Author: tobyzerner

src/model.ts

@@ -1,8 +1,5 @@
 import { JsonApiResource, ModelForType, SchemaCollection } from './types';
-
-type PartialJsonApiResource<T extends JsonApiResource> = {
-    [P in keyof T]?: Partial<T[P]>;
-};
+import { Store } from './store.ts';
 
 class ModelBase<Schema extends JsonApiResource = JsonApiResource> {
     public type: Schema['type'];
@@ -12,7 +9,10 @@ class ModelBase<Schema extends JsonApiResource = JsonApiResource> {
     public meta: Schema['meta'] = {};
     public links: Schema['links'] = {};
 
-    constructor(data: Schema) {
+    constructor(
+        data: Schema,
+        protected store: Store,
+    ) {
         this.type = data.type;
         this.id = data.id;
 
@@ -32,23 +32,73 @@ class ModelBase<Schema extends JsonApiResource = JsonApiResource> {
     /**
      * Merge new JSON:API resource data into the model.
      */
-    public merge(data: PartialJsonApiResource<Schema>): void {
+    public merge(
+        data: Omit<JsonApiResource<Schema['type']>, 'type' | 'id'>,
+    ): void {
         this.links = data.links ?? this.links;
         this.meta = data.meta ?? this.meta;
 
         if (data.attributes) {
             Object.assign(this.attributes, data.attributes);
+
+            Object.keys(data.attributes).forEach((name) => {
+                if (
+                    Object.getOwnPropertyDescriptor(
+                        Object.getPrototypeOf(this),
+                        name,
+                    ) ||
+                    Object.getOwnPropertyDescriptor(this, name)
+                ) {
+                    return;
+                }
+
+                Object.defineProperty(this, name, {
+                    get: () => this.attributes[name],
+                    configurable: true,
+                    enumerable: true,
+                });
+            });
         }
 
         if (data.relationships) {
             Object.entries(data.relationships).forEach(
                 ([name, relationship]) => {
                     this.relationships[name] = this.relationships[name] || {};
+
                     Object.assign(this.relationships[name], relationship);
+
+                    if (
+                        Object.getOwnPropertyDescriptor(
+                            Object.getPrototypeOf(this),
+                            name,
+                        ) ||
+                        Object.getOwnPropertyDescriptor(this, name)
+                    ) {
+                        return;
+                    }
+
+                    Object.defineProperty(this, name, {
+                        get: () => this.getRelationship(name),
+                        configurable: true,
+                        enumerable: true,
+                    });
                 },
             );
         }
     }
+
+    private getRelationship(name: string) {
+        const data = this.relationships[name].data;
+
+        // https://github.com/microsoft/TypeScript/issues/14107
+        if (Array.isArray(data)) {
+            return this.store.find(data);
+        }
+
+        if (data) {
+            return this.store.find(data);
+        }
+    }
 }
 
 type ProxiedModel<
@@ -79,4 +129,5 @@ export const Model: new <
     Schemas extends SchemaCollection = SchemaCollection,
 >(
     data: JsonApiResource<Schema['type']>,
+    store: Store<Schemas>,
 ) => Model<Schema, Schemas> = ModelBase as any;

src/store.ts

@@ -93,22 +93,7 @@ export class Store<Schemas extends SchemaCollection = {}> {
     ): ModelForType<Type, Schemas> {
         const ModelClass = this.models[data.type] || Model;
 
-        return new Proxy(new ModelClass(data), {
-            get: (target, prop, receiver) => {
-                if (typeof prop === 'string') {
-                    if (target.attributes?.[prop] !== undefined) {
-                        return target.attributes[prop];
-                    }
-                    const data = target.relationships?.[prop]?.data;
-                    if (data !== undefined) {
-                        return Array.isArray(data)
-                            ? this.find(data)
-                            : this.find(data);
-                    }
-                }
-                return Reflect.get(target, prop, receiver);
-            },
-        }) as ModelForType<Type, Schemas>;
+        return new ModelClass(data, this) as ModelForType<Type, Schemas>;
     }
 
     public forget(data: JsonApiIdentifier): void {

src/types.ts

@@ -1,4 +1,5 @@
 import { Model } from './model.ts';
+import { Store } from './store.ts';
 
 export interface JsonApiDocument<Type extends string = string> {
     data: JsonApiResource<Type> | JsonApiResource<Type>[] | null;
@@ -43,10 +44,13 @@ export type SchemaCollection = { [Type in string]: JsonApiResource<Type> };
 export type ModelMap<Schemas extends SchemaCollection = SchemaCollection> = {
     [Type in keyof Schemas & string]?: new (
         data: JsonApiResource<Type>,
+        store: Store<Schemas>,
     ) => Schemas[Type];
 };
 
 export type ModelForType<
     Type extends string,
-    Schemas,
-> = Type extends keyof Schemas ? Schemas[Type] : Model<JsonApiResource<Type>>;
+    Schemas extends SchemaCollection,
+> = Type extends keyof Schemas
+    ? Model<Schemas[Type], Schemas>
+    : Model<JsonApiResource<Type>, Schemas>;