versioning and deps for proxy

Author: timgit

packages/proxy/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pg-boss/proxy",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "HTTP proxy for pg-boss",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,21 +29,21 @@
     "prepublishOnly": "npm run typecheck && npm run build && npm test"
   },
   "dependencies": {
-    "@hono/node-server": "^1.19.14",
+    "@hono/node-server": "^2.0.5",
     "@hono/swagger-ui": "^0.6.1",
-    "@hono/zod-openapi": "^1.3.0",
-    "@logtape/hono": "^2.0.5",
-    "@logtape/logtape": "^2.0.5",
-    "hono": "^4.12.14",
-    "pg-boss": "^12.16.0",
-    "zod": "^4.3.6"
+    "@hono/zod-openapi": "^1.4.0",
+    "@logtape/hono": "^2.1.5",
+    "@logtape/logtape": "^2.1.5",
+    "hono": "^4.12.26",
+    "pg-boss": "^12.20.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^22.19.17",
+    "@types/node": "^22.19.21",
     "cross-env": "^10.1.0",
-    "tsx": "^4.21.0",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.9"
   },
   "repository": {
     "type": "git",

packages/proxy/package.json

@@ -120,6 +120,14 @@ export const jobInsertSchema = z.object({
   deadLetter: z.string().optional(),
 }) satisfies z.ZodType<types.HttpJobInsert>
 
+export const flowJobSchema = z.object({
+  ref: z.string(),
+  name: queueNameSchema,
+  data: jsonRecordSchema.optional(),
+  options: jobInsertSchema.omit({ data: true }).optional(),
+  dependsOn: z.array(z.string()).optional(),
+}) satisfies z.ZodType<types.HttpFlowJob>
+
 const jobSchemaBase = z.object({
   id: z.string(),
   name: z.string(),
@@ -162,6 +170,11 @@ export const commandResponseSchema = z.object({
   affected: z.number(),
 }) satisfies z.ZodType<types.HttpCommandResponse>
 
+export const dependencyRefSchema = z.object({
+  name: z.string(),
+  id: z.string(),
+}) satisfies z.ZodType<types.HttpDependencyRef>
+
 export const queueResultSchema = z.object({
   name: z.string(),
   expireInSeconds: z.number().optional(),
@@ -274,6 +287,15 @@ export const insertResponseSchema: z.ZodType<types.HttpInsertResponse> = z.objec
   result: z.array(z.string()).nullable()
 })
 
+export const flowRequestSchema: z.ZodType<types.HttpFlowRequest> = z.object({
+  jobs: z.array(flowJobSchema)
+})
+
+export const flowResponseSchema: z.ZodType<types.HttpFlowResponse> = z.object({
+  ok: z.literal(true),
+  result: z.record(z.string(), z.string())
+})
+
 export const fetchRequestSchema: z.ZodType<types.HttpFetchRequest> = z.object({
   name: queueNameSchema,
   options: fetchOptionsSchema.optional()
@@ -410,6 +432,16 @@ export const findJobsResponseSchema: z.ZodType<types.HttpFindJobsResponse> = z.o
   result: z.array(jobWithMetadataSchema)
 })
 
+export const getDependenciesResponseSchema: z.ZodType<types.HttpGetDependenciesResponse> = z.object({
+  ok: z.literal(true),
+  result: z.array(dependencyRefSchema)
+})
+
+export const getDependentsResponseSchema: z.ZodType<types.HttpGetDependentsResponse> = z.object({
+  ok: z.literal(true),
+  result: z.array(dependencyRefSchema)
+})
+
 export const createQueueRequestSchema: z.ZodType<types.HttpCreateQueueRequest> = z.object({
   name: queueNameSchema,
   options: queueOptionsSchema.and(z.object({

packages/proxy/src/contracts.ts

@@ -20,9 +20,13 @@ import {
   failResponseSchema,
   fetchRequestSchema,
   fetchResponseSchema,
+  flowRequestSchema,
+  flowResponseSchema,
   findJobsResponseSchema,
   getBamStatusResponseSchema,
   getBlockedKeysResponseSchema,
+  getDependenciesResponseSchema,
+  getDependentsResponseSchema,
   getQueueResponseSchema,
   getQueuesResponseSchema,
   getSchedulesResponseSchema,
@@ -154,12 +158,18 @@ const blockedKeysQuerySchema = z.object({
   name: z.string().min(1)
 })
 
+const dependencyQuerySchema = z.object({
+  name: z.string().min(1),
+  id: z.string().min(1)
+})
+
 export const postMethods: RouteEntry[] = [
   post('jobs', 'send', sendRequestSchema, sendResponseSchema, (body) => withOptionalDataOptions([body.name], body.data, body.options)),
   post('jobs', 'sendAfter', sendAfterRequestSchema, sendAfterResponseSchema, (body) => withFixedDataOptions([body.name], body.data, body.options, [body.after])),
   post('jobs', 'sendThrottled', sendThrottledRequestSchema, sendThrottledResponseSchema, (body) => withFixedDataOptions([body.name], body.data, body.options, [body.seconds, body.key])),
   post('jobs', 'sendDebounced', sendDebouncedRequestSchema, sendDebouncedResponseSchema, (body) => withFixedDataOptions([body.name], body.data, body.options, [body.seconds, body.key])),
   post('jobs', 'insert', insertRequestSchema, insertResponseSchema, (body) => withOptionalOptions([body.name, body.jobs], body.options)),
+  post('jobs', 'flow', flowRequestSchema, flowResponseSchema, (body) => [body.jobs]),
   post('jobs', 'fetch', fetchRequestSchema, fetchResponseSchema, (body) => withOptionalOptions([body.name], body.options)),
   post('jobs', 'complete', completeRequestSchema, completeResponseSchema, (body) => withOptionalDataOptions([body.name, body.id], body.data, body.options)),
   post('jobs', 'fail', failRequestSchema, failResponseSchema, (body) => withOptionalDataOptions([body.name, body.id], body.data)),
@@ -193,6 +203,8 @@ export const getMethods: RouteEntry[] = [
     if (q.name) return [q.name]
     return []
   }),
+  get('jobs', 'getDependencies', getDependenciesResponseSchema, dependencyQuerySchema, (q) => [q.name, q.id]),
+  get('jobs', 'getDependents', getDependentsResponseSchema, dependencyQuerySchema, (q) => [q.name, q.id]),
   get('jobs', 'findJobs', findJobsResponseSchema, findJobsQuerySchema, (q) => {
     const args: unknown[] = [q.name]
     const options: Record<string, unknown> = {}

packages/proxy/src/routes.ts

@@ -45,6 +45,11 @@ export type HttpCompleteOptions = Omit<types.CompleteOptions, 'db'>
 
 export type HttpJobInsert = types.JobInsert<HttpJsonRecord>
 
+export type HttpFlowJob = Omit<types.FlowJob, 'data' | 'options'> & {
+  data?: HttpJsonRecord
+  options?: Omit<HttpJobInsert, 'data'>
+}
+
 export type HttpJob = Omit<types.Job<HttpJsonRecord>, 'signal'>
 
 export type HttpJobWithMetadata = Omit<
@@ -57,6 +62,8 @@ export type HttpJobWithMetadata = Omit<
 
 export type HttpCommandResponse = types.CommandResponse
 
+export type HttpDependencyRef = types.DependencyRef
+
 export type HttpQueueResult = types.QueueResult
 
 export type HttpSchedule = Omit<types.Schedule, 'data' | 'options'> & {
@@ -128,6 +135,15 @@ export type HttpInsertResponse = {
   result: string[] | null
 }
 
+export type HttpFlowRequest = {
+  jobs: HttpFlowJob[]
+}
+
+export type HttpFlowResponse = {
+  ok: true
+  result: Record<string, string>
+}
+
 export type HttpFetchRequest = {
   name: HttpQueueName
   options?: HttpFetchOptions
@@ -222,6 +238,16 @@ export type HttpFindJobsResponse = {
   result: HttpJobWithMetadata[]
 }
 
+export type HttpGetDependenciesResponse = {
+  ok: true
+  result: HttpDependencyRef[]
+}
+
+export type HttpGetDependentsResponse = {
+  ok: true
+  result: HttpDependencyRef[]
+}
+
 export type HttpCreateQueueOptions = HttpQueueOptions & {
   policy?: string
   partition?: boolean

packages/proxy/src/types.ts

@@ -395,6 +395,11 @@ describe('proxy api routes', () => {
         body: { name: 'queue', jobs: [{ id: '1', data: {} }], options: { returnId: true } },
         expected: ['queue', [{ id: '1', data: {} }], { returnId: true }]
       },
+      {
+        method: 'flow',
+        body: { jobs: [{ ref: 'a', name: 'queue' }, { ref: 'b', name: 'queue', dependsOn: ['a'] }] },
+        expected: [[{ ref: 'a', name: 'queue' }, { ref: 'b', name: 'queue', dependsOn: ['a'] }]]
+      },
       {
         method: 'fetch',
         body: { name: 'queue', options: { includeMetadata: true } },
@@ -517,6 +522,8 @@ describe('proxy api routes', () => {
       { method: 'getBamStatus', expected: [] },
       { method: 'getQueue', query: 'name=queue', expected: ['queue'] },
       { method: 'getBlockedKeys', query: 'name=queue', expected: ['queue'] },
+      { method: 'getDependencies', query: 'name=queue&id=1', expected: ['queue', '1'] },
+      { method: 'getDependents', query: 'name=queue&id=1', expected: ['queue', '1'] },
       { method: 'getQueues', query: 'names=a&names=b', expected: [['a', 'b']] },
       { method: 'getQueues', expected: [] },
       { method: 'getSchedules', query: 'name=queue&key=k', expected: ['queue', 'k'] },

packages/proxy/test/apiCallsTest.ts

@@ -64,6 +64,10 @@ describe('Zod schema / HTTP type key drift', () => {
     expect(assertKeysMatch<AssertKeysMatch<SchemaOutput<typeof contracts.jobInsertSchema>, httpTypes.HttpJobInsert>>()).toBe(true)
   })
 
+  it('flowJobSchema matches HttpFlowJob', () => {
+    expect(assertKeysMatch<AssertKeysMatch<SchemaOutput<typeof contracts.flowJobSchema>, httpTypes.HttpFlowJob>>()).toBe(true)
+  })
+
   it('jobSchema matches HttpJob', () => {
     expect(assertKeysMatch<AssertKeysMatch<SchemaOutput<typeof contracts.jobSchema>, httpTypes.HttpJob>>()).toBe(true)
   })
@@ -76,6 +80,10 @@ describe('Zod schema / HTTP type key drift', () => {
     expect(assertKeysMatch<AssertKeysMatch<SchemaOutput<typeof contracts.commandResponseSchema>, httpTypes.HttpCommandResponse>>()).toBe(true)
   })
 
+  it('dependencyRefSchema matches HttpDependencyRef', () => {
+    expect(assertKeysMatch<AssertKeysMatch<SchemaOutput<typeof contracts.dependencyRefSchema>, httpTypes.HttpDependencyRef>>()).toBe(true)
+  })
+
   it('queueResultSchema matches HttpQueueResult', () => {
     expect(assertKeysMatch<AssertKeysMatch<SchemaOutput<typeof contracts.queueResultSchema>, httpTypes.HttpQueueResult>>()).toBe(true)
   })