chore: type attr decorator

Author: runspired

packages/model/package.json

@@ -145,6 +145,7 @@
     "@warp-drive/internal-config": "workspace:5.4.0-alpha.28",
     "ember-inflector": "^4.0.2",
     "ember-source": "~5.6.0",
+    "expect-type": "^0.18.0",
     "rollup": "^4.9.6",
     "typescript": "^5.3.3",
     "walk-sync": "^3.0.0",

packages/model/src/-private.ts

@@ -1,7 +1,7 @@
-export { default as attr } from './-private/attr';
+export { attr } from './-private/attr';
 export { default as belongsTo } from './-private/belongs-to';
 export { default as hasMany } from './-private/has-many';
-export { default as Model } from './-private/model';
+export { Model } from './-private/model';
 export { default as Errors } from './-private/errors';
 
 export { default as ManyArray } from './-private/many-array';

packages/model/src/-private/attr.js packages/model/src/-private/attr.ts

@@ -1,21 +1,63 @@
 import { assert } from '@ember/debug';
 import { computed } from '@ember/object';
 
+/**
+  @module @ember-data/model
+*/
+import { expectTypeOf } from 'expect-type';
+
 import { DEBUG } from '@ember-data/env';
 import { recordIdentifierFor } from '@ember-data/store';
 import { peekCache } from '@ember-data/store/-private';
+import type { Value } from '@warp-drive/core-types/json/raw';
 
-import { computedMacroWithOptionalParams } from './util';
+import type { Model } from './model';
+import type { DataDecorator, DecoratorPropertyDescriptor } from './util';
+import { isElementDescriptor } from './util';
 
 /**
-  @module @ember-data/model
-*/
+ * Options provided to the attr decorator are
+ * supplied to the associated transform. Any
+ * key-value pair is valid; however, it is highly
+ * recommended to only use statically defined values
+ * that could be serialized to JSON.
+ *
+ * If no transform is provided, the only valid
+ * option is `defaultValue`.
+ *
+ * Examples:
+ *
+ * ```ts
+ * class User extends Model {
+ *  @attr('string', { defaultValue: 'Anonymous' }) name;
+ *  @attr('date', { defaultValue: () => new Date() }) createdAt;
+ *  @attr({ defaultValue: () => ({}) }) preferences;
+ *  @attr('boolean') hasVerifiedEmail;
+ *  @attr address;
+ * }
+ *
+ * @typedoc
+ */
+type AttrOptions = {
+  /**
+   * The default value for this attribute.
+   *
+   * Default values can be provided as a value or a function that will be
+   * executed to generate the default value.
+   *
+   * Default values *should not* be stateful (object, arrays, etc.) as
+   * they will be shared across all instances of the record.
+   *
+   * @typedoc
+   */
+  defaultValue?: string | number | boolean | null | (() => unknown);
+};
 
 /**
   `attr` defines an attribute on a [Model](/ember-data/release/classes/Model).
   By default, attributes are passed through as-is, however you can specify an
   optional type to have the value automatically transformed.
-  Ember Data ships with four basic transform types: `string`, `number`,
+  EmberData ships with four basic transform types: `string`, `number`,
   `boolean` and `date`. You can define your own transforms by subclassing
   [Transform](/ember-data/release/classes/Transform).
 
@@ -101,7 +143,7 @@ import { computedMacroWithOptionalParams } from './util';
   @param {Object} options a hash of options
   @return {Attribute}
 */
-function attr(type, options) {
+function _attr(type?: string | AttrOptions, options?: AttrOptions & object) {
   if (typeof type === 'object') {
     options = type;
     type = undefined;
@@ -118,9 +160,9 @@ function attr(type, options) {
   };
 
   return computed({
-    get(key) {
+    get(this: Model, key: string) {
       if (DEBUG) {
-        if (['currentState'].indexOf(key) !== -1) {
+        if (['currentState'].includes(key)) {
           throw new Error(
             `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`
           );
@@ -131,28 +173,31 @@ function attr(type, options) {
       }
       return peekCache(this).getAttr(recordIdentifierFor(this), key);
     },
-    set(key, value) {
+    set(this: Model, key: string, value: Value) {
       if (DEBUG) {
-        if (['currentState'].indexOf(key) !== -1) {
+        if (['currentState'].includes(key)) {
           throw new Error(
             `'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`
           );
         }
       }
+      const identifier = recordIdentifierFor(this);
       assert(
-        `Attempted to set '${key}' on the deleted record ${recordIdentifierFor(this)}`,
+        `Attempted to set '${key}' on the deleted record ${identifier.type}:${identifier.id} (${identifier.lid})`,
         !this.currentState.isDeleted
       );
