Improve Mirage setup

mirage/config.js

@@ -2,6 +2,7 @@ import * as Categories from './route-handlers/categories';
 import * as Crates from './route-handlers/crates';
 import * as DocsRS from './route-handlers/docs-rs';
 import * as Keywords from './route-handlers/keywords';
+import * as Me from './route-handlers/me';
 import * as Summary from './route-handlers/summary';
 import * as Teams from './route-handlers/teams';
 import * as Users from './route-handlers/users';
@@ -11,6 +12,7 @@ export default function () {
   Crates.register(this);
   DocsRS.register(this);
   Keywords.register(this);
+  Me.register(this);
   Summary.register(this);
   Teams.register(this);
   Users.register(this);

mirage/factories/api-token.js

@@ -0,0 +1,18 @@
+import { Factory } from 'ember-cli-mirage';
+
+export default Factory.extend({
+  createdAt: '2017-11-19T17:59:22',
+  lastUsedAt: null,
+  name: i => `API Token ${i + 1}`,
+  token: () => generateToken(),
+
+  afterCreate(model) {
+    if (!model.user) {
+      throw new Error('Missing `user` relationship on `api-token`');
+    }
+  },
+});
+
+function generateToken() {
+  return Math.random().toString().slice(2);
+}

mirage/factories/crate-ownership.js

@@ -0,0 +1,14 @@
+import { Factory } from 'ember-cli-mirage';
+
+export default Factory.extend({
+  emailNotifications: true,
+
+  afterCreate(model) {
+    if (!model.crate) {
+      throw new Error('Missing `crate` relationship on `crate-ownership`');
+    }
+    if (model.team && model.user) {
+      throw new Error('`team` and `user` on a `crate-ownership` are mutually exclusive');
+    }
+  },
+});

mirage/factories/mirage-session.js

@@ -0,0 +1,9 @@
+import { Factory } from 'ember-cli-mirage';
+
+export default Factory.extend({
+  afterCreate(session) {
+    if (!session.user) {
+      throw new Error('Missing `user` relationship');
+    }
+  },
+});

mirage/factories/user.js

@@ -8,9 +8,22 @@ export default Factory.extend({
     return dasherize(this.name);
   },
 
+  email() {
+    return `${this.login}@crates.io`;
+  },
+
   url() {
     return `https://github.com/${this.login}`;
   },
 
   avatar: 'https://avatars1.githubusercontent.com/u/14631425?v=4',
+
+  emailVerified: null,
+  emailVerificationToken: null,
+
+  afterCreate(model) {
+    if (model.emailVerified === null) {
+      model.update({ emailVerified: !model.emailVerificationToken });
+    }
+  },
 });

mirage/fixtures/crate-ownerships.js

@@ -0,0 +1,18 @@
+export default [
+  {
+    crateId: 'nanomsg',
+    teamId: 1,
+  },
+  {
+    crateId: 'nanomsg',
+    teamId: 303,
+  },
+  {
+    crateId: 'nanomsg',
+    userId: 2,
+  },
+  {
+    crateId: 'nanomsg',
+    userId: 303,
+  },
+];

mirage/models/api-token.js

@@ -1,3 +1,5 @@
-import { Model } from 'ember-cli-mirage';
+import { Model, belongsTo } from 'ember-cli-mirage';
 
-export default Model.extend({});
+export default Model.extend({
+  user: belongsTo(),
+});

mirage/models/crate-ownership.js

@@ -0,0 +1,7 @@
+import { Model, belongsTo } from 'ember-cli-mirage';
+
+export default Model.extend({
+  crate: belongsTo(),
+  team: belongsTo(),
+  user: belongsTo(),
+});

mirage/models/crate.js

@@ -3,7 +3,5 @@ import { Model, hasMany } from 'ember-cli-mirage';
 export default Model.extend({
   categories: hasMany(),
   keywords: hasMany(),
-  teamOwners: hasMany('team'),
   versions: hasMany(),
-  userOwners: hasMany('user'),
 });

mirage/models/mirage-session.js

