Merge pull request #67 from craftship/deprecate

Add npm deprecate Support

Author: jonsharratt

src/adapters/logger.js

@@ -1,7 +1,8 @@
 import fetch from 'node-fetch';
 
 export default class Logger {
-  constructor(namespace, credentials = {}) {
+  constructor(cmd, namespace, credentials = {}) {
+    this.command = cmd;
     this.namespace = namespace;
     this.credentials = credentials;
   }
@@ -25,6 +26,7 @@ export default class Logger {
       timestamp: new Date(),
       level: 'error',
       namespace: `error:${this.namespace}`,
+      command: this.command,
       body: {
         message,
         stack,
@@ -40,6 +42,7 @@ export default class Logger {
       timestamp: new Date(),
       level: 'info',
       namespace: `info:${this.namespace}`,
+      command: this.command,
       body: message,
     };
 

src/contextFactory.js

@@ -7,15 +7,26 @@ const user = authorizer => ({
   avatar: authorizer.avatar,
 });
 
+const command = (headers) => {
+  const refererParts = headers.Referer.split(' ');
+  const name = refererParts[0];
+
+  return {
+    name,
+    args: refererParts.slice(1),
+  };
+};
+
 const storage = (region, bucket) =>
   new S3({
     region,
     bucket,
   });
 
-const log = (namespace, region, topic) => {
+const log = (cmd, namespace, region, topic) => {
   if (process.env.clientId && process.env.secret) {
     return new Logger(
+      cmd,
       namespace,
       {
         clientId: process.env.clientId,
@@ -25,25 +36,29 @@ const log = (namespace, region, topic) => {
   }
 
   return new Logger(
+    cmd,
     namespace, {
       region,
       topic,
     });
 };
 
-export default (namespace, { authorizer }) => {
+export default (namespace, { headers, requestContext }) => {
   const {
     registry,
     bucket,
     region,
     logTopic,
   } = process.env;
 
+  const cmd = command(headers);
+
   return {
+    command: cmd,
     registry,
-    user: user(authorizer),
+    user: user(requestContext.authorizer),
     storage: storage(region, bucket),
-    log: log(namespace, region, logTopic),
+    log: log(cmd, namespace, region, logTopic),
     npm,
   };
 };

src/get/index.js

@@ -1,11 +1,13 @@
 import lib from './lib';
 import contextFactory from '../contextFactory';
 
-export default async (event, _, callback) => lib(
-  event,
-  contextFactory(
-    'package:get',
-    event.requestContext,
-  ),
-  callback,
-);
+export default async (event, _, callback) => {
+  lib(
+    event,
+    contextFactory(
+      'package:get',
+      event,
+    ),
+    callback,
+  );
+};

src/put/deprecate.js

@@ -0,0 +1,37 @@
+export default async ({
+  requestContext,
+  pathParameters,
+  body,
+}, {
+  registry,
+  user,
+  storage,
+  npm,
+  log,
+}, callback) => {
+  const name = `${decodeURIComponent(pathParameters.name)}`;
+
+  try {
+    await storage.put(
+      `${name}/index.json`,
+      body.toString(),
+    );
+
+    return callback(null, {
+      statusCode: 200,
+      body: JSON.stringify({
+        success: true,
+      }),
+    });
+  } catch (putError) {
+    await log.error(user, putError);
+
+    return callback(null, {
+      statusCode: 500,
+      body: JSON.stringify({
+        success: false,
+        error: putError.message,
+      }),
+    });
+  }
+};

src/put/index.js

@@ -1,11 +1,24 @@
-import lib from './lib';
+import deprecate from './deprecate';
+import publish from './publish';
 import contextFactory from '../contextFactory';
 
-export default async (event, _, callback) => lib(
-  event,
-  contextFactory(
+export default async (event, _, callback) => {
+  const context = contextFactory(
     'package:put',
-    event.requestContext,
-  ),
-  callback,
-);
+    event,
+  );
+
+  if (context.command.name === 'deprecate') {
+    return deprecate(
+      event,
+      context,
+      callback,
+    );
+  }
+
+  return publish(
+    event,
+    context,
+    callback,
+  );
+};

src/put/lib.js src/put/publish.jssrc/put/lib.js renamed to src/put/publish.js

@@ -21,7 +21,7 @@ describe('Logger', () => {
 
   describe('#info()', () => {
     it('should call insights logging endpoint  with correct parameters', async () => {
-      const subject = new Subject('foo:bar', {
+      const subject = new Subject({ name: 'foo', args: [] }, 'foo:bar', {
         clientId: 'foo-client-id',
         secret: 'bar-secret',
       });
@@ -34,14 +34,14 @@ describe('Logger', () => {
           'Content-Type': 'application/json',
           Authorization: 'Bearer foo-client-id:bar-secret',
         },
-        body: '{"user":{"name":"foo","avatar":"https://example.com"},"timestamp":"1970-01-01T00:00:00.000Z","level":"info","namespace":"info:foo:bar","body":{"foo":"bar"}}',
+        body: '{"user":{"name":"foo","avatar":"https://example.com"},"timestamp":"1970-01-01T00:00:00.000Z","level":"info","namespace":"info:foo:bar","command":{"name":"foo","args":[]},"body":{"foo":"bar"}}',
       }));
     });
   });
 
   describe('#error()', () => {
     it('should call insights logging endpoint  with correct parameters', async () => {
-      const subject = new Subject('foo:bar', {
+      const subject = new Subject({ name: 'foo', args: [] }, 'foo:bar', {
         clientId: 'foo-client-id',
         secret: 'bar-secret',
       });
@@ -57,7 +57,7 @@ describe('Logger', () => {
           'Content-Type': 'application/json',
           Authorization: 'Bearer foo-client-id:bar-secret',
         },
-        body: '{"user":{"name":"foo","avatar":"https://example.com"},"timestamp":"1970-01-01T00:00:00.000Z","level":"error","namespace":"error:foo:bar","body":{"message":"Foo Bar","stack":"foo bar stack"}}',
+        body: '{"user":{"name":"foo","avatar":"https://example.com"},"timestamp":"1970-01-01T00:00:00.000Z","level":"error","namespace":"error:foo:bar","command":{"name":"foo","args":[]},"body":{"message":"Foo Bar","stack":"foo bar stack"}}',
       }));
     });
   });

test/adapters/logger.test.js

@@ -1,4 +1,32 @@
 export default {
+  deprecate: (msg, {
+    major,
+    minor,
+    patch,
+  }) => new Buffer(
+    JSON.stringify({
+      _id: 'foo-bar-package',
+      name: 'foo-bar-package',
+      'dist-tags': {
+        latest: `${major}.${minor}.${patch}`,
+      },
+      versions: {
+        [`${major}.${minor}.${patch}`]: {
+          name: 'foo-bar-package',
+          version: `${major}.${minor}.${patch}`,
+          deprecated: msg,
+          dist: {
+            tarball: `https://example.com/registry/foo-bar-package/-/foo-bar-package-${major}.${minor}.${patch}.tgz`,
+          },
+        },
+      },
+      _attachments: {
+        [`foo-bar-package-${major}.${minor}.${patch}.tgz`]: {
+          data: 'foo-package-data',
+        },
+      },
+    }),
+  ),
   withAttachments: ({
     major,
     minor,

test/fixtures/package.js

@@ -0,0 +1,138 @@
+/* eslint-disable no-underscore-dangle */
+import pkg from '../fixtures/package';
+
+import subject from '../../src/put/deprecate';
+
+describe('PUT /registry/{name}', () => {
+  let event;
+  let callback;
+  let storageStub;
+
+  beforeEach(() => {
+    const env = {
+      bucket: 'foo-bucket',
+      region: 'bar-region',
+    };
+
+    process.env = env;
+
+    event = (msg, version) => ({
+      requestContext: {
+        authorizer: {
+          username: 'foo',
+          avatar: 'https://example.com',
+        },
+      },
+      body: pkg.deprecate(msg, version),
+      pathParameters: {
+        name: 'foo-bar-package',
+      },
+    });
+
+    callback = stub();
+  });
+
+  describe('deprecate', () => {
+    beforeEach(() => {
+      storageStub = {
+        put: stub(),
+      };
+    });
+
+    it('should store package json', async () => {
+      await subject(
+        event('This package is deprecated', {
+          major: 1,
+          minor: 0,
+          patch: 0,
+        }), {
+          registry: 'https://example.com',
+          user: stub(),
+          log: {
+            info: stub(),
+            error: stub(),
+          },
+          npm: stub(),
+          storage: storageStub,
+          command: {
+            name: 'deprecate',
+            message: 'This package is deprecated',
+          },
+        },
+        callback,
+      );
+
+      assert(storageStub.put.calledWithExactly(
+        'foo-bar-package/index.json',
+        pkg.deprecate('This package is deprecated', {
+          major: 1,
+          minor: 0,
+          patch: 0,
+        }).toString(),
+      ));
+    });
+
+    it('should return correct response', async () => {
+      await subject(
+        event('This package is deprecated', {
+          major: 1,
+          minor: 0,
+          patch: 0,
+        }), {
+          registry: 'https://example.com',
+          user: stub(),
+          log: {
+            info: stub(),
+            error: stub(),
+          },
+          npm: stub(),
+          storage: storageStub,
+        },
+        callback,
+      );
+
+      assert(callback.calledWithExactly(null, {
+        statusCode: 200,
+        body: '{"success":true}',
+      }));
+    });
+
+    context('storage put error', () => {
+      beforeEach(() => {
+        storageStub = {
+          get: stub().returns(pkg.deprecate('This package is deprecated', {
+            major: 1,
+            minor: 0,
+            patch: 0,
+          })),
+          put: stub().throws(new Error('Failed to put')),
+        };
+      });
+
+      it('should return 500 response', async () => {
+        await subject(
+          event('This package is deprecated', {
+            major: 2,
+            minor: 0,
+            patch: 0,
+          }), {
+            registry: 'https://example.com',
+            user: stub(),
+            log: {
+              error: stub(),
+              info: stub(),
+            },
+            npm: stub(),
+            storage: storageStub,
+          },
+          callback,
+        );
+
+        assert(callback.calledWithExactly(null, {
+          statusCode: 500,
+          body: '{"success":false,"error":"Failed to put"}',
+        }));
+      });
+    });
+  });
+});

test/put/deprecate.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-underscore-dangle */
 import pkg from '../fixtures/package';
 
-import subject from '../../src/put/lib';
+import subject from '../../src/put/publish';
 
 describe('PUT /registry/{name}', () => {
   let event;