feat: add dist-tags support

packages/emeralt-cli/package.json

@@ -23,10 +23,10 @@
     "start": "node build/index.js"
   },
   "dependencies": {
-    "@emeralt/auth-inmemory": "^0.7.0",
-    "@emeralt/database-inmemory": "^0.7.0",
     "@emeralt/server": "^0.7.0",
-    "@emeralt/storage-inmemory": "^0.7.0",
+    "@emeralt/auth-inmemory": "^0.7.0",
+    "@emeralt/database-localfs": "^0.7.0",
+    "@emeralt/storage-localfs": "^0.7.0",
     "chalk": "^2.4.2"
   }
 }

packages/emeralt-cli/src/index.ts

@@ -1,17 +1,23 @@
 import chalk from 'chalk'
+import { homedir } from 'os'
+import { resolve } from 'path'
 import { createEmeraltServer } from '@emeralt/server'
 import { EmeraltAuthInMemory } from '@emeralt/auth-inmemory'
-import { EmeraltDatabaseInMemory } from '@emeralt/database-inmemory'
-import { EmeraltStorageInMemory } from '@emeralt/storage-inmemory'
+import { EmeraltDatabaseLocalFS } from '@emeralt/database-localfs'
+import { EmeraltStorageLocalFS } from '@emeralt/storage-localfs'
 
 createEmeraltServer({
   auth: EmeraltAuthInMemory({
     users: {
       emeralt: 'emeralt',
     },
   }),
-  database: EmeraltDatabaseInMemory({}),
-  storage: EmeraltStorageInMemory({}),
+  database: EmeraltDatabaseLocalFS({
+    path: resolve(homedir(), '.emeralt'),
+  }),
+  storage: EmeraltStorageLocalFS({
+    path: resolve(homedir(), '.emeralt'),
+  }),
 }).then((server) => {
   server.listen(8080, () => {
     console.log(chalk.bold.greenBright('Emeralt is listening at 8080...'))

packages/emeralt-cli/test/index.test.ts

@@ -1,31 +1,19 @@
 import test from 'ava'
 import supertest from 'supertest'
-import { spawn } from 'child_process'
+import { fork } from 'child_process'
 
-test('start server', async (t) => {
-  require('../src/index')
+const sleep = (t) => new Promise((resolve) => setTimeout(resolve, t))
+
+test.serial('start server', async (t) => {
+  const server = fork('build/index.js')
+
+  await sleep(1000)
 
   await supertest('http://localhost:8080')
     .get('/-/ping')
     .expect(200)
 
-  t.pass()
-})
-
-test('start built server', async (t) => {
-  const { status, body } = await new Promise(async (resolve) => {
-    const server = spawn('node', ['build/index.js'])
-
-    const { status, body } = await supertest('http://localhost:8080').get(
-      '/-/ping',
-    )
+  server.kill('SIGTERM')
 
-    server.kill('SIGTERM')
-    server.on('close', () => {
-      resolve({ status, body })
-    })
-  })
-
-  t.is(status, 200)
-  t.deepEqual(body, {})
+  t.pass()
 })

packages/emeralt-database-localfs/src/index.ts

@@ -6,7 +6,6 @@ import {
 } from '@emeralt/types'
 import fs from 'fs-extra'
 import { join } from 'path'
-import { isNull } from 'util'
 
 interface Options {
   path?: string
@@ -43,8 +42,8 @@ class CEmeraltDatabaseLocalFS implements CEmeraltDatabase {
 
   constructor(private options: Options) {
     this.paths = {
-      metadatas: join(process.cwd(), options.path, 'metadatas'),
-      versions: join(process.cwd(), options.path, 'versions'),
+      metadatas: join(options.path, 'metadatas'),
+      versions: join(options.path, 'versions'),
     }
   }
 
@@ -107,14 +106,14 @@ class CEmeraltDatabaseLocalFS implements CEmeraltDatabase {
   }
 }
 
-export const EmeraltDatabaseInMemory: IEmeraltDatabase<Options> = (
+export const EmeraltDatabaseLocalFS: IEmeraltDatabase<Options> = (
   userOptions,
 ) => async () => {
   const options = Object.assign({}, defaultOptions, userOptions)
 
-  await fs.ensureDir(join(process.cwd(), options.path))
-  await fs.ensureDir(join(process.cwd(), options.path, 'metadatas'))
-  await fs.ensureDir(join(process.cwd(), options.path, 'versions'))
+  await fs.ensureDir(join(options.path))
+  await fs.ensureDir(join(options.path, 'metadatas'))
+  await fs.ensureDir(join(options.path, 'versions'))
 
   return new CEmeraltDatabaseLocalFS(options)
 }

packages/emeralt-server/package.json

@@ -24,6 +24,7 @@
     "compression": "^1.7.3",
     "deepmerge": "^3.0.0",
     "express": "^4.16.4",
+    "express-pino-logger": "^4.0.0",
     "jsonwebtoken": "^8.4.0",
     "libnpm": "^2.0.1",
     "morgan": "^1.9.1",
@@ -41,7 +42,6 @@
     "@types/npm-packlist": "^1.1.0",
     "@types/supertest": "2.0.7",
     "@types/tar": "^4.0.0",
-    "casual": "^1.6.0",
     "doasync": "^2.0.1",
     "node-fetch": "^2.3.0",
     "npm-packlist": "^1.2.0",

packages/emeralt-server/src/config.ts

@@ -1,7 +1,13 @@
 import { TEmeraltServerConfig } from '@emeralt/types'
 
+const getLogLevel = () => {
+  if (process.env.NODE_ENV === 'test') return 'silent'
+  if (process.env.NODE_ENV === 'production') return 'production'
+  else return 'dev'
+}
+
 export const emeraltServerDefaultConfig: TEmeraltServerConfig = {
-  logLevel: 'dev',
+  logLevel: getLogLevel(),
   jwt: {
     secret: 'secret',
   },
@@ -15,6 +21,13 @@ export const emeraltServerDefaultConfig: TEmeraltServerConfig = {
     package: {
       get: true,
       publish: true,
+      tarball: true,
+    },
+
+    distTags: {
+      get: true,
+      create: true,
+      delete: true,
     },
 
     sys: {

packages/emeralt-server/src/constants.ts

@@ -6,10 +6,16 @@ export const endpoints = {
 
   package: {
     get: '/:package_name',
-    getTarball: '/-/tarball/:name/:version',
+    getTarball: '/-/tarball/:package_name/:version',
     publish: '/:package_name',
   },
 
+  distTags: {
+    get: '/-/package/:package_name/dist-tags',
+    create: '/-/package/:package_name/dist-tags/:dist_tag',
+    delete: '/-/package/:package_name/dist-tags/:dist_tag',
+  },
+
   sys: {
     healthz: '/-/sys/healthz',
   },

packages/emeralt-server/src/handlers/adduser.ts

@@ -1,23 +1,36 @@
 import { TEmeraltHandlerParams } from '@emeralt/types'
-import { endpoints } from '@/constants'
 import { Router } from 'express'
 import jwt from 'jsonwebtoken'
+
+import { endpoints } from '@/constants'
 import { useIf } from '@/utils'
 
-export const adduserHandler = ({ auth, config }: TEmeraltHandlerParams) =>
+export const adduserHandler = ({
+  config,
+  middlewares,
+  services,
+  auth,
+}: TEmeraltHandlerParams) =>
   useIf(
     config.endpoints.adduser,
-    Router().put(endpoints.adduser, async (req, res, next) => {
-      const { name, password }: TRegistryAuthenticateRequestBody = req.body
+    Router().put(
+      endpoints.adduser,
+      middlewares.json,
+      async (req, res, next) => {
+        const {
+          name: username,
+          password,
+        }: TRegistryAuthenticateRequestBody = req.body
 
-      const valid = await auth.comparePassword(name, password)
+        const valid = await auth.comparePassword(username, password)
 
-      return res.status(valid ? 201 : 401).json({
-        ok: valid,
-        id: name,
-        token: valid ? jwt.sign({ name }, 'secret') : null,
-      })
-    }),
+        return res.status(valid ? 201 : 401).json({
+          ok: valid,
+          id: username,
+          token: valid ? services.jwt.sign({ username }) : null,
+        })
+      },
+    ),
   )
 
 type TRegistryAuthenticateRequestBody = {

packages/emeralt-server/src/handlers/dist-tags/create.ts

@@ -0,0 +1,38 @@
+import { TEmeraltHandlerParams } from '@emeralt/types'
+import { Router } from 'express'
+
+import { endpoints } from '@/constants'
+import { useIf } from '@/utils'
+
+export const createDistTagHandler = ({
+  config,
+  middlewares,
+  database,
+}: TEmeraltHandlerParams) =>
+  useIf(
+    config.endpoints.distTags.create,
+    Router().put(
+      endpoints.distTags.create,
+      middlewares.verifyToken,
+      middlewares.text,
+      async (req, res) => {
+        const { package_name, dist_tag } = req.params
+
+        const metadata = await database.getMetadata(package_name)
+
+        if (!metadata) {
+          return res.status(400).json({ ok: false })
+        }
+
+        if (!metadata['dist-tags']) {
+          metadata['dist-tags'] = {}
+        }
+
+        metadata['dist-tags'][dist_tag] = req.body
+
+        await database.putMetadata(package_name, metadata)
+
+        return res.status(200).json({ ok: true })
+      },
+    ),
+  )

packages/emeralt-server/src/handlers/dist-tags/delete.ts

@@ -0,0 +1,29 @@
+import { TEmeraltHandlerParams } from '@emeralt/types'
+import { Router } from 'express'
+
+import { endpoints } from '@/constants'
+import { useIf } from '@/utils'
+
+export const deleteDistTagHandler = ({
+  config,
+  middlewares,
+  database,
+}: TEmeraltHandlerParams) =>
+  useIf(
+    config.endpoints.distTags.delete,
+    Router().delete(
+      endpoints.distTags.delete,
+      middlewares.verifyToken,
+      async (req, res) => {
+        const { package_name, dist_tag } = req.params
+
+        const metadata = await database.getMetadata(package_name)
+
+        delete metadata['dist-tags'][dist_tag]
+
+        await database.putMetadata(package_name, metadata)
+
+        return res.status(200).json({ ok: true })
+      },
+    ),
+  )

packages/emeralt-server/src/handlers/dist-tags/get.ts

@@ -0,0 +1,23 @@
+import { TEmeraltHandlerParams } from '@emeralt/types'
+import { Router } from 'express'
+
+import { endpoints } from '@/constants'
+import { useIf } from '@/utils'
+
+export const getDistTagsHandler = ({
+  config,
+  middlewares,
+  database,
+}: TEmeraltHandlerParams) =>
+  useIf(
+    config.endpoints.distTags.get,
+    Router().get(endpoints.distTags.get, async (req, res) => {
+      const metadata = await database.getMetadata(req.params.package_name)
+
+      if (metadata) {
+        return res.status(200).json(metadata['dist-tags'])
+      } else {
+        return res.status(404).json({ ok: false })
+      }
+    }),
+  )

packages/emeralt-server/src/handlers/dist-tags/index.ts

@@ -0,0 +1,13 @@
+import { TEmeraltHandlerParams } from '@emeralt/types'
+import { Router } from 'express'
+
+// handlers
+import { createDistTagHandler } from './create'
+import { getDistTagsHandler } from './get'
+import { deleteDistTagHandler } from './delete'
+
+export const distTagsHandler = (params: TEmeraltHandlerParams) =>
+  Router()
+    .use(getDistTagsHandler(params))
+    .use(createDistTagHandler(params))
+    .use(deleteDistTagHandler(params))

packages/emeralt-server/src/handlers/index.ts

@@ -4,6 +4,7 @@ import { TEmeraltHandlerParams } from '@emeralt/types'
 import { pingHandler } from './ping'
 import { searchHandler } from './search'
 import { packagesHandler } from './packages'
+import { distTagsHandler } from './dist-tags'
 import { loginHandler } from './login'
 import { adduserHandler } from './adduser'
 import { sysHandler } from './sys'
@@ -12,6 +13,7 @@ export const createHandlers = (params: TEmeraltHandlerParams) => ({
   ping: pingHandler(params),
   search: searchHandler(params),
   packages: packagesHandler(params),
+  distTags: distTagsHandler(params),
   login: loginHandler(params),
   adduser: adduserHandler(params),
   sys: sysHandler(params),

packages/emeralt-server/src/handlers/login.ts

@@ -1,7 +1,8 @@
 import { TEmeraltHandlerParams } from '@emeralt/types'
+import { Router } from 'express'
+
 import { endpoints } from '@/constants'
 import { useIf } from '@/utils'
-import { Router } from 'express'
 
 export const loginHandler = ({ config }: TEmeraltHandlerParams) =>
   useIf(

packages/emeralt-server/src/handlers/packages/get.ts

@@ -1,9 +1,10 @@
 import { TEmeraltHandlerParams } from '@emeralt/types'
-import { endpoints } from '@/constants'
-import { useIf } from '@/utils'
 import { Router } from 'express'
 import { resolve } from 'url'
 
+import { endpoints } from '@/constants'
+import { useIf } from '@/utils'
+
 export const getPackageHandler = ({
   config,
   database,