@nxtedition/lib 26.0.0 → 26.0.1

package/app.js

@@ -29,8 +29,7 @@ import rx from 'rxjs/operators'
 import { performance } from 'perf_hooks'
 import hashString from './hash.js'
 import { makeTrace } from './trace.js'
-import compose from 'koa-compose'
-import { createServer } from './http.js'
+import { compose, createServer } from './http.js'
 import { json } from 'node:stream/consumers'
 import { monitorEventLoopDelay } from 'node:perf_hooks'
 import xuid from 'xuid'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "26.0.0",
+  "version": "26.0.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -48,8 +48,6 @@
     "yield.js"
   ],
   "scripts": {
-    "prepublishOnly": "pinst --disable",
-    "postpublish": "pinst --enable",
     "test": "node --test-timeout 60000 --test",
     "prepare": "husky"
   },
@@ -84,7 +82,6 @@
     "mitata": "^1.0.34",
     "moment-timezone": "^0.5.48",
     "nconf": "^0.13.0",
-    "nested-error-stacks": "^2.1.1",
     "object-hash": "^3.0.0",
     "p-queue": "^8.0.1",
     "pino": "^9.9.0",
@@ -110,11 +107,8 @@
     "eslint-plugin-promise": "^7.2.1",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.5",
-    "pinst": "^3.0.0",
     "prettier": "^3.6.2",
     "rxjs": "^7.8.2",
-    "send": "^1.1.0",
-    "tap": "^21.1.0",
     "typescript-eslint": "^8.40.0"
   },
   "peerDependencies": {

package/rxjs/combineMap.test.js

@@ -0,0 +1,199 @@
+import { test } from 'node:test'
+import combineMap from './combineMap.js'
+import * as rxjs from 'rxjs'
+
+test('combineMap sync', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of([1, 2, 3])
+    .pipe(combineMap((val) => rxjs.of(val * 2)))
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [2, 4, 6])
+    })
+})
+
+test('combineMap async', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of([1, 2, 3])
+    .pipe(combineMap(async (val) => val * 2))
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [2, 4, 6])
+    })
+})
+
+test('combineMap empty', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of([])
+    .pipe(combineMap((val) => rxjs.of(val * 2)))
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [])
+    })
+})
+
+test('combineMap throw in resolver', (t) => {
+  t.plan(1, { wait: true })
+  const _err = new Error('asd')
+  rxjs
+    .of([1, 2, 3])
+    .pipe(
+      combineMap((val) => {
+        throw _err
+      }),
+    )
+    .subscribe({
+      error: (err) => {
+        t.assert.strictEqual(err, _err)
+      },
+    })
+})
+
+test('combineMap throw in source', (t) => {
+  t.plan(1, { wait: true })
+  const _err = new Error('asd')
+  rxjs
+    .throwError(() => _err)
+    .pipe(combineMap((val) => rxjs.of(val)))
+    .subscribe({
+      error: (err) => {
+        t.assert.strictEqual(err, _err)
+      },
+    })
+})
+
+test('combineMap bad resolve', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of([1])
+    .pipe(combineMap((val) => val))
+    .subscribe({
+      error: () => {
+        t.assert.ok(true)
+      },
+    })
+})
+
+test('combineMap no change no tick', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .concat(
+      rxjs.timer(10).pipe(rxjs.map(() => [1, 2, 3])),
+      rxjs.timer(10).pipe(rxjs.map(() => [1, 2, 3])),
+    )
+    .pipe(combineMap((val) => rxjs.of(val * 2)))
+    .subscribe(() => {
+      t.assert.ok(true)
+    })
+})
+
+test('combineMap combine in single tick', (t) => {
+  t.plan(2, { wait: true })
+  rxjs
+    .concat(
+      rxjs.timer(10).pipe(rxjs.map(() => [1, 2, 3])),
+      rxjs.timer(10).pipe(rxjs.map(() => [4, 5, 6])),
+    )
+    .pipe(combineMap((val) => rxjs.from([val * 2, val * 2])))
+    .subscribe(() => {
+      t.assert.ok(true)
+    })
+})
+
+test('combineLatest completion', (t) => {
+  t.plan(1, { wait: true })
+  rxjs.combineLatest([1, 2, 3].map((x) => rxjs.of(x))).subscribe({
+    complete: () => {
+      t.assert.ok(true)
+    },
+  })
+})
+
+test('combineMap completion', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of([1, 2, 3])
+    .pipe(combineMap((x) => rxjs.of(x)))
+    .subscribe({
+      complete: () => {
+        t.assert.ok(true)
+      },
+    })
+})
+
+test('combineLatest no completion', (t) => {
+  t.plan(1, { wait: true })
+  const subscription = rxjs
+    .combineLatest([1, 2, 3].map((x) => rxjs.timer(0, 1e3).pipe(rxjs.map(() => x))))
+    .subscribe({
+      next: () => {
+        t.assert.ok(true)
+      },
+      complete: () => {
+        t.assert.fail()
+      },
+    })
+  t.after(() => subscription.unsubscribe())
+})
+
+test('combineMap no completion', (t) => {
+  t.plan(1, { wait: true })
+  const subscription = rxjs
+    .of([1, 2, 3])
+    .pipe(combineMap((x) => rxjs.timer(0, 1e3).pipe(rxjs.map(() => x))))
+    .subscribe({
+      next: () => {
+        t.assert.ok(true)
+      },
+      complete: () => {
+        t.assert.fail()
+      },
+    })
+  t.after(() => subscription.unsubscribe())
+})
+
+test('combineLatest no value', (t) => {
+  t.plan(1, { wait: true })
+  rxjs.combineLatest([1, 2, 3].map((x) => rxjs.EMPTY)).subscribe({
+    complete: () => {
+      t.assert.ok(true)
+    },
+  })
+})
+
+test('combineMap no value', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of([1, 2, 3])
+    .pipe(combineMap((x) => rxjs.EMPTY))
+    .subscribe({
+      complete: () => {
+        t.assert.ok(true)
+      },
+    })
+})
+
+test('combineMap object keys removed', (t) => {
+  t.plan(3, { wait: true })
+  const a = {}
+  const b = {}
+  const c = {}
+
+  let i = 0
+  rxjs
+    .concat(rxjs.of([a, b, c]), rxjs.of([a, b]).pipe(rxjs.delay(10)))
+    .pipe(combineMap((x) => rxjs.of(x)))
+    .subscribe({
+      next: (value) => {
+        if (i === 0) {
+          t.assert.deepStrictEqual(value, [a, b, c])
+        } else if (i === 1) {
+          t.assert.deepStrictEqual(value, [a, b])
+        }
+        i++
+      },
+      complete: () => {
+        t.assert.ok(true)
+      },
+    })
+})