@@ -0,0 +1,13 @@
+import { Model, belongsTo } from 'ember-cli-mirage';
+
+/**
+ * This is a mirage-only model, that is used to keep track of the current
+ * session and the associated `user` model, because in route handlers we don't
+ * have access to the cookie data that the actual API is using for these things.
+ *
+ * This mock implementation means that there can only ever exist one
+ * session at a time.
+ */
+export default Model.extend({
+  user: belongsTo(),
+});

mirage/route-handlers/crates.js

@@ -18,12 +18,12 @@ export function register(server) {
 
     if (request.queryParams.user_id) {
       let userId = parseInt(request.queryParams.user_id, 10);
-      crates = crates.filter(crate => (crate._owner_users || []).indexOf(userId) !== -1);
+      crates = crates.filter(crate => schema.crateOwnerships.findBy({ crateId: crate.id, userId }));
     }
 
     if (request.queryParams.team_id) {
       let teamId = parseInt(request.queryParams.team_id, 10);
-      crates = crates.filter(crate => (crate._owner_teams || []).indexOf(teamId) !== -1);
+      crates = crates.filter(crate => schema.crateOwnerships.findBy({ crateId: crate.id, teamId }));
     }
 
     if (request.queryParams.sort === 'alpha') {
@@ -99,27 +99,31 @@ export function register(server) {
     let crate = schema.crates.find(crateId);
     if (!crate) return notFound();
 
-    let response = this.serialize(crate.userOwners);
+    let ownerships = schema.crateOwnerships.where({ crateId }).filter(it => it.userId).models;
 
-    response.users.forEach(user => {
-      user.kind = 'user';
-    });
-
-    return response;
+    return {
+      users: ownerships.map(it => {
+        let json = this.serialize(it.user, 'user').user;
+        json.kind = 'user';
+        return json;
+      }),
+    };
   });
 
   server.get('/api/v1/crates/:crate_id/owner_team', function (schema, request) {
     let crateId = request.params.crate_id;
     let crate = schema.crates.find(crateId);
     if (!crate) return notFound();
 
-    let response = this.serialize(crate.teamOwners);
+    let ownerships = schema.crateOwnerships.where({ crateId }).filter(it => it.teamId).models;
 
-    response.teams.forEach(team => {
-      team.kind = 'team';
-    });
-
-    return response;
+    return {
+      teams: ownerships.map(it => {
+        let json = this.serialize(it.team, 'team').team;
+        json.kind = 'team';
+        return json;
+      }),
+    };
   });
 
   server.get('/api/v1/crates/:crate_id/reverse_dependencies', function (schema, request) {

mirage/route-handlers/me.js

@@ -0,0 +1,74 @@
+import { Response } from 'ember-cli-mirage';
+
+import { getSession } from '../utils/session';
+
+export function register(server) {
+  server.get('/api/v1/me', function (schema) {
+    let { user } = getSession(schema);
+    if (!user) {
+      return new Response(403, {}, { errors: [{ detail: 'must be logged in to perform that action' }] });
+    }
+
+    let ownerships = schema.crateOwnerships.where({ userId: user.id }).models;
+
+    let json = this.serialize(user);
+
+    json.owned_crates = ownerships.map(ownership => ({
+      id: ownership.crate.id,
+      name: ownership.crate.name,
+      email_notifications: ownership.emailNotifications,
+    }));
+
+    return json;
+  });
+
+  server.get('/api/v1/me/tokens', function (schema) {
+    let { user } = getSession(schema);
+    if (!user) {
+      return new Response(403, {}, { errors: [{ detail: 'must be logged in to perform that action' }] });
+    }
+
+    return schema.apiTokens.where({ userId: user.id }).sort((a, b) => Number(b.id) - Number(a.id));
+  });
+
+  server.put('/api/v1/me/tokens', function (schema) {
+    let { user } = getSession(schema);
+    if (!user) {
+      return new Response(403, {}, { errors: [{ detail: 'must be logged in to perform that action' }] });
+    }
+
+    let { name } = this.normalizedRequestAttrs('api-token');
+    let token = server.create('api-token', { user, name, createdAt: new Date().toISOString() });
+
+    let json = this.serialize(token);
+    json.api_token.revoked = false;
+    json.api_token.token = token.token;
+    return json;
+  });
+
+  server.delete('/api/v1/me/tokens/:tokenId', function (schema, request) {
+    let { user } = getSession(schema);
+    if (!user) {
+      return new Response(403, {}, { errors: [{ detail: 'must be logged in to perform that action' }] });
+    }
+
+    let { tokenId } = request.params;
+    let token = schema.apiTokens.findBy({ id: tokenId, userId: user.id });
+    if (token) token.destroy();
+
+    return {};
+  });
+
+  server.put('/api/v1/confirm/:token', (schema, request) => {
+    let { token } = request.params;
+
+    let user = schema.users.findBy({ emailVerificationToken: token });
+    if (!user) {
+      return new Response(400, {}, { errors: [{ detail: 'Email belonging to token not found.' }] });
+    }
+
+    user.update({ emailVerified: true, emailVerificationToken: null });
+
+    return { ok: true };
+  });
+}

mirage/serializers/api-token.js

@@ -0,0 +1,29 @@
+import BaseSerializer from './application';
+
+export default BaseSerializer.extend({
+  getHashForResource() {
+    let [hash, addToIncludes] = BaseSerializer.prototype.getHashForResource.apply(this, arguments);
+
+    if (Array.isArray(hash)) {
+      for (let resource of hash) {
+        this._adjust(resource);
+      }
+    } else {
+      this._adjust(hash);
+    }
+
+    return [hash, addToIncludes];
+  },
+
+  _adjust(hash) {
+    hash.id = Number(hash.id);
+    if (hash.created_at) {
+      hash.created_at = new Date(hash.created_at).toISOString();
+    }
+    if (hash.last_used_at) {
+      hash.last_used_at = new Date(hash.last_used_at).toISOString();
+    }
+    delete hash.token;
+    delete hash.user_id;
+  },
+});

mirage/serializers/team.js

@@ -0,0 +1,21 @@
+import BaseSerializer from './application';
+
+export default BaseSerializer.extend({
+  getHashForResource() {
+    let [hash, addToIncludes] = BaseSerializer.prototype.getHashForResource.apply(this, arguments);
+
+    if (Array.isArray(hash)) {
+      for (let resource of hash) {
+        this._adjust(resource);
+      }
+    } else {
+      this._adjust(hash);
+    }
+
+    return [hash, addToIncludes];
+  },
+
+  _adjust(hash) {
+    hash.id = Number(hash.id);
+  },
+});

mirage/serializers/user.js

@@ -0,0 +1,32 @@
+import BaseSerializer from './application';
+
+export default BaseSerializer.extend({
+  getHashForResource() {
+    let [hash, addToIncludes] = BaseSerializer.prototype.getHashForResource.apply(this, arguments);
+
+    let removePrivateData = this.request.url !== '/api/v1/me';
+
+    if (Array.isArray(hash)) {
+      for (let resource of hash) {
+        this._adjust(resource, { removePrivateData });
+      }
+    } else {
+      this._adjust(hash, { removePrivateData });
+    }
+
+    return [hash, addToIncludes];
+  },
+
+  _adjust(hash, { removePrivateData }) {
+    hash.id = Number(hash.id);
+
+    if (removePrivateData) {
+      delete hash.email;
+      delete hash.email_verified;
+    } else {
+      hash.email_verification_sent = hash.email_verified || Boolean(hash.email_verification_token);
+    }
+
+    delete hash.email_verification_token;
+  },
+});

mirage/utils/session.js

@@ -0,0 +1,9 @@
+export function getSession(schema) {
+  let session = schema.mirageSessions.first();
+  if (!session || Date.parse(session.expires) < Date.now()) {
+    return {};
+  }
+
+  let user = schema.users.find(session.userId);
+  return { session, user };
+}