Ember Data: merge latest.

types/ember-data/test/adapter.ts

@@ -1,6 +1,11 @@
 import Ember from 'ember';
 import DS from 'ember-data';
 
+class Session extends Ember.Service {}
+declare module '@ember/service' {
+    interface Registry { 'session': Session; }
+}
+
 const JsonApi = DS.JSONAPIAdapter.extend({
     // Application specific overrides go here
 });
@@ -55,6 +60,13 @@ const UseAjaxOptionsWithOptionalThirdParams = DS.JSONAPIAdapter.extend({
     }
 });
 
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'rootModel': any;
+        'super-user': any;
+    }
+}
+
 // https://github.com/emberjs/data/blob/c9d8212c857ca78218ad98d11621819b38dba98f/tests/unit/adapters/build-url-mixin/build-url-test.js
 const BuildURLAdapter = DS.RESTAdapter.extend({
     worksWithOnlyModelNameAndId() {

types/ember-data/test/belongs-to.ts

@@ -3,8 +3,14 @@ import { assertType } from './lib/assert';
 
 class Folder extends DS.Model {
     name = DS.attr('string');
-    children = DS.hasMany<Folder>('folder', { inverse: 'parent' });
-    parent = DS.belongsTo<Folder>('folder', { inverse: 'children' });
+    children = DS.hasMany('folder', { inverse: 'parent' });
+    parent = DS.belongsTo('folder', { inverse: 'children' });
+}
+
+declare module 'ember-data' {
+    interface ModelRegistry {
+        folder: Folder;
+    }
 }
 
 const folder = Folder.create();

types/ember-data/test/has-many.ts

@@ -1,43 +1,56 @@
 import DS from 'ember-data';
 import { assertType } from './lib/assert';
 
-class Comment extends DS.Model {
+class BlogComment extends DS.Model {
     text = DS.attr('string');
 }
 
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'blog-comment': BlogComment;
+    }
+}
+
 class BlogPost extends DS.Model {
     title = DS.attr('string');
-    commentsAsync = DS.hasMany<Comment>('comment');
-    commentsSync = DS.hasMany<Comment>('comment', { async: false });
+    commentsAsync = DS.hasMany('blog-comment');
+    commentsSync = DS.hasMany('blog-comment', { async: false });
 }
 
-const post = BlogPost.create();
+const blogPost = BlogPost.create();
 
-assertType<DS.PromiseArray<Comment>>(post.get('commentsSync').reload());
-assertType<Comment>(post.get('commentsSync').createRecord());
+assertType<DS.PromiseArray<BlogComment>>(blogPost.get('commentsSync').reload());
+assertType<BlogComment>(blogPost.get('commentsSync').createRecord());
 
-const comment = post.get('commentsSync').get('firstObject');
-assertType<Comment | undefined>(comment);
+const comment = blogPost.get('commentsSync').get('firstObject');
+assertType<BlogComment | undefined>(comment);
 if (comment) {
     assertType<string>(comment.get('text'));
 }
 
-assertType<DS.PromiseArray<Comment>>(post.get('commentsAsync').reload());
-assertType<Comment>(post.get('commentsAsync').createRecord());
-assertType<Comment | undefined>(post.get('commentsAsync').get('firstObject'));
+assertType<DS.PromiseArray<BlogComment>>(blogPost.get('commentsAsync').reload());
+assertType<BlogComment>(blogPost.get('commentsAsync').createRecord());
+assertType<BlogComment | undefined>(blogPost.get('commentsAsync').get('firstObject'));
 
-const commentAsync = post.get('commentsAsync').get('firstObject');
-assertType<Comment | undefined>(commentAsync);
+const commentAsync = blogPost.get('commentsAsync').get('firstObject');
+assertType<BlogComment | undefined>(commentAsync);
 if (commentAsync) {
     assertType<string>(commentAsync.get('text'));
 }
-assertType<boolean>(post.get('commentsAsync').get('isFulfilled'));
+assertType<boolean>(blogPost.get('commentsAsync').get('isFulfilled'));
 
-post.get('commentsAsync').then(comments => {
-    assertType<Comment | undefined>(comments.get('firstObject'));
+blogPost.get('commentsAsync').then(comments => {
+    assertType<BlogComment | undefined>(comments.get('firstObject'));
     assertType<string>(comments.get('firstObject')!.get('text'));
 });
 
+class PaymentMethod extends DS.Model {}
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'payment-method': PaymentMethod;
+    }
+}
+
 class Polymorphic extends DS.Model {
     paymentMethods = DS.hasMany('payment-method', { polymorphic: true });
 }

types/ember-data/test/injections.ts

@@ -1,6 +1,14 @@
 import Ember from 'ember';
 import DS from 'ember-data';
 
+class MyModel extends DS.Model {}
+
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'my-model': MyModel;
+    }
+}
+
 Ember.Route.extend({
     model(): any {
         return this.store.findAll('my-model');

types/ember-data/test/record-reference.ts

@@ -7,7 +7,13 @@ class User extends DS.Model {
     username = DS.attr('string');
 }
 
-let userRef = store.getReference<User>('user', 1);
+declare module 'ember-data' {
+    interface ModelRegistry {
+        user: User;
+    }
+}
+
+let userRef = store.getReference('user', 1);
 
 // get the record of the reference (null if not yet available)
 let user = userRef.value();

types/ember-data/test/relationships.ts

@@ -16,14 +16,21 @@ class Comment extends DS.Model {
     author = DS.attr('string');
 }
 
-class BlogPost extends DS.Model {
+class RelationalPost extends DS.Model {
     title = DS.attr('string');
     tag = DS.attr('string');
-    comments = DS.hasMany<Comment>('comment', { async: true });
+    comments = DS.hasMany('comment', { async: true });
     relatedPosts = DS.hasMany('post');
 }
 
-let blogPost = store.peekRecord<BlogPost>('blog-post', 1);
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'relational-post': RelationalPost;
+        comment: Comment;
+    }
+}
+
+let blogPost = store.peekRecord('relational-post', 1);
 blogPost!.get('comments').then((comments) => {
     // now we can work with the comments
     let author: string = comments.get('firstObject')!.get('author');

types/ember-data/test/serializer.ts

@@ -4,7 +4,8 @@ import DS from 'ember-data';
 const JsonApi = DS.JSONAPISerializer.extend({});
 
 const Customized = DS.JSONAPISerializer.extend({
-    serialize(snapshot: DS.Snapshot, options: {}) {
+    serialize(snapshot: DS.Snapshot<'user'>, options: {}) {
+        const lookup = snapshot.belongsTo('username');
         let json: any = this._super(...Array.from(arguments));
 
         json.data.attributes.cost = {

types/ember-data/test/store.ts

@@ -4,13 +4,20 @@ import { assertType } from "./lib/assert";
 
 declare const store: DS.Store;
 
-class Comment extends DS.Model {}
+class PostComment extends DS.Model {}
 class Post extends DS.Model {
   title = DS.attr('string');
-  comments = DS.hasMany<Comment>('comment');
+  comments = DS.hasMany('comment');
 }
 
-let post = store.createRecord<Post>('post', {
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'post': Post;
+        'post-comment': PostComment;
+    }
+}
+
+let post = store.createRecord('post', {
     title: 'Rails is Omakase',
     body: 'Lorem ipsum'
 });
@@ -20,7 +27,7 @@ post.save().then((saved) => {
     assertType<Post>(saved);
 });
 
-store.findRecord<Post>('post', 1).then(function(post) {
+store.findRecord('post', 1).then(function(post) {
     post.get('title'); // => "Rails is Omakase"
     post.set('title', 'A new post');
     post.save(); // => PATCH to '/posts/1'
@@ -30,21 +37,30 @@ class User extends DS.Model {
     username = DS.attr('string');
 }
 
-store.queryRecord<User>('user', {}).then(function(user) {
+class Author extends User {}
+
+declare module 'ember-data' {
+    interface ModelRegistry {
+        'user': User;
+        'author': Author;
+    }
+}
+
+store.queryRecord('user', {}).then(function(user) {
     let username = user.get('username');
     console.log(`Currently logged in as ${username}`);
 });
 
-store.findAll('blog-post'); // => GET /blog-posts
+store.findAll('post'); // => GET /posts
 store.findAll('author', { reload: true }).then(function(authors) {
     authors.getEach('id'); // ['first', 'second']
 });
 store.findAll('post', {
-    adapterOptions: { subscribe: false }
+    adapterOptions: { subscribe: false },
 });
 store.findAll('post', { include: 'comments,comments.author' });
 
-store.peekAll('blog-post'); // => no network request
+store.peekAll('post'); // => no network request
 
 if (store.hasRecordForId('post', 1)) {
     let maybePost = store.peekRecord('post', 1);
@@ -57,13 +73,19 @@ class Message extends DS.Model {
   hasBeenSeen = DS.attr('boolean');
 }
 
-const messages = store.peekAll<Message>('message');
+declare module 'ember-data' {
+    interface ModelRegistry {
+        message: Message;
+    }
+}
+
+const messages = store.peekAll('message');
 messages.forEach(function(message) {
     message.set('hasBeenSeen', true);
 });
 messages.save();
 
-const people = store.peekAll('person');
+const people = store.peekAll('user');
 people.get('isUpdating'); // false
 people.update().then(function() {
     people.get('isUpdating'); // false
@@ -79,27 +101,27 @@ const MyRoute = Ember.Route.extend({
 const MyRouteAsync = Ember.Route.extend({
     async beforeModel(): Promise<Ember.Array<DS.Model>> {
         const store = Ember.get(this, 'store');
-        return await store.findAll('someStoreRecord');
+        return await store.findAll('post-comment');
     },
     async model(): Promise<DS.Model> {
         const store = this.get('store');
-        return await store.findRecord('someStoreRecord', 1);
+        return await store.findRecord('post-comment', 1);
     },
-    async afterModel(): Promise<Ember.Array<Comment>> {
-        const post = await this.get('store').findRecord<Post>('post', 1);
+    async afterModel(): Promise<Ember.Array<PostComment>> {
+        const post = await this.get('store').findRecord('post', 1);
         return await post.get('comments');
     }
 });
 
 class MyRouteAsyncES6 extends Ember.Route {
     async beforeModel(): Promise<Ember.Array<DS.Model>> {
-        return await this.store.findAll('someStoreRecord');
+        return await this.store.findAll('post-comment');
     }
     async model(): Promise<DS.Model> {
-        return await this.store.findRecord('someStoreRecord', 1);
+        return await this.store.findRecord('post-comment', 1);
     }
-    async afterModel(): Promise<Ember.Array<Comment>> {
-        const post = await this.store.findRecord<Post>('post', 1);
+    async afterModel(): Promise<Ember.Array<PostComment>> {
+        const post = await this.store.findRecord('post', 1);
         return await post.get('comments');
     }
 }
@@ -145,8 +167,22 @@ store.push({
     }]
 });
 
-class UserAdapter extends DS.Adapter { }
-class UserSerializer extends DS.Serializer { }
+class UserAdapter extends DS.Adapter {
+    thisAdapterOnlyMethod(): void {}
+}
+class UserSerializer extends DS.Serializer {
+    thisSerializerOnlyMethod(): void {}
+}
 
-assertType<UserAdapter>(store.adapterFor<UserAdapter>('user'));
-assertType<UserSerializer>(store.serializerFor<UserSerializer>('user'));
+declare module 'ember-data' {
+    interface AdapterRegistry {
+        user: UserAdapter;
+    }
+
+    interface SerializerRegistry {
+        user: UserSerializer;
+    }
+}
+
+assertType<UserAdapter>(store.adapterFor('user'));
+assertType<UserSerializer>(store.serializerFor('user'));

types/ember-data/tsconfig.json

@@ -10,10 +10,13 @@
         "strictNullChecks": true,
         "strictFunctionTypes": false,
         "baseUrl": "../",
-        "typeRoots": ["../"],
+        "typeRoots": [
+            "../"
+        ],
         "types": [],
         "noEmit": true,
-        "forceConsistentCasingInFileNames": true
+        "forceConsistentCasingInFileNames": true,
+        "esModuleInterop": true
     },
     "files": [
         "index.d.ts",
@@ -31,4 +34,4 @@
         "test/injections.ts",
         "test/error.ts"
     ]
-}
+}

types/ember-data/tslint.json

@@ -1,6 +1,7 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
+        "strict-export-declare-modifiers": false,
         // Heavy use of Function type in this older package.
         "ban-types": false,
         "jsdoc-format": false,