-      const identifier = recordIdentifierFor(this);
       const cache = peekCache(this);
 
       const currentValue = cache.getAttr(identifier, key);
       if (currentValue !== value) {
         cache.setAttr(identifier, key, value);
 
         if (!this.isValid) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           const { errors } = this;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
           if (errors.get(key)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             errors.remove(key);
             this.currentState.cleanErrorRequests();
           }
@@ -164,4 +209,43 @@ function attr(type, options) {
   }).meta(meta);
 }
 
-export default computedMacroWithOptionalParams(attr);
+export function attr(): DataDecorator;
+export function attr(type: string): DataDecorator;
+export function attr(options: AttrOptions): DataDecorator;
+export function attr(type: string, options?: AttrOptions & object): DataDecorator;
+export function attr(target: object, key: string, desc: PropertyDescriptor): DecoratorPropertyDescriptor;
+export function attr(
+  type?: string | AttrOptions | object,
+  options?: (AttrOptions & object) | string,
+  desc?: PropertyDescriptor
+): DataDecorator | DecoratorPropertyDescriptor {
+  const args = [type, options, desc];
+  return isElementDescriptor(args) ? _attr()(...args) : _attr(type, options as object);
+}
+
+// positive tests
+expectTypeOf(attr({}, 'key', {})).toEqualTypeOf<DecoratorPropertyDescriptor>();
+expectTypeOf(attr('string')).toEqualTypeOf<DataDecorator>();
+expectTypeOf(attr({})).toEqualTypeOf<DataDecorator>();
+expectTypeOf(attr('string', {})).toEqualTypeOf<DataDecorator>();
+expectTypeOf(attr()).toEqualTypeOf<DataDecorator>();
+
+expectTypeOf(attr('string', { defaultValue: 'hello' })).toEqualTypeOf<DataDecorator>();
+expectTypeOf(attr({ defaultValue: 'hello' })).toEqualTypeOf<DataDecorator>();
+expectTypeOf(attr('string', { defaultValue: () => {} })).toEqualTypeOf<DataDecorator>();
+expectTypeOf(attr({ defaultValue: () => {} })).toEqualTypeOf<DataDecorator>();
+
+/* prettier-ignore */
+expectTypeOf(
+  // @ts-expect-error
+  attr(
+    { defaultValue: {} }
+  )
+).toBeNever;
+expectTypeOf(
+  attr(
+    // @ts-expect-error
+    1,
+    { defaultValue: 'hello' }
+  )
+).toBeNever;

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

@@ -6,8 +6,7 @@ import type { StableRecordIdentifier } from '@warp-drive/core-types';
 import type { Cache } from '@warp-drive/core-types/cache';
 import type { TypeFromInstance, TypeFromInstanceOrString } from '@warp-drive/core-types/record';
 
-import type { ModelStore } from './model';
-import type Model from './model';
+import type { Model, ModelStore } from './model';
 import { getModelFactory } from './schema-provider';
 import { normalizeModelName } from './util';
 

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

@@ -84,7 +84,7 @@ interface Model {
   constructor: typeof Model;
 }
 
-export default Model;
+export { Model };
 
 export type StaticModel = typeof Model;
 

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

@@ -2109,4 +2109,4 @@ if (DEBUG) {
   };
 }
 
-export default Model;
+export { Model };

packages/model/src/-private/notify-changes.ts

@@ -7,7 +7,7 @@ import type { StableRecordIdentifier } from '@warp-drive/core-types';
 import type { RelationshipSchema } from '@warp-drive/core-types/schema';
 
 import { LEGACY_SUPPORT } from './legacy-relationships-support';
-import type Model from './model';
+import type { Model } from './model';
 
 export default function notifyChanges(
   identifier: StableRecordIdentifier,

packages/model/src/-private/schema-provider.ts

@@ -5,8 +5,7 @@ import type { FieldSchema } from '@ember-data/store/-types/q/schema-service';
 import type { RecordIdentifier } from '@warp-drive/core-types/identifier';
 import type { AttributesSchema, RelationshipsSchema } from '@warp-drive/core-types/schema';
 
-import type { FactoryCache, ModelFactory, ModelStore } from './model';
-import type Model from './model';
+import type { FactoryCache, Model, ModelFactory, ModelStore } from './model';
 import _modelForMixin from './model-for-mixin';
 import { normalizeModelName } from './util';
 

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

@@ -25,8 +25,12 @@ export function isElementDescriptor(args: unknown[]): args is [object, string, D
   );
 }
 
-type DataDecorator = (target: object, key: string, desc?: DecoratorPropertyDescriptor) => DecoratorPropertyDescriptor;
-type DataDecoratorFactory = (...args: unknown[]) => DataDecorator;
+export type DataDecorator = (
+  target: object,
+  key: string,
+  desc?: DecoratorPropertyDescriptor
+) => DecoratorPropertyDescriptor;
+export type DataDecoratorFactory = (...args: unknown[]) => DataDecorator;
 
 export function computedMacroWithOptionalParams(fn: DataDecorator | DataDecoratorFactory) {
   return (...maybeDesc: unknown[]) =>