@nxtedition/lib 22.1.3 → 22.2.0

package/couch.d.ts

@@ -0,0 +1,69 @@
+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
+  }
+  seq?: string
+  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,48 @@
+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
+}
+
+type SerializableError = null | undefined | Error | string | NxtError | SerializableError[]
+
+export function serializeError(err: SerializableError): 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.3",
+  "version": "22.2.0",
   "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,9 +31,12 @@
     "weakCache.js",
     "weakCache.d.ts",
     "couch.js",
+    "couch.d.ts",
     "app.js",
     "errors.js",
+    "errors.d.ts",
     "worker.js",
+    "scheduler.js",
     "stream.js",
     "timeline.js",
     "docker-secrets.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>

package/scheduler.js

@@ -0,0 +1,32 @@
+import { setImmediate } from 'timers/promises'
+
+let yieldTime = performance.now()
+let yieldPromise = undefined
+
+function reset() {
+  yieldTime = performance.now()
+  yieldPromise = undefined
+}
+
+setInterval(reset, 100).unref()
+
+export function shouldYield() {
+  if (yieldPromise === undefined) {
+    yieldPromise = performance.now() - yieldTime > 50 ? null : undefined
+  }
+  return yieldPromise !== undefined
+}
+
+export function maybeYield() {
+  if (yieldPromise === undefined) {
+    yieldPromise = performance.now() - yieldTime > 50 ? null : undefined
+  }
+  if (yieldPromise === null) {
+    yieldPromise = setImmediate().then(reset)
+  }
+  return yieldPromise ?? null
+}
+
+export async function yield() {
+  return (yieldPromise ??= setImmediate().then(reset))
+}

package/util/template/javascript.js

@@ -233,7 +233,6 @@ export default function ({ ds, proxify, compiler }) {
       this._wrap = null
       this._suspended = false
       this._errored = false
-      this._refreshImpl = this._refreshImpl.bind(this)
 
       if (rxjs.isObservable(args)) {
         this._subscription = args.subscribe({
@@ -243,10 +242,6 @@ export default function ({ ds, proxify, compiler }) {
           },
           error: (err) => {
             this._observer.error(err)
-            this._subscription = null
-          },
-          complete: () => {
-            this._subscription = null
           },
         })
       } else {
@@ -338,7 +333,7 @@ export default function ({ ds, proxify, compiler }) {
       this._entries.clear()
     }
 
-    _refreshImpl() {
+    _refreshImpl = () => {
       this._refreshing = false
 
       if (this._destroyed || this._disposing || this._args === kEmpty) {