@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/pino-abstract-transport/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "pino-abstract-transport",
+  "version": "2.0.0",
+  "description": "Write Pino transports easily",
+  "main": "index.js",
+  "scripts": {
+    "prepare": "husky install",
+    "test": "standard | snazzy && tap test/*.test.js  && tsd",
+    "test-ci": "standard | snazzy && tap test/*.test.js --coverage-report=lcovonly && tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/pino-abstract-transport.git"
+  },
+  "keywords": [
+    "pino",
+    "transport"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-abstract-transport/issues"
+  },
+  "homepage": "https://github.com/pinojs/pino-abstract-transport#readme",
+  "dependencies": {
+    "split2": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.1.0",
+    "husky": "^9.0.6",
+    "snazzy": "^9.0.0",
+    "standard": "^17.0.0",
+    "tap": "^16.0.0",
+    "thread-stream": "^2.6.0",
+    "tsd": "^0.31.0"
+  },
+  "tsd": {
+    "directory": "./test/types"
+  }
+}

package/.output/server/node_modules/pino-std-serializers/index.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const errSerializer = require('./lib/err')
+const errWithCauseSerializer = require('./lib/err-with-cause')
+const reqSerializers = require('./lib/req')
+const resSerializers = require('./lib/res')
+
+module.exports = {
+  err: errSerializer,
+  errWithCause: errWithCauseSerializer,
+  mapHttpRequest: reqSerializers.mapHttpRequest,
+  mapHttpResponse: resSerializers.mapHttpResponse,
+  req: reqSerializers.reqSerializer,
+  res: resSerializers.resSerializer,
+
+  wrapErrorSerializer: function wrapErrorSerializer (customSerializer) {
+    if (customSerializer === errSerializer) return customSerializer
+    return function wrapErrSerializer (err) {
+      return customSerializer(errSerializer(err))
+    }
+  },
+
+  wrapRequestSerializer: function wrapRequestSerializer (customSerializer) {
+    if (customSerializer === reqSerializers.reqSerializer) return customSerializer
+    return function wrappedReqSerializer (req) {
+      return customSerializer(reqSerializers.reqSerializer(req))
+    }
+  },
+
+  wrapResponseSerializer: function wrapResponseSerializer (customSerializer) {
+    if (customSerializer === resSerializers.resSerializer) return customSerializer
+    return function wrappedResSerializer (res) {
+      return customSerializer(resSerializers.resSerializer(res))
+    }
+  }
+}

package/.output/server/node_modules/pino-std-serializers/lib/err-helpers.js

@@ -0,0 +1,118 @@
+'use strict'
+
+// **************************************************************
+// * Code initially copied/adapted from "pony-cause" npm module *
+// * Please upstream improvements there                         *
+// **************************************************************
+
+const isErrorLike = (err) => {
+  return err && typeof err.message === 'string'
+}
+
+/**
+ * @param {Error|{ cause?: unknown|(()=>err)}} err
+ * @returns {Error|Object|undefined}
+ */
+const getErrorCause = (err) => {
+  if (!err) return
+
+  /** @type {unknown} */
+  // @ts-ignore
+  const cause = err.cause
+
+  // VError / NError style causes
+  if (typeof cause === 'function') {
+    // @ts-ignore
+    const causeResult = err.cause()
+
+    return isErrorLike(causeResult)
+      ? causeResult
+      : undefined
+  } else {
+    return isErrorLike(cause)
+      ? cause
+      : undefined
+  }
+}
+
+/**
+ * Internal method that keeps a track of which error we have already added, to avoid circular recursion
+ *
+ * @private
+ * @param {Error} err
+ * @param {Set<Error>} seen
+ * @returns {string}
+ */
+const _stackWithCauses = (err, seen) => {
+  if (!isErrorLike(err)) return ''
+
+  const stack = err.stack || ''
+
+  // Ensure we don't go circular or crazily deep
+  if (seen.has(err)) {
+    return stack + '\ncauses have become circular...'
+  }
+
+  const cause = getErrorCause(err)
+
+  if (cause) {
+    seen.add(err)
+    return (stack + '\ncaused by: ' + _stackWithCauses(cause, seen))
+  } else {
+    return stack
+  }
+}
+
+/**
+ * @param {Error} err
+ * @returns {string}
+ */
+const stackWithCauses = (err) => _stackWithCauses(err, new Set())
+
+/**
+ * Internal method that keeps a track of which error we have already added, to avoid circular recursion
+ *
+ * @private
+ * @param {Error} err
+ * @param {Set<Error>} seen
+ * @param {boolean} [skip]
+ * @returns {string}
+ */
+const _messageWithCauses = (err, seen, skip) => {
+  if (!isErrorLike(err)) return ''
+
+  const message = skip ? '' : (err.message || '')
+
+  // Ensure we don't go circular or crazily deep
+  if (seen.has(err)) {
+    return message + ': ...'
+  }
+
+  const cause = getErrorCause(err)
+
+  if (cause) {
+    seen.add(err)
+
+    // @ts-ignore
+    const skipIfVErrorStyleCause = typeof err.cause === 'function'
+
+    return (message +
+      (skipIfVErrorStyleCause ? '' : ': ') +
+      _messageWithCauses(cause, seen, skipIfVErrorStyleCause))
+  } else {
+    return message
+  }
+}
+
+/**
+ * @param {Error} err
+ * @returns {string}
+ */
+const messageWithCauses = (err) => _messageWithCauses(err, new Set())
+
+module.exports = {
+  isErrorLike,
+  getErrorCause,
+  stackWithCauses,
+  messageWithCauses
+}

