WIP: Migrate from ember-cli-mirage to msw and @mswjs/data

.github/workflows/ci.yml

@@ -233,6 +233,8 @@ jobs:
 
       - run: pnpm install
 
+      - run: pnpm --filter "@crates-io/msw" test
+
       - if: github.repository == 'rust-lang/crates.io'
         run: pnpm percy exec --parallel -- pnpm test-coverage
 

.gitignore

@@ -6,7 +6,7 @@
 /tmp
 
 # dependencies
-/node_modules
+node_modules/
 /bower_components
 package-lock.json
 yarn.lock

packages/crates-io-msw/handlers/api-tokens.js

@@ -0,0 +1,5 @@
+import createToken from './api-tokens/create.js';
+import deleteToken from './api-tokens/delete.js';
+import listTokens from './api-tokens/list.js';
+
+export default [createToken, listTokens, deleteToken];

packages/crates-io-msw/handlers/api-tokens/create.js

@@ -0,0 +1,27 @@
+import { http, HttpResponse } from 'msw';
+
+import { db } from '../../index.js';
+import { serializeApiToken } from '../../serializers/api-token.js';
+import { getSession } from '../../utils/session.js';
+
+export default http.put('/api/v1/me/tokens', async ({ request }) => {
+  let { user } = getSession();
+  if (!user) {
+    return HttpResponse.json({ errors: [{ detail: 'must be logged in to perform that action' }] }, { status: 403 });
+  }
+
+  let json = await request.json();
+
+  let token = db.apiToken.create({
+    user,
+    name: json.api_token.name,
+    crateScopes: json.api_token.crate_scopes ?? null,
+    endpointScopes: json.api_token.endpoint_scopes ?? null,
+    expiredAt: json.api_token.expired_at ?? null,
+    createdAt: new Date().toISOString(),
+  });
+
+  return HttpResponse.json({
+    api_token: serializeApiToken(token, { forCreate: true }),
+  });
+});

packages/crates-io-msw/handlers/api-tokens/create.test.js

@@ -0,0 +1,110 @@
+import { afterEach, assert, beforeEach, test, vi } from 'vitest';
+
+import { db } from '../../index.js';
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date('2017-11-20T11:23:45Z'));
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+test('creates a new API token', async function () {
+  let user = db.user.create();
+  db.mswSession.create({ user });
+
+  let body = JSON.stringify({ api_token: { name: 'foooo' } });
+  let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
+  assert.strictEqual(response.status, 200);
+
+  let token = db.apiToken.findMany({})[0];
+  assert.ok(token);
+
+  assert.deepEqual(await response.json(), {
+    api_token: {
+      id: 1,
+      crate_scopes: null,
+      created_at: '2017-11-20T11:23:45.000Z',
+      endpoint_scopes: null,
+      expired_at: null,
+      last_used_at: null,
+      name: 'foooo',
+      revoked: false,
+      token: token.token,
+    },
+  });
+});
+
+test('creates a new API token with scopes', async function () {
+  let user = db.user.create();
+  db.mswSession.create({ user });
+
+  let body = JSON.stringify({
+    api_token: {
+      name: 'foooo',
+      crate_scopes: ['serde', 'serde-*'],
+      endpoint_scopes: ['publish-update'],
+    },
+  });
+  let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
+  assert.strictEqual(response.status, 200);
+
+  let token = db.apiToken.findMany({})[0];
+  assert.ok(token);
+
+  assert.deepEqual(await response.json(), {
+    api_token: {
+      id: 1,
+      crate_scopes: ['serde', 'serde-*'],
+      created_at: '2017-11-20T11:23:45.000Z',
+      endpoint_scopes: ['publish-update'],
+      expired_at: null,
+      last_used_at: null,
+      name: 'foooo',
+      revoked: false,
+      token: token.token,
+    },
+  });
+});
+
+test('creates a new API token with expiry date', async function () {
+  let user = db.user.create();
+  db.mswSession.create({ user });
+
+  let body = JSON.stringify({
+    api_token: {
+      name: 'foooo',
+      expired_at: '2023-12-24T12:34:56Z',
+    },
+  });
+  let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
+  assert.strictEqual(response.status, 200);
+
+  let token = db.apiToken.findMany({})[0];
+  assert.ok(token);
+
+  assert.deepEqual(await response.json(), {
+    api_token: {
+      id: 1,
+      crate_scopes: null,
+      created_at: '2017-11-20T11:23:45.000Z',
+      endpoint_scopes: null,
+      expired_at: '2023-12-24T12:34:56.000Z',
+      last_used_at: null,
+      name: 'foooo',
+      revoked: false,
+      token: token.token,
+    },
+  });
+});
+
+test('returns an error if unauthenticated', async function () {
+  let body = JSON.stringify({ api_token: {} });
+  let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
+  assert.strictEqual(response.status, 403);
+  assert.deepEqual(await response.json(), {
+    errors: [{ detail: 'must be logged in to perform that action' }],
+  });
+});