package/util/compare-rev.test.js

@@ -0,0 +1,113 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import compareRev from './compare-rev.js'
+
+const cases = [
+  [null, null, 0],
+  [null, '1-00000000000000', -1],
+  ['1-00000000000000', null, 1],
+  ['INF-00000000000000', '1-00000000000000', 1],
+  ['1-00000000000000', 'INF-00000000000000', -1],
+  ['INF-00000000000000', 'INF-00000000000000', 0],
+  ['INF-00000000000001', 'INF-00000000000000', 1],
+  ['INF-00000000000001', 'INF-00000000000002', -1],
+  ['1-00000000000000', '1-00000000000000', 0],
+  ['1-00000000000000', '1-00000000000001', -1],
+  ['1-00000000000001', '1-00000000000000', 1],
+  ['1-00000000000000', '2-00000000000000', -1],
+  ['2-00000000000000', '1-00000000000000', 1],
+  ['1-00000000000000', '02-00000000000000', -1],
+  ['02-00000000000000', '1-00000000000000', 1],
+  ['01-00000000000000', '02-00000000000000', -1],
+  ['02-00000000000000', '01-00000000000000', 1],
+  ['11-00000000000000', '2-00000000000000', 1],
+  ['2-00000000000000', '11-00000000000000', -1],
+  ['837-N', '5763-/h', -1],
+  ['000000837-N', '5763-/h', -1],
+  ['1-A', '1-AA', -1],
+  ['4-UI7WqKrsEZJdA1-_asset', '6-UI7YZdKsENJfhH-_asset', -1],
+]
+
+for (const [a, b, r] of cases) {
+  await test(`${a} ${b} ${r}`, async (t) => {
+    const expected = _compareRev(a, b)
+    if (r != null) {
+      assert.equal(expected, r) // sanity check
+      assert.equal(Math.sign(compareRev(a, b)), r)
+    }
+
+    assert.equal(Math.sign(compareRev(a && Buffer.from(a), b)), expected)
+    assert.equal(Math.sign(compareRev(a, b && Buffer.from(b))), expected)
+    assert.equal(Math.sign(compareRev(a && Buffer.from(a), b && Buffer.from(b))), expected)
+  })
+}
+
+const ascii = Array.from({ length: 128 })
+  .map((_, index) => (index > 27 && index < 127 ? String.fromCharCode(index) : null))
+  .filter(Boolean)
+  .join('')
+const rand = (n) => Math.floor(Math.random() * n)
+const randChar = () => ascii[rand(ascii.length)]
+const randId = () => Array.from({ length: rand(63) + 1 }, randChar).join('')
+const randRev = (other) => {
+  const num = other && !rand(3) ? parseInt(other) : rand(10e3)
+  let id
+  if (other && !rand(3)) {
+    id = other.slice(other.indexOf('-') + 1)
+    if (rand(3)) {
+      id = id.slice(0, rand(id.length - 1) + 1)
+    }
+  } else {
+    id = randId()
+  }
+  return `${String(num).padStart(rand(10), '0')}-${id}`
+}
+
+await test('fuzz', async (t) => {
+  const N = 1e4
+  for (let i = 0; i < N; i++) {
+    let a = randRev()
+    let b = randRev(a)
+    if (rand(2)) {
+      ;[a, b] = [b, a]
+    }
+    const r = _compareRev(a, b)
+
+    await t.test(`${a} ${b} ${r}`, (t) => {
+      assert.equal(Math.sign(compareRev(a, b)), r)
+      assert.equal(Math.sign(compareRev(a && Buffer.from(a), b)), r)
+      assert.equal(Math.sign(compareRev(a, b && Buffer.from(b))), r)
+      assert.equal(Math.sign(compareRev(a && Buffer.from(a), b && Buffer.from(b))), r)
+    })
+  }
+})
+
+function _compareRev(a, b) {
+  if (!a) {
+    return b ? -1 : 0
+  }
+
+  if (!b) {
+    return a ? 1 : 0
+  }
+
+  if (a === b) {
+    return 0
+  }
+
+  const av = a[0] === 'I' ? Infinity : parseInt(a)
+  const bv = b[0] === 'I' ? Infinity : parseInt(b)
+
+  if (av !== bv) {
+    return av > bv ? 1 : -1
+  }
+
+  const ar = a.slice(a.indexOf('-') + 1)
+  const br = b.slice(b.indexOf('-') + 1)
+
+  if (ar !== br) {
+    return ar > br ? 1 : -1
+  }
+
+  return 0
+}

