@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/thread-stream/test/thread-management.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { fork } = require('child_process')
 const { join } = require('path')
 const { readFile } = require('fs').promises
@@ -13,10 +14,10 @@ test('exits with 0', async function (t) {
   const child = fork(join(__dirname, 'create-and-exit.js'), [dest])
 
   const [code] = await once(child, 'exit')
-  t.equal(code, 0)
+  assert.strictEqual(code, 0)
 
   const data = await readFile(dest, 'utf8')
-  t.equal(data, 'hello world\n')
+  assert.strictEqual(data, 'hello world\n')
 })
 
 test('emit error if thread exits', async function (t) {
@@ -25,20 +26,27 @@ test('emit error if thread exits', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker thread exited')
+  assert.strictEqual(err.message, 'the worker thread exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('emit error if thread have unhandledRejection', async function (t) {
@@ -47,20 +55,27 @@ test('emit error if thread have unhandledRejection', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'kaboom')
+  assert.strictEqual(err.message, 'kaboom')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('emit error if worker stream emit error', async function (t) {
@@ -69,20 +84,27 @@ test('emit error if worker stream emit error', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'kaboom')
+  assert.strictEqual(err.message, 'kaboom')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('emit error if thread have uncaughtException', async function (t) {
@@ -91,20 +113,27 @@ test('emit error if thread have uncaughtException', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'kaboom')
+  assert.strictEqual(err.message, 'kaboom')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('close the work if out of scope on gc', { skip: !global.WeakRef }, async function (t) {
@@ -114,8 +143,8 @@ test('close the work if out of scope on gc', { skip: !global.WeakRef }, async fu
   })
 
   const [code] = await once(child, 'exit')
-  t.equal(code, 0)
+  assert.strictEqual(code, 0)
 
   const data = await readFile(dest, 'utf8')
-  t.equal(data, 'hello world\n')
+  assert.strictEqual(data, 'hello world\n')
 })

package/node_modules/thread-stream/test/transpiled.test.js

@@ -1,14 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('./helper')
 const ThreadStream = require('..')
 
 function basic (esVersion) {
-  test(`transpiled-ts-to-${esVersion}`, function (t) {
-    t.plan(2)
-
+  test(`transpiled-ts-to-${esVersion}`, function () {
     const dest = file()
     const stream = new ThreadStream({
       filename: join(__dirname, 'ts', `to-file.${esVersion}.cjs`),
@@ -18,9 +17,9 @@ function basic (esVersion) {
 
     // There are arbitrary checks, the important aspect of this test is to ensure
     // that we can properly load the transpiled file into our worker thread.
-    t.same(stream.writableEnded, false)
+    assert.deepStrictEqual(stream.writableEnded, false)
     stream.end()
-    t.same(stream.writableEnded, true)
+    assert.deepStrictEqual(stream.writableEnded, true)
   })
 }
 

package/node_modules/thread-stream/test/ts-native.test.mjs

@@ -0,0 +1,35 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'fs/promises'
+import ThreadStream from '../index.js'
+import { join } from 'desm'
+import { file } from './helper.js'
+
+const nodeVersion = parseInt(process.versions.node.split('.')[0], 10)
+
+// Native TypeScript stripping (--experimental-strip-types) is only available in Node 22.6+
+test('typescript module with native type stripping', { skip: nodeVersion < 22 }, async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(import.meta.url, 'ts', 'to-file.ts'),
+    workerData: { dest },
+    workerOpts: {
+      execArgv: ['--experimental-strip-types', '--disable-warning=ExperimentalWarning']
+    },
+    sync: false
+  })
+
+  t.after(() => stream.end())
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  await new Promise((resolve) => {
+    stream.on('close', resolve)
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\nsomething else\n')
+})

package/node_modules/thread-stream/test/ts-node-fallback.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { readFile } = require('fs/promises')
+const { join } = require('path')
+const { file } = require('./helper')
+const ThreadStream = require('..')
+
+// This test verifies that TypeScript files can be loaded via ts-node
+// when native type stripping is not enabled in the worker thread.
+// Unlike ts.test.ts which passes --experimental-strip-types via execArgv,
+// this test does NOT pass that flag, so the worker will fall back to ts-node.
+test('typescript module with ts-node fallback', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'ts', 'to-file.ts'),
+    workerData: { dest },
+    sync: false
+  })
+
+  t.after(() => stream.end())
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  await new Promise((resolve) => {
+    stream.on('close', resolve)
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\nsomething else\n')
+})

package/node_modules/thread-stream/test/watch-mode.test.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { once } = require('events')
 const { join } = require('path')
 const ThreadStream = require('..')
 
-test('ignores worker messages without a protocol code', function (t) {
-  t.plan(2)
-
+test('ignores worker messages without a protocol code', async function () {
   const stream = new ThreadStream({
     filename: join(__dirname, 'message-without-code.js'),
     sync: false
@@ -17,12 +17,14 @@ test('ignores worker messages without a protocol code', function (t) {
     errors.push(err)
   })
 
-  stream.on('ready', () => {
-    t.ok(stream.write('hello world\n'))
-    stream.end()
-  })
+  const ready = once(stream, 'ready')
+  const close = once(stream, 'close')
 
-  stream.on('finish', () => {
-    t.same(errors, [])
-  })
+  assert.ok(stream.write('hello world\n'))
+  stream.end()
+
+  await ready
+  await close
+
+  assert.deepStrictEqual(errors, [])
 })

package/node_modules/thread-stream/test/worker-name.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { once } = require('events')
+const { MessageChannel } = require('worker_threads')
+const ThreadStream = require('..')
+
+// threadName was added in Node.js v22.20.0 and v24.6.0
+const [major, minor] = process.versions.node.split('.').map(Number)
+const supportsThreadName = (major === 22 && minor >= 20) || major >= 24
+
+test('worker has default name "thread-stream"', { skip: !supportsThreadName }, async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'report-thread-name.js'),
+    sync: true
+  })
+
+  t.after(() => stream.end())
+
+  stream.emit('message', { port: port1 }, [port1])
+  const [{ threadName }] = await once(port2, 'message')
+  assert.strictEqual(threadName, 'thread-stream')
+})
+
+test('worker name can be overridden via workerOpts', { skip: !supportsThreadName }, async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'report-thread-name.js'),
+    workerOpts: {
+      name: 'my-custom-worker'
+    },
+    sync: true
+  })
+
+  t.after(() => stream.end())
+
+  stream.emit('message', { port: port1 }, [port1])
+  const [{ threadName }] = await once(port2, 'message')
+  assert.strictEqual(threadName, 'my-custom-worker')
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuplo/cli",
-  "version": "7.0.2",
+  "version": "7.1.1",
   "repository": "https://github.com/zuplo/zuplo",
   "author": "Zuplo, Inc.",
   "type": "module",
@@ -28,10 +28,10 @@
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "0.220.0",
     "@swc/core": "1.10.18",
-    "@zuplo/core": "7.0.2",
+    "@zuplo/core": "7.1.1",
     "@zuplo/editor": "1.0.30996641385",
-    "@zuplo/openapi-tools": "7.0.2",
-    "@zuplo/runtime": "7.0.2",
+    "@zuplo/openapi-tools": "7.1.1",
+    "@zuplo/runtime": "7.1.1",
     "chalk": "5.4.1",
     "chokidar": "3.5.3",
     "cookie": "1.0.2",
@@ -49,8 +49,8 @@
     "minimatch": "10.2.5",
     "open": "10.1.0",
     "ora": "8.2.0",
-    "pino": "9.5.0",
-    "pino-pretty": "11.3.0",
+    "pino": "10.3.1",
+    "pino-pretty": "13.1.3",
     "posthog-node": "5.38.1",
     "prettier": "3.8.1",
     "rimraf": "6.0.1",
@@ -62,8 +62,8 @@
     "workerd": "1.20241230.0",
     "yargs": "17.7.2",
     "zod": "4.4.3",
-    "@zuplo/graphql": "7.0.2",
-    "@zuplo/otel": "7.0.2"
+    "@zuplo/graphql": "7.1.1",
+    "@zuplo/otel": "7.1.1"
   },
   "bundleDependencies": [
     "@inquirer/prompts",

package/node_modules/@zuplo/editor/node_modules/process-warning/.github/dependabot.yml

@@ -1,53 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    commit-message:
-      # Prefix all commit messages with "chore: "
-      prefix: "chore"
-    schedule:
-      interval: "weekly"
-    cooldown:
-      default-days: 7
-    allow:
-      - dependency-name: "*"
-        update-types:
-          - "version-update:semver-major"
-    open-pull-requests-limit: 10
-
-  - package-ecosystem: "npm"
-    directory: "/"
-    commit-message:
-      # Prefix all commit messages with "chore: "
-      prefix: "chore"
-    schedule:
-      interval: "weekly"
-    cooldown:
-      default-days: 7
-    versioning-strategy: "increase-if-necessary"
-    allow:
-      - dependency-name: "*"
-        update-types:
-          - "version-update:semver-major"
-    ignore:
-      # TODO: remove ignore until neostandard support ESLint 10
-      - dependency-name: "eslint"
-      - dependency-name: "neostandard"
-      - dependency-name: "@stylistic/*"
-    open-pull-requests-limit: 10
-    groups:
-      # Production dependencies with breaking changes
-      dependencies:
-        dependency-type: "production"
-      # ESLint related dependencies
-      dev-dependencies-eslint:
-        patterns:
-          - "eslint"
-          - "neostandard"
-          - "@stylistic/*"
-      # TypeScript related dependencies
-      dev-dependencies-typescript:
-        patterns:
-          - "@types/*"
-          - "tstyche"
-          - "typescript"

package/node_modules/@zuplo/editor/node_modules/process-warning/.github/workflows/ci.yml

@@ -1,33 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-     - main
-     - next
-     - 'v*'
-    paths-ignore:
-      - 'docs/**'
-      - '*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '*.md'
-
-# This allows a subsequently queued workflow run to interrupt previous runs
-concurrency:
-    group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
-    cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    permissions:
-      contents: write
-      pull-requests: write
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@2073dc8e1f9e172bf42daa3843c9dbd31af1e8cb # v6.0.0
-    with:
-      license-check: true
-      lint: true

package/node_modules/@zuplo/editor/node_modules/process-warning/README.md

@@ -1,157 +0,0 @@
-# process-warning
-
-[![CI](https://github.com/fastify/process-warning/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/process-warning/actions/workflows/ci.yml)
-[![NPM version](https://img.shields.io/npm/v/process-warning.svg?style=flat)](https://www.npmjs.com/package/process-warning)
-[![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
-
-A small utility for generating consistent [warning objects](https://nodejs.org/api/process.html#event-warning) across your codebase.
-It also exposes a utility for emitting those warnings, guaranteeing that they are issued only once (unless configured otherwise).
-
-_This module is used by the [Fastify](https://fastify.dev) framework and it was called `fastify-warning` prior to version 1.0.0._
-
-### Install
-
-```
-npm i process-warning
-```
-
-### Usage
-
-The module exports two builder functions for creating warnings.
-
-```js
-const {
-  createWarning,
-  createDeprecation
-} = require('process-warning')
-
-const warning = createWarning({
-  name: 'ExampleWarning',
-  code: 'EXP_WRN_001',
-  message: 'Hello %s',
-  unlimited: true
-})
-const emitted = warning('world')
-```
-
-#### Methods
-
-##### `createWarning({ name, code, message[, unlimited] })`
-
-- `name` (`string`, required) - The error name, you can access it later with
-`error.name`. For consistency, we recommend prefixing module error names
-with `{YourModule}Warning`
-- `code` (`string`, required) - The warning code, you can access it later with
-`error.code`. For consistency, we recommend prefixing plugin error codes with
-`{ThreeLetterModuleName}_`, e.g. `FST_`. NOTE: codes should be all uppercase.
-- `message` (`string`, required) - The warning message. You can also use
-interpolated strings for formatting the message.
-- `options` (`object`, optional) - Optional options with the following
-properties:
-  + `unlimited` (`boolean`, optional) - Should the warning be emitted more than
-  once? Defaults to `false`.
-
-
-##### `createDeprecation({code, message[, options]})`
-
-This is a wrapper for `createWarning`. It is equivalent to invoking
-`createWarning` with the `name` parameter set to "DeprecationWarning".
-
-Deprecation warnings have extended support for the Node.js CLI options:
-`--throw-deprecation`, `--no-deprecation`, and `--trace-deprecation`.
-
-##### `warning([, a [, b [, c]]])`
-
-The returned `warning` function can used for emitting warnings.
-A warning is guaranteed to be emitted at least once.
-
-- `[, a [, b [, c]]]` (`any`, optional) - Parameters for string interpolation.
-
-```js
-const { createWarning } = require('process-warning')
-const FST_ERROR_CODE = createWarning({ name: 'MyAppWarning', code: 'FST_ERROR_CODE', message: 'message' })
-FST_ERROR_CODE()
-```
-
-How to use an interpolated string:
-```js
-const { createWarning } = require('process-warning')
-const FST_ERROR_CODE = createWarning({ name: 'MyAppWarning', code: 'FST_ERROR_CODE', message: 'Hello %s'})
-FST_ERROR_CODE('world')
-```
-
-The `warning` object has methods and properties for managing the warning's state. Useful for testing.
-```js
-const { createWarning } = require('process-warning')
-const FST_ERROR_CODE = createWarning({ name: 'MyAppWarning', code: 'FST_ERROR_CODE', message: 'Hello %s'})
-console.log(FST_ERROR_CODE.emitted) // false
-FST_ERROR_CODE('world')
-console.log(FST_ERROR_CODE.emitted) // true
-
-const FST_ERROR_CODE_2 = createWarning('MyAppWarning', 'FST_ERROR_CODE_2', 'Hello %s')
-FST_ERROR_CODE_2.emitted = true
-FST_ERROR_CODE_2('world') // will not be emitted because it is not unlimited
-```
-
-How to use an unlimited warning:
-```js
-const { createWarning } = require('process-warning')
-const FST_ERROR_CODE = createWarning({ name: 'MyAppWarning', code: 'FST_ERROR_CODE', message: 'Hello %s', unlimited: true })
-FST_ERROR_CODE('world') // will be emitted
-FST_ERROR_CODE('world') // will be emitted again
-```
-
-#### `spyWarning(warning)`
-
-Spy the created warning function for testing purpose.
-
-```js
-const { test } = require('node:test')
-const { createWarning, spyWarning } = require('process-warning')
-const FST_ERROR_CODE = createWarning({ name: 'MyAppWarning', code: 'FST_ERROR_CODE', message: 'Hello %s' })
-
-test('spy warning', t => {
-  const spyData = spyWarning(FST_ERROR_CODE)
-
-  // call after spy
-  const emitted = FST_ERROR_CODE('world')
-  t.assert.strictEqual(emitted, true)
-
-  // restore the warning function
-  // it must be called when you do not need to spy anymore
-  // otherwise, the calls data will accumulates.
-  t.after(() => spyData.restore())
-
-  t.assert.strictEqual(FST_ERROR_CODE.emitted, true)
-  // calls return the arguments and result.
-  // result indicate whether warning is emitted through process.emitWarning
-  console.log(spyData.calls) // [{ arguments: ['world'], result: true }]
-  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['world'])
-  t.assert.strictEqual(spyData.calls[0].result,  true)
-  // number of times called the function
-  console.log(spyData.callCount()) // 1
-  t.assert.strictEqual(spyData.callCount(),  1)
-
-  // reset the spy stat and warning state
-  spyData.reset()
-  t.assert.strictEqual(FST_ERROR_CODE.emitted, false)
-  t.assert.deepStrictEqual(spyData.calls, [])
-  t.assert.strictEqual(spyData.callCount(),  0)
-})
-```
-
-#### Suppressing warnings
-
-It is possible to suppress warnings by utilizing one of node's built-in warning suppression mechanisms.
-
-Warnings can be suppressed:
-
-- by setting the `NODE_NO_WARNINGS` environment variable to `1`
-- by passing the `--no-warnings` flag to the node process
-- by setting '--no-warnings' in the `NODE_OPTIONS` environment variable
-
-For more information see [node's documentation](https://nodejs.org/api/cli.html).
-
-## License
-
-Licensed under [MIT](./LICENSE).

package/node_modules/@zuplo/editor/node_modules/process-warning/benchmarks/warn.js

@@ -1,25 +0,0 @@
-'use strict'
-
-const { Suite } = require('benchmark')
-const { createWarning } = require('..')
-
-const err1 = createWarning({
-  name: 'TestWarning',
-  code: 'TST_ERROR_CODE_1',
-  message: 'message'
-})
-const err2 = createWarning({
-  name: 'TestWarning',
-  code: 'TST_ERROR_CODE_2',
-  message: 'message'
-})
-
-new Suite()
-  .add('warn', function () {
-    err1()
-    err2()
-  })
-  .on('cycle', function (event) {
-    console.log(String(event.target))
-  })
-  .run()

package/node_modules/@zuplo/editor/node_modules/process-warning/examples/example.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const { createWarning } = require('..')
-
-const CUSTDEP001 = createWarning({
-  name: 'DeprecationWarning',
-  code: 'CUSTDEP001',
-  message: 'This is a deprecation warning'
-})
-
-CUSTDEP001()