packages/crates-io-msw/handlers/api-tokens/delete.js

@@ -0,0 +1,21 @@
+import { http, HttpResponse } from 'msw';
+
+import { db } from '../../index.js';
+import { getSession } from '../../utils/session.js';
+
+export default http.delete('/api/v1/me/tokens/:tokenId', async ({ params }) => {
+  let { user } = getSession();
+  if (!user) {
+    return HttpResponse.json({ errors: [{ detail: 'must be logged in to perform that action' }] }, { status: 403 });
+  }
+
+  let { tokenId } = params;
+  db.apiToken.delete({
+    where: {
+      id: { equals: parseInt(tokenId) },
+      user: { id: { equals: user.id } },
+    },
+  });
+
+  return HttpResponse.json({});
+});

packages/crates-io-msw/handlers/api-tokens/delete.test.js

@@ -0,0 +1,28 @@
+import { assert, test } from 'vitest';
+
+import { db } from '../../index.js';
+
+test('revokes an API token', async function () {
+  let user = db.user.create();
+  db.mswSession.create({ user });
+
+  let token = db.apiToken.create({ user });
+
+  let response = await fetch(`/api/v1/me/tokens/${token.id}`, { method: 'DELETE' });
+  assert.strictEqual(response.status, 200);
+  assert.deepEqual(await response.json(), {});
+
+  let tokens = db.apiToken.findMany({});
+  assert.strictEqual(tokens.length, 0);
+});
+
+test('returns an error if unauthenticated', async function () {
+  let user = db.user.create();
+  let token = db.apiToken.create({ user });
+
+  let response = await fetch(`/api/v1/me/tokens/${token.id}`, { method: 'DELETE' });
+  assert.strictEqual(response.status, 403);
+  assert.deepEqual(await response.json(), {
+    errors: [{ detail: 'must be logged in to perform that action' }],
+  });
+});

packages/crates-io-msw/handlers/api-tokens/list.js

@@ -0,0 +1,30 @@
+import { http, HttpResponse } from 'msw';
+
+import { db } from '../../index.js';
+import { serializeApiToken } from '../../serializers/api-token.js';
+import { getSession } from '../../utils/session.js';
+
+export default http.get('/api/v1/me/tokens', async ({ request }) => {
+  let url = new URL(request.url);
+
+  let { user } = getSession();
+  if (!user) {
+    return HttpResponse.json({ errors: [{ detail: 'must be logged in to perform that action' }] }, { status: 403 });
+  }
+
+  let expiredAfter = new Date();
+  if (url.searchParams.has('expired_days')) {
+    expiredAfter.setUTCDate(expiredAfter.getUTCDate() - url.searchParams.get('expired_days'));
+  }
+
+  let apiTokens = db.apiToken
+    .findMany({
+      where: { user: { id: { equals: user.id } } },
+      orderBy: { id: 'desc' },
+    })
+    .filter(token => !token.expiredAt || new Date(token.expiredAt) > expiredAfter);
+
+  return HttpResponse.json({
+    api_tokens: apiTokens.map(token => serializeApiToken(token)),
+  });
+});

packages/crates-io-msw/handlers/api-tokens/list.test.js