package/util/template/index.test.js

@@ -50,3 +50,32 @@ test('return function', async () => {
     'BARBAZ',
   )
 })
+
+test('noop', async (t) => {
+  const { resolveTemplate } = makeTemplateCompiler({})
+  const x = { foo: 1, bar: {} }
+  const y = await resolveTemplate(x)
+  assert.strictEqual(x, y)
+})
+
+test('simple', async (t) => {
+  const { resolveTemplate } = makeTemplateCompiler({})
+  const x = { bar: '{{#js $.test }}' }
+  const y = await resolveTemplate(x, { test: 1 })
+  assert.deepStrictEqual(y, { bar: 1 })
+})
+
+// test('cache', async (t) => {
+//   const x = '{{#js $.test }}'
+//   t.equal(compileTemplate(x), compileTemplate(x))
+//   t.end()
+// })
+
+test('string concat', async (t) => {
+  const { resolveTemplate } = makeTemplateCompiler({})
+  const x = '{{#js $.pre }} {{#js $.body}} {{#js $.post}}'
+  assert.strictEqual(
+    await resolveTemplate(x, { pre: 'pre', body: 'body', post: 'post' }),
+    'pre body post',
+  )
+})

package/util/template/nextpressions.test.js

@@ -0,0 +1,165 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { makeTemplateCompiler } from './index.js'
+import * as rxjs from 'rxjs'
+
+const { resolveTemplate } = makeTemplateCompiler({
+  ds: {
+    record: {
+      observe: () => rxjs.of({ foo: 'bar' }),
+    },
+  },
+})
+
+test('hash to int', async () => {
+  const val = await resolveTemplate('{{test | hashaint() | mod(128)}}', { test: { foo: '11d1' } })
+  assert.strictEqual(Number.isFinite(val), true)
+})
+
+test('baseValue', async () => {
+  assert.strictEqual(await resolveTemplate('{{test}}', { test: '11d1' }), '11d1')
+  assert.strictEqual(await resolveTemplate('{{test}}', { test: rxjs.of('11d1') }), '11d1')
+  assert.strictEqual(
+    await resolveTemplate('{{test.asd}}', { test: rxjs.of({ asd: '11d1' }) }),
+    '11d1',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{test.asd}}', { test: { asd: rxjs.of('11d1') } }),
+    '11d1',
+  )
+})
+
+test('integer ops', async () => {
+  assert.strictEqual(await resolveTemplate('{{test | div(2)}}', { test: '8' }), 4)
+  assert.strictEqual(await resolveTemplate('{{test | div(2)}}', { test: 8 }), 4)
+  assert.strictEqual(await resolveTemplate('{{test | mul(2)}}', { test: '8' }), 16)
+  assert.strictEqual(await resolveTemplate('{{test | mul(2)}}', { test: 8 }), 16)
+  assert.strictEqual(await resolveTemplate('{{test | add(2)}}', { test: '10' }), 12)
+  assert.strictEqual(await resolveTemplate('{{test | add(2)}}', { test: 10 }), 12)
+  assert.strictEqual(await resolveTemplate('{{test | sub(2)}}', { test: '10' }), 8)
+  assert.strictEqual(await resolveTemplate('{{test | sub(2)}}', { test: 10 }), 8)
+})
+
+test('null undefined args', async () => {
+  assert.strictEqual(await resolveTemplate('{{asd | default(null, true)}}', {}), null)
+  assert.strictEqual(await resolveTemplate('{{asd | default(undefined, true)}}', {}), undefined)
+})
+
+test('path var', async () => {
+  assert.strictEqual(await resolveTemplate('{{test.foo}}', { test: { foo: '111' } }), '111')
+})
+
+test('replaces strings', async () => {
+  assert.strictEqual(await resolveTemplate('{{test}}', { test: '111' }), '111')
+  assert.strictEqual(await resolveTemplate('pre{{test}}post', { test: '111' }), 'pre111post')
+  assert.strictEqual(
+    await resolveTemplate('123{{test}}456{{test}}{{test}}', { test: 'body' }),
+    '123body456bodybody',
+  )
+  assert.strictEqual(
+    await resolveTemplate('test{{test.foo}}test{{test.bar.baz}}test', {
+      test: { foo: '111', bar: { baz: '222' } },
+    }),
+    'test111test222test',
+  )
+  assert.strictEqual(await resolveTemplate('{{ asd | default("te | st")}}', {}), 'te | st')
+  assert.strictEqual(await resolveTemplate('{{ asd | default("test\n") }}', {}), 'test\n')
+  assert.strictEqual(await resolveTemplate('{{ asd | default("test\n\n") }}', {}), 'test\n\n')
+  assert.strictEqual(await resolveTemplate('{{ asd | default("test\r\n") }}', {}), 'test\r\n')
+})
+
+test('nested', async () => {
+  assert.strictEqual(
+    await resolveTemplate('{{ asd | default("{{foo}}") }}', { foo: '"test"' }),
+    '"test"',
+  )
+  assert.strictEqual(await resolveTemplate('{{{{foo}}}}', { test: '111', foo: 'test' }), '111')
+  assert.strictEqual(
+    await resolveTemplate('f{{oo}}', { test: '111', foo: 'test', oo: 'oo' }),
+    'foo',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{f{{oo}}}}', { test: '111', foo: 'test', oo: 'oo' }),
+    'test',
+  )
+  assert.strictEqual(await resolveTemplate('{{{{foo}}}}', { test: '111', foo: 'test' }), '111')
+  assert.strictEqual(
+    await resolveTemplate('{{{{f{{o}}o}}}}', { test: '111', foo: 'test', o: 'o' }),
+    '111',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{ asd | default("{{test}}")}}', { test: '111', foo: 'test' }),
+    '111',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{ asd | default("{{t{{es}}t}}")}}', {
+      test: '111',
+      foo: 'test',
+      es: 'es',
+    }),
+    '111',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{ asd | default("{{test | default("test\n")}}")}}', {}),
+    'test\n',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{ asd | default("{{test | default("test\n\n")}}")}}', {}),
+    'test\n\n',
+  )
+  assert.strictEqual(
+    await resolveTemplate('{{ asd | default("{{test | default("test\r\n")}}")}}', {}),
+    'test\r\n',
+  )
+})
+
+test('append', async () => {
+  assert.strictEqual(await resolveTemplate("{{test | append('1')}}", { test: '111' }), '1111')
+})
+
+test('object', async () => {
+  const obj = { foo: 1 }
+  assert.strictEqual(await resolveTemplate('{{test}}', { test: obj }), obj)
+})
+
+test('ds', async () => {
+  assert.strictEqual(
+    await resolveTemplate("{{test | ds() | pluck('foo')}}", { test: 'foo' }),
+    'bar',
+  )
+})
+
+test('replace array', async () => {
+  assert.deepStrictEqual(
+    await resolveTemplate('{{test | join("#") | replace("foo", "bar") | split("#")}}', {
+      test: ['foo', 'bar'],
+    }),
+    ['bar', 'bar'],
+  )
+  assert.deepStrictEqual(
+    await resolveTemplate('{{test | join(",") | replace("foo", "bar") | split(",")}}', {
+      test: ['foo', 'bar'],
+    }),
+    ['bar', 'bar'],
+  )
+})
+
+test('You Do Not Know Me', async () => {
+  assert.deepStrictEqual(
+    await resolveTemplate('{{id | default("You Do Not Know", true)}} -', {}),
+    'You Do Not Know -',
+  )
+})
+
+test('object 1', async () => {
+  assert.deepStrictEqual(await resolveTemplate({ asd: ['{{foo}}'] }, { foo: 'bar' }), {
+    asd: ['bar'],
+  })
+})
+
+test('empty arg', async () => {
+  assert.deepStrictEqual(
+    await resolveTemplate('{{source.value | includes("salami") | ternary([], )}}', {}),
+    undefined,
+  )
+})