@nxtedition/lib 22.1.1 → 22.1.4

package/app.js

@@ -818,61 +818,46 @@ export function makeApp(appConfig, onTerminate) {
       inspectBC.onmessage = ({ data }) => {
         const { type, id } = data
 
-        if (id !== threadId) {
-          return
-        }
-
-        if (type === 'inspect:open') {
-          // TODO (fix): What happens if you call inspect:open multiple times?
-          if (!inspectOpen) {
-            inspector.open(data.port, data.hostname)
-            inspectOpen = true
-          }
-        } else if (type === 'inspect:close') {
-          if (inspectOpen) {
-            inspector.close()
-            inspectOpen = false
+        if (id === threadId) {
+          if (type === 'inspect:open') {
+            // TODO (fix): What happens if you call inspect:open multiple times?
+            if (!inspectOpen) {
+              inspector.open(data.port, data.hostname)
+              inspectOpen = true
+            }
+          } else if (type === 'inspect:close') {
+            if (inspectOpen) {
+              inspector.close()
+              inspectOpen = false
+            }
           }
         }
       }
-
-      inspectBC.postMessage({
-        type: 'inspect:register',
-        id: threadId,
-        worker: {
-          id: threadId,
-          name: serviceName,
-          module: serviceModule,
-          version: serviceVersion,
-          workerId: serviceWorkerId,
-          instanceId: serviceInstanceId,
-          threadId,
-          processId: process.pid,
-        },
-      })
-      destroyers.unshift(() => {
-        if (inspectOpen) {
-          inspector.close()
-          inspectOpen = false
-        }
-        inspectBC.postMessage({ type: 'inspect:unregister', id: threadId })
-        setTimeout(() => {
-          inspectBC.close()
-        }, 100)
-      })
     } else {
       const inspectMap = new Map()
 
       inspectBC.onmessage = ({ data }) => {
-        const { type, worker } = data
+        const { type, worker, id } = data
 
         if (type === 'inspect:register') {
           inspectMap.set(data.id, worker)
         } else if (type === 'inspect:unregister') {
           inspectMap.delete(data.id)
+        } else if (id === threadId) {
+          if (type === 'inspect:open') {
+            // TODO (fix): What happens if you call inspect:open multiple times?
+            if (!inspectOpen) {
+              inspector.open(data.port, data.hostname)
+              inspectOpen = true
+            }
+          } else if (type === 'inspect:close') {
+            if (inspectOpen) {
+              inspector.close()
+              inspectOpen = false
+            }
+          }
         }
       }
-      destroyers.unshift(() => inspectBC.close())
 
       // TODO (fix): Determinisitc port also in dev mode... hash of something?
       const port =
@@ -938,6 +923,31 @@ export function makeApp(appConfig, onTerminate) {
 
       destroyers.unshift(() => new Promise((resolve) => server.close(resolve)))
     }
+
+    inspectBC.postMessage({
+      type: 'inspect:register',
+      id: threadId,
+      worker: {
+        id: threadId,
+        name: serviceName,
+        module: serviceModule,
+        version: serviceVersion,
+        workerId: serviceWorkerId,
+        instanceId: serviceInstanceId,
+        threadId,
+        processId: process.pid,
+      },
+    })
+    destroyers.unshift(() => {
+      if (inspectOpen) {
+        inspector.close()
+        inspectOpen = false
+      }
+      inspectBC.postMessage({ type: 'inspect:unregister', id: threadId })
+      setTimeout(() => {
+        inspectBC.close()
+      }, 100)
+    })
   }
 
   if (appConfig.utils !== false && !cluster.isWorker) {

package/couch.d.ts

@@ -0,0 +1,68 @@
+import type { Logger } from './logger.js'
+import { HttpError } from 'http-errors'
+
+export interface CouchOptions {
+  url?: string
+}
+
+export function makeCouch(opts: string | CouchOptions): CouchClient
+
+export interface CouchRequestOptions<Stream extends boolean = false> {
+  url?: URL
+  pathname?: string
+  path?: string
+  method?: string
+  body?: unknown
+  query?: {
+    startkey?: string
+    endkey?: string
+    update?: boolean
+  }
+  signal?: AbortSignal
+  logger?: Logger
+  stream?: Stream
+  // TODO add more or extend undicii type?
+}
+
+export interface CouchResponse<T> {
+  rows: T[]
+}
+
+export function request<T, Stream extends boolean = false>(
+  url: string | URL | { origin: string; path?: string; pathname?: string },
+  opts?: CouchRequestOptions<Stream> | null,
+): Stream extends true ? AsyncGenerator<T> & { length: number } : Promise<CouchResponse<T>>
+
+interface ChangesOptions {
+  signal?: AbortSignal | null
+  descending?: boolean
+  include_docs?: boolean
+  seq_interval?: number | null
+  live?: boolean
+  heartbeat?: number
+  retry?: (
+    err: HttpError,
+    retryCount: number,
+    params: {
+      since?: string | 0 | null
+    },
+    ac: { signal: AbortSignal },
+    next: () => void,
+  ) => void | null | Promise<void>
+  since?: string | 0 | null
+  selector?: object | null
+}
+
+interface ChangeItem {
+  id: string
+  seq?: string
+  doc?: object
+  deleted?: boolean
+  changes: Array<{ rev: string }>
+}
+
+export interface CouchClient {
+  changes: (
+    options?: ChangesOptions & { client?: unknown; logger?: Logger },
+  ) => AsyncGenerator<ChangeItem[] & { lastSeq?: string | 0 | null }, void, unknown>
+}

package/deepstream.d.ts

@@ -0,0 +1,19 @@
+import { DeepstreamClient, RecordHandler } from '@nxtedition/deepstream.io-client-js'
+
+export function makeDeepstream<Records, RpcMethods>(
+  client: DeepstreamClient<Records, RpcMethods>,
+): NxtDeepstreamClient<Records, RpcMethods>
+
+export interface NxtDeepstreamClient<Records, RpcMethods> {
+  ds: DeepstreamClient<Records, RpcMethods> & { nxt: NxtDeepstreamClient<Records, RpcMethods> }
+  record: {
+    provide: RecordHandler<Records>['provide']
+    observe: RecordHandler<Records>['observe']
+    observe2: RecordHandler<Records>['observe2']
+    query: RecordHandler<Records>['query']
+    set: RecordHandler<Records>['set']
+    get: RecordHandler<Records>['get']
+    getRecord: RecordHandler<Records>['getRecord']
+    update: RecordHandler<Records>['update']
+  }
+}

package/errors.d.ts

@@ -0,0 +1,46 @@
+export class AbortError extends Error {
+  constructor(message: string)
+}
+
+export function parseError(err: unknown): Error | null
+
+export interface NxtError {
+  message: string
+  type?: string
+  code?: string
+  exitCode?: number
+  signalCode?: number
+  statusCode?: number
+  headers?: Record<string, string>
+  data?: object
+  cause?: NxtError | null
+  errors?: NxtError[] | null
+}
+
+export function serializeError(err: Error | string): NxtError[] | null
+
+export type Message = {
+  msg: string
+  title?: string
+  id: string
+  level: number
+  code?: string
+  data?: object
+  expose?: boolean | null
+  index?: object | null
+}
+
+export type MessageOptions = {
+  id?: string
+  level?: number
+  code?: string
+  codes?: Record<string, string>
+  index?: boolean
+}
+
+export function makeMessages(
+  error: MessageError | MessageError[],
+  options?: MessageOptions,
+): Message[]
+
+export function makeErrorString(err: unknown): string

package/logger.d.ts

@@ -0,0 +1,18 @@
+import { pino } from 'pino'
+
+export type Logger = pino.Logger
+
+interface LoggerOptions extends pino.LoggerOptions {
+  flushInterval?: number
+  stream?: ReturnType<(typeof pino)['destination']> | (typeof process)['stdout'] | null
+}
+
+export function createLogger(
+  {
+    level = isProduction ? 'debug' : 'trace',
+    flushInterval = 1e3,
+    stream = null,
+    ...options
+  }: LoggerOptions = {},
+  onTerminate: unknown,
+): Logger

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "22.1.1",
+  "version": "22.1.4",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -20,8 +20,10 @@
     "time.js",
     "mutex.js",
     "deepstream.js",
+    "deepstream.d.ts",
     "sequence.js",
     "logger.js",
+    "logger.d.ts",
     "mime.js",
     "proxy.js",
     "timers.js",
@@ -29,8 +31,10 @@
     "weakCache.js",
     "weakCache.d.ts",
     "couch.js",
+    "couch.d.ts",
     "app.js",
     "errors.js",
+    "errors.d.ts",
     "worker.js",
     "stream.js",
     "timeline.js",

package/rxjs/firstValueFrom.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs'
+
+interface FirstValueFromConfig<T> {
+  signal?: AbortSignal
+  timeout?: number
+  defaultValue?: T
+}
+
+export default function firstValueFrom<T>(
+  source: Observable<T>,
+  config?: FirstValueFromConfig<T>,
+): Promise<T>