@@ -0,0 +1,78 @@
+import { afterEach, assert, beforeEach, test, vi } from 'vitest';
+
+import { db } from '../../index.js';
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date('2017-11-20T12:00:00'));
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+test('returns the list of API token for the authenticated `user`', async function () {
+  let user = db.user.create();
+  db.mswSession.create({ user });
+
+  db.apiToken.create({
+    user,
+    createdAt: '2017-11-19T12:59:22Z',
+    crateScopes: ['serde', 'serde-*'],
+    endpointScopes: ['publish-update'],
+  });
+  db.apiToken.create({ user, createdAt: '2017-11-19T13:59:22Z', expiredAt: '2023-11-20T10:59:22Z' });
+  db.apiToken.create({ user, createdAt: '2017-11-19T14:59:22Z' });
+  db.apiToken.create({ user, createdAt: '2017-11-19T15:59:22Z', expiredAt: '2017-11-20T10:59:22Z' });
+
+  let response = await fetch('/api/v1/me/tokens');
+  assert.strictEqual(response.status, 200);
+  assert.deepEqual(await response.json(), {
+    api_tokens: [
+      {
+        id: 3,
+        crate_scopes: null,
+        created_at: '2017-11-19T14:59:22.000Z',
+        endpoint_scopes: null,
+        expired_at: null,
+        last_used_at: null,
+        name: 'API Token 3',
+      },
+      {
+        id: 2,
+        crate_scopes: null,
+        created_at: '2017-11-19T13:59:22.000Z',
+        endpoint_scopes: null,
+        expired_at: '2023-11-20T10:59:22.000Z',
+        last_used_at: null,
+        name: 'API Token 2',
+      },
+      {
+        id: 1,
+        crate_scopes: ['serde', 'serde-*'],
+        created_at: '2017-11-19T12:59:22.000Z',
+        endpoint_scopes: ['publish-update'],
+        expired_at: null,
+        last_used_at: null,
+        name: 'API Token 1',
+      },
+    ],
+  });
+});
+
+test('empty list case', async function () {
+  let user = db.user.create();
+  db.mswSession.create({ user });
+
+  let response = await fetch('/api/v1/me/tokens');
+  assert.strictEqual(response.status, 200);
+  assert.deepEqual(await response.json(), { api_tokens: [] });
+});
+
+test('returns an error if unauthenticated', async function () {
+  let response = await fetch('/api/v1/me/tokens');
+  assert.strictEqual(response.status, 403);
+  assert.deepEqual(await response.json(), {
+    errors: [{ detail: 'must be logged in to perform that action' }],
+  });
+});

packages/crates-io-msw/handlers/categories.js

@@ -0,0 +1,5 @@
+import getCategory from './categories/get.js';
+import listCategorySlugs from './categories/list-slugs.js';
+import listCategories from './categories/list.js';
+
+export default [listCategories, getCategory, listCategorySlugs];

packages/crates-io-msw/handlers/categories/get.js

@@ -0,0 +1,15 @@
+import { http, HttpResponse } from 'msw';
+
+import { db } from '../../index.js';
+import { serializeCategory } from '../../serializers/category.js';
+import { notFound } from '../../utils/handlers.js';
+
+export default http.get('/api/v1/categories/:category_id', ({ params }) => {
+  let catId = params.category_id;
+  let category = db.category.findFirst({ where: { id: { equals: catId } } });
+  if (!category) {
+    return notFound();
+  }
+
+  return HttpResponse.json({ category: serializeCategory(category) });
+});

packages/crates-io-msw/handlers/categories/get.test.js

@@ -0,0 +1,49 @@
+import { assert, test } from 'vitest';
+
+import { db } from '../../index.js';
+
+test('returns 404 for unknown categories', async function () {
+  let response = await fetch('/api/v1/categories/foo');
+  assert.strictEqual(response.status, 404);
+  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+});
+
+test('returns a category object for known categories', async function () {
+  db.category.create({
+    category: 'no-std',
+    description: 'Crates that are able to function without the Rust standard library.',
+  });
+
+  let response = await fetch('/api/v1/categories/no-std');
+  assert.strictEqual(response.status, 200);
+  assert.deepEqual(await response.json(), {
+    category: {
+      id: 'no-std',
+      category: 'no-std',
+      crates_cnt: 0,
+      created_at: '2010-06-16T21:30:45Z',
+      description: 'Crates that are able to function without the Rust standard library.',
+      slug: 'no-std',
+    },
+  });
+});
+
+test('calculates `crates_cnt` correctly', async function () {
+  let cli = db.category.create({ category: 'cli' });
+  Array.from({ length: 7 }, () => db.crate.create({ categories: [cli] }));
+  let notCli = db.category.create({ category: 'not-cli' });
+  Array.from({ length: 3 }, () => db.crate.create({ categories: [notCli] }));
+
+  let response = await fetch('/api/v1/categories/cli');
+  assert.strictEqual(response.status, 200);
+  assert.deepEqual(await response.json(), {
+    category: {
+      category: 'cli',
+      crates_cnt: 7,
+      created_at: '2010-06-16T21:30:45Z',
+      description: 'This is the description for the category called "cli"',
+      id: 'cli',
+      slug: 'cli',
+    },
+  });
+});