feat(connect): add queue.create and queue.destroy #619

Author: TillaTheHun0

packages/connect/deno/mod.ts

@@ -247,6 +247,16 @@ export function connect(CONNECTION_STRING: string, domain = 'default'): Hyper {
           .then(queue.queued())
           .then($fetch)
           .then(handleResponse),
+      create: (target, secret) =>
+        Promise.resolve(h)
+          .then(queue.create(target, secret))
+          .then($fetch)
+          .then(handleResponse),
+      destroy: (confirm) =>
+        Promise.resolve(h)
+          .then(queue.destroy(confirm))
+          .then($fetch)
+          .then(handleResponse),
     },
     info: {
       services: () =>

packages/connect/deno/services/queue.ts

@@ -10,3 +10,11 @@ export const errors = () => (h: HyperRequestFunction) =>
 
 export const queued = () => (h: HyperRequestFunction) =>
   h({ service, method: Method.GET, params: { status: QueueStatus.READY } })
+
+export const create = (target: string, secret?: string) => (hyper: HyperRequestFunction) =>
+  hyper({ service, method: Method.PUT, body: { target, secret } })
+
+export const destroy = (confirm?: boolean) => (hyper: HyperRequestFunction) =>
+  confirm
+    ? hyper({ service, method: Method.DELETE })
+    : Promise.reject({ ok: false, msg: 'request not confirmed!' })

packages/connect/deno/tests/queue.test.ts

@@ -1,7 +1,9 @@
 import { HyperRequest } from '../types.ts'
-import { assertEquals } from '../dev_deps.ts'
+import { assert, assertEquals } from '../dev_deps.ts'
 
 import { enqueue, errors, queued } from '../services/queue.ts'
+import { create } from '../services/queue.ts'
+import { destroy } from '../services/queue.ts'
 
 const test = Deno.test
 
@@ -57,3 +59,45 @@ test('queue.queued', async () => {
   const request = await queued()(mockRequest)
   assertEquals(request.url, 'http://localhost/?status=READY')
 })
+
+test('queue.create', async () => {
+  const mockRequest = (h: HyperRequest) => {
+    assertEquals(h.service, 'queue')
+    assertEquals(h.method, 'PUT')
+    return Promise.resolve(
+      new Request('http://localhost', {
+        method: 'PUT',
+        body: JSON.stringify(h.body),
+      }),
+    )
+  }
+
+  const result = await create('https://foo.bar', 'shhhh')(mockRequest)
+  const body = await result.json()
+  assertEquals(body, { target: 'https://foo.bar', secret: 'shhhh' })
+
+  const noSecret = await create('https://foo.bar')(mockRequest)
+  const noSecertBody = await noSecret.json()
+  assertEquals(noSecertBody, { target: 'https://foo.bar' })
+})
+
+test('queue.destroy', async () => {
+  const mockRequest = (h: HyperRequest) => {
+    assertEquals(h.service, 'queue')
+    assertEquals(h.method, 'DELETE')
+    return Promise.resolve(
+      new Request('http://localhost', { method: 'DELETE' }),
+    )
+  }
+
+  await destroy(true)(mockRequest)
+
+  const noConfirmRequest = (_h: HyperRequest) => {
+    assert(false, 'unreachable')
+    return Promise.resolve(
+      new Request('http://localhost', { method: 'DELETE' }),
+    )
+  }
+
+  await destroy()(noConfirmRequest).catch(assert)
+})

packages/connect/deno/types.ts

@@ -175,6 +175,11 @@ export interface HyperQueue {
   enqueue: <Job>(job: Job) => Promise<Result>
   errors: <Job>() => Promise<Job[]>
   queued: <Job>() => Promise<Job[]>
+  create: (
+    target: string,
+    secret?: string,
+  ) => Promise<Result>
+  destroy: (confirm: boolean) => Promise<Result>
 }
 
 export interface HyperRequest {