package/.output/server/node_modules/pino-std-serializers/lib/err-proto.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const seen = Symbol('circular-ref-tag')
+const rawSymbol = Symbol('pino-raw-err-ref')
+
+const pinoErrProto = Object.create({}, {
+  type: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  message: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  stack: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  aggregateErrors: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoErrProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+module.exports = {
+  pinoErrProto,
+  pinoErrorSymbols: {
+    seen,
+    rawSymbol
+  }
+}

package/.output/server/node_modules/pino-std-serializers/lib/err-with-cause.js

@@ -0,0 +1,48 @@
+'use strict'
+
+module.exports = errWithCauseSerializer
+
+const { isErrorLike } = require('./err-helpers')
+const { pinoErrProto, pinoErrorSymbols } = require('./err-proto')
+const { seen } = pinoErrorSymbols
+
+const { toString } = Object.prototype
+
+function errWithCauseSerializer (err) {
+  if (!isErrorLike(err)) {
+    return err
+  }
+
+  err[seen] = undefined // tag to prevent re-looking at this
+  const _err = Object.create(pinoErrProto)
+  _err.type = toString.call(err.constructor) === '[object Function]'
+    ? err.constructor.name
+    : err.name
+  _err.message = err.message
+  _err.stack = err.stack
+
+  if (Array.isArray(err.errors)) {
+    _err.aggregateErrors = err.errors.map(err => errWithCauseSerializer(err))
+  }
+
+  if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
+    _err.cause = errWithCauseSerializer(err.cause)
+  }
+
+  for (const key in err) {
+    if (_err[key] === undefined) {
+      const val = err[key]
+      if (isErrorLike(val)) {
+        if (!Object.prototype.hasOwnProperty.call(val, seen)) {
+          _err[key] = errWithCauseSerializer(val)
+        }
+      } else {
+        _err[key] = val
+      }
+    }
+  }
+
+  delete err[seen] // clean up tag in case err is serialized again later
+  _err.raw = err
+  return _err
+}

package/.output/server/node_modules/pino-std-serializers/lib/err.js

@@ -0,0 +1,45 @@
+'use strict'
+
+module.exports = errSerializer
+
+const { messageWithCauses, stackWithCauses, isErrorLike } = require('./err-helpers')
+const { pinoErrProto, pinoErrorSymbols } = require('./err-proto')
+const { seen } = pinoErrorSymbols
+
+const { toString } = Object.prototype
+
+function errSerializer (err) {
+  if (!isErrorLike(err)) {
+    return err
+  }
+
+  err[seen] = undefined // tag to prevent re-looking at this
+  const _err = Object.create(pinoErrProto)
+  _err.type = toString.call(err.constructor) === '[object Function]'
+    ? err.constructor.name
+    : err.name
+  _err.message = messageWithCauses(err)
+  _err.stack = stackWithCauses(err)
+
+  if (Array.isArray(err.errors)) {
+    _err.aggregateErrors = err.errors.map(err => errSerializer(err))
+  }
+
+  for (const key in err) {
+    if (_err[key] === undefined) {
+      const val = err[key]
+      if (isErrorLike(val)) {
+        // We append cause messages and stacks to _err, therefore skipping causes here
+        if (key !== 'cause' && !Object.prototype.hasOwnProperty.call(val, seen)) {
+          _err[key] = errSerializer(val)
+        }
+      } else {
+        _err[key] = val
+      }
+    }
+  }
+
+  delete err[seen] // clean up tag in case err is serialized again later
+  _err.raw = err
+  return _err
+}

package/.output/server/node_modules/pino-std-serializers/lib/req.js

@@ -0,0 +1,100 @@
+'use strict'
+
+module.exports = {
+  mapHttpRequest,
+  reqSerializer
+}
+
+const rawSymbol = Symbol('pino-raw-req-ref')
+const pinoReqProto = Object.create({}, {
+  id: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  method: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  url: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  query: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  params: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  headers: {
+    enumerable: true,
+    writable: true,
+    value: {}
+  },
+  remoteAddress: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  remotePort: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoReqProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function reqSerializer (req) {
+  // req.info is for hapi compat.
+  const connection = req.info || req.socket
+  const _req = Object.create(pinoReqProto)
+  _req.id = (typeof req.id === 'function' ? req.id() : (req.id || (req.info ? req.info.id : undefined)))
+  _req.method = req.method
+  // req.originalUrl is for expressjs compat.
+  if (req.originalUrl) {
+    _req.url = req.originalUrl
+  } else {
+    const path = req.path
+    // path for safe hapi compat.
+    _req.url = typeof path === 'string' ? path : (req.url ? req.url.path || req.url : undefined)
+  }
+
+  if (req.query) {
+    _req.query = req.query
+  }
+
+  if (req.params) {
+    _req.params = req.params
+  }
+
+  _req.headers = req.headers
+  _req.remoteAddress = connection && connection.remoteAddress
+  _req.remotePort = connection && connection.remotePort
+  // req.raw is  for hapi compat/equivalence
+  _req.raw = req.raw || req
+  return _req
+}
+
+function mapHttpRequest (req) {
+  return {
+    req: reqSerializer(req)
+  }
+}

package/.output/server/node_modules/pino-std-serializers/lib/res.js

@@ -0,0 +1,47 @@
+'use strict'
+
+module.exports = {
+  mapHttpResponse,
+  resSerializer
+}
+
+const rawSymbol = Symbol('pino-raw-res-ref')
+const pinoResProto = Object.create({}, {
+  statusCode: {
+    enumerable: true,
+    writable: true,
+    value: 0
+  },
+  headers: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoResProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function resSerializer (res) {
+  const _res = Object.create(pinoResProto)
+  _res.statusCode = res.headersSent ? res.statusCode : null
+  _res.headers = res.getHeaders ? res.getHeaders() : res._headers
+  _res.raw = res
+  return _res
+}
+
+function mapHttpResponse (res) {
+  return {
+    res: resSerializer(res)
+  }
+}

package/.output/server/node_modules/pino-std-serializers/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "pino-std-serializers",
+  "version": "7.0.0",
+  "description": "A collection of standard object serializers for Pino",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "index.d.ts",
+  "scripts": {
+    "lint": "standard | snazzy",
+    "lint-ci": "standard",
+    "test": "borp -p 'test/**/*.js'",
+    "test-ci": "borp --coverage -p 'test/**/*.js'",
+    "test-types": "tsc && tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/pinojs/pino-std-serializers.git"
+  },
+  "keywords": [
+    "pino",
+    "logging"
+  ],
+  "author": "James Sumners <james.sumners@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-std-serializers/issues"
+  },
+  "homepage": "https://github.com/pinojs/pino-std-serializers#readme",
+  "precommit": [
+    "lint",
+    "test",
+    "test-types"
+  ],
+  "devDependencies": {
+    "@matteo.collina/tspl": "^0.1.1",
+    "@types/node": "^20.11.17",
+    "borp": "^0.9.1",
+    "pre-commit": "^1.2.2",
+    "snazzy": "^9.0.0",
+    "standard": "^17.1.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.3.3"
+  },
+  "tsd": {
+    "directory": "test/types"
+  }
+}

package/.output/server/node_modules/pkg-types/dist/index.mjs

@@ -0,0 +1,157 @@
+import { statSync, promises } from 'node:fs';
+import { resolve, join, isAbsolute, dirname } from 'pathe';
+import { resolvePath } from 'mlly';
+import { parseJSON, parseJSONC, stringifyJSON, stringifyJSONC } from 'confbox';
+
+const defaultFindOptions = {
+  startingFrom: ".",
+  rootPattern: /^node_modules$/,
+  reverse: false,
+  test: (filePath) => {
+    try {
+      if (statSync(filePath).isFile()) {
+        return true;
+      }
+    } catch {
+    }
+  }
+};
+async function findFile(filename, _options = {}) {
+  const filenames = Array.isArray(filename) ? filename : [filename];
+  const options = { ...defaultFindOptions, ..._options };
+  const basePath = resolve(options.startingFrom);
+  const leadingSlash = basePath[0] === "/";
+  const segments = basePath.split("/").filter(Boolean);
+  if (leadingSlash) {
+    segments[0] = "/" + segments[0];
+  }
+  let root = segments.findIndex((r) => r.match(options.rootPattern));
+  if (root === -1) {
+    root = 0;
+  }
+  if (options.reverse) {
+    for (let index = root + 1; index <= segments.length; index++) {
+      for (const filename2 of filenames) {
+        const filePath = join(...segments.slice(0, index), filename2);
+        if (await options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  } else {
+    for (let index = segments.length; index > root; index--) {
+      for (const filename2 of filenames) {
+        const filePath = join(...segments.slice(0, index), filename2);
+        if (await options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  }
+  throw new Error(
+    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
+  );
+}
+function findNearestFile(filename, _options = {}) {
+  return findFile(filename, _options);
+}
+function findFarthestFile(filename, _options = {}) {
+  return findFile(filename, { ..._options, reverse: true });
+}
+
+function definePackageJSON(package_) {
+  return package_;
+}
+function defineTSConfig(tsconfig) {
+  return tsconfig;
+}
+const FileCache = /* @__PURE__ */ new Map();
+async function readPackageJSON(id, options = {}) {
+  const resolvedPath = await resolvePackageJSON(id, options);
+  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+  if (options.cache && cache.has(resolvedPath)) {
+    return cache.get(resolvedPath);
+  }
+  const blob = await promises.readFile(resolvedPath, "utf8");
+  let parsed;
+  try {
+    parsed = parseJSON(blob);
+  } catch {
+    parsed = parseJSONC(blob);
+  }
+  cache.set(resolvedPath, parsed);
+  return parsed;
+}
+async function writePackageJSON(path, package_) {
+  await promises.writeFile(path, stringifyJSON(package_));
+}
+async function readTSConfig(id, options = {}) {
+  const resolvedPath = await resolveTSConfig(id, options);
+  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+  if (options.cache && cache.has(resolvedPath)) {
+    return cache.get(resolvedPath);
+  }
+  const text = await promises.readFile(resolvedPath, "utf8");
+  const parsed = parseJSONC(text);
+  cache.set(resolvedPath, parsed);
+  return parsed;
+}
+async function writeTSConfig(path, tsconfig) {
+  await promises.writeFile(path, stringifyJSONC(tsconfig));
+}
+async function resolvePackageJSON(id = process.cwd(), options = {}) {
+  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
+  return findNearestFile("package.json", {
+    startingFrom: resolvedPath,
+    ...options
+  });
+}
+async function resolveTSConfig(id = process.cwd(), options = {}) {
+  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
+  return findNearestFile("tsconfig.json", {
+    startingFrom: resolvedPath,
+    ...options
+  });
+}
+const lockFiles = [
+  "yarn.lock",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "npm-shrinkwrap.json",
+  "bun.lockb",
+  "bun.lock"
+];
+async function resolveLockfile(id = process.cwd(), options = {}) {
+  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
+  const _options = { startingFrom: resolvedPath, ...options };
+  try {
+    return await findNearestFile(lockFiles, _options);
+  } catch {
+  }
+  throw new Error("No lockfile found from " + id);
+}
+async function findWorkspaceDir(id = process.cwd(), options = {}) {
+  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
+  const _options = { startingFrom: resolvedPath, ...options };
+  try {
+    const r = await findNearestFile(".git/config", _options);
+    return resolve(r, "../..");
+  } catch {
+  }
+  try {
+    const r = await resolveLockfile(resolvedPath, {
+      ..._options,
+      reverse: true
+    });
+    return dirname(r);
+  } catch {
+  }
+  try {
+    const r = await findFile(resolvedPath, _options);
+    return dirname(r);
+  } catch {
+  }
+  throw new Error("Cannot detect workspace root from " + id);
+}
+
+export { definePackageJSON, defineTSConfig, findFarthestFile, findFile, findNearestFile, findWorkspaceDir, readPackageJSON, readTSConfig, resolveLockfile, resolvePackageJSON, resolveTSConfig, writePackageJSON, writeTSConfig };